1 /* Functions related to building classes and their related objects.
2 Copyright (C) 1987, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* High-level class interface. */
34 #define obstack_chunk_alloc xmalloc
35 #define obstack_chunk_free free
37 extern struct obstack permanent_obstack;
39 /* This is how we tell when two virtual member functions are really the
41 #define SAME_FN(FN1DECL, FN2DECL) (DECL_ASSEMBLER_NAME (FN1DECL) == DECL_ASSEMBLER_NAME (FN2DECL))
43 extern void set_class_shadows PROTO ((tree));
45 /* Way of stacking class types. */
46 static tree *current_class_base, *current_class_stack;
47 static int current_class_stacksize;
48 int current_class_depth;
52 /* The previous class level. */
53 struct class_level *level_chain;
55 /* The class instance variable, as a PARM_DECL. */
57 /* The class instance variable, as an object. */
59 /* The virtual function table pointer
60 for the class instance variable. */
63 /* Name of the current class. */
65 /* Type of the current class. */
68 /* Flags for this class level. */
75 tree current_class_decl, C_C_D; /* PARM_DECL: the class instance variable */
77 /* The following two can be derived from the previous one */
78 tree current_class_name; /* IDENTIFIER_NODE: name of current class */
79 tree current_class_type; /* _TYPE: the type of the current class */
80 tree previous_class_type; /* _TYPE: the previous type that was a class */
81 tree previous_class_values; /* TREE_LIST: copy of the class_shadowed list
82 when leaving an outermost class scope. */
83 static tree get_vfield_name PROTO((tree));
85 /* Way of stacking language names. */
86 tree *current_lang_base, *current_lang_stack;
87 int current_lang_stacksize;
89 /* Names of languages we recognize. */
90 tree lang_name_c, lang_name_cplusplus;
91 tree current_lang_name;
93 char *dont_allow_type_definitions;
95 /* When layout out an aggregate type, the size of the
96 basetypes (virtual and non-virtual) is passed to layout_record
98 static tree base_layout_decl;
100 /* Constants used for access control. */
101 tree access_default_node; /* 0 */
102 tree access_public_node; /* 1 */
103 tree access_protected_node; /* 2 */
104 tree access_private_node; /* 3 */
105 tree access_default_virtual_node; /* 4 */
106 tree access_public_virtual_node; /* 5 */
107 tree access_private_virtual_node; /* 6 */
109 /* Variables shared between class.c and call.c. */
111 #ifdef GATHER_STATISTICS
113 int n_vtable_entries = 0;
114 int n_vtable_searches = 0;
115 int n_vtable_elems = 0;
116 int n_convert_harshness = 0;
117 int n_compute_conversion_costs = 0;
118 int n_build_method_call = 0;
119 int n_inner_fields_searched = 0;
122 /* Virtual baseclass things. */
124 build_vbase_pointer (exp, type)
129 name = (char *) alloca (TYPE_NAME_LENGTH (type) + sizeof (VBASE_NAME) + 1);
130 sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (type));
131 return build_component_ref (exp, get_identifier (name), 0, 0);
134 /* Is the type of the EXPR, the complete type of the object?
135 If we are going to be wrong, we must be conservative, and return 0. */
137 complete_type_p (expr)
140 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
143 switch (TREE_CODE (expr))
150 expr = TREE_OPERAND (expr, 0);
154 if (! TREE_HAS_CONSTRUCTOR (expr))
156 /* fall through... */
159 if (TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
160 && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (expr)))
161 && TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type)
163 /* fall through... */
166 if (IS_AGGR_TYPE (TREE_TYPE (expr))
167 && TYPE_MAIN_VARIANT (TREE_TYPE (expr)) == type)
169 /* fall through... */
179 /* Build multi-level access to EXPR using hierarchy path PATH.
180 CODE is PLUS_EXPR if we are going with the grain,
181 and MINUS_EXPR if we are not (in which case, we cannot traverse
182 virtual baseclass links).
184 TYPE is the type we want this path to have on exit.
186 ALIAS_THIS is non-zero if EXPR in an expression involving `this'. */
188 build_vbase_path (code, type, expr, path, alias_this)
190 tree type, expr, path;
193 register int changed = 0;
194 tree last = NULL_TREE, last_virtual = NULL_TREE;
196 int fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull);
197 tree null_expr = 0, nonnull_expr;
199 tree offset = integer_zero_node;
201 if (nonnull == 0 && (alias_this && flag_this_is_variable <= 0))
204 /* We need additional logic to convert back to the unconverted type
205 (the static type of the complete object), and then convert back
206 to the type we want. Until that is done, or until we can
207 recognize when that is, we cannot do the short cut logic. (mrs) */
208 /* Do this, until we can undo any previous conversions. See net35.C
210 fixed_type_p = complete_type_p (expr);
212 if (!fixed_type_p && TREE_SIDE_EFFECTS (expr))
213 expr = save_expr (expr);
216 if (BINFO_INHERITANCE_CHAIN (path))
218 tree reverse_path = NULL_TREE;
222 tree r = copy_node (path);
223 BINFO_INHERITANCE_CHAIN (r) = reverse_path;
225 path = BINFO_INHERITANCE_CHAIN (path);
230 basetype = BINFO_TYPE (path);
234 if (TREE_VIA_VIRTUAL (path))
236 last_virtual = BINFO_TYPE (path);
237 if (code == PLUS_EXPR)
239 changed = ! fixed_type_p;
243 extern int flag_assume_nonnull_objects;
246 /* We already check for ambiguous things in the caller, just
250 tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (nonnull_expr))), 0);
251 nonnull_expr = convert_pointer_to_real (binfo, nonnull_expr);
253 ind = build_indirect_ref (nonnull_expr, NULL_PTR);
254 nonnull_expr = build_vbase_pointer (ind, last_virtual);
256 && (TREE_CODE (type) == POINTER_TYPE
257 || !flag_assume_nonnull_objects)
258 && null_expr == NULL_TREE)
260 null_expr = build1 (NOP_EXPR, build_pointer_type (last_virtual), integer_zero_node);
261 expr = build (COND_EXPR, build_pointer_type (last_virtual),
262 build (EQ_EXPR, boolean_type_node, expr,
264 null_expr, nonnull_expr);
267 /* else we'll figure out the offset below. */
269 /* Happens in the case of parse errors. */
270 if (nonnull_expr == error_mark_node)
271 return error_mark_node;
275 cp_error ("cannot cast up from virtual baseclass `%T'",
277 return error_mark_node;
281 path = BINFO_INHERITANCE_CHAIN (path);
283 /* LAST is now the last basetype assoc on the path. */
285 /* A pointer to a virtual base member of a non-null object
286 is non-null. Therefore, we only need to test for zeroness once.
287 Make EXPR the canonical expression to deal with here. */
290 TREE_OPERAND (expr, 2) = nonnull_expr;
291 TREE_TYPE (TREE_OPERAND (expr, 1)) = TREE_TYPE (nonnull_expr);
296 /* If we go through any virtual base pointers, make sure that
297 casts to BASETYPE from the last virtual base class use
298 the right value for BASETYPE. */
301 tree intype = TREE_TYPE (TREE_TYPE (expr));
302 if (TYPE_MAIN_VARIANT (intype) != BINFO_TYPE (last))
304 tree binfo = get_binfo (last, TYPE_MAIN_VARIANT (intype), 0);
305 offset = BINFO_OFFSET (binfo);
312 offset = BINFO_OFFSET (binfo_member (last_virtual,
313 CLASSTYPE_VBASECLASSES (basetype)));
314 offset = size_binop (PLUS_EXPR, offset, BINFO_OFFSET (last));
317 offset = BINFO_OFFSET (last);
320 if (TREE_INT_CST_LOW (offset))
322 /* Bash types to make the backend happy. */
323 offset = convert (type, offset);
324 expr = build1 (NOP_EXPR, type, expr);
326 /* For multiple inheritance: if `this' can be set by any
327 function, then it could be 0 on entry to any function.
328 Preserve such zeroness here. Otherwise, only in the
329 case of constructors need we worry, and in those cases,
330 it will be zero, or initialized to some valid value to
335 TREE_TYPE (null_expr) = type;
337 null_expr = build1 (NOP_EXPR, type, integer_zero_node);
338 if (TREE_SIDE_EFFECTS (expr))
339 expr = save_expr (expr);
341 return build (COND_EXPR, type,
342 build (EQ_EXPR, boolean_type_node, expr, integer_zero_node),
344 build (code, type, expr, offset));
346 else return build (code, type, expr, offset);
349 /* Cannot change the TREE_TYPE of a NOP_EXPR here, since it may
350 be used multiple times in initialization of multiple inheritance. */
353 TREE_TYPE (expr) = type;
357 return build1 (NOP_EXPR, type, expr);
360 /* Virtual function things. */
362 /* Virtual functions to be dealt with after laying out our base
363 classes. We do all overrides after we layout virtual base classes.
365 static tree pending_hard_virtuals;
367 /* Build an entry in the virtual function table.
368 DELTA is the offset for the `this' pointer.
369 PFN is an ADDR_EXPR containing a pointer to the virtual function.
370 Note that the index (DELTA2) in the virtual function table
373 build_vtable_entry (delta, pfn)
377 if (flag_vtable_thunks)
379 HOST_WIDE_INT idelta = TREE_INT_CST_LOW (delta);
380 extern tree make_thunk ();
383 pfn = build1 (ADDR_EXPR, vtable_entry_type,
384 make_thunk (pfn, idelta));
385 TREE_READONLY (pfn) = 1;
386 TREE_CONSTANT (pfn) = 1;
388 #ifdef GATHER_STATISTICS
389 n_vtable_entries += 1;
395 extern int flag_huge_objects;
396 tree elems = tree_cons (NULL_TREE, delta,
397 tree_cons (NULL_TREE, integer_zero_node,
398 build_tree_list (NULL_TREE, pfn)));
399 tree entry = build (CONSTRUCTOR, vtable_entry_type, NULL_TREE, elems);
401 /* DELTA is constructed by `size_int', which means it may be an
402 unsigned quantity on some platforms. Therefore, we cannot use
403 `int_fits_type_p', because when DELTA is really negative,
404 `force_fit_type' will make it look like a very large number. */
406 if ((TREE_INT_CST_LOW (TYPE_MAX_VALUE (delta_type_node))
407 < TREE_INT_CST_LOW (delta))
408 || (TREE_INT_CST_LOW (delta)
409 < TREE_INT_CST_LOW (TYPE_MIN_VALUE (delta_type_node))))
410 if (flag_huge_objects)
411 sorry ("object size exceeds built-in limit for virtual function table implementation");
413 sorry ("object size exceeds normal limit for virtual function table implementation, recompile all source and use -fhuge-objects");
415 TREE_CONSTANT (entry) = 1;
416 TREE_STATIC (entry) = 1;
417 TREE_READONLY (entry) = 1;
419 #ifdef GATHER_STATISTICS
420 n_vtable_entries += 1;
427 /* Given an object INSTANCE, return an expression which yields the
428 virtual function corresponding to INDEX. There are many special
429 cases for INSTANCE which we take care of here, mainly to avoid
430 creating extra tree nodes when we don't have to. */
432 build_vfn_ref (ptr_to_instptr, instance, idx)
433 tree *ptr_to_instptr, instance;
437 tree basetype = TREE_TYPE (instance);
439 if (TREE_CODE (basetype) == REFERENCE_TYPE)
440 basetype = TREE_TYPE (basetype);
442 if (instance == C_C_D)
443 vtbl = build_indirect_ref (build_vfield_ref (instance, basetype),
449 /* Try to figure out what a reference refers to, and
450 access its virtual function table directly. */
451 tree ref = NULL_TREE;
453 if (TREE_CODE (instance) == INDIRECT_REF
454 && TREE_CODE (TREE_TYPE (TREE_OPERAND (instance, 0))) == REFERENCE_TYPE)
455 ref = TREE_OPERAND (instance, 0);
456 else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
459 if (ref && TREE_CODE (ref) == VAR_DECL
460 && DECL_INITIAL (ref))
462 tree init = DECL_INITIAL (ref);
464 while (TREE_CODE (init) == NOP_EXPR
465 || TREE_CODE (init) == NON_LVALUE_EXPR)
466 init = TREE_OPERAND (init, 0);
467 if (TREE_CODE (init) == ADDR_EXPR)
469 init = TREE_OPERAND (init, 0);
470 if (IS_AGGR_TYPE (TREE_TYPE (init))
471 && (TREE_CODE (init) == PARM_DECL
472 || TREE_CODE (init) == VAR_DECL))
478 if (IS_AGGR_TYPE (TREE_TYPE (instance))
479 && (TREE_CODE (instance) == RESULT_DECL
480 || TREE_CODE (instance) == PARM_DECL
481 || TREE_CODE (instance) == VAR_DECL))
482 vtbl = TYPE_BINFO_VTABLE (basetype);
484 vtbl = build_indirect_ref (build_vfield_ref (instance, basetype),
487 assemble_external (vtbl);
488 aref = build_array_ref (vtbl, idx);
490 /* Save the intermediate result in a SAVE_EXPR so we don't have to
491 compute each component of the virtual function pointer twice. */
492 if (TREE_CODE (aref) == INDIRECT_REF)
493 TREE_OPERAND (aref, 0) = save_expr (TREE_OPERAND (aref, 0));
495 if (flag_vtable_thunks)
501 = build (PLUS_EXPR, TREE_TYPE (*ptr_to_instptr),
503 convert (ptrdiff_type_node,
504 build_component_ref (aref, delta_identifier, 0, 0)));
505 return build_component_ref (aref, pfn_identifier, 0, 0);
509 /* Return the name of the virtual function table (as an IDENTIFIER_NODE)
510 for the given TYPE. */
512 get_vtable_name (type)
515 tree type_id = build_typename_overload (type);
516 char *buf = (char *)alloca (strlen (VTABLE_NAME_FORMAT)
517 + IDENTIFIER_LENGTH (type_id) + 2);
518 char *ptr = IDENTIFIER_POINTER (type_id);
520 for (i = 0; ptr[i] == OPERATOR_TYPENAME_FORMAT[i]; i++) ;
522 /* We don't take off the numbers; prepare_fresh_vtable uses the
523 DECL_ASSEMBLER_NAME for the type, which includes the number
524 in `3foo'. If we were to pull them off here, we'd end up with
525 something like `_vt.foo.3bar', instead of a uniform definition. */
526 while (ptr[i] >= '0' && ptr[i] <= '9')
529 sprintf (buf, VTABLE_NAME_FORMAT, ptr+i);
530 return get_identifier (buf);
533 /* Build a virtual function for type TYPE.
534 If BINFO is non-NULL, build the vtable starting with the initial
535 approximation that it is the same as the one which is the head of
536 the association list. */
538 build_vtable (binfo, type)
541 tree name = get_vtable_name (type);
546 virtuals = copy_list (BINFO_VIRTUALS (binfo));
547 decl = build_decl (VAR_DECL, name, TREE_TYPE (BINFO_VTABLE (binfo)));
551 virtuals = NULL_TREE;
552 decl = build_decl (VAR_DECL, name, void_type_node);
555 #ifdef GATHER_STATISTICS
557 n_vtable_elems += list_length (virtuals);
560 /* Set TREE_PUBLIC and TREE_EXTERN as appropriate. */
561 import_export_vtable (decl, type, 0);
563 IDENTIFIER_GLOBAL_VALUE (name) = decl = pushdecl_top_level (decl);
564 /* Initialize the association list for this type, based
565 on our first approximation. */
566 TYPE_BINFO_VTABLE (type) = decl;
567 TYPE_BINFO_VIRTUALS (type) = virtuals;
569 TREE_STATIC (decl) = 1;
570 #ifndef WRITABLE_VTABLES
571 /* Make them READONLY by default. (mrs) */
572 TREE_READONLY (decl) = 1;
574 /* At one time the vtable info was grabbed 2 words at a time. This
575 fails on sparc unless you have 8-byte alignment. (tiemann) */
576 DECL_ALIGN (decl) = MAX (TYPE_ALIGN (double_type_node),
579 /* Why is this conditional? (mrs) */
580 if (binfo && write_virtuals >= 0)
581 DECL_VIRTUAL_P (decl) = 1;
582 DECL_CONTEXT (decl) = type;
584 binfo = TYPE_BINFO (type);
585 SET_BINFO_NEW_VTABLE_MARKED (binfo);
589 /* Given a base type PARENT, and a derived type TYPE, build
590 a name which distinguishes exactly the PARENT member of TYPE's type.
592 FORMAT is a string which controls how sprintf formats the name
597 class A; class B; class C : A, B;
599 it is possible to distinguish "A" from "C's A". And given
602 class A : L; class B : L; class C : A, B;
604 it is possible to distinguish "L" from "A's L", and also from
607 Make sure to use the DECL_ASSEMBLER_NAME of the TYPE_NAME of the
608 type, as template have DECL_NAMEs like: X<int>, whereas the
609 DECL_ASSEMBLER_NAME is set to be something the assembler can handle.
612 build_type_pathname (format, parent, type)
616 extern struct obstack temporary_obstack;
617 char *first, *base, *name;
621 parent = TYPE_MAIN_VARIANT (parent);
623 /* Remember where to cut the obstack to. */
624 first = obstack_base (&temporary_obstack);
626 /* Put on TYPE+PARENT. */
627 obstack_grow (&temporary_obstack,
628 TYPE_ASSEMBLER_NAME_STRING (type),
629 TYPE_ASSEMBLER_NAME_LENGTH (type));
631 obstack_1grow (&temporary_obstack, JOINER);
633 obstack_1grow (&temporary_obstack, '_');
635 obstack_grow0 (&temporary_obstack,
636 TYPE_ASSEMBLER_NAME_STRING (parent),
637 TYPE_ASSEMBLER_NAME_LENGTH (parent));
638 i = obstack_object_size (&temporary_obstack);
639 base = obstack_base (&temporary_obstack);
640 obstack_finish (&temporary_obstack);
642 /* Put on FORMAT+TYPE+PARENT. */
643 obstack_blank (&temporary_obstack, strlen (format) + i + 1);
644 name = obstack_base (&temporary_obstack);
645 sprintf (name, format, base);
646 id = get_identifier (name);
647 obstack_free (&temporary_obstack, first);
652 /* Update the rtti info for this class. */
654 set_rtti_entry (virtuals, offset, type)
655 tree virtuals, offset, type;
657 if (! flag_vtable_thunks)
658 TREE_VALUE (virtuals)
659 = build_vtable_entry (offset,
661 ? build_t_desc (type, 0)
662 : integer_zero_node));
665 tree vfn = build1 (NOP_EXPR, vfunc_ptr_type_node, offset);
666 TREE_CONSTANT (vfn) = 1;
668 TREE_VALUE (virtuals)
669 = build_vtable_entry (integer_zero_node, vfn);
670 /* The second slot is for the tdesc pointer when thunks are used. */
672 ? build_t_desc (type, 0)
674 vfn = build1 (NOP_EXPR, vfunc_ptr_type_node, vfn);
675 TREE_CONSTANT (vfn) = 1;
677 TREE_VALUE (TREE_CHAIN (virtuals))
678 = build_vtable_entry (integer_zero_node, vfn);
682 /* Give TYPE a new virtual function table which is initialized
683 with a skeleton-copy of its original initialization. The only
684 entry that changes is the `delta' entry, so we can really
685 share a lot of structure.
687 FOR_TYPE is the derived type which caused this table to
690 BINFO is the type association which provided TYPE for FOR_TYPE. */
692 prepare_fresh_vtable (binfo, for_type)
693 tree binfo, for_type;
695 tree basetype = BINFO_TYPE (binfo);
696 tree orig_decl = BINFO_VTABLE (binfo);
697 /* This name is too simplistic. We can have multiple basetypes for
698 for_type, and we really want different names. (mrs) */
699 tree name = build_type_pathname (VTABLE_NAME_FORMAT, basetype, for_type);
700 tree new_decl = build_decl (VAR_DECL, name, TREE_TYPE (orig_decl));
703 /* Remember which class this vtable is really for. */
704 DECL_CONTEXT (new_decl) = for_type;
706 TREE_STATIC (new_decl) = 1;
707 BINFO_VTABLE (binfo) = pushdecl_top_level (new_decl);
708 DECL_VIRTUAL_P (new_decl) = 1;
709 #ifndef WRITABLE_VTABLES
710 /* Make them READONLY by default. (mrs) */
711 TREE_READONLY (new_decl) = 1;
713 DECL_ALIGN (new_decl) = DECL_ALIGN (orig_decl);
715 /* Make fresh virtual list, so we can smash it later. */
716 BINFO_VIRTUALS (binfo) = copy_list (BINFO_VIRTUALS (binfo));
718 if (TREE_VIA_VIRTUAL (binfo))
719 offset = BINFO_OFFSET (binfo_member (BINFO_TYPE (binfo),
720 CLASSTYPE_VBASECLASSES (for_type)));
722 offset = BINFO_OFFSET (binfo);
724 set_rtti_entry (BINFO_VIRTUALS (binfo),
725 size_binop (MINUS_EXPR, integer_zero_node, offset),
728 #ifdef GATHER_STATISTICS
730 n_vtable_elems += list_length (BINFO_VIRTUALS (binfo));
733 /* Set TREE_PUBLIC and TREE_EXTERN as appropriate. */
734 import_export_vtable (new_decl, for_type, 0);
736 if (TREE_VIA_VIRTUAL (binfo))
737 my_friendly_assert (binfo == binfo_member (BINFO_TYPE (binfo),
738 CLASSTYPE_VBASECLASSES (current_class_type)),
740 SET_BINFO_NEW_VTABLE_MARKED (binfo);
744 /* Access the virtual function table entry that logically
745 contains BASE_FNDECL. VIRTUALS is the virtual function table's
746 initializer. We can run off the end, when dealing with virtual
747 destructors in MI situations, return NULL_TREE in that case. */
749 get_vtable_entry (virtuals, base_fndecl)
750 tree virtuals, base_fndecl;
752 unsigned HOST_WIDE_INT n = (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD
753 ? (TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl))
754 & (((unsigned HOST_WIDE_INT)1<<(BITS_PER_WORD-1))-1))
755 : TREE_INT_CST_LOW (DECL_VINDEX (base_fndecl)));
757 #ifdef GATHER_STATISTICS
758 n_vtable_searches += n;
761 while (n > 0 && virtuals)
764 virtuals = TREE_CHAIN (virtuals);
770 /* Put new entry ENTRY into virtual function table initializer
773 Also update DECL_VINDEX (FNDECL). */
776 modify_vtable_entry (old_entry_in_list, new_entry, fndecl)
777 tree old_entry_in_list, new_entry, fndecl;
779 tree base_fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (old_entry_in_list)), 0);
782 cp_warning ("replaced %D with %D", DECL_ASSEMBLER_NAME (base_fndecl),
783 DECL_ASSEMBLER_NAME (fndecl));
785 TREE_VALUE (old_entry_in_list) = new_entry;
787 /* Now assign virtual dispatch information, if unset. */
788 /* We can dispatch this, through any overridden base function. */
789 if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
791 DECL_VINDEX (fndecl) = DECL_VINDEX (base_fndecl);
792 DECL_CONTEXT (fndecl) = DECL_CONTEXT (base_fndecl);
796 /* Access the virtual function table entry i. VIRTUALS is the virtual
797 function table's initializer. */
799 get_vtable_entry_n (virtuals, n)
801 unsigned HOST_WIDE_INT n;
806 virtuals = TREE_CHAIN (virtuals);
811 /* Add a virtual function to all the appropriate vtables for the class
812 T. DECL_VINDEX(X) should be error_mark_node, if we want to
813 allocate a new slot in our table. If it is error_mark_node, we
814 know that no other function from another vtable is overridden by X.
815 HAS_VIRTUAL keeps track of how many virtuals there are in our main
816 vtable for the type, and we build upon the PENDING_VIRTUALS list
819 add_virtual_function (pending_virtuals, has_virtual, fndecl, t)
820 tree pending_virtuals;
823 tree t; /* Structure type. */
825 /* FUNCTION_TYPEs and OFFSET_TYPEs no longer freely
826 convert to void *. Make such a conversion here. */
827 tree vfn = build1 (ADDR_EXPR, vfunc_ptr_type_node, fndecl);
828 TREE_CONSTANT (vfn) = 1;
831 if (current_class_type == 0)
832 cp_warning ("internal problem, current_class_type is zero when adding `%D', please report",
834 if (current_class_type && t != current_class_type)
835 cp_warning ("internal problem, current_class_type differs when adding `%D', please report",
839 /* If the virtual function is a redefinition of a prior one,
840 figure out in which base class the new definition goes,
841 and if necessary, make a fresh virtual function table
842 to hold that entry. */
843 if (DECL_VINDEX (fndecl) == error_mark_node)
847 if (flag_rtti && *has_virtual == 0)
849 /* CLASSTYPE_RTTI is only used as a Boolean (NULL or not). */
850 CLASSTYPE_RTTI (t) = integer_one_node;
853 /* If we are using thunks, use two slots at the front, one
854 for the offset pointer, one for the tdesc pointer. */
855 if (*has_virtual == 0 && flag_vtable_thunks)
860 /* Build a new INT_CST for this DECL_VINDEX. */
862 static tree index_table[256];
864 /* We skip a slot for the offset/tdesc entry. */
865 int i = ++(*has_virtual);
867 if (i >= 256 || index_table[i] == 0)
869 index = build_int_2 (i, 0);
871 index_table[i] = index;
874 index = index_table[i];
876 /* Now assign virtual dispatch information. */
877 DECL_VINDEX (fndecl) = index;
878 DECL_CONTEXT (fndecl) = t;
880 entry = build_vtable_entry (integer_zero_node, vfn);
881 pending_virtuals = tree_cons (DECL_VINDEX (fndecl), entry, pending_virtuals);
883 /* Might already be INTEGER_CST if declared twice in class. We will
884 give error later or we've already given it. */
885 else if (TREE_CODE (DECL_VINDEX (fndecl)) != INTEGER_CST)
887 /* Need an entry in some other virtual function table.
888 Deal with this after we have laid out our virtual base classes. */
889 pending_hard_virtuals = temp_tree_cons (fndecl, vfn, pending_hard_virtuals);
891 return pending_virtuals;
894 /* Obstack on which to build the vector of class methods. */
895 struct obstack class_obstack;
896 extern struct obstack *current_obstack;
898 /* Add method METHOD to class TYPE. This is used when a method
899 has been defined which did not initially appear in the class definition,
900 and helps cut down on spurious error messages.
902 FIELDS is the entry in the METHOD_VEC vector entry of the class type where
903 the method should be added. */
905 add_method (type, fields, method)
906 tree type, *fields, method;
908 /* We must make a copy of METHOD here, since we must be sure that
909 we have exclusive title to this method's DECL_CHAIN. */
912 push_obstacks (&permanent_obstack, &permanent_obstack);
914 decl = copy_node (method);
915 if (DECL_RTL (decl) == 0
916 && (!processing_template_decl
917 || !uses_template_parms (decl)))
919 make_function_rtl (decl);
920 DECL_RTL (method) = DECL_RTL (decl);
924 if (fields && *fields)
926 /* Take care not to hide destructor. */
927 DECL_CHAIN (decl) = DECL_CHAIN (*fields);
928 DECL_CHAIN (*fields) = decl;
930 else if (CLASSTYPE_METHOD_VEC (type) == 0)
932 tree method_vec = make_node (TREE_VEC);
933 if (TYPE_IDENTIFIER (type) == DECL_NAME (decl))
935 TREE_VEC_ELT (method_vec, 0) = decl;
936 TREE_VEC_LENGTH (method_vec) = 1;
940 /* ??? Is it possible for there to have been enough room in the
941 current chunk for the tree_vec structure but not a tree_vec
942 plus a tree*? Will this work in that case? */
943 obstack_free (current_obstack, method_vec);
944 obstack_blank (current_obstack, sizeof (struct tree_vec) + sizeof (tree *));
945 TREE_VEC_ELT (method_vec, 1) = decl;
946 TREE_VEC_LENGTH (method_vec) = 2;
947 obstack_finish (current_obstack);
949 CLASSTYPE_METHOD_VEC (type) = method_vec;
953 tree method_vec = CLASSTYPE_METHOD_VEC (type);
954 int len = TREE_VEC_LENGTH (method_vec);
956 /* Adding a new ctor or dtor. This is easy because our
957 METHOD_VEC always has a slot for such entries. */
958 if (TYPE_IDENTIFIER (type) == DECL_NAME (decl))
960 /* TREE_VEC_ELT (method_vec, 0) = decl; */
961 if (decl != TREE_VEC_ELT (method_vec, 0))
963 DECL_CHAIN (decl) = TREE_VEC_ELT (method_vec, 0);
964 TREE_VEC_ELT (method_vec, 0) = decl;
969 /* This is trickier. We try to extend the TREE_VEC in-place,
970 but if that does not work, we copy all its data to a new
971 TREE_VEC that's large enough. */
972 struct obstack *ob = &class_obstack;
973 tree *end = (tree *)obstack_next_free (ob);
975 if (end != TREE_VEC_END (method_vec))
977 ob = current_obstack;
978 TREE_VEC_LENGTH (method_vec) += 1;
979 TREE_VEC_ELT (method_vec, len) = NULL_TREE;
980 method_vec = copy_node (method_vec);
981 TREE_VEC_LENGTH (method_vec) -= 1;
985 tree tmp_vec = (tree) obstack_base (ob);
986 if (obstack_room (ob) < sizeof (tree))
988 obstack_blank (ob, sizeof (struct tree_common)
989 + tree_code_length[(int) TREE_VEC]
991 + len * sizeof (tree));
992 tmp_vec = (tree) obstack_base (ob);
993 bcopy ((char *) method_vec, (char *) tmp_vec,
994 (sizeof (struct tree_common)
995 + tree_code_length[(int) TREE_VEC] * sizeof (char *)
996 + (len-1) * sizeof (tree)));
997 method_vec = tmp_vec;
1000 obstack_blank (ob, sizeof (tree));
1003 obstack_finish (ob);
1004 TREE_VEC_ELT (method_vec, len) = decl;
1005 TREE_VEC_LENGTH (method_vec) = len + 1;
1006 CLASSTYPE_METHOD_VEC (type) = method_vec;
1008 if (TYPE_BINFO_BASETYPES (type) && CLASSTYPE_BASELINK_VEC (type))
1010 /* ??? May be better to know whether these can be extended? */
1011 tree baselink_vec = CLASSTYPE_BASELINK_VEC (type);
1013 TREE_VEC_LENGTH (baselink_vec) += 1;
1014 CLASSTYPE_BASELINK_VEC (type) = copy_node (baselink_vec);
1015 TREE_VEC_LENGTH (baselink_vec) -= 1;
1017 TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type), len) = 0;
1021 DECL_CONTEXT (decl) = type;
1022 DECL_CLASS_CONTEXT (decl) = type;
1027 /* Subroutines of finish_struct. */
1029 /* Look through the list of fields for this struct, deleting
1030 duplicates as we go. This must be recursive to handle
1033 FIELD is the field which may not appear anywhere in FIELDS.
1034 FIELD_PTR, if non-null, is the starting point at which
1035 chained deletions may take place.
1036 The value returned is the first acceptable entry found
1039 Note that anonymous fields which are not of UNION_TYPE are
1040 not duplicates, they are just anonymous fields. This happens
1041 when we have unnamed bitfields, for example. */
1043 delete_duplicate_fields_1 (field, fields)
1048 if (DECL_NAME (field) == 0)
1050 if (TREE_CODE (TREE_TYPE (field)) != UNION_TYPE)
1053 for (x = TYPE_FIELDS (TREE_TYPE (field)); x; x = TREE_CHAIN (x))
1054 fields = delete_duplicate_fields_1 (x, fields);
1059 for (x = fields; x; prev = x, x = TREE_CHAIN (x))
1061 if (DECL_NAME (x) == 0)
1063 if (TREE_CODE (TREE_TYPE (x)) != UNION_TYPE)
1065 TYPE_FIELDS (TREE_TYPE (x))
1066 = delete_duplicate_fields_1 (field, TYPE_FIELDS (TREE_TYPE (x)));
1067 if (TYPE_FIELDS (TREE_TYPE (x)) == 0)
1070 fields = TREE_CHAIN (fields);
1072 TREE_CHAIN (prev) = TREE_CHAIN (x);
1077 if (DECL_NAME (field) == DECL_NAME (x))
1079 if (TREE_CODE (field) == CONST_DECL
1080 && TREE_CODE (x) == CONST_DECL)
1081 cp_error_at ("duplicate enum value `%D'", x);
1082 else if (TREE_CODE (field) == CONST_DECL
1083 || TREE_CODE (x) == CONST_DECL)
1084 cp_error_at ("duplicate field `%D' (as enum and non-enum)",
1086 else if (TREE_CODE (field) == TYPE_DECL
1087 && TREE_CODE (x) == TYPE_DECL)
1088 cp_error_at ("duplicate nested type `%D'", x);
1089 else if (TREE_CODE (field) == TYPE_DECL
1090 || TREE_CODE (x) == TYPE_DECL)
1092 /* Hide tag decls. */
1093 if ((TREE_CODE (field) == TYPE_DECL
1094 && DECL_ARTIFICIAL (field))
1095 || (TREE_CODE (x) == TYPE_DECL
1096 && DECL_ARTIFICIAL (x)))
1098 cp_error_at ("duplicate field `%D' (as type and non-type)",
1102 cp_error_at ("duplicate member `%D'", x);
1104 fields = TREE_CHAIN (fields);
1106 TREE_CHAIN (prev) = TREE_CHAIN (x);
1115 delete_duplicate_fields (fields)
1119 for (x = fields; x && TREE_CHAIN (x); x = TREE_CHAIN (x))
1120 TREE_CHAIN (x) = delete_duplicate_fields_1 (x, TREE_CHAIN (x));
1123 /* Change the access of FDECL to ACCESS in T.
1124 Return 1 if change was legit, otherwise return 0. */
1126 alter_access (t, fdecl, access)
1131 tree elem = purpose_member (t, DECL_ACCESS (fdecl));
1132 if (elem && TREE_VALUE (elem) != access)
1134 if (TREE_CODE (TREE_TYPE (fdecl)) == FUNCTION_DECL)
1136 cp_error_at ("conflicting access specifications for method `%D', ignored", TREE_TYPE (fdecl));
1139 error ("conflicting access specifications for field `%s', ignored",
1140 IDENTIFIER_POINTER (DECL_NAME (fdecl)));
1142 else if (TREE_PRIVATE (fdecl))
1144 if (access != access_private_node)
1145 cp_error_at ("cannot make private `%D' non-private", fdecl);
1148 else if (TREE_PROTECTED (fdecl))
1150 if (access != access_protected_node)
1151 cp_error_at ("cannot make protected `%D' non-protected", fdecl);
1154 /* ARM 11.3: an access declaration may not be used to restrict access
1155 to a member that is accessible in the base class. */
1156 else if (access != access_public_node)
1157 cp_error_at ("cannot reduce access of public member `%D'", fdecl);
1158 else if (elem == NULL_TREE)
1161 DECL_ACCESS (fdecl) = tree_cons (t, access, DECL_ACCESS (fdecl));
1167 /* Return the offset to the main vtable for a given base BINFO. */
1169 get_vfield_offset (binfo)
1172 return size_binop (PLUS_EXPR,
1173 size_binop (FLOOR_DIV_EXPR,
1174 DECL_FIELD_BITPOS (CLASSTYPE_VFIELD (BINFO_TYPE (binfo))),
1175 size_int (BITS_PER_UNIT)),
1176 BINFO_OFFSET (binfo));
1179 /* Get the offset to the start of the original binfo that we derived
1180 this binfo from. If we find TYPE first, return the offset only
1181 that far. The shortened search is useful because the this pointer
1182 on method calling is expected to point to a DECL_CONTEXT (fndecl)
1183 object, and not a baseclass of it. */
1185 get_derived_offset (binfo, type)
1188 tree offset1 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
1191 while (BINFO_BASETYPES (binfo)
1192 && (i=CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1)
1194 tree binfos = BINFO_BASETYPES (binfo);
1195 if (BINFO_TYPE (binfo) == type)
1197 binfo = TREE_VEC_ELT (binfos, i);
1199 offset2 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo)));
1200 return size_binop (MINUS_EXPR, offset1, offset2);
1203 /* If FOR_TYPE needs to reinitialize virtual function table pointers
1204 for TYPE's sub-objects, add such reinitializations to BASE_INIT_LIST.
1205 Returns BASE_INIT_LIST appropriately modified. */
1208 maybe_fixup_vptrs (for_type, binfo, base_init_list)
1209 tree for_type, binfo, base_init_list;
1211 /* Now reinitialize any slots that don't fall under our virtual
1212 function table pointer. */
1213 tree vfields = CLASSTYPE_VFIELDS (BINFO_TYPE (binfo));
1216 tree basetype = VF_NORMAL_VALUE (vfields)
1217 ? TYPE_MAIN_VARIANT (VF_NORMAL_VALUE (vfields))
1218 : VF_BASETYPE_VALUE (vfields);
1220 tree base_binfo = get_binfo (basetype, for_type, 0);
1221 /* Punt until this is implemented. */
1222 if (1 /* BINFO_MODIFIED (base_binfo) */)
1224 tree base_offset = get_vfield_offset (base_binfo);
1225 if (! tree_int_cst_equal (base_offset, get_vfield_offset (TYPE_BINFO (for_type)))
1226 && ! tree_int_cst_equal (base_offset, get_vfield_offset (binfo)))
1227 base_init_list = tree_cons (error_mark_node, base_binfo,
1230 vfields = TREE_CHAIN (vfields);
1232 return base_init_list;
1235 /* If TYPE does not have a constructor, then the compiler must
1236 manually deal with all of the initialization this type requires.
1238 If a base initializer exists only to fill in the virtual function
1239 table pointer, then we mark that fact with the TREE_VIRTUAL bit.
1240 This way, we avoid multiple initializations of the same field by
1241 each virtual function table up the class hierarchy.
1243 Virtual base class pointers are not initialized here. They are
1244 initialized only at the "top level" of object creation. If we
1245 initialized them here, we would have to skip a lot of work. */
1248 build_class_init_list (type)
1251 tree base_init_list = NULL_TREE;
1252 tree member_init_list = NULL_TREE;
1254 /* Since we build member_init_list and base_init_list using
1255 tree_cons, backwards fields the all through work. */
1257 tree binfos = BINFO_BASETYPES (TYPE_BINFO (type));
1258 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1260 for (x = TYPE_FIELDS (type); x; x = TREE_CHAIN (x))
1262 if (TREE_CODE (x) != FIELD_DECL)
1265 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (x))
1266 || DECL_INITIAL (x) != NULL_TREE)
1267 member_init_list = tree_cons (x, type, member_init_list);
1269 member_init_list = nreverse (member_init_list);
1271 /* We will end up doing this last. Need special marker
1272 to avoid infinite regress. */
1273 if (TYPE_VIRTUAL_P (type))
1275 base_init_list = build_tree_list (error_mark_node, TYPE_BINFO (type));
1276 if (CLASSTYPE_NEEDS_VIRTUAL_REINIT (type) == 0)
1277 TREE_VALUE (base_init_list) = NULL_TREE;
1278 TREE_ADDRESSABLE (base_init_list) = 1;
1281 /* Each base class which needs to have initialization
1282 of some kind gets to make such requests known here. */
1283 for (i = n_baseclasses-1; i >= 0; i--)
1285 tree base_binfo = TREE_VEC_ELT (binfos, i);
1288 /* Don't initialize virtual baseclasses this way. */
1289 if (TREE_VIA_VIRTUAL (base_binfo))
1292 if (TYPE_HAS_CONSTRUCTOR (BINFO_TYPE (base_binfo)))
1294 /* ...and the last shall come first... */
1295 base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
1296 base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
1300 if ((blist = CLASSTYPE_BASE_INIT_LIST (BINFO_TYPE (base_binfo))) == NULL_TREE)
1301 /* Nothing to initialize. */
1305 base_init_list = maybe_fixup_vptrs (type, base_binfo, base_init_list);
1307 /* This is normally true for single inheritance.
1308 The win is we can shrink the chain of initializations
1309 to be done by only converting to the actual type
1310 we are interested in. */
1311 if (TREE_VALUE (blist)
1312 && TREE_CODE (TREE_VALUE (blist)) == TREE_VEC
1313 && tree_int_cst_equal (BINFO_OFFSET (base_binfo),
1314 BINFO_OFFSET (TREE_VALUE (blist))))
1318 /* Does it do more than just fill in a
1319 virtual function table pointer? */
1320 if (! TREE_ADDRESSABLE (blist))
1321 base_init_list = build_tree_list (blist, base_init_list);
1322 /* Can we get by just with the virtual function table
1323 pointer that it fills in? */
1324 else if (TREE_ADDRESSABLE (base_init_list)
1325 && TREE_VALUE (base_init_list) == 0)
1326 base_init_list = blist;
1327 /* Maybe, but it is not obvious as the previous case. */
1328 else if (! CLASSTYPE_NEEDS_VIRTUAL_REINIT (type))
1330 tree last = tree_last (base_init_list);
1331 while (TREE_VALUE (last)
1332 && TREE_CODE (TREE_VALUE (last)) == TREE_LIST)
1333 last = tree_last (TREE_VALUE (last));
1334 if (TREE_VALUE (last) == 0)
1335 base_init_list = build_tree_list (blist, base_init_list);
1339 base_init_list = blist;
1343 /* The function expand_aggr_init knows how to do the
1344 initialization of `basetype' without getting
1345 an explicit `blist'. */
1347 base_init_list = tree_cons (NULL_TREE, base_binfo, base_init_list);
1349 base_init_list = CLASSTYPE_BINFO_AS_LIST (BINFO_TYPE (base_binfo));
1354 if (member_init_list)
1355 CLASSTYPE_BASE_INIT_LIST (type) = build_tree_list (base_init_list, member_init_list);
1357 CLASSTYPE_BASE_INIT_LIST (type) = base_init_list;
1358 else if (member_init_list)
1359 CLASSTYPE_BASE_INIT_LIST (type) = member_init_list;
1365 int max_has_virtual;
1369 char cant_have_default_ctor;
1370 char cant_have_const_ctor;
1371 char cant_synth_copy_ctor;
1372 char cant_synth_asn_ref;
1373 char no_const_asn_ref;
1374 char needs_virtual_dtor;
1377 /* Record information about type T derived from its base classes.
1378 Store most of that information in T itself, and place the
1379 remaining information in the struct BASE_INFO.
1381 Propagate basetype offsets throughout the lattice. Note that the
1382 lattice topped by T is really a pair: it's a DAG that gives the
1383 structure of the derivation hierarchy, and it's a list of the
1384 virtual baseclasses that appear anywhere in the DAG. When a vbase
1385 type appears in the DAG, it's offset is 0, and it's children start
1386 their offsets from that point. When a vbase type appears in the list,
1387 its offset is the offset it has in the hierarchy, and its children's
1388 offsets include that offset in theirs.
1390 Returns the index of the first base class to have virtual functions,
1391 or -1 if no such base class.
1393 Note that at this point TYPE_BINFO (t) != t_binfo. */
1396 finish_base_struct (t, b, t_binfo)
1398 struct base_info *b;
1401 tree binfos = BINFO_BASETYPES (t_binfo);
1402 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
1403 int first_vfn_base_index = -1;
1404 bzero ((char *) b, sizeof (struct base_info));
1406 for (i = 0; i < n_baseclasses; i++)
1408 tree base_binfo = TREE_VEC_ELT (binfos, i);
1409 tree basetype = BINFO_TYPE (base_binfo);
1411 /* If the type of basetype is incomplete, then
1412 we already complained about that fact
1413 (and we should have fixed it up as well). */
1414 if (TYPE_SIZE (basetype) == 0)
1417 /* The base type is of incomplete type. It is
1418 probably best to pretend that it does not
1420 if (i == n_baseclasses-1)
1421 TREE_VEC_ELT (binfos, i) = NULL_TREE;
1422 TREE_VEC_LENGTH (binfos) -= 1;
1424 for (j = i; j+1 < n_baseclasses; j++)
1425 TREE_VEC_ELT (binfos, j) = TREE_VEC_ELT (binfos, j+1);
1428 if (TYPE_HAS_INIT_REF (basetype)
1429 && !TYPE_HAS_CONST_INIT_REF (basetype))
1430 b->cant_have_const_ctor = 1;
1431 if (! TYPE_HAS_INIT_REF (basetype)
1432 || (TYPE_HAS_NONPUBLIC_CTOR (basetype) == 2
1433 && ! is_friend_type (t, basetype)))
1434 b->cant_synth_copy_ctor = 1;
1436 if (TYPE_HAS_CONSTRUCTOR (basetype)
1437 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (basetype))
1439 b->cant_have_default_ctor = 1;
1440 if (! TYPE_HAS_CONSTRUCTOR (t))
1442 cp_pedwarn ("base `%T' with only non-default constructor",
1444 cp_pedwarn ("in class without a constructor");
1448 if (TYPE_HAS_ASSIGN_REF (basetype)
1449 && !TYPE_HAS_CONST_ASSIGN_REF (basetype))
1450 b->no_const_asn_ref = 1;
1451 if (! TYPE_HAS_ASSIGN_REF (basetype)
1452 || TYPE_HAS_ABSTRACT_ASSIGN_REF (basetype)
1453 || (TYPE_HAS_NONPUBLIC_ASSIGN_REF (basetype) == 2
1454 && ! is_friend_type (t, basetype)))
1455 b->cant_synth_asn_ref = 1;
1457 b->n_ancestors += CLASSTYPE_N_SUPERCLASSES (basetype);
1458 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (basetype);
1459 TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (basetype);
1460 TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (basetype);
1461 TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (basetype);
1463 TYPE_OVERLOADS_CALL_EXPR (t) |= TYPE_OVERLOADS_CALL_EXPR (basetype);
1464 TYPE_OVERLOADS_ARRAY_REF (t) |= TYPE_OVERLOADS_ARRAY_REF (basetype);
1465 TYPE_OVERLOADS_ARROW (t) |= TYPE_OVERLOADS_ARROW (basetype);
1467 if (! TREE_VIA_VIRTUAL (base_binfo)
1469 /* This cannot be done, as prepare_fresh_vtable wants to modify
1470 binfos associated with vfields anywhere in the hierarchy, not
1471 just immediate base classes. Due to unsharing, the compiler
1472 might consume 3% more memory on a real program.
1474 && ! BINFO_OFFSET_ZEROP (base_binfo)
1476 && BINFO_BASETYPES (base_binfo))
1478 tree base_binfos = BINFO_BASETYPES (base_binfo);
1479 tree chain = NULL_TREE;
1482 /* Now unshare the structure beneath BASE_BINFO. */
1483 for (j = TREE_VEC_LENGTH (base_binfos)-1;
1486 tree base_base_binfo = TREE_VEC_ELT (base_binfos, j);
1487 if (! TREE_VIA_VIRTUAL (base_base_binfo))
1488 TREE_VEC_ELT (base_binfos, j)
1489 = make_binfo (BINFO_OFFSET (base_base_binfo),
1491 BINFO_VTABLE (base_base_binfo),
1492 BINFO_VIRTUALS (base_base_binfo),
1494 chain = TREE_VEC_ELT (base_binfos, j);
1495 TREE_VIA_PUBLIC (chain) = TREE_VIA_PUBLIC (base_base_binfo);
1496 TREE_VIA_PROTECTED (chain) = TREE_VIA_PROTECTED (base_base_binfo);
1497 BINFO_INHERITANCE_CHAIN (chain) = base_binfo;
1500 /* Completely unshare potentially shared data, and
1501 update what is ours. */
1502 propagate_binfo_offsets (base_binfo, BINFO_OFFSET (base_binfo));
1505 if (! TREE_VIA_VIRTUAL (base_binfo))
1506 CLASSTYPE_N_SUPERCLASSES (t) += 1;
1508 if (TYPE_VIRTUAL_P (basetype))
1510 /* If there's going to be a destructor needed, make
1511 sure it will be virtual. */
1512 b->needs_virtual_dtor = 1;
1514 /* Don't borrow virtuals from virtual baseclasses. */
1515 if (TREE_VIA_VIRTUAL (base_binfo))
1518 if (first_vfn_base_index < 0)
1521 first_vfn_base_index = i;
1523 /* Update these two, now that we know what vtable we are
1524 going to extend. This is so that we can add virtual
1525 functions, and override them properly. */
1526 BINFO_VTABLE (t_binfo) = TYPE_BINFO_VTABLE (basetype);
1527 BINFO_VIRTUALS (t_binfo) = TYPE_BINFO_VIRTUALS (basetype);
1528 b->has_virtual = CLASSTYPE_VSIZE (basetype);
1529 b->vfield = CLASSTYPE_VFIELD (basetype);
1530 b->vfields = copy_list (CLASSTYPE_VFIELDS (basetype));
1531 vfields = b->vfields;
1534 if (VF_BINFO_VALUE (vfields) == NULL_TREE
1535 || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1537 tree value = VF_BASETYPE_VALUE (vfields);
1538 if (DECL_NAME (CLASSTYPE_VFIELD (value))
1539 == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1540 VF_NORMAL_VALUE (b->vfields) = basetype;
1542 VF_NORMAL_VALUE (b->vfields) = VF_NORMAL_VALUE (vfields);
1544 vfields = TREE_CHAIN (vfields);
1546 CLASSTYPE_VFIELD (t) = b->vfield;
1550 /* Only add unique vfields, and flatten them out as we go. */
1551 tree vfields = CLASSTYPE_VFIELDS (basetype);
1554 if (VF_BINFO_VALUE (vfields) == NULL_TREE
1555 || ! TREE_VIA_VIRTUAL (VF_BINFO_VALUE (vfields)))
1557 tree value = VF_BASETYPE_VALUE (vfields);
1558 b->vfields = tree_cons (base_binfo, value, b->vfields);
1559 if (DECL_NAME (CLASSTYPE_VFIELD (value))
1560 == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1561 VF_NORMAL_VALUE (b->vfields) = basetype;
1563 VF_NORMAL_VALUE (b->vfields) = VF_NORMAL_VALUE (vfields);
1565 vfields = TREE_CHAIN (vfields);
1568 if (b->has_virtual == 0)
1570 first_vfn_base_index = i;
1572 /* Update these two, now that we know what vtable we are
1573 going to extend. This is so that we can add virtual
1574 functions, and override them properly. */
1575 BINFO_VTABLE (t_binfo) = TYPE_BINFO_VTABLE (basetype);
1576 BINFO_VIRTUALS (t_binfo) = TYPE_BINFO_VIRTUALS (basetype);
1577 b->has_virtual = CLASSTYPE_VSIZE (basetype);
1578 b->vfield = CLASSTYPE_VFIELD (basetype);
1579 CLASSTYPE_VFIELD (t) = b->vfield;
1580 /* When we install the first one, set the VF_NORMAL_VALUE
1581 to be the current class, as this it is the most derived
1582 class. Hopefully, this is not set to something else
1584 vfields = b->vfields;
1587 if (DECL_NAME (CLASSTYPE_VFIELD (t))
1588 == DECL_NAME (CLASSTYPE_VFIELD (basetype)))
1590 VF_NORMAL_VALUE (vfields) = t;
1591 /* There should only be one of them! And it should
1592 always be found, if we get into here. (mrs) */
1595 vfields = TREE_CHAIN (vfields);
1602 /* Must come after offsets are fixed for all bases. */
1603 for (i = 0; i < n_baseclasses; i++)
1605 tree base_binfo = TREE_VEC_ELT (binfos, i);
1606 tree basetype = BINFO_TYPE (base_binfo);
1608 if (get_base_distance (basetype, t_binfo, 0, (tree*)0) == -2)
1610 cp_warning ("direct base `%T' inaccessible in `%T' due to ambiguity",
1612 b->cant_synth_asn_ref = 1;
1613 b->cant_synth_copy_ctor = 1;
1617 tree v = get_vbase_types (t_binfo);
1619 for (; v; v = TREE_CHAIN (v))
1621 tree basetype = BINFO_TYPE (v);
1622 if (get_base_distance (basetype, t_binfo, 0, (tree*)0) == -2)
1625 cp_warning ("virtual base `%T' inaccessible in `%T' due to ambiguity",
1627 b->cant_synth_asn_ref = 1;
1628 b->cant_synth_copy_ctor = 1;
1635 /* Find the base class with the largest number of virtual functions. */
1636 for (vfields = b->vfields; vfields; vfields = TREE_CHAIN (vfields))
1638 if (CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields)) > b->max_has_virtual)
1639 b->max_has_virtual = CLASSTYPE_VSIZE (VF_BASETYPE_VALUE (vfields));
1640 if (VF_DERIVED_VALUE (vfields)
1641 && CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields)) > b->max_has_virtual)
1642 b->max_has_virtual = CLASSTYPE_VSIZE (VF_DERIVED_VALUE (vfields));
1647 /* If all virtual functions come only from virtual baseclasses. */
1649 return first_vfn_base_index;
1653 typecode_p (type, code)
1655 enum tree_code code;
1657 return (TREE_CODE (type) == code
1658 || (TREE_CODE (type) == REFERENCE_TYPE
1659 && TREE_CODE (TREE_TYPE (type)) == code));
1662 /* Set memoizing fields and bits of T (and its variants) for later use.
1663 MAX_HAS_VIRTUAL is the largest size of any T's virtual function tables. */
1665 finish_struct_bits (t, max_has_virtual)
1667 int max_has_virtual;
1669 int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1671 /* Fix up variants (if any). */
1672 tree variants = TYPE_NEXT_VARIANT (t);
1675 /* These fields are in the _TYPE part of the node, not in
1676 the TYPE_LANG_SPECIFIC component, so they are not shared. */
1677 TYPE_HAS_CONSTRUCTOR (variants) = TYPE_HAS_CONSTRUCTOR (t);
1678 TYPE_HAS_DESTRUCTOR (variants) = TYPE_HAS_DESTRUCTOR (t);
1679 TYPE_NEEDS_CONSTRUCTING (variants) = TYPE_NEEDS_CONSTRUCTING (t);
1680 TYPE_NEEDS_DESTRUCTOR (variants) = TYPE_NEEDS_DESTRUCTOR (t);
1682 TYPE_USES_COMPLEX_INHERITANCE (variants) = TYPE_USES_COMPLEX_INHERITANCE (t);
1683 TYPE_VIRTUAL_P (variants) = TYPE_VIRTUAL_P (t);
1684 TYPE_USES_VIRTUAL_BASECLASSES (variants) = TYPE_USES_VIRTUAL_BASECLASSES (t);
1685 /* Copy whatever these are holding today. */
1686 TYPE_MIN_VALUE (variants) = TYPE_MIN_VALUE (t);
1687 TYPE_MAX_VALUE (variants) = TYPE_MAX_VALUE (t);
1688 TYPE_FIELDS (variants) = TYPE_FIELDS (t);
1689 variants = TYPE_NEXT_VARIANT (variants);
1692 if (n_baseclasses && max_has_virtual)
1694 /* Done by `finish_struct' for classes without baseclasses. */
1695 int might_have_abstract_virtuals = CLASSTYPE_ABSTRACT_VIRTUALS (t) != 0;
1696 tree binfos = TYPE_BINFO_BASETYPES (t);
1697 for (i = n_baseclasses-1; i >= 0; i--)
1699 might_have_abstract_virtuals
1700 |= (CLASSTYPE_ABSTRACT_VIRTUALS (BINFO_TYPE (TREE_VEC_ELT (binfos, i))) != 0);
1701 if (might_have_abstract_virtuals)
1704 if (might_have_abstract_virtuals)
1706 /* We use error_mark_node from override_one_vtable to signal
1707 an artificial abstract. */
1708 if (CLASSTYPE_ABSTRACT_VIRTUALS (t) == error_mark_node)
1709 CLASSTYPE_ABSTRACT_VIRTUALS (t) = NULL_TREE;
1710 CLASSTYPE_ABSTRACT_VIRTUALS (t) = get_abstract_virtuals (t);
1716 /* Notice whether this class has type conversion functions defined. */
1717 tree binfo = TYPE_BINFO (t);
1718 tree binfos = BINFO_BASETYPES (binfo);
1721 for (i = n_baseclasses-1; i >= 0; i--)
1723 basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i));
1725 if (TYPE_HAS_CONVERSION (basetype))
1727 TYPE_HAS_CONVERSION (t) = 1;
1728 TYPE_HAS_INT_CONVERSION (t) |= TYPE_HAS_INT_CONVERSION (basetype);
1729 TYPE_HAS_REAL_CONVERSION (t) |= TYPE_HAS_REAL_CONVERSION (basetype);
1731 if (CLASSTYPE_MAX_DEPTH (basetype) >= CLASSTYPE_MAX_DEPTH (t))
1732 CLASSTYPE_MAX_DEPTH (t) = CLASSTYPE_MAX_DEPTH (basetype) + 1;
1736 /* If this type has a copy constructor, force its mode to be BLKmode, and
1737 force its TREE_ADDRESSABLE bit to be nonzero. This will cause it to
1738 be passed by invisible reference and prevent it from being returned in
1741 Also do this if the class has BLKmode but can still be returned in
1742 registers, since function_cannot_inline_p won't let us inline
1743 functions returning such a type. This affects the HP-PA. */
1744 if (! TYPE_HAS_TRIVIAL_INIT_REF (t)
1745 || (TYPE_MODE (t) == BLKmode && ! aggregate_value_p (t)
1746 && CLASSTYPE_NON_AGGREGATE (t)))
1749 if (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
1750 DECL_MODE (TYPE_NAME (t)) = BLKmode;
1751 for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
1753 TYPE_MODE (variants) = BLKmode;
1754 TREE_ADDRESSABLE (variants) = 1;
1759 /* Add FN to the method_vec growing on the class_obstack. Used by
1760 finish_struct_methods. */
1762 grow_method (fn, method_vec_ptr)
1764 tree *method_vec_ptr;
1766 tree method_vec = (tree)obstack_base (&class_obstack);
1767 tree *testp = &TREE_VEC_ELT (method_vec, 0);
1768 if (*testp == NULL_TREE)
1770 while (((HOST_WIDE_INT) testp
1771 < (HOST_WIDE_INT) obstack_next_free (&class_obstack))
1772 && DECL_NAME (*testp) != DECL_NAME (fn))
1774 if ((HOST_WIDE_INT) testp
1775 < (HOST_WIDE_INT) obstack_next_free (&class_obstack))
1779 for (x = *testp; x; x = DECL_CHAIN (x))
1781 if (DECL_NAME (fn) == ansi_opname[(int) DELETE_EXPR]
1782 || DECL_NAME (fn) == ansi_opname[(int) VEC_DELETE_EXPR])
1784 /* ANSI C++ June 5 1992 WP 12.5.5.1 */
1785 cp_error_at ("`%D' overloaded", fn);
1786 cp_error_at ("previous declaration as `%D' here", x);
1788 if (DECL_ASSEMBLER_NAME (fn)==DECL_ASSEMBLER_NAME (x))
1790 /* We complain about multiple destructors on sight,
1791 so we do not repeat the warning here. Friend-friend
1792 ambiguities are warned about outside this loop. */
1793 if (!DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fn)))
1794 cp_error_at ("ambiguous method `%#D' in structure", fn);
1802 DECL_CHAIN (prev_x) = fn;
1809 obstack_ptr_grow (&class_obstack, fn);
1810 *method_vec_ptr = (tree)obstack_base (&class_obstack);
1814 /* Warn about duplicate methods in fn_fields. Also compact method
1815 lists so that lookup can be made faster.
1817 Algorithm: Outer loop builds lists by method name. Inner loop
1818 checks for redundant method names within a list.
1820 Data Structure: List of method lists. The outer list is a
1821 TREE_LIST, whose TREE_PURPOSE field is the field name and the
1822 TREE_VALUE is the DECL_CHAIN of the FUNCTION_DECLs. TREE_CHAIN
1823 links the entire list of methods for TYPE_METHODS. Friends are
1824 chained in the same way as member functions (? TREE_CHAIN or
1825 DECL_CHAIN), but they live in the TREE_TYPE field of the outer
1826 list. That allows them to be quickly deleted, and requires no
1829 If there are any constructors/destructors, they are moved to the
1830 front of the list. This makes pushclass more efficient.
1832 We also link each field which has shares a name with its baseclass
1833 to the head of the list of fields for that base class. This allows
1834 us to reduce search time in places like `build_method_call' to
1835 consider only reasonably likely functions. */
1838 finish_struct_methods (t, fn_fields, nonprivate_method)
1841 int nonprivate_method;
1844 tree save_fn_fields = fn_fields;
1845 tree name = constructor_name (t);
1846 int i, n_baseclasses = CLASSTYPE_N_BASECLASSES (t);
1848 /* Now prepare to gather fn_fields into vector. */
1849 struct obstack *ambient_obstack = current_obstack;
1850 current_obstack = &class_obstack;
1851 method_vec = make_node (TREE_VEC);
1852 /* Room has been saved for constructors and destructors. */
1853 current_obstack = ambient_obstack;
1854 /* Now make this a live vector. */
1855 obstack_free (&class_obstack, method_vec);
1856 obstack_blank (&class_obstack, sizeof (struct tree_vec));
1858 /* First fill in entry 0 with the constructors, and the next few with
1859 type conversion operators (if any). */
1861 for (; fn_fields; fn_fields = TREE_CHAIN (fn_fields))
1863 tree fn_name = DECL_NAME (fn_fields);
1864 if (fn_name == NULL_TREE)
1867 /* Clear out this flag.
1869 @@ Doug may figure out how to break
1870 @@ this with nested classes and friends. */
1871 DECL_IN_AGGR_P (fn_fields) = 0;
1873 /* Note here that a copy ctor is private, so we don't dare generate
1874 a default copy constructor for a class that has a member
1875 of this type without making sure they have access to it. */
1876 if (fn_name == name)
1878 tree parmtypes = FUNCTION_ARG_CHAIN (fn_fields);
1879 tree parmtype = parmtypes ? TREE_VALUE (parmtypes) : void_type_node;
1881 if (TREE_CODE (parmtype) == REFERENCE_TYPE
1882 && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == t)
1884 if (TREE_CHAIN (parmtypes) == NULL_TREE
1885 || TREE_CHAIN (parmtypes) == void_list_node
1886 || TREE_PURPOSE (TREE_CHAIN (parmtypes)))
1888 if (TREE_PROTECTED (fn_fields))
1889 TYPE_HAS_NONPUBLIC_CTOR (t) = 1;
1890 else if (TREE_PRIVATE (fn_fields))
1891 TYPE_HAS_NONPUBLIC_CTOR (t) = 2;
1894 /* Constructors are handled easily in search routines. */
1895 DECL_CHAIN (fn_fields) = TREE_VEC_ELT (method_vec, 0);
1896 TREE_VEC_ELT (method_vec, 0) = fn_fields;
1898 else if (IDENTIFIER_TYPENAME_P (fn_name))
1900 tree return_type = TREE_TYPE (TREE_TYPE (fn_fields));
1902 if (typecode_p (return_type, INTEGER_TYPE)
1903 || typecode_p (return_type, BOOLEAN_TYPE)
1904 || typecode_p (return_type, ENUMERAL_TYPE))
1905 TYPE_HAS_INT_CONVERSION (t) = 1;
1906 else if (typecode_p (return_type, REAL_TYPE))
1907 TYPE_HAS_REAL_CONVERSION (t) = 1;
1909 grow_method (fn_fields, &method_vec);
1913 fn_fields = save_fn_fields;
1914 for (; fn_fields; fn_fields = TREE_CHAIN (fn_fields))
1916 tree fn_name = DECL_NAME (fn_fields);
1917 if (fn_name == NULL_TREE)
1920 if (fn_name == name || IDENTIFIER_TYPENAME_P (fn_name))
1923 if (fn_name == ansi_opname[(int) MODIFY_EXPR])
1925 tree parmtype = TREE_VALUE (FUNCTION_ARG_CHAIN (fn_fields));
1927 if (copy_assignment_arg_p (parmtype, DECL_VIRTUAL_P (fn_fields)))
1929 if (TREE_PROTECTED (fn_fields))
1930 TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 1;
1931 else if (TREE_PRIVATE (fn_fields))
1932 TYPE_HAS_NONPUBLIC_ASSIGN_REF (t) = 2;
1936 grow_method (fn_fields, &method_vec);
1939 TREE_VEC_LENGTH (method_vec) = (tree *)obstack_next_free (&class_obstack)
1940 - (&TREE_VEC_ELT (method_vec, 0));
1941 obstack_finish (&class_obstack);
1942 CLASSTYPE_METHOD_VEC (t) = method_vec;
1944 if (nonprivate_method == 0
1945 && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
1946 && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
1948 tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
1949 for (i = 0; i < n_baseclasses; i++)
1950 if (TREE_VIA_PUBLIC (TREE_VEC_ELT (binfos, i))
1951 || TREE_VIA_PROTECTED (TREE_VEC_ELT (binfos, i)))
1953 nonprivate_method = 1;
1956 if (nonprivate_method == 0)
1957 cp_warning ("all member functions in class `%T' are private", t);
1960 /* If there are constructors (and destructors), they are at the
1961 front. Place destructors at very front. Also warn if all
1962 constructors and/or destructors are private (in which case this
1963 class is effectively unusable. */
1964 if (TYPE_HAS_DESTRUCTOR (t))
1968 for (dtor = TREE_VEC_ELT (method_vec, 0);
1970 prev = dtor, dtor = DECL_CHAIN (dtor))
1972 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (dtor)))
1974 if (TREE_PRIVATE (dtor)
1975 && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
1976 && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE
1977 && warn_ctor_dtor_privacy)
1978 cp_warning ("`%#T' only defines a private destructor and has no friends",
1984 /* Wild parse errors can cause this to happen. */
1985 if (dtor == NULL_TREE)
1986 TYPE_HAS_DESTRUCTOR (t) = 0;
1987 else if (dtor != TREE_VEC_ELT (method_vec, 0))
1989 DECL_CHAIN (prev) = DECL_CHAIN (dtor);
1990 DECL_CHAIN (dtor) = TREE_VEC_ELT (method_vec, 0);
1991 TREE_VEC_ELT (method_vec, 0) = dtor;
1995 /* Now for each member function (except for constructors and
1996 destructors), compute where member functions of the same
1997 name reside in base classes. */
1998 if (n_baseclasses != 0
1999 && TREE_VEC_LENGTH (method_vec) > 1)
2001 int len = TREE_VEC_LENGTH (method_vec);
2002 tree baselink_vec = make_tree_vec (len);
2004 tree baselink_binfo = build_tree_list (NULL_TREE, TYPE_BINFO (t));
2006 for (i = 1; i < len; i++)
2008 TREE_VEC_ELT (baselink_vec, i)
2009 = get_baselinks (baselink_binfo, t, DECL_NAME (TREE_VEC_ELT (method_vec, i)));
2010 if (TREE_VEC_ELT (baselink_vec, i) != 0)
2014 CLASSTYPE_BASELINK_VEC (t) = baselink_vec;
2016 obstack_free (current_obstack, baselink_vec);
2020 /* Now add the methods to the TYPE_METHODS of T, arranged in a chain. */
2022 tree x, last_x = NULL_TREE;
2023 int limit = TREE_VEC_LENGTH (method_vec);
2025 for (i = 1; i < limit; i++)
2027 for (x = TREE_VEC_ELT (method_vec, i); x; x = DECL_CHAIN (x))
2029 if (last_x != NULL_TREE)
2030 TREE_CHAIN (last_x) = x;
2035 /* Put ctors and dtors at the front of the list. */
2036 x = TREE_VEC_ELT (method_vec, 0);
2039 while (DECL_CHAIN (x))
2041 /* Let's avoid being circular about this. */
2042 if (x == DECL_CHAIN (x))
2044 TREE_CHAIN (x) = DECL_CHAIN (x);
2047 if (TREE_VEC_LENGTH (method_vec) > 1)
2048 TREE_CHAIN (x) = TREE_VEC_ELT (method_vec, 1);
2050 TREE_CHAIN (x) = NULL_TREE;
2054 TYPE_METHODS (t) = method_vec;
2060 /* Emit error when a duplicate definition of a type is seen. Patch up. */
2063 duplicate_tag_error (t)
2066 cp_error ("redefinition of `%#T'", t);
2067 cp_error_at ("previous definition here", t);
2069 /* Pretend we haven't defined this type. */
2071 /* All of the component_decl's were TREE_CHAINed together in the parser.
2072 finish_struct_methods walks these chains and assembles all methods with
2073 the same base name into DECL_CHAINs. Now we don't need the parser chains
2074 anymore, so we unravel them.
2077 * This used to be in finish_struct, but it turns out that the
2078 * TREE_CHAIN is used by dbxout_type_methods and perhaps some other things...
2080 if (CLASSTYPE_METHOD_VEC(t))
2082 tree tv = CLASSTYPE_METHOD_VEC(t);
2083 int i, len = TREE_VEC_LENGTH (tv);
2084 for (i = 0; i < len; i++)
2086 tree unchain = TREE_VEC_ELT (tv, i);
2087 while (unchain != NULL_TREE)
2089 TREE_CHAIN (unchain) = NULL_TREE;
2090 unchain = DECL_CHAIN(unchain);
2095 if (TYPE_LANG_SPECIFIC (t))
2097 tree as_list = CLASSTYPE_AS_LIST (t);
2098 tree binfo = TYPE_BINFO (t);
2099 tree binfo_as_list = CLASSTYPE_BINFO_AS_LIST (t);
2100 int interface_only = CLASSTYPE_INTERFACE_ONLY (t);
2101 int interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (t);
2103 bzero ((char *) TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type));
2104 BINFO_BASETYPES(binfo) = NULL_TREE;
2106 CLASSTYPE_AS_LIST (t) = as_list;
2107 TYPE_BINFO (t) = binfo;
2108 CLASSTYPE_BINFO_AS_LIST (t) = binfo_as_list;
2109 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
2110 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
2111 CLASSTYPE_VBASE_SIZE (t) = integer_zero_node;
2112 TYPE_REDEFINED (t) = 1;
2114 TYPE_SIZE (t) = NULL_TREE;
2115 TYPE_MODE (t) = VOIDmode;
2116 TYPE_FIELDS (t) = NULL_TREE;
2117 TYPE_METHODS (t) = NULL_TREE;
2118 TYPE_VFIELD (t) = NULL_TREE;
2119 TYPE_CONTEXT (t) = NULL_TREE;
2122 /* finish up all new vtables. */
2124 finish_vtbls (binfo, do_self, t)
2128 tree binfos = BINFO_BASETYPES (binfo);
2129 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2131 /* Should we use something besides CLASSTYPE_VFIELDS? */
2132 if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2134 if (BINFO_NEW_VTABLE_MARKED (binfo))
2138 decl = BINFO_VTABLE (binfo);
2139 context = DECL_CONTEXT (decl);
2140 DECL_CONTEXT (decl) = 0;
2141 if (write_virtuals >= 0
2142 && DECL_INITIAL (decl) != BINFO_VIRTUALS (binfo))
2143 DECL_INITIAL (decl) = build_nt (CONSTRUCTOR, NULL_TREE,
2144 BINFO_VIRTUALS (binfo));
2145 cp_finish_decl (decl, DECL_INITIAL (decl), NULL_TREE, 0, 0);
2146 DECL_CONTEXT (decl) = context;
2148 CLEAR_BINFO_NEW_VTABLE_MARKED (binfo);
2151 for (i = 0; i < n_baselinks; i++)
2153 tree base_binfo = TREE_VEC_ELT (binfos, i);
2154 int is_not_base_vtable =
2155 i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2156 if (TREE_VIA_VIRTUAL (base_binfo))
2158 base_binfo = binfo_member (BINFO_TYPE (base_binfo), CLASSTYPE_VBASECLASSES (t));
2160 finish_vtbls (base_binfo, is_not_base_vtable, t);
2164 /* True if we should override the given BASE_FNDECL with the given
2167 overrides (fndecl, base_fndecl)
2168 tree fndecl, base_fndecl;
2170 /* Destructors have special names. */
2171 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl)) &&
2172 DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
2174 if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (base_fndecl)) ||
2175 DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl)))
2177 if (DECL_NAME (fndecl) == DECL_NAME (base_fndecl))
2179 tree types, base_types;
2181 retypes = TREE_TYPE (TREE_TYPE (fndecl));
2182 base_retypes = TREE_TYPE (TREE_TYPE (base_fndecl));
2184 types = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2185 base_types = TYPE_ARG_TYPES (TREE_TYPE (base_fndecl));
2186 if ((TYPE_READONLY (TREE_TYPE (TREE_VALUE (base_types)))
2187 == TYPE_READONLY (TREE_TYPE (TREE_VALUE (types))))
2188 && compparms (TREE_CHAIN (base_types), TREE_CHAIN (types), 3))
2195 get_class_offset_1 (parent, binfo, context, t, fndecl)
2196 tree parent, binfo, context, t, fndecl;
2198 tree binfos = BINFO_BASETYPES (binfo);
2199 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2200 tree rval = NULL_TREE;
2202 if (binfo == parent)
2203 return error_mark_node;
2205 for (i = 0; i < n_baselinks; i++)
2207 tree base_binfo = TREE_VEC_ELT (binfos, i);
2210 if (TREE_VIA_VIRTUAL (base_binfo))
2211 base_binfo = binfo_member (BINFO_TYPE (base_binfo),
2212 CLASSTYPE_VBASECLASSES (t));
2213 nrval = get_class_offset_1 (parent, base_binfo, context, t, fndecl);
2214 /* See if we have a new value */
2215 if (nrval && (nrval != error_mark_node || rval==0))
2217 /* Only compare if we have two offsets */
2218 if (rval && rval != error_mark_node
2219 && ! tree_int_cst_equal (nrval, rval))
2221 /* Only give error if the two offsets are different */
2222 error ("every virtual function must have a unique final overrider");
2223 cp_error (" found two (or more) `%T' class subobjects in `%T'", context, t);
2224 cp_error (" with virtual `%D' from virtual base class", fndecl);
2230 if (rval && BINFO_TYPE (binfo) == context)
2232 my_friendly_assert (rval == error_mark_node
2233 || tree_int_cst_equal (rval, BINFO_OFFSET (binfo)), 999);
2234 rval = BINFO_OFFSET (binfo);
2240 /* Get the offset to the CONTEXT subobject that is related to the
2243 get_class_offset (context, t, binfo, fndecl)
2244 tree context, t, binfo, fndecl;
2246 tree first_binfo = binfo;
2251 return integer_zero_node;
2253 if (BINFO_TYPE (binfo) == context)
2254 return BINFO_OFFSET (binfo);
2256 /* Check less derived binfos first. */
2257 while (BINFO_BASETYPES (binfo)
2258 && (i=CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1)
2260 tree binfos = BINFO_BASETYPES (binfo);
2261 binfo = TREE_VEC_ELT (binfos, i);
2262 if (BINFO_TYPE (binfo) == context)
2263 return BINFO_OFFSET (binfo);
2266 /* Ok, not found in the less derived binfos, now check the more
2268 offset = get_class_offset_1 (first_binfo, TYPE_BINFO (t), context, t, fndecl);
2269 if (offset==0 || TREE_CODE (offset) != INTEGER_CST)
2270 my_friendly_abort (999); /* we have to find it. */
2274 /* Skip RTTI information at the front of the virtual list. */
2275 unsigned HOST_WIDE_INT
2276 skip_rtti_stuff (virtuals)
2284 /* We always reserve a slot for the offset/tdesc entry. */
2286 *virtuals = TREE_CHAIN (*virtuals);
2288 if (flag_vtable_thunks && *virtuals)
2290 /* The second slot is reserved for the tdesc pointer when thunks
2293 *virtuals = TREE_CHAIN (*virtuals);
2299 modify_one_vtable (binfo, t, fndecl, pfn)
2300 tree binfo, t, fndecl, pfn;
2302 tree virtuals = BINFO_VIRTUALS (binfo);
2303 unsigned HOST_WIDE_INT n;
2305 /* update rtti entry */
2308 if (binfo == TYPE_BINFO (t))
2310 if (! BINFO_NEW_VTABLE_MARKED (binfo))
2311 build_vtable (TYPE_BINFO (DECL_CONTEXT (CLASSTYPE_VFIELD (t))), t);
2315 if (! BINFO_NEW_VTABLE_MARKED (binfo))
2316 prepare_fresh_vtable (binfo, t);
2319 if (fndecl == NULL_TREE)
2322 n = skip_rtti_stuff (&virtuals);
2326 tree current_fndecl = TREE_VALUE (virtuals);
2327 current_fndecl = FNADDR_FROM_VTABLE_ENTRY (current_fndecl);
2328 current_fndecl = TREE_OPERAND (current_fndecl, 0);
2329 if (current_fndecl && overrides (fndecl, current_fndecl))
2331 tree base_offset, offset;
2332 tree context = DECL_CLASS_CONTEXT (fndecl);
2333 tree vfield = CLASSTYPE_VFIELD (t);
2336 offset = get_class_offset (context, t, binfo, fndecl);
2338 /* Find the right offset for the this pointer based on the
2339 base class we just found. We have to take into
2340 consideration the virtual base class pointers that we
2341 stick in before the virtual function table pointer.
2343 Also, we want just the delta between the most base class
2344 that we derived this vfield from and us. */
2345 base_offset = size_binop (PLUS_EXPR,
2346 get_derived_offset (binfo, DECL_CONTEXT (current_fndecl)),
2347 BINFO_OFFSET (binfo));
2348 this_offset = size_binop (MINUS_EXPR, offset, base_offset);
2350 /* Make sure we can modify the derived association with immunity. */
2351 if (TREE_USED (binfo))
2352 my_friendly_assert (0, 999);
2354 if (binfo == TYPE_BINFO (t))
2356 /* In this case, it is *type*'s vtable we are modifying.
2357 We start with the approximation that it's vtable is that
2358 of the immediate base class. */
2359 if (! BINFO_NEW_VTABLE_MARKED (binfo))
2360 build_vtable (TYPE_BINFO (DECL_CONTEXT (vfield)), t);
2364 /* This is our very own copy of `basetype' to play with.
2365 Later, we will fill in all the virtual functions
2366 that override the virtual functions in these base classes
2367 which are not defined by the current type. */
2368 if (! BINFO_NEW_VTABLE_MARKED (binfo))
2369 prepare_fresh_vtable (binfo, t);
2373 cp_warning ("in %D", DECL_NAME (BINFO_VTABLE (binfo)));
2375 modify_vtable_entry (get_vtable_entry_n (BINFO_VIRTUALS (binfo), n),
2376 build_vtable_entry (this_offset, pfn),
2380 virtuals = TREE_CHAIN (virtuals);
2384 /* These are the ones that are not through virtual base classes. */
2386 modify_all_direct_vtables (binfo, do_self, t, fndecl, pfn)
2387 tree binfo, t, fndecl, pfn;
2390 tree binfos = BINFO_BASETYPES (binfo);
2391 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2393 /* Should we use something besides CLASSTYPE_VFIELDS? */
2394 if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2396 modify_one_vtable (binfo, t, fndecl, pfn);
2399 for (i = 0; i < n_baselinks; i++)
2401 tree base_binfo = TREE_VEC_ELT (binfos, i);
2402 int is_not_base_vtable =
2403 i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2404 if (! TREE_VIA_VIRTUAL (base_binfo))
2405 modify_all_direct_vtables (base_binfo, is_not_base_vtable, t, fndecl, pfn);
2409 /* Fixup all the delta entries in this one vtable that need updating. */
2411 fixup_vtable_deltas1 (binfo, t)
2414 tree virtuals = BINFO_VIRTUALS (binfo);
2415 unsigned HOST_WIDE_INT n;
2417 n = skip_rtti_stuff (&virtuals);
2421 tree fndecl = TREE_VALUE (virtuals);
2422 tree pfn = FNADDR_FROM_VTABLE_ENTRY (fndecl);
2423 tree delta = DELTA_FROM_VTABLE_ENTRY (fndecl);
2424 fndecl = TREE_OPERAND (pfn, 0);
2427 tree base_offset, offset;
2428 tree context = DECL_CLASS_CONTEXT (fndecl);
2429 tree vfield = CLASSTYPE_VFIELD (t);
2432 offset = get_class_offset (context, t, binfo, fndecl);
2434 /* Find the right offset for the this pointer based on the
2435 base class we just found. We have to take into
2436 consideration the virtual base class pointers that we
2437 stick in before the virtual function table pointer.
2439 Also, we want just the delta between the most base class
2440 that we derived this vfield from and us. */
2441 base_offset = size_binop (PLUS_EXPR,
2442 get_derived_offset (binfo, DECL_CONTEXT (fndecl)),
2443 BINFO_OFFSET (binfo));
2444 this_offset = size_binop (MINUS_EXPR, offset, base_offset);
2446 if (! tree_int_cst_equal (this_offset, delta))
2448 /* Make sure we can modify the derived association with immunity. */
2449 if (TREE_USED (binfo))
2450 my_friendly_assert (0, 999);
2452 if (binfo == TYPE_BINFO (t))
2454 /* In this case, it is *type*'s vtable we are modifying.
2455 We start with the approximation that it's vtable is that
2456 of the immediate base class. */
2457 if (! BINFO_NEW_VTABLE_MARKED (binfo))
2458 build_vtable (TYPE_BINFO (DECL_CONTEXT (vfield)), t);
2462 /* This is our very own copy of `basetype' to play with.
2463 Later, we will fill in all the virtual functions
2464 that override the virtual functions in these base classes
2465 which are not defined by the current type. */
2466 if (! BINFO_NEW_VTABLE_MARKED (binfo))
2467 prepare_fresh_vtable (binfo, t);
2470 modify_vtable_entry (get_vtable_entry_n (BINFO_VIRTUALS (binfo), n),
2471 build_vtable_entry (this_offset, pfn),
2476 virtuals = TREE_CHAIN (virtuals);
2480 /* Fixup all the delta entries in all the direct vtables that need updating.
2481 This happens when we have non-overridden virtual functions from a
2482 virtual base class, that are at a different offset, in the new
2483 hierarchy, because the layout of the virtual bases has changed. */
2485 fixup_vtable_deltas (binfo, init_self, t)
2489 tree binfos = BINFO_BASETYPES (binfo);
2490 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2492 for (i = 0; i < n_baselinks; i++)
2494 tree base_binfo = TREE_VEC_ELT (binfos, i);
2495 int is_not_base_vtable =
2496 i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2497 if (! TREE_VIA_VIRTUAL (base_binfo))
2498 fixup_vtable_deltas (base_binfo, is_not_base_vtable, t);
2500 /* Should we use something besides CLASSTYPE_VFIELDS? */
2501 if (init_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2503 fixup_vtable_deltas1 (binfo, t);
2507 /* These are the ones that are through virtual base classes. */
2509 modify_all_indirect_vtables (binfo, do_self, via_virtual, t, fndecl, pfn)
2510 tree binfo, t, fndecl, pfn;
2511 int do_self, via_virtual;
2513 tree binfos = BINFO_BASETYPES (binfo);
2514 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2516 /* Should we use something besides CLASSTYPE_VFIELDS? */
2517 if (do_self && via_virtual && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2519 modify_one_vtable (binfo, t, fndecl, pfn);
2522 for (i = 0; i < n_baselinks; i++)
2524 tree base_binfo = TREE_VEC_ELT (binfos, i);
2525 int is_not_base_vtable =
2526 i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2527 if (TREE_VIA_VIRTUAL (base_binfo))
2530 base_binfo = binfo_member (BINFO_TYPE (base_binfo), CLASSTYPE_VBASECLASSES (t));
2532 modify_all_indirect_vtables (base_binfo, is_not_base_vtable, via_virtual, t, fndecl, pfn);
2537 modify_all_vtables (t, fndecl, vfn)
2538 tree t, fndecl, vfn;
2540 /* Do these first, so that we will make use of any non-virtual class's
2541 vtable, over a virtual classes vtable. */
2542 modify_all_direct_vtables (TYPE_BINFO (t), 1, t, fndecl, vfn);
2543 if (TYPE_USES_VIRTUAL_BASECLASSES (t))
2544 modify_all_indirect_vtables (TYPE_BINFO (t), 1, 0, t, fndecl, vfn);
2547 /* Here, we already know that they match in every respect.
2548 All we have to check is where they had their declarations. */
2550 strictly_overrides (fndecl1, fndecl2)
2551 tree fndecl1, fndecl2;
2553 int distance = get_base_distance (DECL_CLASS_CONTEXT (fndecl2),
2554 DECL_CLASS_CONTEXT (fndecl1),
2556 if (distance == -2 || distance > 0)
2561 /* Merge overrides for one vtable.
2562 If we want to merge in same function, we are fine.
2564 if one has a DECL_CLASS_CONTEXT that is a parent of the
2565 other, than choose the more derived one
2567 potentially ill-formed (see 10.3 [class.virtual])
2568 we have to check later to see if there was an
2569 override in this class. If there was ok, if not
2570 then it is ill-formed. (mrs)
2572 We take special care to reuse a vtable, if we can. */
2574 override_one_vtable (binfo, old, t)
2577 tree virtuals = BINFO_VIRTUALS (binfo);
2578 tree old_virtuals = BINFO_VIRTUALS (old);
2579 enum { REUSE_NEW, REUSE_OLD, UNDECIDED, NEITHER } choose = UNDECIDED;
2581 /* If we have already committed to modifying it, then don't try and
2582 reuse another vtable. */
2583 if (BINFO_NEW_VTABLE_MARKED (binfo))
2586 skip_rtti_stuff (&virtuals);
2587 skip_rtti_stuff (&old_virtuals);
2591 tree fndecl = TREE_VALUE (virtuals);
2592 tree old_fndecl = TREE_VALUE (old_virtuals);
2593 fndecl = FNADDR_FROM_VTABLE_ENTRY (fndecl);
2594 old_fndecl = FNADDR_FROM_VTABLE_ENTRY (old_fndecl);
2595 fndecl = TREE_OPERAND (fndecl, 0);
2596 old_fndecl = TREE_OPERAND (old_fndecl, 0);
2597 /* First check to see if they are the same. */
2598 if (DECL_ASSEMBLER_NAME (fndecl) == DECL_ASSEMBLER_NAME (old_fndecl))
2600 /* No need to do anything. */
2602 else if (strictly_overrides (fndecl, old_fndecl))
2604 if (choose == UNDECIDED)
2606 else if (choose == REUSE_OLD)
2609 if (! BINFO_NEW_VTABLE_MARKED (binfo))
2611 prepare_fresh_vtable (binfo, t);
2612 override_one_vtable (binfo, old, t);
2617 else if (strictly_overrides (old_fndecl, fndecl))
2619 if (choose == UNDECIDED)
2621 else if (choose == REUSE_NEW)
2624 if (! BINFO_NEW_VTABLE_MARKED (binfo))
2626 prepare_fresh_vtable (binfo, t);
2627 override_one_vtable (binfo, old, t);
2630 TREE_VALUE (virtuals) = TREE_VALUE (old_virtuals);
2632 else if (choose == NEITHER)
2634 TREE_VALUE (virtuals) = TREE_VALUE (old_virtuals);
2640 if (! BINFO_NEW_VTABLE_MARKED (binfo))
2642 prepare_fresh_vtable (binfo, t);
2643 override_one_vtable (binfo, old, t);
2647 /* This MUST be overridden, or the class is ill-formed. */
2648 /* For now, we just make it abstract. */
2649 tree fndecl = TREE_OPERAND (FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals)), 0);
2652 fndecl = copy_node (fndecl);
2653 copy_lang_decl (fndecl);
2654 DECL_ABSTRACT_VIRTUAL_P (fndecl) = 1;
2655 /* Make sure we search for it later. */
2656 if (! CLASSTYPE_ABSTRACT_VIRTUALS (t))
2657 CLASSTYPE_ABSTRACT_VIRTUALS (t) = error_mark_node;
2659 vfn = build1 (ADDR_EXPR, vfunc_ptr_type_node, fndecl);
2660 TREE_CONSTANT (vfn) = 1;
2662 /* We can use integer_zero_node, as we will will core dump
2663 if this is used anyway. */
2664 TREE_VALUE (virtuals) = build_vtable_entry (integer_zero_node, vfn);
2667 virtuals = TREE_CHAIN (virtuals);
2668 old_virtuals = TREE_CHAIN (old_virtuals);
2671 /* Let's reuse the old vtable. */
2672 if (choose == REUSE_OLD)
2674 BINFO_VTABLE (binfo) = BINFO_VTABLE (old);
2675 BINFO_VIRTUALS (binfo) = BINFO_VIRTUALS (old);
2679 /* Merge in overrides for virtual bases.
2680 BINFO is the hierarchy we want to modify, and OLD has the potential
2683 merge_overrides (binfo, old, do_self, t)
2687 tree binfos = BINFO_BASETYPES (binfo);
2688 tree old_binfos = BINFO_BASETYPES (old);
2689 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2691 /* Should we use something besides CLASSTYPE_VFIELDS? */
2692 if (do_self && CLASSTYPE_VFIELDS (BINFO_TYPE (binfo)))
2694 override_one_vtable (binfo, old, t);
2697 for (i = 0; i < n_baselinks; i++)
2699 tree base_binfo = TREE_VEC_ELT (binfos, i);
2700 tree old_base_binfo = TREE_VEC_ELT (old_binfos, i);
2701 int is_not_base_vtable =
2702 i != CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo));
2703 if (! TREE_VIA_VIRTUAL (base_binfo))
2704 merge_overrides (base_binfo, old_base_binfo, is_not_base_vtable, t);
2708 /* Get the base virtual function declarations in T that are either
2709 overridden or hidden by FNDECL as a list. We set TREE_PURPOSE with
2710 the overrider/hider. */
2712 get_basefndecls (fndecl, t)
2715 tree methods = TYPE_METHODS (t);
2716 tree base_fndecls = NULL_TREE;
2717 tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
2718 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2722 if (TREE_CODE (methods) == FUNCTION_DECL
2723 && DECL_VINDEX (methods) != NULL_TREE
2724 && DECL_NAME (fndecl) == DECL_NAME (methods))
2725 base_fndecls = temp_tree_cons (fndecl, methods, base_fndecls);
2727 methods = TREE_CHAIN (methods);
2731 return base_fndecls;
2733 for (i = 0; i < n_baseclasses; i++)
2735 tree base_binfo = TREE_VEC_ELT (binfos, i);
2736 tree basetype = BINFO_TYPE (base_binfo);
2738 base_fndecls = chainon (get_basefndecls (fndecl, basetype),
2742 return base_fndecls;
2745 /* Mark the functions that have been hidden with their overriders.
2746 Since we start out with all functions already marked with a hider,
2747 no need to mark functions that are just hidden. */
2749 mark_overriders (fndecl, base_fndecls)
2750 tree fndecl, base_fndecls;
2752 while (base_fndecls)
2754 if (overrides (TREE_VALUE (base_fndecls), fndecl))
2755 TREE_PURPOSE (base_fndecls) = fndecl;
2757 base_fndecls = TREE_CHAIN (base_fndecls);
2761 /* If this declaration supersedes the declaration of
2762 a method declared virtual in the base class, then
2763 mark this field as being virtual as well. */
2766 check_for_override (decl, ctype)
2769 tree binfos = BINFO_BASETYPES (TYPE_BINFO (ctype));
2770 int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2771 int virtualp = DECL_VIRTUAL_P (decl);
2773 for (i = 0; i < n_baselinks; i++)
2775 tree base_binfo = TREE_VEC_ELT (binfos, i);
2776 if (TYPE_VIRTUAL_P (BINFO_TYPE (base_binfo))
2777 || flag_all_virtual == 1)
2779 tree tmp = get_matching_virtual
2781 DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl)));
2784 /* If this function overrides some virtual in some base
2785 class, then the function itself is also necessarily
2786 virtual, even if the user didn't explicitly say so. */
2787 DECL_VIRTUAL_P (decl) = 1;
2789 /* The TMP we really want is the one from the deepest
2790 baseclass on this path, taking care not to
2791 duplicate if we have already found it (via another
2792 path to its virtual baseclass. */
2793 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
2795 cp_error_at ("method `%D' may not be declared static",
2797 cp_error_at ("(since `%D' declared virtual in base class.)",
2804 /* The argument types may have changed... */
2805 tree type = TREE_TYPE (decl);
2806 tree argtypes = TYPE_ARG_TYPES (type);
2807 tree base_variant = TREE_TYPE (TREE_VALUE (argtypes));
2808 tree raises = TYPE_RAISES_EXCEPTIONS (type);
2810 argtypes = commonparms (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (tmp))),
2811 TREE_CHAIN (argtypes));
2812 /* But the return type has not. */
2813 type = build_cplus_method_type (base_variant, TREE_TYPE (type), argtypes);
2815 type = build_exception_variant (type, raises);
2816 TREE_TYPE (decl) = type;
2818 = tree_cons (NULL_TREE, tmp, DECL_VINDEX (decl));
2826 if (DECL_VINDEX (decl) == NULL_TREE)
2827 DECL_VINDEX (decl) = error_mark_node;
2828 IDENTIFIER_VIRTUAL_P (DECL_NAME (decl)) = 1;
2832 /* Warn about hidden virtual functions that are not overridden in t. */
2837 tree method_vec = CLASSTYPE_METHOD_VEC (t);
2838 int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
2841 /* We go through each separately named virtual function. */
2842 for (i = 1; i < n_methods; ++i)
2844 tree fndecl = TREE_VEC_ELT (method_vec, i);
2846 tree base_fndecls = NULL_TREE;
2847 tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
2848 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
2850 if (DECL_VINDEX (fndecl) == NULL_TREE)
2853 /* First we get a list of all possible functions that might be
2854 hidden from each base class. */
2855 for (i = 0; i < n_baseclasses; i++)
2857 tree base_binfo = TREE_VEC_ELT (binfos, i);
2858 tree basetype = BINFO_TYPE (base_binfo);
2860 base_fndecls = chainon (get_basefndecls (fndecl, basetype),
2864 if (TREE_CHAIN (fndecl)
2865 && DECL_NAME (TREE_CHAIN (fndecl)) == DECL_NAME (fndecl))
2866 fndecl = TREE_CHAIN (fndecl);
2870 /* ...then mark up all the base functions with overriders, preferring
2871 overriders to hiders. */
2875 mark_overriders (fndecl, base_fndecls);
2877 if (TREE_CHAIN (fndecl)
2878 && DECL_NAME (TREE_CHAIN (fndecl)) == DECL_NAME (fndecl))
2879 fndecl = TREE_CHAIN (fndecl);
2884 /* Now give a warning for all base functions without overriders,
2885 as they are hidden. */
2886 while (base_fndecls)
2888 if (! overrides (TREE_VALUE (base_fndecls),
2889 TREE_PURPOSE (base_fndecls)))
2891 /* Here we know it is a hider, and no overrider exists. */
2892 cp_warning_at ("`%D' was hidden", TREE_VALUE (base_fndecls));
2893 cp_warning_at (" by `%D'", TREE_PURPOSE (base_fndecls));
2896 base_fndecls = TREE_CHAIN (base_fndecls);
2901 /* Check for things that are invalid. There are probably plenty of other
2902 things we should check for also. */
2904 finish_struct_anon (t)
2908 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
2910 if (TREE_STATIC (field))
2912 if (TREE_CODE (field) != FIELD_DECL)
2915 if (DECL_NAME (field) == NULL_TREE
2916 && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
2918 tree* uelt = &TYPE_FIELDS (TREE_TYPE (field));
2919 for (; *uelt; uelt = &TREE_CHAIN (*uelt))
2921 if (TREE_CODE (*uelt) != FIELD_DECL)
2924 if (TREE_PRIVATE (*uelt))
2925 cp_pedwarn_at ("private member `%#D' in anonymous union",
2927 else if (TREE_PROTECTED (*uelt))
2928 cp_pedwarn_at ("protected member `%#D' in anonymous union",
2935 extern int interface_only, interface_unknown;
2937 /* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration
2938 (or C++ class declaration).
2940 For C++, we must handle the building of derived classes.
2941 Also, C++ allows static class members. The way that this is
2942 handled is to keep the field name where it is (as the DECL_NAME
2943 of the field), and place the overloaded decl in the DECL_FIELD_BITPOS
2944 of the field. layout_record and layout_union will know about this.
2946 More C++ hair: inline functions have text in their
2947 DECL_PENDING_INLINE_INFO nodes which must somehow be parsed into
2948 meaningful tree structure. After the struct has been laid out, set
2949 things up so that this can happen.
2951 And still more: virtual functions. In the case of single inheritance,
2952 when a new virtual function is seen which redefines a virtual function
2953 from the base class, the new virtual function is placed into
2954 the virtual function table at exactly the same address that
2955 it had in the base class. When this is extended to multiple
2956 inheritance, the same thing happens, except that multiple virtual
2957 function tables must be maintained. The first virtual function
2958 table is treated in exactly the same way as in the case of single
2959 inheritance. Additional virtual function tables have different
2960 DELTAs, which tell how to adjust `this' to point to the right thing.
2962 LIST_OF_FIELDLISTS is just that. The elements of the list are
2963 TREE_LIST elements, whose TREE_PURPOSE field tells what access
2964 the list has, and the TREE_VALUE slot gives the actual fields.
2966 ATTRIBUTES is the set of decl attributes to be applied, if any.
2968 If flag_all_virtual == 1, then we lay all functions into
2969 the virtual function table, as though they were declared
2970 virtual. Constructors do not lay down in the virtual function table.
2972 If flag_all_virtual == 2, then we lay all functions into
2973 the virtual function table, such that virtual functions
2974 occupy a space by themselves, and then all functions
2975 of the class occupy a space by themselves. This is illustrated
2976 in the following diagram:
2978 class A; class B : A;
2980 Class A's vtbl: Class B's vtbl:
2981 --------------------------------------------------------------------
2982 | A's virtual functions| | B's virtual functions |
2983 | | | (may inherit some from A). |
2984 --------------------------------------------------------------------
2985 | All of A's functions | | All of A's functions |
2986 | (such as a->A::f). | | (such as b->A::f) |
2987 --------------------------------------------------------------------
2988 | B's new virtual functions |
2989 | (not defined in A.) |
2990 -------------------------------
2991 | All of B's functions |
2992 | (such as b->B::f) |
2993 -------------------------------
2995 this allows the program to make references to any function, virtual
2996 or otherwise in a type-consistent manner. */
2999 finish_struct_1 (t, attributes, warn_anon)
3004 tree name = TYPE_IDENTIFIER (t);
3005 enum tree_code code = TREE_CODE (t);
3006 tree fields = TYPE_FIELDS (t);
3007 tree fn_fields = TYPE_METHODS (t);
3008 tree x, last_x, method_vec;
3009 int needs_virtual_dtor;
3012 int max_has_virtual;
3013 tree pending_virtuals = NULL_TREE;
3014 tree abstract_virtuals = NULL_TREE;
3017 int cant_have_default_ctor;
3018 int cant_have_const_ctor;
3019 int cant_synth_copy_ctor;
3020 int cant_synth_asn_ref;
3021 int no_const_asn_ref;
3023 /* The index of the first base class which has virtual
3024 functions. Only applied to non-virtual baseclasses. */
3025 int first_vfn_base_index;
3028 int any_default_members = 0;
3029 int const_sans_init = 0;
3030 int ref_sans_init = 0;
3031 int nonprivate_method = 0;
3032 tree t_binfo = TYPE_BINFO (t);
3033 tree access_decls = NULL_TREE;
3036 if (warn_anon && code != UNION_TYPE && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
3037 pedwarn ("anonymous class type not used to declare any objects");
3041 if (IS_AGGR_TYPE (t))
3042 cp_error ("redefinition of `%#T'", t);
3044 my_friendly_abort (172);
3049 if (dont_allow_type_definitions)
3051 pedwarn ("types cannot be defined %s",
3052 dont_allow_type_definitions);
3055 GNU_xref_decl (current_function_decl, t);
3057 /* If this type was previously laid out as a forward reference,
3058 make sure we lay it out again. */
3060 TYPE_SIZE (t) = NULL_TREE;
3061 CLASSTYPE_GOT_SEMICOLON (t) = 0;
3063 cplus_decl_attributes (t, attributes, NULL_TREE);
3066 /* This is in general too late to do this. I moved the main case up to
3067 left_curly, what else needs to move? */
3068 if (! IS_SIGNATURE (t))
3070 my_friendly_assert (CLASSTYPE_INTERFACE_ONLY (t) == interface_only, 999);
3071 my_friendly_assert (CLASSTYPE_INTERFACE_KNOWN (t) == ! interface_unknown, 999);
3077 build_t_desc (t, 0);
3080 TYPE_BINFO (t) = NULL_TREE;
3082 old = suspend_momentary ();
3084 /* Install struct as DECL_FIELD_CONTEXT of each field decl.
3085 Also process specified field sizes.
3086 Set DECL_FIELD_SIZE to the specified size, or 0 if none specified.
3087 The specified size is found in the DECL_INITIAL.
3088 Store 0 there, except for ": 0" fields (so we can find them
3089 and delete them, below). */
3091 if (t_binfo && BINFO_BASETYPES (t_binfo))
3092 n_baseclasses = TREE_VEC_LENGTH (BINFO_BASETYPES (t_binfo));
3096 if (n_baseclasses > 0)
3098 struct base_info base_info;
3100 /* If using multiple inheritance, this may cause variants of our
3101 basetypes to be used (instead of their canonical forms). */
3102 tree vf = layout_basetypes (t, BINFO_BASETYPES (t_binfo));
3103 last_x = tree_last (vf);
3104 fields = chainon (vf, fields);
3106 first_vfn_base_index = finish_base_struct (t, &base_info, t_binfo);
3107 /* Remember where we got our vfield from */
3108 CLASSTYPE_VFIELD_PARENT (t) = first_vfn_base_index;
3109 has_virtual = base_info.has_virtual;
3110 max_has_virtual = base_info.max_has_virtual;
3111 CLASSTYPE_N_SUPERCLASSES (t) += base_info.n_ancestors;
3112 vfield = base_info.vfield;
3113 vfields = base_info.vfields;
3114 cant_have_default_ctor = base_info.cant_have_default_ctor;
3115 cant_have_const_ctor = base_info.cant_have_const_ctor;
3116 cant_synth_copy_ctor = base_info.cant_synth_copy_ctor;
3117 cant_synth_asn_ref = base_info.cant_synth_asn_ref;
3118 no_const_asn_ref = base_info.no_const_asn_ref;
3119 needs_virtual_dtor = base_info.needs_virtual_dtor;
3120 n_baseclasses = TREE_VEC_LENGTH (BINFO_BASETYPES (t_binfo));
3125 first_vfn_base_index = -1;
3127 max_has_virtual = has_virtual;
3129 vfields = NULL_TREE;
3131 cant_have_default_ctor = 0;
3132 cant_have_const_ctor = 0;
3133 cant_synth_copy_ctor = 0;
3134 cant_synth_asn_ref = 0;
3135 no_const_asn_ref = 0;
3136 needs_virtual_dtor = 0;
3140 /* Both of these should be done before now. */
3141 if (write_virtuals == 3 && CLASSTYPE_INTERFACE_KNOWN (t)
3142 && ! IS_SIGNATURE (t))
3144 my_friendly_assert (CLASSTYPE_INTERFACE_ONLY (t) == interface_only, 999);
3145 my_friendly_assert (CLASSTYPE_VTABLE_NEEDS_WRITING (t) == ! interface_only, 999);
3149 /* The three of these are approximations which may later be
3150 modified. Needed at this point to make add_virtual_function
3151 and modify_vtable_entries work. */
3152 TREE_CHAIN (t_binfo) = TYPE_BINFO (t);
3153 TYPE_BINFO (t) = t_binfo;
3154 CLASSTYPE_VFIELDS (t) = vfields;
3155 CLASSTYPE_VFIELD (t) = vfield;
3157 if (IS_SIGNATURE (t))
3159 else if (flag_all_virtual == 1 && TYPE_OVERLOADS_METHOD_CALL_EXPR (t))
3164 for (x = TYPE_METHODS (t); x; x = TREE_CHAIN (x))
3166 GNU_xref_member (current_class_name, x);
3168 nonprivate_method |= ! TREE_PRIVATE (x);
3170 /* If this was an evil function, don't keep it in class. */
3171 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
3174 DECL_CLASS_CONTEXT (x) = t;
3176 /* Do both of these, even though they're in the same union;
3177 if the insn `r' member and the size `i' member are
3178 different sizes, as on the alpha, the larger of the two
3179 will end up with garbage in it. */
3180 DECL_SAVED_INSNS (x) = NULL_RTX;
3181 DECL_FIELD_SIZE (x) = 0;
3183 check_for_override (x, t);
3184 if (DECL_ABSTRACT_VIRTUAL_P (x) && ! DECL_VINDEX (x))
3185 cp_error_at ("initializer specified for non-virtual method `%D'", x);
3187 /* The name of the field is the original field name
3188 Save this in auxiliary field for later overloading. */
3190 || (all_virtual == 1 && ! DECL_CONSTRUCTOR_P (x)))
3192 pending_virtuals = add_virtual_function (pending_virtuals,
3193 &has_virtual, x, t);
3194 if (DECL_ABSTRACT_VIRTUAL_P (x))
3195 abstract_virtuals = tree_cons (NULL_TREE, x, abstract_virtuals);
3197 /* XXX Why did I comment this out? (jason) */
3204 for (x = TYPE_FIELDS (t); x; x = TREE_CHAIN (x))
3206 GNU_xref_member (current_class_name, x);
3208 /* Handle access declarations. */
3209 if (TREE_CODE (x) == USING_DECL)
3211 tree ctype = DECL_INITIAL (x);
3212 tree sname = DECL_NAME (x);
3214 = TREE_PRIVATE (x) ? access_private_node :
3215 TREE_PROTECTED (x) ? access_protected_node : access_public_node;
3219 TREE_CHAIN (last_x) = TREE_CHAIN (x);
3221 fields = TREE_CHAIN (x);
3223 binfo = binfo_or_else (ctype, t);
3227 if (sname == constructor_name (ctype)
3228 || sname == constructor_name_full (ctype))
3229 cp_error_at ("using-declaration for constructor", x);
3231 fdecl = lookup_field (binfo, sname, 0, 0);
3233 fdecl = lookup_fnfields (binfo, sname, 0);
3236 access_decls = tree_cons (access, fdecl, access_decls);
3238 cp_error_at ("no members matching `%D' in `%#T'", x, ctype);
3244 if (TREE_CODE (x) == TYPE_DECL)
3247 /* If we've gotten this far, it's a data member, possibly static,
3248 or an enumerator. */
3250 DECL_FIELD_CONTEXT (x) = t;
3252 /* ``A local class cannot have static data members.'' ARM 9.4 */
3253 if (current_function_decl && TREE_STATIC (x))
3254 cp_error_at ("field `%D' in local class cannot be static", x);
3256 /* Perform error checking that did not get done in
3258 if (TREE_CODE (TREE_TYPE (x)) == FUNCTION_TYPE)
3260 cp_error_at ("field `%D' invalidly declared function type",
3262 TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
3264 else if (TREE_CODE (TREE_TYPE (x)) == METHOD_TYPE)
3266 cp_error_at ("field `%D' invalidly declared method type", x);
3267 TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
3269 else if (TREE_CODE (TREE_TYPE (x)) == OFFSET_TYPE)
3271 cp_error_at ("field `%D' invalidly declared offset type", x);
3272 TREE_TYPE (x) = build_pointer_type (TREE_TYPE (x));
3276 if (DECL_NAME (x) == constructor_name (t))
3277 cant_have_default_ctor = cant_synth_copy_ctor = 1;
3280 if (TREE_TYPE (x) == error_mark_node)
3283 DECL_SAVED_INSNS (x) = NULL_RTX;
3284 DECL_FIELD_SIZE (x) = 0;
3286 /* When this goes into scope, it will be a non-local reference. */
3287 DECL_NONLOCAL (x) = 1;
3289 if (TREE_CODE (x) == CONST_DECL)
3292 if (TREE_CODE (x) == VAR_DECL)
3294 if (TREE_CODE (t) == UNION_TYPE)
3295 /* Unions cannot have static members. */
3296 cp_error_at ("field `%D' declared static in union", x);
3301 /* Now it can only be a FIELD_DECL. */
3303 if (TREE_PRIVATE (x) || TREE_PROTECTED (x))
3306 /* If this is of reference type, check if it needs an init.
3307 Also do a little ANSI jig if necessary. */
3308 if (TREE_CODE (TREE_TYPE (x)) == REFERENCE_TYPE)
3310 if (DECL_INITIAL (x) == NULL_TREE)
3313 /* ARM $12.6.2: [A member initializer list] (or, for an
3314 aggregate, initialization by a brace-enclosed list) is the
3315 only way to initialize nonstatic const and reference
3317 cant_synth_asn_ref = 1;
3318 cant_have_default_ctor = 1;
3320 if (! TYPE_HAS_CONSTRUCTOR (t) && extra_warnings)
3323 cp_warning_at ("non-static reference `%#D' in class without a constructor", x);
3325 cp_warning_at ("non-static reference in class without a constructor", x);
3329 /* If any field is const, the structure type is pseudo-const. */
3330 if (TREE_READONLY (x))
3332 C_TYPE_FIELDS_READONLY (t) = 1;
3333 if (DECL_INITIAL (x) == NULL_TREE)
3334 const_sans_init = 1;
3336 /* ARM $12.6.2: [A member initializer list] (or, for an
3337 aggregate, initialization by a brace-enclosed list) is the
3338 only way to initialize nonstatic const and reference
3340 cant_synth_asn_ref = 1;
3341 cant_have_default_ctor = 1;
3343 if (! TYPE_HAS_CONSTRUCTOR (t) && !IS_SIGNATURE (t)
3347 cp_warning_at ("non-static const member `%#D' in class without a constructor", x);
3349 cp_warning_at ("non-static const member in class without a constructor", x);
3354 /* A field that is pseudo-const makes the structure
3356 tree t1 = TREE_TYPE (x);
3357 while (TREE_CODE (t1) == ARRAY_TYPE)
3358 t1 = TREE_TYPE (t1);
3359 if (IS_AGGR_TYPE (t1))
3361 if (C_TYPE_FIELDS_READONLY (t1))
3362 C_TYPE_FIELDS_READONLY (t) = 1;
3363 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (t1))
3364 const_sans_init = 1;
3368 /* We set DECL_BIT_FIELD tentatively in grokbitfield.
3369 If the type and width are valid, we'll keep it set.
3370 Otherwise, the flag is cleared. */
3371 if (DECL_BIT_FIELD (x))
3373 DECL_BIT_FIELD (x) = 0;
3374 /* Invalid bit-field size done by grokfield. */
3375 /* Detect invalid bit-field type. */
3376 if (DECL_INITIAL (x)
3377 && ! INTEGRAL_TYPE_P (TREE_TYPE (x)))
3379 cp_error_at ("bit-field `%#D' with non-integral type", x);
3380 DECL_INITIAL (x) = NULL;
3383 /* Detect and ignore out of range field width. */
3384 if (DECL_INITIAL (x))
3386 tree w = DECL_INITIAL (x);
3389 /* Avoid the non_lvalue wrapper added by fold for PLUS_EXPRs. */
3392 /* detect invalid field size. */
3393 if (TREE_CODE (w) == CONST_DECL)
3394 w = DECL_INITIAL (w);
3395 else if (TREE_READONLY_DECL_P (w))
3396 w = decl_constant_value (w);
3398 if (TREE_CODE (w) != INTEGER_CST)
3400 cp_error_at ("bit-field `%D' width not an integer constant",
3402 DECL_INITIAL (x) = NULL_TREE;
3404 else if (width = TREE_INT_CST_LOW (w),
3407 DECL_INITIAL (x) = NULL;
3408 cp_error_at ("negative width in bit-field `%D'", x);
3410 else if (width == 0 && DECL_NAME (x) != 0)
3412 DECL_INITIAL (x) = NULL;
3413 cp_error_at ("zero width for bit-field `%D'", x);
3416 > TYPE_PRECISION (long_long_unsigned_type_node))
3418 /* The backend will dump if you try to use something
3419 too big; avoid that. */
3420 DECL_INITIAL (x) = NULL;
3421 sorry ("bit-fields larger than %d bits",
3422 TYPE_PRECISION (long_long_unsigned_type_node));
3423 cp_error_at (" in declaration of `%D'", x);
3425 else if (width > TYPE_PRECISION (TREE_TYPE (x))
3426 && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
3428 cp_warning_at ("width of `%D' exceeds its type", x);
3430 else if (TREE_CODE (TREE_TYPE (x)) == ENUMERAL_TYPE
3431 && ((min_precision (TYPE_MIN_VALUE (TREE_TYPE (x)),
3432 TREE_UNSIGNED (TREE_TYPE (x))) > width)
3433 || (min_precision (TYPE_MAX_VALUE (TREE_TYPE (x)),
3434 TREE_UNSIGNED (TREE_TYPE (x))) > width)))
3436 cp_warning_at ("`%D' is too small to hold all values of `%#T'",
3441 /* Process valid field width. */
3442 if (DECL_INITIAL (x))
3444 register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
3448 #ifdef EMPTY_FIELD_BOUNDARY
3449 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), EMPTY_FIELD_BOUNDARY);
3451 #ifdef PCC_BITFIELD_TYPE_MATTERS
3452 DECL_ALIGN (x) = MAX (DECL_ALIGN (x),
3453 TYPE_ALIGN (TREE_TYPE (x)));
3458 DECL_INITIAL (x) = NULL_TREE;
3459 DECL_FIELD_SIZE (x) = width;
3460 DECL_BIT_FIELD (x) = 1;
3461 /* Traditionally a bit field is unsigned
3462 even if declared signed. */
3463 if (flag_traditional
3464 && TREE_CODE (TREE_TYPE (x)) == INTEGER_TYPE)
3465 TREE_TYPE (x) = unsigned_type_node;
3469 /* Non-bit-fields are aligned for their type. */
3470 DECL_ALIGN (x) = MAX (DECL_ALIGN (x), TYPE_ALIGN (TREE_TYPE (x)));
3474 tree type = TREE_TYPE (x);
3476 while (TREE_CODE (type) == ARRAY_TYPE)
3477 type = TREE_TYPE (type);
3479 if (TYPE_LANG_SPECIFIC (type) && ! ANON_UNION_P (x)
3480 && ! TYPE_PTRMEMFUNC_P (type))
3482 /* Never let anything with uninheritable virtuals
3483 make it through without complaint. */
3484 if (CLASSTYPE_ABSTRACT_VIRTUALS (type))
3485 abstract_virtuals_error (x, type);
3487 /* Don't let signatures make it through either. */
3488 if (IS_SIGNATURE (type))
3489 signature_error (x, type);
3491 if (code == UNION_TYPE)
3494 if (TYPE_NEEDS_CONSTRUCTING (type))
3495 fie = "constructor";
3496 else if (TYPE_NEEDS_DESTRUCTOR (type))
3498 else if (TYPE_HAS_REAL_ASSIGNMENT (type))
3499 fie = "assignment operator";
3501 cp_error_at ("member `%#D' with %s not allowed in union", x,
3506 TYPE_NEEDS_CONSTRUCTING (t) |= TYPE_NEEDS_CONSTRUCTING (type);
3507 TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_NEEDS_DESTRUCTOR (type);
3508 TYPE_HAS_COMPLEX_ASSIGN_REF (t) |= TYPE_HAS_COMPLEX_ASSIGN_REF (type);
3509 TYPE_HAS_COMPLEX_INIT_REF (t) |= TYPE_HAS_COMPLEX_INIT_REF (type);
3512 if (! TYPE_HAS_INIT_REF (type)
3513 || (TYPE_HAS_NONPUBLIC_CTOR (type)
3514 && ! is_friend (t, type)))
3515 cant_synth_copy_ctor = 1;
3516 else if (!TYPE_HAS_CONST_INIT_REF (type))
3517 cant_have_const_ctor = 1;
3519 if (! TYPE_HAS_ASSIGN_REF (type)
3520 || (TYPE_HAS_NONPUBLIC_ASSIGN_REF (type)
3521 && ! is_friend (t, type)))
3522 cant_synth_asn_ref = 1;
3523 else if (!TYPE_HAS_CONST_ASSIGN_REF (type))
3524 no_const_asn_ref = 1;
3526 if (TYPE_HAS_CONSTRUCTOR (type)
3527 && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
3529 cant_have_default_ctor = 1;
3531 /* This is wrong for aggregates. */
3532 if (! TYPE_HAS_CONSTRUCTOR (t))
3535 cp_pedwarn_at ("member `%#D' with only non-default constructor", x);
3537 cp_pedwarn_at ("member with only non-default constructor", x);
3538 cp_pedwarn_at ("in class without a constructor",
3544 if (DECL_INITIAL (x) != NULL_TREE)
3546 /* `build_class_init_list' does not recognize
3548 if (code == UNION_TYPE && any_default_members != 0)
3549 cp_error_at ("multiple fields in union `%T' initialized");
3550 any_default_members = 1;
3555 /* If this type has any constant members which did not come
3556 with their own initialization, mark that fact here. It is
3557 not an error here, since such types can be saved either by their
3558 constructors, or by fortuitous initialization. */
3559 CLASSTYPE_READONLY_FIELDS_NEED_INIT (t) = const_sans_init;
3560 CLASSTYPE_REF_FIELDS_NEED_INIT (t) = ref_sans_init;
3561 CLASSTYPE_ABSTRACT_VIRTUALS (t) = abstract_virtuals;
3563 /* Synthesize any needed methods. Note that methods will be synthesized
3564 for anonymous unions; grok_x_components undoes that. */
3567 nonprivate_method = 1;
3569 if (TYPE_NEEDS_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t)
3570 && !IS_SIGNATURE (t))
3572 /* Here we must cons up a destructor on the fly. */
3573 tree dtor = cons_up_default_function (t, name, needs_virtual_dtor != 0);
3574 check_for_override (dtor, t);
3576 /* If we couldn't make it work, then pretend we didn't need it. */
3577 if (dtor == void_type_node)
3578 TYPE_NEEDS_DESTRUCTOR (t) = 0;
3581 /* Link dtor onto end of fn_fields. */
3583 TREE_CHAIN (dtor) = fn_fields;
3586 if (DECL_VINDEX (dtor) == NULL_TREE
3587 && (needs_virtual_dtor
3588 || pending_virtuals != NULL_TREE
3589 || pending_hard_virtuals != NULL_TREE))
3590 DECL_VINDEX (dtor) = error_mark_node;
3591 if (DECL_VINDEX (dtor))
3592 pending_virtuals = add_virtual_function (pending_virtuals,
3593 &has_virtual, dtor, t);
3594 nonprivate_method = 1;
3598 TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t);
3599 if (flag_rtti && (max_has_virtual > 0 || needs_virtual_dtor) &&
3603 TYPE_HAS_COMPLEX_INIT_REF (t)
3604 |= (TYPE_HAS_INIT_REF (t) || TYPE_USES_VIRTUAL_BASECLASSES (t)
3605 || any_default_members);
3606 TYPE_NEEDS_CONSTRUCTING (t)
3607 |= (TYPE_HAS_CONSTRUCTOR (t) || TYPE_USES_VIRTUAL_BASECLASSES (t)
3608 || has_virtual || any_default_members || first_vfn_base_index >= 0);
3609 if (! IS_SIGNATURE (t))
3610 CLASSTYPE_NON_AGGREGATE (t)
3611 = ! aggregate || has_virtual || TYPE_HAS_CONSTRUCTOR (t);
3613 /* ARM $12.1: A default constructor will be generated for a class X
3614 only if no constructor has been declared for class X. So we
3615 check TYPE_HAS_CONSTRUCTOR also, to make sure we don't generate
3616 one if they declared a constructor in this class. */
3617 if (! TYPE_HAS_CONSTRUCTOR (t) && ! cant_have_default_ctor
3618 && ! IS_SIGNATURE (t))
3620 tree default_fn = cons_up_default_function (t, name, 2);
3621 TREE_CHAIN (default_fn) = fn_fields;
3622 fn_fields = default_fn;
3625 /* Create default copy constructor, if needed. */
3626 if (! TYPE_HAS_INIT_REF (t) && ! cant_synth_copy_ctor
3627 && ! IS_SIGNATURE (t))
3629 /* ARM 12.18: You get either X(X&) or X(const X&), but
3631 tree default_fn = cons_up_default_function (t, name,
3632 3 + cant_have_const_ctor);
3633 TREE_CHAIN (default_fn) = fn_fields;
3634 fn_fields = default_fn;
3637 TYPE_HAS_REAL_ASSIGNMENT (t) |= TYPE_HAS_ASSIGNMENT (t);
3638 TYPE_HAS_REAL_ASSIGN_REF (t) |= TYPE_HAS_ASSIGN_REF (t);
3639 TYPE_HAS_COMPLEX_ASSIGN_REF (t)
3640 |= TYPE_HAS_ASSIGN_REF (t) || TYPE_USES_VIRTUAL_BASECLASSES (t);
3642 if (! TYPE_HAS_ASSIGN_REF (t) && ! cant_synth_asn_ref
3643 && ! IS_SIGNATURE (t))
3645 tree default_fn = cons_up_default_function (t, name,
3646 5 + no_const_asn_ref);
3647 TREE_CHAIN (default_fn) = fn_fields;
3648 fn_fields = default_fn;
3653 method_vec = finish_struct_methods (t, fn_fields, nonprivate_method);
3655 if (TYPE_HAS_CONSTRUCTOR (t)
3656 && CLASSTYPE_FRIEND_CLASSES (t) == NULL_TREE
3657 && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE)
3659 int nonprivate_ctor = 0;
3662 for (ctor = TREE_VEC_ELT (method_vec, 0);
3664 ctor = DECL_CHAIN (ctor))
3665 if (! TREE_PRIVATE (ctor))
3667 nonprivate_ctor = 1;
3671 if (nonprivate_ctor == 0 && warn_ctor_dtor_privacy)
3672 cp_warning ("`%#T' only defines private constructors and has no friends",
3680 /* Just in case these got accidentally
3681 filled in by syntax errors. */
3682 TYPE_HAS_CONSTRUCTOR (t) = 0;
3683 TYPE_HAS_DESTRUCTOR (t) = 0;
3687 int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
3689 for (access_decls = nreverse (access_decls); access_decls;
3690 access_decls = TREE_CHAIN (access_decls))
3692 tree fdecl = TREE_VALUE (access_decls);
3693 tree flist = NULL_TREE;
3695 tree access = TREE_PURPOSE(access_decls);
3696 int i = TREE_VEC_ELT (method_vec, 0) ? 0 : 1;
3699 if (TREE_CODE (fdecl) == TREE_LIST)
3702 fdecl = TREE_VALUE (flist);
3705 name = DECL_NAME (fdecl);
3707 for (; i < n_methods; i++)
3708 if (DECL_NAME (TREE_VEC_ELT (method_vec, i)) == name)
3710 cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
3711 cp_error_at (" because of local method `%#D' with same name",
3712 TREE_VEC_ELT (method_vec, i));
3720 for (tmp = fields; tmp; tmp = TREE_CHAIN (tmp))
3721 if (DECL_NAME (tmp) == name)
3723 cp_error ("cannot adjust access to `%#D' in `%#T'", fdecl, t);
3724 cp_error_at (" because of local field `%#D' with same name", tmp);
3732 /* Make type T see field decl FDECL with access ACCESS.*/
3735 fdecl = TREE_VALUE (flist);
3738 if (alter_access (t, fdecl, access) == 0)
3740 fdecl = DECL_CHAIN (fdecl);
3744 alter_access (t, fdecl, access);
3749 if (vfield == NULL_TREE && has_virtual)
3751 /* We build this decl with ptr_type_node, and
3752 change the type when we know what it should be. */
3753 vfield = build_lang_field_decl (FIELD_DECL, get_vfield_name (t),
3755 /* If you change any of the below, take a look at all the
3756 other VFIELD_BASEs and VTABLE_BASEs in the code, and change
3758 DECL_ASSEMBLER_NAME (vfield) = get_identifier (VFIELD_BASE);
3759 CLASSTYPE_VFIELD (t) = vfield;
3760 DECL_VIRTUAL_P (vfield) = 1;
3761 DECL_FIELD_CONTEXT (vfield) = t;
3762 DECL_CLASS_CONTEXT (vfield) = t;
3763 DECL_FCONTEXT (vfield) = t;
3764 DECL_SAVED_INSNS (vfield) = NULL_RTX;
3765 DECL_FIELD_SIZE (vfield) = 0;
3766 DECL_ALIGN (vfield) = TYPE_ALIGN (ptr_type_node);
3767 if (CLASSTYPE_RTTI (t))
3769 /* vfield is always first entry in structure. */
3770 TREE_CHAIN (vfield) = fields;
3775 my_friendly_assert (TREE_CHAIN (last_x) == NULL_TREE, 175);
3776 TREE_CHAIN (last_x) = vfield;
3781 vfields = chainon (vfields, CLASSTYPE_AS_LIST (t));
3784 /* Now DECL_INITIAL is null on all members except for zero-width bit-fields.
3785 And they have already done their work.
3787 C++: maybe we will support default field initialization some day... */
3789 /* Delete all zero-width bit-fields from the front of the fieldlist */
3790 while (fields && DECL_BIT_FIELD (fields)
3791 && DECL_INITIAL (fields))
3792 fields = TREE_CHAIN (fields);
3793 /* Delete all such fields from the rest of the fields. */
3794 for (x = fields; x;)
3796 if (TREE_CHAIN (x) && DECL_BIT_FIELD (TREE_CHAIN (x))
3797 && DECL_INITIAL (TREE_CHAIN (x)))
3798 TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
3802 /* Delete all duplicate fields from the fields */
3803 delete_duplicate_fields (fields);
3805 /* Catch function/field name conflict. We don't need to do this for a
3806 signature, since it can only contain the fields constructed in
3807 append_signature_fields. */
3808 if (! IS_SIGNATURE (t))
3810 int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0;
3811 for (x = fields; x; x = TREE_CHAIN (x))
3813 tree name = DECL_NAME (x);
3814 int i = /*TREE_VEC_ELT (method_vec, 0) ? 0 : */ 1;
3815 if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
3817 for (; i < n_methods; ++i)
3818 if (DECL_NAME (TREE_VEC_ELT (method_vec, i)) == name)
3820 cp_error_at ("data member `%#D' conflicts with", x);
3821 cp_error_at ("function member `%#D'",
3822 TREE_VEC_ELT (method_vec, i));
3828 /* Now we have the final fieldlist for the data fields. Record it,
3829 then lay out the structure or union (including the fields). */
3831 TYPE_FIELDS (t) = fields;
3833 /* Pass layout information about base classes to layout_type, if any. */
3836 tree pseudo_basetype = TREE_TYPE (base_layout_decl);
3838 TREE_CHAIN (base_layout_decl) = TYPE_FIELDS (t);
3839 TYPE_FIELDS (t) = base_layout_decl;
3841 TYPE_SIZE (pseudo_basetype) = CLASSTYPE_SIZE (t);
3842 TYPE_MODE (pseudo_basetype) = TYPE_MODE (t);
3843 TYPE_ALIGN (pseudo_basetype) = CLASSTYPE_ALIGN (t);
3844 DECL_ALIGN (base_layout_decl) = TYPE_ALIGN (pseudo_basetype);
3845 /* Don't re-use old size. */
3846 DECL_SIZE (base_layout_decl) = NULL_TREE;
3851 finish_struct_anon (t);
3854 TYPE_FIELDS (t) = TREE_CHAIN (TYPE_FIELDS (t));
3856 /* C++: do not let empty structures exist. */
3857 if (integer_zerop (TYPE_SIZE (t)))
3858 TYPE_SIZE (t) = TYPE_SIZE (char_type_node);
3860 /* Set the TYPE_DECL for this type to contain the right
3861 value for DECL_OFFSET, so that we can use it as part
3862 of a COMPONENT_REF for multiple inheritance. */
3864 if (TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
3865 layout_decl (TYPE_NAME (t), 0);
3867 /* Now fix up any virtual base class types that we left lying
3868 around. We must get these done before we try to lay out the
3869 virtual function table. */
3870 pending_hard_virtuals = nreverse (pending_hard_virtuals);
3872 if (TYPE_USES_VIRTUAL_BASECLASSES (t))
3876 max_has_virtual = layout_vbasetypes (t, max_has_virtual);
3877 vbases = CLASSTYPE_VBASECLASSES (t);
3878 CLASSTYPE_N_VBASECLASSES (t) = list_length (vbases);
3880 /* The rtti code should do this. (mrs) */
3884 /* Update rtti info with offsets for virtual baseclasses. */
3885 if (flag_rtti && ! BINFO_NEW_VTABLE_MARKED (vbases))
3886 prepare_fresh_vtable (vbases, t);
3887 vbases = TREE_CHAIN (vbases);
3892 /* Now fixup overrides of all functions in vtables from all
3893 direct or indirect virtual base classes. */
3894 tree binfos = BINFO_BASETYPES (TYPE_BINFO (t));
3895 int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0;
3897 for (i = 0; i < n_baseclasses; i++)
3899 tree base_binfo = TREE_VEC_ELT (binfos, i);
3900 tree basetype = BINFO_TYPE (base_binfo);
3903 vbases = CLASSTYPE_VBASECLASSES (basetype);
3906 merge_overrides (binfo_member (BINFO_TYPE (vbases),
3907 CLASSTYPE_VBASECLASSES (t)),
3909 vbases = TREE_CHAIN (vbases);
3915 /* Set up the DECL_FIELD_BITPOS of the vfield if we need to, as we
3916 might need to know it for setting up the offsets in the vtable
3917 (or in thunks) below. */
3918 if (vfield != NULL_TREE
3919 && DECL_FIELD_CONTEXT (vfield) != t)
3921 tree binfo = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
3922 tree offset = BINFO_OFFSET (binfo);
3924 vfield = copy_node (vfield);
3925 copy_lang_decl (vfield);
3927 if (! integer_zerop (offset))
3928 offset = size_binop (MULT_EXPR, offset, size_int (BITS_PER_UNIT));
3929 DECL_FIELD_CONTEXT (vfield) = t;
3930 DECL_CLASS_CONTEXT (vfield) = t;
3931 DECL_FIELD_BITPOS (vfield)
3932 = size_binop (PLUS_EXPR, offset, DECL_FIELD_BITPOS (vfield));
3933 CLASSTYPE_VFIELD (t) = vfield;
3937 cp_warning ("Doing hard virtuals for %T...", t);
3940 if (has_virtual > max_has_virtual)
3941 max_has_virtual = has_virtual;
3942 if (max_has_virtual > 0)
3943 TYPE_VIRTUAL_P (t) = 1;
3945 if (flag_rtti && TYPE_VIRTUAL_P (t) && !pending_hard_virtuals)
3946 modify_all_vtables (t, NULL_TREE, NULL_TREE);
3948 while (pending_hard_virtuals)
3950 modify_all_vtables (t,
3951 TREE_PURPOSE (pending_hard_virtuals),
3952 TREE_VALUE (pending_hard_virtuals));
3953 pending_hard_virtuals = TREE_CHAIN (pending_hard_virtuals);
3956 if (TYPE_USES_VIRTUAL_BASECLASSES (t))
3959 /* Now fixup any virtual function entries from virtual bases
3960 that have different deltas. This has to come after we do the
3961 pending hard virtuals, as we might have a function that comes
3962 from multiple virtual base instances that is only overridden
3963 by a hard virtual above. */
3964 vbases = CLASSTYPE_VBASECLASSES (t);
3967 /* We might be able to shorten the amount of work we do by
3968 only doing this for vtables that come from virtual bases
3969 that have differing offsets, but don't want to miss any
3971 fixup_vtable_deltas (vbases, 1, t);
3972 vbases = TREE_CHAIN (vbases);
3976 /* Under our model of GC, every C++ class gets its own virtual
3977 function table, at least virtually. */
3978 if (pending_virtuals || (flag_rtti && TYPE_VIRTUAL_P (t)))
3980 pending_virtuals = nreverse (pending_virtuals);
3981 /* We must enter these virtuals into the table. */
3982 if (first_vfn_base_index < 0)
3984 /* The first slot is for the rtti offset. */
3985 pending_virtuals = tree_cons (NULL_TREE, NULL_TREE, pending_virtuals);
3987 /* The second slot is for the tdesc pointer when thunks are used. */
3988 if (flag_vtable_thunks)
3989 pending_virtuals = tree_cons (NULL_TREE, NULL_TREE, pending_virtuals);
3991 set_rtti_entry (pending_virtuals, integer_zero_node, t);
3992 build_vtable (NULL_TREE, t);
3997 /* Here we know enough to change the type of our virtual
3998 function table, but we will wait until later this function. */
4000 if (! BINFO_NEW_VTABLE_MARKED (TYPE_BINFO (t)))
4001 build_vtable (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), first_vfn_base_index), t);
4003 offset = get_derived_offset (TYPE_BINFO (t), NULL_TREE);
4004 offset = size_binop (MINUS_EXPR, integer_zero_node, offset);
4005 set_rtti_entry (TYPE_BINFO_VIRTUALS (t), offset, t);
4008 /* If this type has basetypes with constructors, then those
4009 constructors might clobber the virtual function table. But
4010 they don't if the derived class shares the exact vtable of the base
4013 CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
4015 else if (first_vfn_base_index >= 0)
4017 tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), first_vfn_base_index);
4018 /* This class contributes nothing new to the virtual function
4019 table. However, it may have declared functions which
4020 went into the virtual function table "inherited" from the
4021 base class. If so, we grab a copy of those updated functions,
4022 and pretend they are ours. */
4024 /* See if we should steal the virtual info from base class. */
4025 if (TYPE_BINFO_VTABLE (t) == NULL_TREE)
4026 TYPE_BINFO_VTABLE (t) = BINFO_VTABLE (binfo);
4027 if (TYPE_BINFO_VIRTUALS (t) == NULL_TREE)
4028 TYPE_BINFO_VIRTUALS (t) = BINFO_VIRTUALS (binfo);
4029 if (TYPE_BINFO_VTABLE (t) != BINFO_VTABLE (binfo))
4030 CLASSTYPE_NEEDS_VIRTUAL_REINIT (t) = 1;
4033 if (max_has_virtual || first_vfn_base_index >= 0)
4035 CLASSTYPE_VSIZE (t) = has_virtual;
4036 if (first_vfn_base_index >= 0)
4038 if (pending_virtuals)
4039 TYPE_BINFO_VIRTUALS (t) = chainon (TYPE_BINFO_VIRTUALS (t),
4042 else if (has_virtual)
4044 TYPE_BINFO_VIRTUALS (t) = pending_virtuals;
4045 if (write_virtuals >= 0)
4046 DECL_VIRTUAL_P (TYPE_BINFO_VTABLE (t)) = 1;
4050 /* Now lay out the virtual function table. */
4055 if (TREE_TYPE (vfield) == ptr_type_node)
4057 /* We must create a pointer to this table because
4058 the one inherited from base class does not exist.
4059 We will fill in the type when we know what it
4060 should really be. Use `size_int' so values are memoized
4062 itype = build_index_type (size_int (has_virtual));
4063 atype = build_array_type (vtable_entry_type, itype);
4064 layout_type (atype);
4065 TREE_TYPE (vfield) = build_pointer_type (atype);
4069 atype = TREE_TYPE (TREE_TYPE (vfield));
4071 if (has_virtual != TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (atype))))
4073 /* We must extend (or create) the boundaries on this array,
4074 because we picked up virtual functions from multiple
4076 itype = build_index_type (size_int (has_virtual));
4077 atype = build_array_type (vtable_entry_type, itype);
4078 layout_type (atype);
4079 vfield = copy_node (vfield);
4080 TREE_TYPE (vfield) = build_pointer_type (atype);
4084 CLASSTYPE_VFIELD (t) = vfield;
4085 if (TREE_TYPE (TYPE_BINFO_VTABLE (t)) != atype)
4087 TREE_TYPE (TYPE_BINFO_VTABLE (t)) = atype;
4088 DECL_SIZE (TYPE_BINFO_VTABLE (t)) = 0;
4089 layout_decl (TYPE_BINFO_VTABLE (t), 0);
4090 /* At one time the vtable info was grabbed 2 words at a time. This
4091 fails on sparc unless you have 8-byte alignment. (tiemann) */
4092 DECL_ALIGN (TYPE_BINFO_VTABLE (t))
4093 = MAX (TYPE_ALIGN (double_type_node),
4094 DECL_ALIGN (TYPE_BINFO_VTABLE (t)));
4097 else if (first_vfn_base_index >= 0)
4098 CLASSTYPE_VFIELD (t) = vfield;
4099 CLASSTYPE_VFIELDS (t) = vfields;
4101 finish_struct_bits (t, max_has_virtual);
4103 /* Complete the rtl for any static member objects of the type we're
4105 for (x = fields; x; x = TREE_CHAIN (x))
4107 if (TREE_CODE (x) == VAR_DECL && TREE_STATIC (x)
4108 && TREE_TYPE (x) == t)
4110 DECL_MODE (x) = TYPE_MODE (t);
4111 make_decl_rtl (x, NULL, 0);
4115 if (TYPE_HAS_CONSTRUCTOR (t))
4117 tree vfields = CLASSTYPE_VFIELDS (t);
4121 /* Mark the fact that constructor for T
4122 could affect anybody inheriting from T
4123 who wants to initialize vtables for VFIELDS's type. */
4124 if (VF_DERIVED_VALUE (vfields))
4125 TREE_ADDRESSABLE (vfields) = 1;
4126 vfields = TREE_CHAIN (vfields);
4128 if (any_default_members != 0)
4129 build_class_init_list (t);
4131 else if (TYPE_NEEDS_CONSTRUCTING (t))
4132 build_class_init_list (t);
4134 /* Write out inline function definitions. */
4135 do_inline_function_hair (t, CLASSTYPE_INLINE_FRIENDS (t));
4136 CLASSTYPE_INLINE_FRIENDS (t) = 0;
4138 if (CLASSTYPE_VSIZE (t) != 0)
4141 /* This is now done above. */
4142 if (DECL_FIELD_CONTEXT (vfield) != t)
4144 tree binfo = get_binfo (DECL_FIELD_CONTEXT (vfield), t, 0);
4145 tree offset = BINFO_OFFSET (binfo);
4147 vfield = copy_node (vfield);
4148 copy_lang_decl (vfield);
4150 if (! integer_zerop (offset))
4151 offset = size_binop (MULT_EXPR, offset, size_int (BITS_PER_UNIT));
4152 DECL_FIELD_CONTEXT (vfield) = t;
4153 DECL_CLASS_CONTEXT (vfield) = t;
4154 DECL_FIELD_BITPOS (vfield)
4155 = size_binop (PLUS_EXPR, offset, DECL_FIELD_BITPOS (vfield));
4156 CLASSTYPE_VFIELD (t) = vfield;
4160 /* In addition to this one, all the other vfields should be listed. */
4161 /* Before that can be done, we have to have FIELD_DECLs for them, and
4162 a place to find them. */
4163 TYPE_NONCOPIED_PARTS (t) = build_tree_list (default_conversion (TYPE_BINFO_VTABLE (t)), vfield);
4165 if (warn_nonvdtor && TYPE_HAS_DESTRUCTOR (t)
4166 && DECL_VINDEX (TREE_VEC_ELT (method_vec, 0)) == NULL_TREE)
4167 cp_warning ("`%#T' has virtual functions but non-virtual destructor",
4171 /* Make the rtl for any new vtables we have created, and unmark
4172 the base types we marked. */
4173 finish_vtbls (TYPE_BINFO (t), 1, t);
4174 hack_incomplete_structures (t);
4177 if (TYPE_NAME (t) && TYPE_IDENTIFIER (t))
4178 undo_template_name_overload (TYPE_IDENTIFIER (t), 1);
4181 resume_momentary (old);
4183 if (warn_overloaded_virtual)
4187 /* This has to be done after we have sorted out what to do with
4188 the enclosing type. */
4189 if (write_symbols != DWARF_DEBUG)
4191 /* Be smarter about nested classes here. If a type is nested,
4192 only output it if we would output the enclosing type. */
4193 if (DECL_CONTEXT (TYPE_NAME (t))
4194 && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (TYPE_NAME (t)))) == 't')
4195 DECL_IGNORED_P (TYPE_NAME (t)) = TREE_ASM_WRITTEN (TYPE_NAME (t));
4199 if (write_symbols != DWARF_DEBUG)
4201 /* If the type has methods, we want to think about cutting down
4202 the amount of symbol table stuff we output. The value stored in
4203 the TYPE_DECL's DECL_IGNORED_P slot is a first approximation.
4204 For example, if a member function is seen and we decide to
4205 write out that member function, then we can change the value
4206 of the DECL_IGNORED_P slot, and the type will be output when
4207 that member function's debug info is written out. */
4208 if (CLASSTYPE_METHOD_VEC (t))
4210 extern tree pending_vtables;
4212 /* Don't output full info about any type
4213 which does not have its implementation defined here. */
4214 if (TYPE_VIRTUAL_P (t) && write_virtuals == 2)
4215 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t))
4216 = (value_member (TYPE_IDENTIFIER (t), pending_vtables) == 0);
4217 else if (CLASSTYPE_INTERFACE_ONLY (t))
4218 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 1;
4220 /* XXX do something about this. */
4221 else if (CLASSTYPE_INTERFACE_UNKNOWN (t))
4222 /* Only a first approximation! */
4223 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 1;
4226 else if (CLASSTYPE_INTERFACE_ONLY (t))
4227 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 1;
4230 /* Finish debugging output for this type. */
4231 rest_of_type_compilation (t, toplevel_bindings_p ());
4237 finish_struct (t, list_of_fieldlists, attributes, warn_anon)
4238 tree t, list_of_fieldlists, attributes;
4241 tree fields = NULL_TREE;
4242 tree *tail = &TYPE_METHODS (t);
4243 tree name = TYPE_NAME (t);
4244 tree x, last_x = NULL_TREE;
4247 if (TREE_CODE (name) == TYPE_DECL)
4251 DECL_SOURCE_FILE (name) = input_filename;
4252 /* For TYPE_DECL that are not typedefs (those marked with a line
4253 number of zero, we don't want to mark them as real typedefs.
4254 If this fails one needs to make sure real typedefs have a
4255 previous line number, even if it is wrong, that way the below
4256 will fill in the right line number. (mrs) */
4257 if (DECL_SOURCE_LINE (name))
4258 DECL_SOURCE_LINE (name) = lineno;
4259 CLASSTYPE_SOURCE_LINE (t) = lineno;
4260 name = DECL_NAME (name);
4263 /* Append the fields we need for constructing signature tables. */
4264 if (IS_SIGNATURE (t))
4265 append_signature_fields (list_of_fieldlists);
4267 if (last_x && list_of_fieldlists)
4268 TREE_CHAIN (last_x) = TREE_VALUE (list_of_fieldlists);
4270 /* For signatures, we made all methods `public' in the parser and
4271 reported an error if a access specifier was used. */
4272 if (CLASSTYPE_DECLARED_CLASS (t) == 0)
4274 if (list_of_fieldlists
4275 && TREE_PURPOSE (list_of_fieldlists) == access_default_node)
4276 TREE_PURPOSE (list_of_fieldlists) = access_public_node;
4278 else if (list_of_fieldlists
4279 && TREE_PURPOSE (list_of_fieldlists) == access_default_node)
4280 TREE_PURPOSE (list_of_fieldlists) = access_private_node;
4282 while (list_of_fieldlists)
4284 access = TREE_PURPOSE (list_of_fieldlists);
4286 for (x = TREE_VALUE (list_of_fieldlists); x; x = TREE_CHAIN (x))
4288 TREE_PRIVATE (x) = access == access_private_node;
4289 TREE_PROTECTED (x) = access == access_protected_node;
4291 /* Check for inconsistent use of this name in the class body.
4292 Enums, types and static vars have already been checked. */
4293 if (TREE_CODE (x) != TYPE_DECL && TREE_CODE (x) != USING_DECL
4294 && TREE_CODE (x) != CONST_DECL && TREE_CODE (x) != VAR_DECL)
4296 tree name = DECL_NAME (x);
4299 /* Don't get confused by access decls. */
4300 if (name && TREE_CODE (name) == IDENTIFIER_NODE)
4301 icv = IDENTIFIER_CLASS_VALUE (name);
4306 /* Don't complain about constructors. */
4307 && name != constructor_name (current_class_type)
4308 /* Or inherited names. */
4309 && id_in_current_class (name)
4310 /* Or shadowed tags. */
4311 && !(TREE_CODE (icv) == TYPE_DECL
4312 && DECL_CONTEXT (icv) == t))
4314 cp_error_at ("declaration of identifier `%D' as `%+#D'",
4316 cp_error_at ("conflicts with other use in class as `%#D'",
4321 if (TREE_CODE (x) == FUNCTION_DECL)
4323 DECL_CLASS_CONTEXT (x) = t;
4325 TREE_CHAIN (last_x) = TREE_CHAIN (x);
4326 /* Link x onto end of TYPE_METHODS. */
4328 tail = &TREE_CHAIN (x);
4333 /* Handle access declarations. */
4334 if (DECL_NAME (x) && TREE_CODE (DECL_NAME (x)) == SCOPE_REF)
4336 tree n = DECL_NAME (x);
4338 (USING_DECL, DECL_NAME (TREE_OPERAND (n, 1)), TREE_TYPE (x));
4339 DECL_RESULT (x) = n;
4342 if (TREE_CODE (x) != TYPE_DECL)
4343 DECL_FIELD_CONTEXT (x) = t;
4349 list_of_fieldlists = TREE_CHAIN (list_of_fieldlists);
4350 /* link the tail while we have it! */
4353 TREE_CHAIN (last_x) = NULL_TREE;
4355 if (list_of_fieldlists
4356 && TREE_VALUE (list_of_fieldlists)
4357 && TREE_CODE (TREE_VALUE (list_of_fieldlists)) != FUNCTION_DECL)
4358 TREE_CHAIN (last_x) = TREE_VALUE (list_of_fieldlists);
4362 /* Now add the tags, if any, to the list of TYPE_DECLs
4363 defined for this type. */
4364 if (CLASSTYPE_TAGS (t))
4366 x = CLASSTYPE_TAGS (t);
4369 tree tag = TYPE_NAME (TREE_VALUE (x));
4371 /* Check to see if it is already there. This will be the case if
4372 was do enum { red; } color; */
4373 if (chain_member (tag, fields))
4379 #ifdef DWARF_DEBUGGING_INFO
4380 if (write_symbols == DWARF_DEBUG)
4382 /* Notify dwarfout.c that this TYPE_DECL node represent a
4383 gratuitous typedef. */
4384 DECL_IGNORED_P (tag) = 1;
4386 #endif /* DWARF_DEBUGGING_INFO */
4388 TREE_NONLOCAL_FLAG (TREE_VALUE (x)) = 0;
4390 last_x = chainon (last_x, tag);
4392 if (fields == NULL_TREE)
4394 CLASSTYPE_LOCAL_TYPEDECLS (t) = 1;
4398 TYPE_FIELDS (t) = fields;
4400 if (processing_template_decl)
4402 tree d = getdecls ();
4403 for (; d; d = TREE_CHAIN (d))
4405 /* If this is the decl for the class or one of the template
4406 parms, we've seen all the injected decls. */
4407 if ((TREE_CODE (d) == TYPE_DECL
4408 && (TREE_TYPE (d) == t
4409 || TREE_CODE (TREE_TYPE (d)) == TEMPLATE_TYPE_PARM))
4410 || TREE_CODE (d) == CONST_DECL)
4412 /* Don't inject TYPE_NESTED_NAMEs. */
4413 else if (TREE_MANGLED (DECL_NAME (d))
4414 || IDENTIFIER_TEMPLATE (DECL_NAME (d)))
4416 DECL_TEMPLATE_INJECT (CLASSTYPE_TI_TEMPLATE (t))
4417 = tree_cons (NULL_TREE, d,
4418 DECL_TEMPLATE_INJECT (CLASSTYPE_TI_TEMPLATE (t)));
4420 CLASSTYPE_METHOD_VEC (t)
4421 = finish_struct_methods (t, TYPE_METHODS (t), 1);
4422 TYPE_SIZE (t) = integer_zero_node;
4425 t = finish_struct_1 (t, attributes, warn_anon);
4427 TYPE_BEING_DEFINED (t) = 0;
4429 if (current_class_type)
4432 error ("trying to finish struct, but kicked out due to previous parse errors.");
4437 /* Return non-zero if the effective type of INSTANCE is static.
4438 Used to determine whether the virtual function table is needed
4441 *NONNULL is set iff INSTANCE can be known to be nonnull, regardless
4442 of our knowledge of its type. */
4444 resolves_to_fixed_type_p (instance, nonnull)
4448 switch (TREE_CODE (instance))
4451 /* Check that we are not going through a cast of some sort. */
4452 if (TREE_TYPE (instance)
4453 == TREE_TYPE (TREE_TYPE (TREE_OPERAND (instance, 0))))
4454 instance = TREE_OPERAND (instance, 0);
4455 /* fall through... */
4457 /* This is a call to a constructor, hence it's never zero. */
4458 if (TREE_HAS_CONSTRUCTOR (instance))
4467 /* This is a call to a constructor, hence it's never zero. */
4468 if (TREE_HAS_CONSTRUCTOR (instance))
4474 return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4477 /* This is a call to `new', hence it's never zero. */
4478 if (TREE_CALLS_NEW (instance))
4488 if (TREE_CODE (TREE_OPERAND (instance, 1)) == INTEGER_CST)
4489 /* Propagate nonnull. */
4490 resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4491 if (TREE_CODE (TREE_OPERAND (instance, 0)) == ADDR_EXPR)
4492 return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4497 return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4502 return resolves_to_fixed_type_p (TREE_OPERAND (instance, 0), nonnull);
4505 return resolves_to_fixed_type_p (TREE_OPERAND (instance, 1), nonnull);
4509 if (TREE_CODE (TREE_TYPE (instance)) == ARRAY_TYPE
4510 && IS_AGGR_TYPE (TREE_TYPE (TREE_TYPE (instance))))
4516 /* fall through... */
4519 if (IS_AGGR_TYPE (TREE_TYPE (instance)))
4527 if (instance == current_class_decl
4528 && flag_this_is_variable <= 0)
4530 /* Some people still use `this = 0' inside destructors. */
4531 *nonnull = ! DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (current_function_decl));
4532 /* In a constructor, we know our type. */
4533 if (flag_this_is_variable < 0)
4536 else if (TREE_CODE (TREE_TYPE (instance)) == REFERENCE_TYPE)
4537 /* Reference variables should be references to objects. */
4548 init_class_processing ()
4550 current_class_depth = 0;
4551 current_class_stacksize = 10;
4552 current_class_base = (tree *)xmalloc(current_class_stacksize * sizeof (tree));
4553 current_class_stack = current_class_base;
4555 current_lang_stacksize = 10;
4556 current_lang_base = (tree *)xmalloc(current_lang_stacksize * sizeof (tree));
4557 current_lang_stack = current_lang_base;
4559 access_default_node = build_int_2 (0, 0);
4560 access_public_node = build_int_2 (1, 0);
4561 access_protected_node = build_int_2 (2, 0);
4562 access_private_node = build_int_2 (3, 0);
4563 access_default_virtual_node = build_int_2 (4, 0);
4564 access_public_virtual_node = build_int_2 (5, 0);
4565 access_private_virtual_node = build_int_2 (6, 0);
4567 /* Keep these values lying around. */
4568 base_layout_decl = build_lang_field_decl (FIELD_DECL, NULL_TREE, error_mark_node);
4569 TREE_TYPE (base_layout_decl) = make_node (RECORD_TYPE);
4571 gcc_obstack_init (&class_obstack);
4574 /* Set current scope to NAME. CODE tells us if this is a
4575 STRUCT, UNION, or ENUM environment.
4577 NAME may end up being NULL_TREE if this is an anonymous or
4578 late-bound struct (as in "struct { ... } foo;") */
4580 /* Set global variables CURRENT_CLASS_NAME and CURRENT_CLASS_TYPE to
4581 appropriate values, found by looking up the type definition of
4584 If MODIFY is 1, we set IDENTIFIER_CLASS_VALUE's of names
4585 which can be seen locally to the class. They are shadowed by
4586 any subsequent local declaration (including parameter names).
4588 If MODIFY is 2, we set IDENTIFIER_CLASS_VALUE's of names
4589 which have static meaning (i.e., static members, static
4590 member functions, enum declarations, etc).
4592 If MODIFY is 3, we set IDENTIFIER_CLASS_VALUE of names
4593 which can be seen locally to the class (as in 1), but
4594 know that we are doing this for declaration purposes
4595 (i.e. friend foo::bar (int)).
4597 So that we may avoid calls to lookup_name, we cache the _TYPE
4598 nodes of local TYPE_DECLs in the TREE_TYPE field of the name.
4600 For multiple inheritance, we perform a two-pass depth-first search
4601 of the type lattice. The first pass performs a pre-order search,
4602 marking types after the type has had its fields installed in
4603 the appropriate IDENTIFIER_CLASS_VALUE slot. The second pass merely
4604 unmarks the marked types. If a field or member function name
4605 appears in an ambiguous way, the IDENTIFIER_CLASS_VALUE of
4606 that name becomes `error_mark_node'. */
4609 pushclass (type, modify)
4613 push_memoized_context (type, modify);
4615 current_class_depth++;
4616 *current_class_stack++ = current_class_name;
4617 *current_class_stack++ = current_class_type;
4618 if (current_class_stack >= current_class_base + current_class_stacksize)
4620 current_class_base =
4621 (tree *)xrealloc (current_class_base,
4622 sizeof (tree) * (current_class_stacksize + 10));
4623 current_class_stack = current_class_base + current_class_stacksize;
4624 current_class_stacksize += 10;
4627 current_class_name = TYPE_NAME (type);
4628 if (TREE_CODE (current_class_name) == TYPE_DECL)
4629 current_class_name = DECL_NAME (current_class_name);
4630 current_class_type = type;
4632 if (previous_class_type != NULL_TREE
4633 && (type != previous_class_type || TYPE_SIZE (previous_class_type) == NULL_TREE)
4634 && current_class_depth == 1)
4636 /* Forcibly remove any old class remnants. */
4638 previous_class_type = NULL_TREE;
4643 if (CLASSTYPE_TEMPLATE_INFO (type))
4644 overload_template_name (type);
4649 tree this_fndecl = current_function_decl;
4651 if (current_function_decl
4652 && DECL_CONTEXT (current_function_decl)
4653 && TREE_CODE (DECL_CONTEXT (current_function_decl)) == FUNCTION_DECL)
4654 current_function_decl = DECL_CONTEXT (current_function_decl);
4656 current_function_decl = NULL_TREE;
4658 if (type != previous_class_type || current_class_depth > 1)
4660 build_mi_matrix (type);
4661 push_class_decls (type);
4663 if (current_class_depth == 1)
4664 previous_class_type = type;
4670 /* Hooray, we successfully cached; let's just install the
4671 cached class_shadowed list, and walk through it to get the
4672 IDENTIFIER_TYPE_VALUEs correct. */
4673 set_class_shadows (previous_class_values);
4674 for (item = previous_class_values; item; item = TREE_CHAIN (item))
4676 tree id = TREE_PURPOSE (item);
4677 tree decl = IDENTIFIER_CLASS_VALUE (id);
4679 if (TREE_CODE (decl) == TYPE_DECL)
4680 set_identifier_type_value (id, TREE_TYPE (decl));
4682 unuse_fields (type);
4685 for (tags = CLASSTYPE_TAGS (type); tags; tags = TREE_CHAIN (tags))
4687 TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 1;
4688 if (! TREE_PURPOSE (tags))
4690 pushtag (TREE_PURPOSE (tags), TREE_VALUE (tags), 0);
4693 current_function_decl = this_fndecl;
4697 /* Get out of the current class scope. If we were in a class scope
4698 previously, that is the one popped to. The flag MODIFY tells whether
4699 the current scope declarations needs to be modified as a result of
4700 popping to the previous scope. 0 is used for class definitions. */
4707 /* Back this old class out completely. */
4708 tree tags = CLASSTYPE_TAGS (previous_class_type);
4711 /* This code can be seen as a cache miss. When we've cached a
4712 class' scope's bindings and we can't use them, we need to reset
4713 them. This is it! */
4714 for (t = previous_class_values; t; t = TREE_CHAIN (t))
4715 IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (t)) = NULL_TREE;
4718 TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 0;
4719 tags = TREE_CHAIN (tags);
4726 /* Just remove from this class what didn't make
4727 it into IDENTIFIER_CLASS_VALUE. */
4728 tree tags = CLASSTYPE_TAGS (current_class_type);
4732 TREE_NONLOCAL_FLAG (TREE_VALUE (tags)) = 0;
4733 tags = TREE_CHAIN (tags);
4737 /* Force clearing of IDENTIFIER_CLASS_VALUEs after a class definition,
4738 since not all class decls make it there currently. */
4739 poplevel_class (! modify);
4741 /* Since poplevel_class does the popping of class decls nowadays,
4742 this really only frees the obstack used for these decls.
4743 That's why it had to be moved down here. */
4747 current_class_depth--;
4748 current_class_type = *--current_class_stack;
4749 current_class_name = *--current_class_stack;
4751 pop_memoized_context (modify);
4757 /* When entering a class scope, all enclosing class scopes' names with
4758 static meaning (static variables, static functions, types and enumerators)
4759 have to be visible. This recursive function calls pushclass for all
4760 enclosing class contexts until global or a local scope is reached.
4761 TYPE is the enclosed class and MODIFY is equivalent with the pushclass
4762 formal of the same name. */
4765 push_nested_class (type, modify)
4771 if (type == NULL_TREE || type == error_mark_node || ! IS_AGGR_TYPE (type)
4772 || TREE_CODE (type) == TEMPLATE_TYPE_PARM)
4775 context = DECL_CONTEXT (TYPE_NAME (type));
4777 if (context && TREE_CODE (context) == RECORD_TYPE)
4778 push_nested_class (context, 2);
4779 pushclass (type, modify);
4782 /* Undoes a push_nested_class call. MODIFY is passed on to popclass. */
4785 pop_nested_class (modify)
4788 tree context = DECL_CONTEXT (TYPE_NAME (current_class_type));
4791 if (context && TREE_CODE (context) == RECORD_TYPE)
4792 pop_nested_class (modify);
4795 /* Set global variables CURRENT_LANG_NAME to appropriate value
4796 so that behavior of name-mangling machinery is correct. */
4799 push_lang_context (name)
4802 *current_lang_stack++ = current_lang_name;
4803 if (current_lang_stack >= current_lang_base + current_lang_stacksize)
4806 (tree *)xrealloc (current_lang_base,
4807 sizeof (tree) * (current_lang_stacksize + 10));
4808 current_lang_stack = current_lang_base + current_lang_stacksize;
4809 current_lang_stacksize += 10;
4812 if (name == lang_name_cplusplus)
4814 strict_prototype = strict_prototypes_lang_cplusplus;
4815 current_lang_name = name;
4817 else if (name == lang_name_c)
4819 strict_prototype = strict_prototypes_lang_c;
4820 current_lang_name = name;
4823 error ("language string `\"%s\"' not recognized", IDENTIFIER_POINTER (name));
4826 /* Get out of the current language scope. */
4830 current_lang_name = *--current_lang_stack;
4831 if (current_lang_name == lang_name_cplusplus)
4832 strict_prototype = strict_prototypes_lang_cplusplus;
4833 else if (current_lang_name == lang_name_c)
4834 strict_prototype = strict_prototypes_lang_c;
4838 root_lang_context_p ()
4840 return current_lang_stack == current_lang_base;
4843 /* Type instantiation routines. */
4845 /* This function will instantiate the type of the expression given
4846 in RHS to match the type of LHSTYPE. If LHSTYPE is NULL_TREE,
4847 or other errors exist, the TREE_TYPE of RHS will be ERROR_MARK_NODE.
4849 This function is used in build_modify_expr, convert_arguments,
4850 build_c_cast, and compute_conversion_costs. */
4852 instantiate_type (lhstype, rhs, complain)
4856 if (TREE_CODE (lhstype) == UNKNOWN_TYPE)
4859 error ("not enough type information");
4860 return error_mark_node;
4863 if (TREE_TYPE (rhs) != NULL_TREE && ! (type_unknown_p (rhs)))
4866 /* This should really only be used when attempting to distinguish
4867 what sort of a pointer to function we have. For now, any
4868 arithmetic operation which is not supported on pointers
4869 is rejected as an error. */
4871 switch (TREE_CODE (rhs))
4878 my_friendly_abort (177);
4879 return error_mark_node;
4883 TREE_TYPE (rhs) = lhstype;
4884 lhstype = build_pointer_type (lhstype);
4885 TREE_OPERAND (rhs, 0)
4886 = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
4887 if (TREE_OPERAND (rhs, 0) == error_mark_node)
4888 return error_mark_node;
4893 rhs = copy_node (TREE_OPERAND (rhs, 0));
4894 TREE_TYPE (rhs) = unknown_type_node;
4895 return instantiate_type (lhstype, rhs, complain);
4899 tree field = TREE_OPERAND (rhs, 1);
4900 if (TREE_CODE (field) == TREE_LIST)
4902 tree function = instantiate_type (lhstype, field, complain);
4903 if (function == error_mark_node)
4904 return error_mark_node;
4905 my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 185);
4906 if (DECL_VINDEX (function))
4908 tree base = TREE_OPERAND (rhs, 0);
4909 tree base_ptr = build_unary_op (ADDR_EXPR, base, 0);
4910 if (base_ptr == error_mark_node)
4911 return error_mark_node;
4912 base_ptr = convert_pointer_to (DECL_CONTEXT (function), base_ptr);
4913 if (base_ptr == error_mark_node)
4914 return error_mark_node;
4915 return build_vfn_ref (&base_ptr, base, DECL_VINDEX (function));
4917 mark_used (function);
4921 my_friendly_assert (TREE_CODE (field) == FIELD_DECL, 178);
4922 my_friendly_assert (!(TREE_CODE (TREE_TYPE (field)) == FUNCTION_TYPE
4923 || TREE_CODE (TREE_TYPE (field)) == METHOD_TYPE),
4926 TREE_TYPE (rhs) = lhstype;
4927 /* First look for an exact match */
4929 while (field && TREE_TYPE (field) != lhstype)
4930 field = DECL_CHAIN (field);
4933 TREE_OPERAND (rhs, 1) = field;
4938 /* No exact match found, look for a compatible function. */
4939 field = TREE_OPERAND (rhs, 1);
4940 while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
4941 field = DECL_CHAIN (field);
4944 TREE_OPERAND (rhs, 1) = field;
4945 field = DECL_CHAIN (field);
4946 while (field && ! comptypes (lhstype, TREE_TYPE (field), 0))
4947 field = DECL_CHAIN (field);
4951 error ("ambiguous overload for COMPONENT_REF requested");
4952 return error_mark_node;
4958 error ("no appropriate overload exists for COMPONENT_REF");
4959 return error_mark_node;
4966 tree elem, baselink, name;
4967 int globals = overloaded_globals_p (rhs);
4969 #if 0 /* obsolete */
4970 /* If there's only one function we know about, return that. */
4971 if (globals > 0 && TREE_CHAIN (rhs) == NULL_TREE)
4972 return TREE_VALUE (rhs);
4975 /* First look for an exact match. Search either overloaded
4976 functions or member functions. May have to undo what
4977 `default_conversion' might do to lhstype. */
4979 if (TYPE_PTRMEMFUNC_P (lhstype))
4980 lhstype = TYPE_PTRMEMFUNC_FN_TYPE (lhstype);
4982 if (TREE_CODE (lhstype) == POINTER_TYPE)
4983 if (TREE_CODE (TREE_TYPE (lhstype)) == FUNCTION_TYPE
4984 || TREE_CODE (TREE_TYPE (lhstype)) == METHOD_TYPE)
4985 lhstype = TREE_TYPE (lhstype);
4989 error ("invalid type combination for overload");
4990 return error_mark_node;
4993 if (TREE_CODE (lhstype) != FUNCTION_TYPE && globals > 0)
4996 cp_error ("cannot resolve overloaded function `%D' based on non-function type",
4997 TREE_PURPOSE (rhs));
4998 return error_mark_node;
5003 elem = get_first_fn (rhs);
5005 if (! comptypes (lhstype, TREE_TYPE (elem), 1))
5006 elem = DECL_CHAIN (elem);
5013 /* No exact match found, look for a compatible template. */
5016 for (elem = get_first_fn (rhs); elem; elem = DECL_CHAIN (elem))
5017 if (TREE_CODE (elem) == TEMPLATE_DECL)
5019 int n = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (elem));
5020 tree *t = (tree *) alloca (sizeof (tree) * n);
5022 i = type_unification (DECL_TEMPLATE_PARMS (elem), t,
5023 TYPE_ARG_TYPES (TREE_TYPE (elem)),
5024 TYPE_ARG_TYPES (lhstype), &d, 0);
5029 cp_error ("ambiguous template instantiation converting to `%#T'", lhstype);
5030 return error_mark_node;
5032 save_elem = instantiate_template (elem, t);
5033 /* Check the return type. */
5034 if (! comptypes (TREE_TYPE (lhstype),
5035 TREE_TYPE (TREE_TYPE (save_elem)), 1))
5041 mark_used (save_elem);
5046 /* No match found, look for a compatible function. */
5047 elem = get_first_fn (rhs);
5048 while (elem && comp_target_types (lhstype,
5049 TREE_TYPE (elem), 1) <= 0)
5050 elem = DECL_CHAIN (elem);
5053 tree save_elem = elem;
5054 elem = DECL_CHAIN (elem);
5055 while (elem && comp_target_types (lhstype,
5056 TREE_TYPE (elem), 0) <= 0)
5057 elem = DECL_CHAIN (elem);
5062 cp_error ("cannot resolve overload to target type `%#T'",
5064 cp_error_at (" ambiguity between `%#D'", save_elem);
5065 cp_error_at (" and `%#D', at least", elem);
5067 return error_mark_node;
5069 mark_used (save_elem);
5074 cp_error ("cannot resolve overload to target type `%#T'",
5076 cp_error (" because no suitable overload of function `%D' exists",
5077 TREE_PURPOSE (rhs));
5079 return error_mark_node;
5082 if (TREE_NONLOCAL_FLAG (rhs))
5084 /* Got to get it as a baselink. */
5085 rhs = lookup_fnfields (TYPE_BINFO (current_class_type),
5086 TREE_PURPOSE (rhs), 0);
5090 my_friendly_assert (TREE_CHAIN (rhs) == NULL_TREE, 181);
5091 if (TREE_CODE (TREE_VALUE (rhs)) == TREE_LIST)
5092 rhs = TREE_VALUE (rhs);
5093 my_friendly_assert (TREE_CODE (TREE_VALUE (rhs)) == FUNCTION_DECL,
5097 for (baselink = rhs; baselink;
5098 baselink = next_baselink (baselink))
5100 elem = TREE_VALUE (baselink);
5102 if (comptypes (lhstype, TREE_TYPE (elem), 1))
5108 elem = DECL_CHAIN (elem);
5111 /* No exact match found, look for a compatible method. */
5112 for (baselink = rhs; baselink;
5113 baselink = next_baselink (baselink))
5115 elem = TREE_VALUE (baselink);
5116 while (elem && comp_target_types (lhstype,
5117 TREE_TYPE (elem), 1) <= 0)
5118 elem = DECL_CHAIN (elem);
5121 tree save_elem = elem;
5122 elem = DECL_CHAIN (elem);
5123 while (elem && comp_target_types (lhstype,
5124 TREE_TYPE (elem), 0) <= 0)
5125 elem = DECL_CHAIN (elem);
5129 error ("ambiguous overload for overloaded method requested");
5130 return error_mark_node;
5132 mark_used (save_elem);
5135 name = DECL_NAME (TREE_VALUE (rhs));
5137 if (TREE_CODE (lhstype) == FUNCTION_TYPE && globals < 0)
5139 /* Try to instantiate from non-member functions. */
5140 rhs = lookup_name_nonclass (name);
5141 if (rhs && TREE_CODE (rhs) == TREE_LIST)
5143 /* This code seems to be missing a `return'. */
5144 my_friendly_abort (4);
5145 instantiate_type (lhstype, rhs, complain);
5151 cp_error ("no compatible member functions named `%D'", name);
5152 return error_mark_node;
5156 /* This is too hard for now. */
5157 my_friendly_abort (183);
5158 return error_mark_node;
5163 TREE_OPERAND (rhs, 0)
5164 = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
5165 if (TREE_OPERAND (rhs, 0) == error_mark_node)
5166 return error_mark_node;
5167 TREE_OPERAND (rhs, 1)
5168 = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
5169 if (TREE_OPERAND (rhs, 1) == error_mark_node)
5170 return error_mark_node;
5172 TREE_TYPE (rhs) = lhstype;
5176 case TRUNC_DIV_EXPR:
5177 case FLOOR_DIV_EXPR:
5179 case ROUND_DIV_EXPR:
5181 case TRUNC_MOD_EXPR:
5182 case FLOOR_MOD_EXPR:
5184 case ROUND_MOD_EXPR:
5185 case FIX_ROUND_EXPR:
5186 case FIX_FLOOR_EXPR:
5188 case FIX_TRUNC_EXPR:
5204 case PREINCREMENT_EXPR:
5205 case PREDECREMENT_EXPR:
5206 case POSTINCREMENT_EXPR:
5207 case POSTDECREMENT_EXPR:
5209 error ("invalid operation on uninstantiated type");
5210 return error_mark_node;
5212 case TRUTH_AND_EXPR:
5214 case TRUTH_XOR_EXPR:
5221 case TRUTH_ANDIF_EXPR:
5222 case TRUTH_ORIF_EXPR:
5223 case TRUTH_NOT_EXPR:
5225 error ("not enough type information");
5226 return error_mark_node;
5229 if (type_unknown_p (TREE_OPERAND (rhs, 0)))
5232 error ("not enough type information");
5233 return error_mark_node;
5235 TREE_OPERAND (rhs, 1)
5236 = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
5237 if (TREE_OPERAND (rhs, 1) == error_mark_node)
5238 return error_mark_node;
5239 TREE_OPERAND (rhs, 2)
5240 = instantiate_type (lhstype, TREE_OPERAND (rhs, 2), complain);
5241 if (TREE_OPERAND (rhs, 2) == error_mark_node)
5242 return error_mark_node;
5244 TREE_TYPE (rhs) = lhstype;
5248 TREE_OPERAND (rhs, 1)
5249 = instantiate_type (lhstype, TREE_OPERAND (rhs, 1), complain);
5250 if (TREE_OPERAND (rhs, 1) == error_mark_node)
5251 return error_mark_node;
5253 TREE_TYPE (rhs) = lhstype;
5257 if (TYPE_PTRMEMFUNC_P (lhstype))
5258 lhstype = TYPE_PTRMEMFUNC_FN_TYPE (lhstype);
5259 else if (TREE_CODE (lhstype) != POINTER_TYPE)
5262 error ("type for resolving address of overloaded function must be pointer type");
5263 return error_mark_node;
5265 TREE_TYPE (rhs) = lhstype;
5266 lhstype = TREE_TYPE (lhstype);
5268 tree fn = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain);
5269 if (fn == error_mark_node)
5270 return error_mark_node;
5271 mark_addressable (fn);
5272 TREE_OPERAND (rhs, 0) = fn;
5273 TREE_CONSTANT (rhs) = staticp (fn);
5277 case ENTRY_VALUE_EXPR:
5278 my_friendly_abort (184);
5279 return error_mark_node;
5282 return error_mark_node;
5285 my_friendly_abort (185);
5286 return error_mark_node;
5290 /* Return the name of the virtual function pointer field
5291 (as an IDENTIFIER_NODE) for the given TYPE. Note that
5292 this may have to look back through base types to find the
5293 ultimate field name. (For single inheritance, these could
5294 all be the same name. Who knows for multiple inheritance). */
5296 get_vfield_name (type)
5299 tree binfo = TYPE_BINFO (type);
5302 while (BINFO_BASETYPES (binfo)
5303 && TYPE_VIRTUAL_P (BINFO_TYPE (BINFO_BASETYPE (binfo, 0)))
5304 && ! TREE_VIA_VIRTUAL (BINFO_BASETYPE (binfo, 0)))
5305 binfo = BINFO_BASETYPE (binfo, 0);
5307 type = BINFO_TYPE (binfo);
5308 buf = (char *)alloca (sizeof (VFIELD_NAME_FORMAT)
5309 + TYPE_NAME_LENGTH (type) + 2);
5310 sprintf (buf, VFIELD_NAME_FORMAT, TYPE_NAME_STRING (type));
5311 return get_identifier (buf);
5315 print_class_statistics ()
5317 #ifdef GATHER_STATISTICS
5318 fprintf (stderr, "convert_harshness = %d\n", n_convert_harshness);
5319 fprintf (stderr, "compute_conversion_costs = %d\n", n_compute_conversion_costs);
5320 fprintf (stderr, "build_method_call = %d (inner = %d)\n",
5321 n_build_method_call, n_inner_fields_searched);
5324 fprintf (stderr, "vtables = %d; vtable searches = %d\n",
5325 n_vtables, n_vtable_searches);
5326 fprintf (stderr, "vtable entries = %d; vtable elems = %d\n",
5327 n_vtable_entries, n_vtable_elems);
5332 /* Push an obstack which is sufficiently long-lived to hold such class
5333 decls that may be cached in the previous_class_values list. For now, let's
5334 use the permanent obstack, later we may create a dedicated obstack just
5335 for this purpose. The effect is undone by pop_obstacks. */
5337 maybe_push_cache_obstack ()
5339 push_obstacks_nochange ();
5340 if (current_class_depth == 1)
5341 current_obstack = &permanent_obstack;