1 /* Breadth-first and depth-first routines for
2 searching multiple-inheritance lattice for GNU C++.
3 Copyright (C) 1987, 89, 92, 93, 94, 1995 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 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
*current_obstack
;
38 extern tree abort_fndecl
;
42 /* Obstack used for remembering decision points of breadth-first. */
44 static struct obstack search_obstack
;
46 /* Methods for pushing and popping objects to and from obstacks. */
49 push_stack_level (obstack
, tp
, size
)
50 struct obstack
*obstack
;
51 char *tp
; /* Sony NewsOS 5.0 compiler doesn't like void * here. */
54 struct stack_level
*stack
;
55 obstack_grow (obstack
, tp
, size
);
56 stack
= (struct stack_level
*) ((char*)obstack_next_free (obstack
) - size
);
57 obstack_finish (obstack
);
58 stack
->obstack
= obstack
;
59 stack
->first
= (tree
*) obstack_base (obstack
);
60 stack
->limit
= obstack_room (obstack
) / sizeof (tree
*);
65 pop_stack_level (stack
)
66 struct stack_level
*stack
;
68 struct stack_level
*tem
= stack
;
69 struct obstack
*obstack
= tem
->obstack
;
71 obstack_free (obstack
, tem
);
75 #define search_level stack_level
76 static struct search_level
*search_stack
;
78 static tree
lookup_field_1 ();
79 static int lookup_fnfields_1
PROTO((tree
, tree
));
80 static void dfs_walk ();
81 static int markedp ();
82 static void dfs_unmark ();
83 static void dfs_init_vbase_pointers ();
85 static tree vbase_types
;
86 static tree vbase_decl_ptr_intermediate
, vbase_decl_ptr
;
87 static tree vbase_init_result
;
89 /* Allocate a level of searching. */
91 static struct search_level
*
92 push_search_level (stack
, obstack
)
93 struct stack_level
*stack
;
94 struct obstack
*obstack
;
96 struct search_level tem
;
99 return push_stack_level (obstack
, (char *)&tem
, sizeof (tem
));
102 /* Discard a level of search allocation. */
104 static struct search_level
*
105 pop_search_level (obstack
)
106 struct stack_level
*obstack
;
108 register struct search_level
*stack
= pop_stack_level (obstack
);
113 /* Search memoization. */
117 struct stack_level base
;
119 /* First object allocated in obstack of entries. */
122 /* Number of types memoized in this context. */
125 /* Type being memoized; save this if we are saving
126 memoized contexts. */
130 /* Obstack used for memoizing member and member function lookup. */
132 static struct obstack type_obstack
, type_obstack_entries
;
133 static struct type_level
*type_stack
;
134 static tree _vptr_name
;
136 /* Make things that look like tree nodes, but allocate them
137 on type_obstack_entries. */
138 static int my_tree_node_counter
;
139 static tree
my_tree_cons (), my_build_string ();
141 extern int flag_memoize_lookups
, flag_save_memoized_contexts
;
143 /* Variables for gathering statistics. */
144 static int my_memoized_entry_counter
;
145 static int memoized_fast_finds
[2], memoized_adds
[2], memoized_fast_rejects
[2];
146 static int memoized_fields_searched
[2];
147 #ifdef GATHER_STATISTICS
148 static int n_fields_searched
;
149 static int n_calls_lookup_field
, n_calls_lookup_field_1
;
150 static int n_calls_lookup_fnfields
, n_calls_lookup_fnfields_1
;
151 static int n_calls_get_base_type
;
152 static int n_outer_fields_searched
;
153 static int n_contexts_saved
;
154 #endif /* GATHER_STATISTICS */
156 /* Local variables to help save memoization contexts. */
157 static tree prev_type_memoized
;
158 static struct type_level
*prev_type_stack
;
160 /* This list is used by push_class_decls to know what decls need to
161 be pushed into class scope. */
162 static tree closed_envelopes
= NULL_TREE
;
164 /* Allocate a level of type memoization context. */
166 static struct type_level
*
167 push_type_level (stack
, obstack
)
168 struct stack_level
*stack
;
169 struct obstack
*obstack
;
171 struct type_level tem
;
173 tem
.base
.prev
= stack
;
175 obstack_finish (&type_obstack_entries
);
176 tem
.entries
= (char *) obstack_base (&type_obstack_entries
);
178 tem
.type
= NULL_TREE
;
180 return (struct type_level
*)push_stack_level (obstack
, (char *)&tem
, sizeof (tem
));
183 /* Discard a level of type memoization context. */
185 static struct type_level
*
186 pop_type_level (stack
)
187 struct type_level
*stack
;
189 obstack_free (&type_obstack_entries
, stack
->entries
);
190 return (struct type_level
*)pop_stack_level ((struct stack_level
*)stack
);
193 /* Make something that looks like a TREE_LIST, but
194 do it on the type_obstack_entries obstack. */
197 my_tree_cons (purpose
, value
, chain
)
198 tree purpose
, value
, chain
;
200 tree p
= (tree
)obstack_alloc (&type_obstack_entries
, sizeof (struct tree_list
));
201 ++my_tree_node_counter
;
202 TREE_TYPE (p
) = NULL_TREE
;
203 ((HOST_WIDE_INT
*)p
)[3] = 0;
204 TREE_SET_CODE (p
, TREE_LIST
);
205 TREE_PURPOSE (p
) = purpose
;
206 TREE_VALUE (p
) = value
;
207 TREE_CHAIN (p
) = chain
;
212 my_build_string (str
)
215 tree p
= (tree
)obstack_alloc (&type_obstack_entries
, sizeof (struct tree_string
));
216 ++my_tree_node_counter
;
219 TREE_SET_CODE (p
, STRING_CST
);
220 TREE_STRING_POINTER (p
) = str
;
221 TREE_STRING_LENGTH (p
) = strlen (str
);
225 /* Memoizing machinery to make searches for multiple inheritance
226 reasonably efficient. */
228 #define MEMOIZE_HASHSIZE 8
229 typedef struct memoized_entry
231 struct memoized_entry
*chain
;
233 tree data_members
[MEMOIZE_HASHSIZE
];
234 tree function_members
[MEMOIZE_HASHSIZE
];
237 #define MEMOIZED_CHAIN(ENTRY) (((ME)ENTRY)->chain)
238 #define MEMOIZED_UID(ENTRY) (((ME)ENTRY)->uid)
239 #define MEMOIZED_FIELDS(ENTRY,INDEX) (((ME)ENTRY)->data_members[INDEX])
240 #define MEMOIZED_FNFIELDS(ENTRY,INDEX) (((ME)ENTRY)->function_members[INDEX])
241 /* The following is probably a lousy hash function. */
242 #define MEMOIZED_HASH_FN(NODE) (((long)(NODE)>>4)&(MEMOIZE_HASHSIZE - 1))
244 static struct memoized_entry
*
245 my_new_memoized_entry (chain
)
246 struct memoized_entry
*chain
;
248 struct memoized_entry
*p
=
249 (struct memoized_entry
*)obstack_alloc (&type_obstack_entries
,
250 sizeof (struct memoized_entry
));
251 bzero ((char *) p
, sizeof (struct memoized_entry
));
252 MEMOIZED_CHAIN (p
) = chain
;
253 MEMOIZED_UID (p
) = ++my_memoized_entry_counter
;
257 /* Clears the deferred pop from pop_memoized_context, if any. */
260 clear_memoized_cache ()
264 type_stack
= pop_type_level (prev_type_stack
);
265 prev_type_memoized
= 0;
270 /* Make an entry in the memoized table for type TYPE
271 that the entry for NAME is FIELD. */
274 make_memoized_table_entry (type
, name
, function_p
)
278 int idx
= MEMOIZED_HASH_FN (name
);
279 tree entry
, *prev_entry
;
281 /* Since we allocate from the type_obstack, we must pop any deferred
283 clear_memoized_cache ();
285 memoized_adds
[function_p
] += 1;
286 if (CLASSTYPE_MTABLE_ENTRY (type
) == 0)
288 obstack_ptr_grow (&type_obstack
, type
);
289 obstack_blank (&type_obstack
, sizeof (struct memoized_entry
*));
290 CLASSTYPE_MTABLE_ENTRY (type
) = (char *)my_new_memoized_entry ((struct memoized_entry
*)0);
292 if (type_stack
->len
* 2 >= type_stack
->base
.limit
)
293 my_friendly_abort (88);
296 prev_entry
= &MEMOIZED_FNFIELDS (CLASSTYPE_MTABLE_ENTRY (type
), idx
);
298 prev_entry
= &MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type
), idx
);
300 entry
= my_tree_cons (name
, NULL_TREE
, *prev_entry
);
303 /* Don't know the error message to give yet. */
304 TREE_TYPE (entry
) = error_mark_node
;
309 /* When a new function or class context is entered, we build
310 a table of types which have been searched for members.
311 The table is an array (obstack) of types. When a type is
312 entered into the obstack, its CLASSTYPE_MTABLE_ENTRY
313 field is set to point to a new record, of type struct memoized_entry.
315 A non-NULL TREE_TYPE of the entry contains an access control error message.
317 The slots for the data members are arrays of tree nodes.
318 These tree nodes are lists, with the TREE_PURPOSE
319 of this list the known member name, and the TREE_VALUE
320 as the FIELD_DECL for the member.
322 For member functions, the TREE_PURPOSE is again the
323 name of the member functions for that class,
324 and the TREE_VALUE of the list is a pairs
325 whose TREE_PURPOSE is a member functions of this name,
326 and whose TREE_VALUE is a list of known argument lists this
327 member function has been called with. The TREE_TYPE of the pair,
328 if non-NULL, is an error message to print. */
330 /* Tell search machinery that we are entering a new context, and
331 to update tables appropriately.
333 TYPE is the type of the context we are entering, which can
334 be NULL_TREE if we are not in a class's scope.
336 USE_OLD, if nonzero tries to use previous context. */
339 push_memoized_context (type
, use_old
)
348 if (use_old
&& prev_type_memoized
== type
)
350 #ifdef GATHER_STATISTICS
352 #endif /* GATHER_STATISTICS */
353 type_stack
= prev_type_stack
;
356 tem
= &type_stack
->base
.first
[0];
357 len
= type_stack
->len
;
359 CLASSTYPE_MTABLE_ENTRY (tem
[len
*2]) = (char *)tem
[len
*2+1];
362 /* Otherwise, need to pop old stack here. */
363 clear_memoized_cache ();
366 type_stack
= push_type_level ((struct stack_level
*)type_stack
,
368 type_stack
->type
= type
;
371 /* Tell search machinery that we have left a context.
372 We do not currently save these contexts for later use.
373 If we wanted to, we could not use pop_search_level, since
374 poping that level allows the data we have collected to
375 be clobbered; a stack of obstacks would be needed. */
378 pop_memoized_context (use_old
)
382 tree
*tem
= &type_stack
->base
.first
[0];
384 if (! flag_save_memoized_contexts
)
388 len
= type_stack
->len
;
390 tem
[len
*2+1] = (tree
)CLASSTYPE_MTABLE_ENTRY (tem
[len
*2]);
392 /* If there was a deferred pop, we need to pop it now. */
393 clear_memoized_cache ();
395 prev_type_stack
= type_stack
;
396 prev_type_memoized
= type_stack
->type
;
399 if (flag_memoize_lookups
)
401 len
= type_stack
->len
;
403 CLASSTYPE_MTABLE_ENTRY (tem
[len
*2])
404 = (char *)MEMOIZED_CHAIN (CLASSTYPE_MTABLE_ENTRY (tem
[len
*2]));
407 type_stack
= pop_type_level (type_stack
);
409 type_stack
= (struct type_level
*)type_stack
->base
.prev
;
412 /* Get a virtual binfo that is found inside BINFO's hierarchy that is
413 the same type as the type given in PARENT. To be optimal, we want
414 the first one that is found by going through the least number of
415 virtual bases. DEPTH should be NULL_PTR. */
418 get_vbase (parent
, binfo
, depth
)
424 tree rval
= NULL_TREE
;
428 unsigned int d
= (unsigned int)-1;
429 return get_vbase (parent
, binfo
, &d
);
432 if (BINFO_TYPE (binfo
) == parent
&& TREE_VIA_VIRTUAL (binfo
))
440 binfos
= BINFO_BASETYPES (binfo
);
441 n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
443 /* Process base types. */
444 for (i
= 0; i
< n_baselinks
; i
++)
446 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
452 nrval
= get_vbase (parent
, base_binfo
, depth
);
460 /* Convert EXPR to a virtual base class of type TYPE. We know that
461 EXPR is a non-null POINTER_TYPE to RECORD_TYPE. We also know that
462 the type of what expr points to has a virtual base of type TYPE. */
465 convert_pointer_to_vbase (type
, expr
)
469 tree vb
= get_vbase (type
, TYPE_BINFO (TREE_TYPE (TREE_TYPE (expr
))), NULL_PTR
);
470 return convert_pointer_to_real (vb
, expr
);
473 /* Check whether the type given in BINFO is derived from PARENT. If
474 it isn't, return 0. If it is, but the derivation is MI-ambiguous
475 AND protect != 0, emit an error message and return error_mark_node.
477 Otherwise, if TYPE is derived from PARENT, return the actual base
478 information, unless a one of the protection violations below
479 occurs, in which case emit an error message and return error_mark_node.
481 If PROTECT is 1, then check if access to a public field of PARENT
482 would be private. Also check for ambiguity. */
485 get_binfo (parent
, binfo
, protect
)
486 register tree parent
, binfo
;
491 tree rval
= NULL_TREE
;
493 if (TREE_CODE (parent
) == TREE_VEC
)
494 parent
= BINFO_TYPE (parent
);
495 else if (! IS_AGGR_TYPE_CODE (TREE_CODE (parent
)))
496 my_friendly_abort (89);
498 if (TREE_CODE (binfo
) == TREE_VEC
)
499 type
= BINFO_TYPE (binfo
);
500 else if (IS_AGGR_TYPE_CODE (TREE_CODE (binfo
)))
503 my_friendly_abort (90);
505 dist
= get_base_distance (parent
, binfo
, protect
, &rval
);
509 cp_error ("fields of `%T' are inaccessible in `%T' due to private inheritance",
511 return error_mark_node
;
513 else if (dist
== -2 && protect
)
515 cp_error ("type `%T' is ambiguous base class for type `%T'", parent
,
517 return error_mark_node
;
523 /* This is the newer depth first get_base_distance routine. */
526 get_base_distance_recursive (binfo
, depth
, is_private
, rval
,
527 rval_private_ptr
, new_binfo_ptr
, parent
, path_ptr
,
528 protect
, via_virtual_ptr
, via_virtual
,
529 current_scope_in_chain
)
531 int depth
, is_private
, rval
;
532 int *rval_private_ptr
;
533 tree
*new_binfo_ptr
, parent
, *path_ptr
;
534 int protect
, *via_virtual_ptr
, via_virtual
;
535 int current_scope_in_chain
;
541 && !current_scope_in_chain
542 && is_friend (BINFO_TYPE (binfo
), current_scope ()))
543 current_scope_in_chain
= 1;
545 if (BINFO_TYPE (binfo
) == parent
|| binfo
== parent
)
550 *rval_private_ptr
= is_private
;
551 *new_binfo_ptr
= binfo
;
552 *via_virtual_ptr
= via_virtual
;
556 int same_object
= (tree_int_cst_equal (BINFO_OFFSET (*new_binfo_ptr
),
557 BINFO_OFFSET (binfo
))
558 && *via_virtual_ptr
&& via_virtual
);
560 if (*via_virtual_ptr
&& via_virtual
==0)
562 *rval_private_ptr
= is_private
;
563 *new_binfo_ptr
= binfo
;
564 *via_virtual_ptr
= via_virtual
;
566 else if (same_object
)
568 if (*rval_private_ptr
&& ! is_private
)
570 *rval_private_ptr
= is_private
;
571 *new_binfo_ptr
= binfo
;
572 *via_virtual_ptr
= via_virtual
;
582 binfos
= BINFO_BASETYPES (binfo
);
583 n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
586 /* Process base types. */
587 for (i
= 0; i
< n_baselinks
; i
++)
589 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
591 /* Find any specific instance of a virtual base, when searching with
593 if (BINFO_MARKED (base_binfo
) == 0 || TREE_CODE (parent
) == TREE_VEC
)
598 || (!TREE_VIA_PUBLIC (base_binfo
)
599 && !(TREE_VIA_PROTECTED (base_binfo
)
600 && current_scope_in_chain
)
601 && !is_friend (BINFO_TYPE (binfo
), current_scope ()))));
602 int this_virtual
= via_virtual
|| TREE_VIA_VIRTUAL (base_binfo
);
605 /* When searching for a non-virtual, we cannot mark
606 virtually found binfos. */
608 SET_BINFO_MARKED (base_binfo
);
610 #define WATCH_VALUES(rval, via_private) (rval == -1 ? 3 : via_private)
612 was
= WATCH_VALUES (rval
, *via_virtual_ptr
);
613 rval
= get_base_distance_recursive (base_binfo
, depth
, via_private
,
614 rval
, rval_private_ptr
,
615 new_binfo_ptr
, parent
, path_ptr
,
616 protect
, via_virtual_ptr
,
618 current_scope_in_chain
);
619 /* watch for updates; only update if path is good. */
620 if (path_ptr
&& WATCH_VALUES (rval
, *via_virtual_ptr
) != was
)
621 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
622 if (rval
== -2 && *via_virtual_ptr
== 0)
633 /* Return the number of levels between type PARENT and the type given
634 in BINFO, following the leftmost path to PARENT not found along a
635 virtual path, if there are no real PARENTs (all come from virtual
636 base classes), then follow the leftmost path to PARENT.
638 Return -1 if TYPE is not derived from PARENT.
639 Return -2 if PARENT is an ambiguous base class of TYPE, and PROTECT is
641 Return -3 if PARENT is private to TYPE, and PROTECT is non-zero.
643 If PATH_PTR is non-NULL, then also build the list of types
644 from PARENT to TYPE, with TREE_VIA_VIRTUAL and TREE_VIA_PUBLIC
647 PARENT can also be a binfo, in which case that exact parent is found
648 and no other. convert_pointer_to_real uses this functionality.
650 If BINFO is a binfo, its BINFO_INHERITANCE_CHAIN will be left alone. */
653 get_base_distance (parent
, binfo
, protect
, path_ptr
)
654 register tree parent
, binfo
;
659 int rval_private
= 0;
661 tree new_binfo
= NULL_TREE
;
663 int watch_access
= protect
;
665 /* Should we be completing types here? */
666 if (TREE_CODE (parent
) != TREE_VEC
)
667 parent
= complete_type (TYPE_MAIN_VARIANT (parent
));
669 complete_type (TREE_TYPE (parent
));
671 if (TREE_CODE (binfo
) == TREE_VEC
)
672 type
= BINFO_TYPE (binfo
);
673 else if (IS_AGGR_TYPE_CODE (TREE_CODE (binfo
)))
675 type
= complete_type (binfo
);
676 binfo
= TYPE_BINFO (type
);
679 BINFO_INHERITANCE_CHAIN (binfo
) = NULL_TREE
;
682 my_friendly_abort (92);
684 if (parent
== type
|| parent
== binfo
)
686 /* If the distance is 0, then we don't really need
687 a path pointer, but we shouldn't let garbage go back. */
696 rval
= get_base_distance_recursive (binfo
, 0, 0, -1,
697 &rval_private
, &new_binfo
, parent
,
698 path_ptr
, watch_access
, &via_virtual
, 0,
701 dfs_walk (binfo
, dfs_unmark
, markedp
);
703 /* Access restrictions don't count if we found an ambiguous basetype. */
704 if (rval
== -2 && protect
>= 0)
707 if (rval
&& protect
&& rval_private
)
710 /* find real virtual base classes. */
711 if (rval
== -1 && TREE_CODE (parent
) == TREE_VEC
712 && parent
== binfo_member (BINFO_TYPE (parent
),
713 CLASSTYPE_VBASECLASSES (type
)))
715 BINFO_INHERITANCE_CHAIN (parent
) = binfo
;
721 *path_ptr
= new_binfo
;
725 /* Search for a member with name NAME in a multiple inheritance lattice
726 specified by TYPE. If it does not exist, return NULL_TREE.
727 If the member is ambiguously referenced, return `error_mark_node'.
728 Otherwise, return the FIELD_DECL. */
730 /* Do a 1-level search for NAME as a member of TYPE. The caller must
731 figure out whether it can access this field. (Since it is only one
732 level, this is reasonable.) */
735 lookup_field_1 (type
, name
)
738 register tree field
= TYPE_FIELDS (type
);
740 #ifdef GATHER_STATISTICS
741 n_calls_lookup_field_1
++;
742 #endif /* GATHER_STATISTICS */
745 #ifdef GATHER_STATISTICS
747 #endif /* GATHER_STATISTICS */
748 if (DECL_NAME (field
) == NULL_TREE
749 && TREE_CODE (TREE_TYPE (field
)) == UNION_TYPE
)
751 tree temp
= lookup_field_1 (TREE_TYPE (field
), name
);
755 if (DECL_NAME (field
) == name
)
757 if ((TREE_CODE(field
) == VAR_DECL
|| TREE_CODE(field
) == CONST_DECL
)
758 && DECL_ASSEMBLER_NAME (field
) != NULL
)
759 GNU_xref_ref(current_function_decl
,
760 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (field
)));
763 field
= TREE_CHAIN (field
);
766 if (name
== _vptr_name
)
768 /* Give the user what s/he thinks s/he wants. */
769 if (TYPE_VIRTUAL_P (type
))
770 return CLASSTYPE_VFIELD (type
);
775 /* There are a number of cases we need to be aware of here:
776 current_class_type current_function_decl
783 Those last two make life interesting. If we're in a function which is
784 itself inside a class, we need decls to go into the fn's decls (our
785 second case below). But if we're in a class and the class itself is
786 inside a function, we need decls to go into the decls for the class. To
787 achieve this last goal, we must see if, when both current_class_ptr and
788 current_function_decl are set, the class was declared inside that
789 function. If so, we know to put the decls into the class's scope. */
794 if (current_function_decl
== NULL_TREE
)
795 return current_class_type
;
796 if (current_class_type
== NULL_TREE
)
797 return current_function_decl
;
798 if (DECL_CLASS_CONTEXT (current_function_decl
) == current_class_type
)
799 return current_function_decl
;
801 return current_class_type
;
804 /* Compute the access of FIELD. This is done by computing
805 the access available to each type in BASETYPES (which comes
806 as a list of [via_public/basetype] in reverse order, namely base
807 class before derived class). The first one which defines a
808 access defines the access for the field. Otherwise, the
809 access of the field is that which occurs normally.
811 Uses global variables CURRENT_CLASS_TYPE and
812 CURRENT_FUNCTION_DECL to use friend relationships
815 This will be static when lookup_fnfield comes into this file.
817 access_public_node means that the field can be accessed by the current lexical
820 access_protected_node means that the field cannot be accessed by the current
821 lexical scope because it is protected.
823 access_private_node means that the field cannot be accessed by the current
824 lexical scope because it is private. */
827 #define PUBLIC_RETURN return (DECL_PUBLIC (field) = 1), access_public_node
828 #define PROTECTED_RETURN return (DECL_PROTECTED (field) = 1), access_protected_node
829 #define PRIVATE_RETURN return (DECL_PRIVATE (field) = 1), access_private_node
831 #define PUBLIC_RETURN return access_public_node
832 #define PROTECTED_RETURN return access_protected_node
833 #define PRIVATE_RETURN return access_private_node
837 /* Disabled with DECL_PUBLIC &c. */
838 static tree previous_scope
= NULL_TREE
;
842 compute_access (basetype_path
, field
)
843 tree basetype_path
, field
;
848 int protected_ok
, via_protected
;
849 extern int flag_access_control
;
851 /* Replaces static decl above. */
855 ((TREE_CODE (field
) == FUNCTION_DECL
&& DECL_STATIC_FUNCTION_P (field
))
856 || (TREE_CODE (field
) != FUNCTION_DECL
&& TREE_STATIC (field
)));
858 if (! flag_access_control
)
859 return access_public_node
;
861 /* The field lives in the current class. */
862 if (BINFO_TYPE (basetype_path
) == current_class_type
)
863 return access_public_node
;
866 /* Disabled until pushing function scope clears these out. If ever. */
867 /* Make these special cases fast. */
868 if (current_scope () == previous_scope
)
870 if (DECL_PUBLIC (field
))
871 return access_public_node
;
872 if (DECL_PROTECTED (field
))
873 return access_protected_node
;
874 if (DECL_PRIVATE (field
))
875 return access_private_node
;
879 /* We don't currently support access control on nested types. */
880 if (TREE_CODE (field
) == TYPE_DECL
)
881 return access_public_node
;
883 previous_scope
= current_scope ();
885 context
= DECL_CLASS_CONTEXT (field
);
886 if (context
== NULL_TREE
)
887 context
= DECL_CONTEXT (field
);
889 /* Fields coming from nested anonymous unions have their DECL_CLASS_CONTEXT
890 slot set to the union type rather than the record type containing
891 the anonymous union. */
892 if (context
&& TREE_CODE (context
) == UNION_TYPE
893 && ANON_AGGRNAME_P (TYPE_IDENTIFIER (context
)))
894 context
= TYPE_CONTEXT (context
);
896 /* Virtual function tables are never private. But we should know that
897 we are looking for this, and not even try to hide it. */
898 if (DECL_NAME (field
) && VFIELD_NAME_P (DECL_NAME (field
)) == 1)
901 /* Member found immediately within object. */
902 if (BINFO_INHERITANCE_CHAIN (basetype_path
) == NULL_TREE
)
904 /* Are we (or an enclosing scope) friends with the class that has
906 if (is_friend (context
, previous_scope
))
909 /* If it's private, it's private, you letch. */
910 if (TREE_PRIVATE (field
))
913 /* ARM $11.5. Member functions of a derived class can access the
914 non-static protected members of a base class only through a
915 pointer to the derived class, a reference to it, or an object
916 of it. Also any subsequently derived classes also have
918 else if (TREE_PROTECTED (field
))
920 if (current_class_type
922 && ACCESSIBLY_DERIVED_FROM_P (context
, current_class_type
))
931 /* must reverse more than one element */
932 basetype_path
= reverse_path (basetype_path
);
933 types
= basetype_path
;
935 access
= access_default_node
;
936 protected_ok
= static_mem
&& current_class_type
937 && ACCESSIBLY_DERIVED_FROM_P (BINFO_TYPE (types
), current_class_type
);
943 tree type
= BINFO_TYPE (binfo
);
946 /* Friends of a class can see protected members of its bases.
947 Note that classes are their own friends. */
948 if (is_friend (type
, previous_scope
))
954 member
= purpose_member (type
, DECL_ACCESS (field
));
957 access
= TREE_VALUE (member
);
961 types
= BINFO_INHERITANCE_CHAIN (types
);
963 /* If the next type was VIA_PROTECTED, then fields of all remaining
964 classes past that one are *at least* protected. */
967 if (TREE_VIA_PROTECTED (types
))
969 else if (! TREE_VIA_PUBLIC (types
) && ! private_ok
)
971 access
= access_private_node
;
978 reverse_path (basetype_path
);
980 /* No special visibilities apply. Use normal rules. */
982 if (access
== access_default_node
)
984 if (is_friend (context
, previous_scope
))
985 access
= access_public_node
;
986 else if (TREE_PRIVATE (field
))
987 access
= access_private_node
;
988 else if (TREE_PROTECTED (field
))
989 access
= access_protected_node
;
991 access
= access_public_node
;
994 if (access
== access_public_node
&& via_protected
)
995 access
= access_protected_node
;
997 if (access
== access_protected_node
&& protected_ok
)
998 access
= access_public_node
;
1001 if (access
== access_public_node
)
1002 DECL_PUBLIC (field
) = 1;
1003 else if (access
== access_protected_node
)
1004 DECL_PROTECTED (field
) = 1;
1005 else if (access
== access_private_node
)
1006 DECL_PRIVATE (field
) = 1;
1007 else my_friendly_abort (96);
1012 /* Routine to see if the sub-object denoted by the binfo PARENT can be
1013 found as a base class and sub-object of the object denoted by
1014 BINFO. This routine relies upon binfos not being shared, except
1015 for binfos for virtual bases. */
1018 is_subobject_of_p (parent
, binfo
)
1021 tree binfos
= BINFO_BASETYPES (binfo
);
1022 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1024 if (parent
== binfo
)
1027 /* Process and/or queue base types. */
1028 for (i
= 0; i
< n_baselinks
; i
++)
1030 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1031 if (TREE_VIA_VIRTUAL (base_binfo
))
1032 base_binfo
= TYPE_BINFO (BINFO_TYPE (base_binfo
));
1033 if (is_subobject_of_p (parent
, base_binfo
))
1039 /* See if a one FIELD_DECL hides another. This routine is meant to
1040 correspond to ANSI working paper Sept 17, 1992 10p4. The two
1041 binfos given are the binfos corresponding to the particular places
1042 the FIELD_DECLs are found. This routine relies upon binfos not
1043 being shared, except for virtual bases. */
1046 hides (hider_binfo
, hidee_binfo
)
1047 tree hider_binfo
, hidee_binfo
;
1049 /* hider hides hidee, if hider has hidee as a base class and
1050 the instance of hidee is a sub-object of hider. The first
1051 part is always true is the second part is true.
1053 When hider and hidee are the same (two ways to get to the exact
1054 same member) we consider either one as hiding the other. */
1055 return is_subobject_of_p (hidee_binfo
, hider_binfo
);
1058 /* Very similar to lookup_fnfields_1 but it ensures that at least one
1059 function was declared inside the class given by TYPE. It really should
1060 only return functions that match the given TYPE. */
1063 lookup_fnfields_here (type
, name
)
1066 int idx
= lookup_fnfields_1 (type
, name
);
1069 /* ctors and dtors are always only in the right class. */
1072 fndecls
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), idx
);
1075 if (TYPE_MAIN_VARIANT (DECL_CLASS_CONTEXT (fndecls
))
1076 == TYPE_MAIN_VARIANT (type
))
1078 fndecls
= TREE_CHAIN (fndecls
);
1083 /* Look for a field named NAME in an inheritance lattice dominated by
1084 XBASETYPE. PROTECT is zero if we can avoid computing access
1085 information, otherwise it is 1. WANT_TYPE is 1 when we should only
1086 return TYPE_DECLs, if no TYPE_DECL can be found return NULL_TREE.
1088 It was not clear what should happen if WANT_TYPE is set, and an
1089 ambiguity is found. At least one use (lookup_name) to not see
1093 lookup_field (xbasetype
, name
, protect
, want_type
)
1094 register tree xbasetype
, name
;
1095 int protect
, want_type
;
1097 int head
= 0, tail
= 0;
1098 tree rval
, rval_binfo
= NULL_TREE
, rval_binfo_h
;
1099 tree type
, basetype_chain
, basetype_path
;
1100 tree this_v
= access_default_node
;
1101 tree entry
, binfo
, binfo_h
;
1102 tree own_access
= access_default_node
;
1103 int vbase_name_p
= VBASE_NAME_P (name
);
1105 /* rval_binfo is the binfo associated with the found member, note,
1106 this can be set with useful information, even when rval is not
1107 set, because it must deal with ALL members, not just non-function
1108 members. It is used for ambiguity checking and the hidden
1109 checks. Whereas rval is only set if a proper (not hidden)
1110 non-function member is found. */
1112 /* rval_binfo_h and binfo_h are binfo values used when we perform the
1113 hiding checks, as virtual base classes may not be shared. The strategy
1114 is we always go into the the binfo hierarchy owned by TYPE_BINFO of
1115 virtual base classes, as we cross virtual base class lines. This way
1116 we know that binfo of a virtual base class will always == itself when
1117 found along any line. (mrs) */
1121 /* Set this to nonzero if we don't know how to compute
1122 accurate error messages for access control. */
1123 int idx
= MEMOIZED_HASH_FN (name
);
1126 /* We cannot search for constructor/destructor names like this. */
1127 /* This can't go here, but where should it go? */
1128 /* If we are looking for a constructor in a templated type, use the
1129 unspecialized name, as that is how we store it. */
1130 if (IDENTIFIER_TEMPLATE (name
))
1131 name
= constructor_name (name
);
1134 if (TREE_CODE (xbasetype
) == TREE_VEC
)
1136 type
= BINFO_TYPE (xbasetype
);
1137 basetype_path
= xbasetype
;
1139 else if (IS_AGGR_TYPE_CODE (TREE_CODE (xbasetype
)))
1141 type
= complete_type (xbasetype
);
1142 basetype_path
= TYPE_BINFO (type
);
1143 BINFO_VIA_PUBLIC (basetype_path
) = 1;
1144 BINFO_INHERITANCE_CHAIN (basetype_path
) = NULL_TREE
;
1146 else my_friendly_abort (97);
1148 if (CLASSTYPE_MTABLE_ENTRY (type
))
1150 tree tem
= MEMOIZED_FIELDS (CLASSTYPE_MTABLE_ENTRY (type
), idx
);
1152 while (tem
&& TREE_PURPOSE (tem
) != name
)
1154 memoized_fields_searched
[0]++;
1155 tem
= TREE_CHAIN (tem
);
1159 if (protect
&& TREE_TYPE (tem
))
1161 error (TREE_STRING_POINTER (TREE_TYPE (tem
)),
1162 IDENTIFIER_POINTER (name
),
1163 TYPE_NAME_STRING (DECL_FIELD_CONTEXT (TREE_VALUE (tem
))));
1164 return error_mark_node
;
1166 if (TREE_VALUE (tem
) == NULL_TREE
)
1167 memoized_fast_rejects
[0] += 1;
1169 memoized_fast_finds
[0] += 1;
1170 return TREE_VALUE (tem
);
1174 #ifdef GATHER_STATISTICS
1175 n_calls_lookup_field
++;
1176 #endif /* GATHER_STATISTICS */
1177 if (protect
&& flag_memoize_lookups
&& ! global_bindings_p ())
1178 entry
= make_memoized_table_entry (type
, name
, 0);
1182 rval
= lookup_field_1 (type
, name
);
1184 if (rval
|| lookup_fnfields_here (type
, name
) >= 0)
1190 if (TREE_CODE (rval
) != TYPE_DECL
)
1192 rval
= purpose_member (name
, CLASSTYPE_TAGS (type
));
1194 rval
= TYPE_MAIN_DECL (TREE_VALUE (rval
));
1199 if (TREE_CODE (rval
) == TYPE_DECL
1200 && lookup_fnfields_here (type
, name
) >= 0)
1205 if (protect
&& rval
)
1207 if (TREE_PRIVATE (rval
) | TREE_PROTECTED (rval
))
1208 this_v
= compute_access (basetype_path
, rval
);
1209 if (TREE_CODE (rval
) == CONST_DECL
)
1211 if (this_v
== access_private_node
)
1212 errstr
= "enum `%D' is a private value of class `%T'";
1213 else if (this_v
== access_protected_node
)
1214 errstr
= "enum `%D' is a protected value of class `%T'";
1218 if (this_v
== access_private_node
)
1219 errstr
= "member `%D' is a private member of class `%T'";
1220 else if (this_v
== access_protected_node
)
1221 errstr
= "member `%D' is a protected member of class `%T'";
1229 /* This depends on behavior of lookup_field_1! */
1230 tree error_string
= my_build_string (errstr
);
1231 TREE_TYPE (entry
) = error_string
;
1235 /* Let entry know there is no problem with this access. */
1236 TREE_TYPE (entry
) = NULL_TREE
;
1238 TREE_VALUE (entry
) = rval
;
1241 if (errstr
&& protect
)
1243 cp_error (errstr
, name
, type
);
1244 return error_mark_node
;
1249 basetype_chain
= build_tree_list (NULL_TREE
, basetype_path
);
1250 TREE_VIA_PUBLIC (basetype_chain
) = TREE_VIA_PUBLIC (basetype_path
);
1251 TREE_VIA_PROTECTED (basetype_chain
) = TREE_VIA_PROTECTED (basetype_path
);
1252 TREE_VIA_VIRTUAL (basetype_chain
) = TREE_VIA_VIRTUAL (basetype_path
);
1254 /* The ambiguity check relies upon breadth first searching. */
1256 search_stack
= push_search_level (search_stack
, &search_obstack
);
1257 binfo
= basetype_path
;
1262 tree binfos
= BINFO_BASETYPES (binfo
);
1263 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1266 /* Process and/or queue base types. */
1267 for (i
= 0; i
< n_baselinks
; i
++)
1269 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1270 if (BINFO_FIELDS_MARKED (base_binfo
) == 0)
1274 SET_BINFO_FIELDS_MARKED (base_binfo
);
1275 btypes
= my_tree_cons (NULL_TREE
, base_binfo
, basetype_chain
);
1276 TREE_VIA_PUBLIC (btypes
) = TREE_VIA_PUBLIC (base_binfo
);
1277 TREE_VIA_PROTECTED (btypes
) = TREE_VIA_PROTECTED (base_binfo
);
1278 TREE_VIA_VIRTUAL (btypes
) = TREE_VIA_VIRTUAL (base_binfo
);
1279 if (TREE_VIA_VIRTUAL (base_binfo
))
1280 btypes
= tree_cons (NULL_TREE
,
1281 TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h
), i
))),
1284 btypes
= tree_cons (NULL_TREE
,
1285 TREE_VEC_ELT (BINFO_BASETYPES (binfo_h
), i
),
1287 obstack_ptr_grow (&search_obstack
, btypes
);
1289 if (tail
>= search_stack
->limit
)
1290 my_friendly_abort (98);
1294 /* Process head of queue, if one exists. */
1298 basetype_chain
= search_stack
->first
[head
++];
1299 binfo_h
= TREE_VALUE (basetype_chain
);
1300 basetype_chain
= TREE_CHAIN (basetype_chain
);
1301 basetype_path
= TREE_VALUE (basetype_chain
);
1302 if (TREE_CHAIN (basetype_chain
))
1303 BINFO_INHERITANCE_CHAIN (basetype_path
) = TREE_VALUE (TREE_CHAIN (basetype_chain
));
1305 BINFO_INHERITANCE_CHAIN (basetype_path
) = NULL_TREE
;
1307 binfo
= basetype_path
;
1308 type
= BINFO_TYPE (binfo
);
1310 /* See if we can find NAME in TYPE. If RVAL is nonzero,
1311 and we do find NAME in TYPE, verify that such a second
1312 sighting is in fact valid. */
1314 nval
= lookup_field_1 (type
, name
);
1316 if (nval
|| lookup_fnfields_here (type
, name
)>=0)
1318 if (nval
&& nval
== rval
&& SHARED_MEMBER_P (nval
))
1320 /* This is ok, the member found is the same [class.ambig] */
1322 else if (rval_binfo
&& hides (rval_binfo_h
, binfo_h
))
1324 /* This is ok, the member found is in rval_binfo, not
1327 else if (rval_binfo
==NULL_TREE
|| hides (binfo_h
, rval_binfo_h
))
1329 /* This is ok, the member found is here (binfo), not in
1334 if (entry
|| protect
)
1335 this_v
= compute_access (basetype_path
, rval
);
1336 /* These may look ambiguous, but they really are not. */
1342 /* Undo finding it before, as something else hides it. */
1346 rval_binfo_h
= binfo_h
;
1350 /* This is ambiguous. */
1351 errstr
= "request for member `%D' is ambiguous";
1358 tree
*tp
= search_stack
->first
;
1359 tree
*search_tail
= tp
+ tail
;
1362 TREE_VALUE (entry
) = rval
;
1366 type
= BINFO_TYPE (rval_binfo
);
1372 if (TREE_CODE (rval
) != TYPE_DECL
)
1374 rval
= purpose_member (name
, CLASSTYPE_TAGS (type
));
1376 rval
= TYPE_MAIN_DECL (TREE_VALUE (rval
));
1381 if (TREE_CODE (rval
) == TYPE_DECL
1382 && lookup_fnfields_here (type
, name
) >= 0)
1388 if (rval
== NULL_TREE
)
1391 /* If this FIELD_DECL defines its own access level, deal with that. */
1392 if (rval
&& errstr
== 0
1393 && ((protect
&1) || entry
)
1394 && DECL_LANG_SPECIFIC (rval
)
1395 && DECL_ACCESS (rval
))
1397 while (tp
< search_tail
)
1399 /* If is possible for one of the derived types on the path to
1400 have defined special access for this field. Look for such
1401 declarations and report an error if a conflict is found. */
1404 if (this_v
!= access_default_node
)
1405 new_v
= compute_access (TREE_VALUE (TREE_CHAIN (*tp
)), rval
);
1406 if (this_v
!= access_default_node
&& new_v
!= this_v
)
1408 errstr
= "conflicting access to member `%D'";
1409 this_v
= access_default_node
;
1412 CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp
)));
1418 while (tp
< search_tail
)
1420 CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp
)));
1425 search_stack
= pop_search_level (search_stack
);
1429 if (own_access
== access_private_node
)
1430 errstr
= "member `%D' declared private";
1431 else if (own_access
== access_protected_node
)
1432 errstr
= "member `%D' declared protected";
1433 else if (this_v
== access_private_node
)
1434 errstr
= TREE_PRIVATE (rval
)
1435 ? "member `%D' is private"
1436 : "member `%D' is from private base class";
1437 else if (this_v
== access_protected_node
)
1438 errstr
= TREE_PROTECTED (rval
)
1439 ? "member `%D' is protected"
1440 : "member `%D' is from protected base class";
1447 tree error_string
= my_build_string (errstr
);
1448 /* Save error message with entry. */
1449 TREE_TYPE (entry
) = error_string
;
1453 /* Mark entry as having no error string. */
1454 TREE_TYPE (entry
) = NULL_TREE
;
1460 /* If we are not interested in ambiguities, don't report them,
1461 just return NULL_TREE. */
1466 if (errstr
&& protect
)
1468 cp_error (errstr
, name
, type
);
1469 rval
= error_mark_node
;
1474 /* Try to find NAME inside a nested class. */
1477 lookup_nested_field (name
, complain
)
1483 tree id
= NULL_TREE
;
1484 if (TREE_CHAIN (current_class_type
))
1486 /* Climb our way up the nested ladder, seeing if we're trying to
1487 modify a field in an enclosing class. If so, we should only
1488 be able to modify if it's static. */
1489 for (t
= TREE_CHAIN (current_class_type
);
1490 t
&& DECL_CONTEXT (t
);
1491 t
= TREE_CHAIN (DECL_CONTEXT (t
)))
1493 if (TREE_CODE (DECL_CONTEXT (t
)) != RECORD_TYPE
)
1496 /* N.B.: lookup_field will do the access checking for us */
1497 id
= lookup_field (DECL_CONTEXT (t
), name
, complain
, 0);
1498 if (id
== error_mark_node
)
1504 if (id
!= NULL_TREE
)
1506 if (TREE_CODE (id
) == FIELD_DECL
1507 && ! TREE_STATIC (id
)
1508 && TREE_TYPE (id
) != error_mark_node
)
1512 /* At parse time, we don't want to give this error, since
1513 we won't have enough state to make this kind of
1514 decision properly. But there are times (e.g., with
1515 enums in nested classes) when we do need to call
1516 this fn at parse time. So, in those cases, we pass
1517 complain as a 0 and just return a NULL_TREE. */
1518 cp_error ("assignment to non-static member `%D' of enclosing class `%T'",
1519 id
, DECL_CONTEXT (t
));
1520 /* Mark this for do_identifier(). It would otherwise
1521 claim that the variable was undeclared. */
1522 TREE_TYPE (id
) = error_mark_node
;
1538 /* TYPE is a class type. Return the index of the fields within
1539 the method vector with name NAME, or -1 is no such field exists. */
1542 lookup_fnfields_1 (type
, name
)
1545 register tree method_vec
= CLASSTYPE_METHOD_VEC (type
);
1547 if (method_vec
!= 0)
1549 register tree
*methods
= &TREE_VEC_ELT (method_vec
, 0);
1550 register tree
*end
= TREE_VEC_END (method_vec
);
1552 #ifdef GATHER_STATISTICS
1553 n_calls_lookup_fnfields_1
++;
1554 #endif /* GATHER_STATISTICS */
1556 /* Constructors are first... */
1557 if (*methods
&& name
== ctor_identifier
)
1560 /* and destructors are second. */
1561 if (*++methods
&& name
== dtor_identifier
)
1564 while (++methods
!= end
)
1566 #ifdef GATHER_STATISTICS
1567 n_outer_fields_searched
++;
1568 #endif /* GATHER_STATISTICS */
1569 if (DECL_NAME (*methods
) == name
)
1573 return methods
- &TREE_VEC_ELT (method_vec
, 0);
1579 /* Starting from BASETYPE, return a TREE_BASELINK-like object
1580 which gives the following information (in a list):
1582 TREE_TYPE: list of basetypes needed to get to...
1583 TREE_VALUE: list of all functions in a given type
1584 which have name NAME.
1586 No access information is computed by this function,
1587 other then to adorn the list of basetypes with
1590 If there are two ways to find a name (two members), if COMPLAIN is
1591 non-zero, then error_mark_node is returned, and an error message is
1592 printed, otherwise, just an error_mark_node is returned.
1594 As a special case, is COMPLAIN is -1, we don't complain, and we
1595 don't return error_mark_node, but rather the complete list of
1596 virtuals. This is used by get_virtuals_named_this. */
1599 lookup_fnfields (basetype_path
, name
, complain
)
1600 tree basetype_path
, name
;
1603 int head
= 0, tail
= 0;
1604 tree type
, rval
, rval_binfo
= NULL_TREE
, rvals
= NULL_TREE
, rval_binfo_h
;
1605 tree entry
, binfo
, basetype_chain
, binfo_h
;
1608 /* rval_binfo is the binfo associated with the found member, note,
1609 this can be set with useful information, even when rval is not
1610 set, because it must deal with ALL members, not just function
1611 members. It is used for ambiguity checking and the hidden
1612 checks. Whereas rval is only set if a proper (not hidden)
1613 function member is found. */
1615 /* rval_binfo_h and binfo_h are binfo values used when we perform the
1616 hiding checks, as virtual base classes may not be shared. The strategy
1617 is we always go into the the binfo hierarchy owned by TYPE_BINFO of
1618 virtual base classes, as we cross virtual base class lines. This way
1619 we know that binfo of a virtual base class will always == itself when
1620 found along any line. (mrs) */
1622 /* For now, don't try this. */
1623 int protect
= complain
;
1627 /* Set this to nonzero if we don't know how to compute
1628 accurate error messages for access control. */
1629 int idx
= MEMOIZED_HASH_FN (name
);
1634 protect
= complain
= 0;
1638 /* We cannot search for constructor/destructor names like this. */
1639 /* This can't go here, but where should it go? */
1640 /* If we are looking for a constructor in a templated type, use the
1641 unspecialized name, as that is how we store it. */
1642 if (IDENTIFIER_TEMPLATE (name
))
1643 name
= constructor_name (name
);
1646 binfo
= basetype_path
;
1648 type
= complete_type (BINFO_TYPE (basetype_path
));
1650 /* The memoization code is in need of maintenance. */
1651 if (!find_all
&& CLASSTYPE_MTABLE_ENTRY (type
))
1653 tree tem
= MEMOIZED_FNFIELDS (CLASSTYPE_MTABLE_ENTRY (type
), idx
);
1655 while (tem
&& TREE_PURPOSE (tem
) != name
)
1657 memoized_fields_searched
[1]++;
1658 tem
= TREE_CHAIN (tem
);
1662 if (protect
&& TREE_TYPE (tem
))
1664 error (TREE_STRING_POINTER (TREE_TYPE (tem
)),
1665 IDENTIFIER_POINTER (name
),
1666 TYPE_NAME_STRING (DECL_CLASS_CONTEXT (TREE_VALUE (TREE_VALUE (tem
)))));
1667 return error_mark_node
;
1669 if (TREE_VALUE (tem
) == NULL_TREE
)
1671 memoized_fast_rejects
[1] += 1;
1676 /* Want to return this, but we must make sure
1677 that access information is consistent. */
1678 tree baselink
= TREE_VALUE (tem
);
1679 tree memoized_basetypes
= TREE_PURPOSE (baselink
);
1680 tree these_basetypes
= basetype_path
;
1681 while (memoized_basetypes
&& these_basetypes
)
1683 memoized_fields_searched
[1]++;
1684 if (TREE_VALUE (memoized_basetypes
) != these_basetypes
)
1686 memoized_basetypes
= TREE_CHAIN (memoized_basetypes
);
1687 these_basetypes
= BINFO_INHERITANCE_CHAIN (these_basetypes
);
1689 /* The following statement is true only when both are NULL. */
1690 if (memoized_basetypes
== these_basetypes
)
1692 memoized_fast_finds
[1] += 1;
1693 return TREE_VALUE (tem
);
1695 /* else, we must re-find this field by hand. */
1696 baselink
= tree_cons (basetype_path
, TREE_VALUE (baselink
), TREE_CHAIN (baselink
));
1702 #ifdef GATHER_STATISTICS
1703 n_calls_lookup_fnfields
++;
1704 #endif /* GATHER_STATISTICS */
1705 if (protect
&& flag_memoize_lookups
&& ! global_bindings_p ())
1706 entry
= make_memoized_table_entry (type
, name
, 1);
1710 idx
= lookup_fnfields_here (type
, name
);
1711 if (idx
>= 0 || lookup_field_1 (type
, name
))
1713 rval_binfo
= basetype_path
;
1714 rval_binfo_h
= rval_binfo
;
1719 rval
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), idx
);
1720 rvals
= my_tree_cons (basetype_path
, rval
, rvals
);
1721 if (BINFO_BASETYPES (binfo
) && CLASSTYPE_BASELINK_VEC (type
))
1722 TREE_TYPE (rvals
) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type
), idx
);
1726 TREE_VALUE (entry
) = rvals
;
1727 TREE_TYPE (entry
) = NULL_TREE
;
1734 if (name
== ctor_identifier
|| name
== dtor_identifier
)
1736 /* Don't allow lookups of constructors and destructors to go
1737 deeper than the first place we look. */
1739 TREE_TYPE (entry
) = TREE_VALUE (entry
) = NULL_TREE
;
1744 if (basetype_path
== TYPE_BINFO (type
))
1746 basetype_chain
= CLASSTYPE_BINFO_AS_LIST (type
);
1747 TREE_VIA_PUBLIC (basetype_chain
) = 1;
1748 BINFO_VIA_PUBLIC (basetype_path
) = 1;
1749 BINFO_INHERITANCE_CHAIN (basetype_path
) = NULL_TREE
;
1753 basetype_chain
= build_tree_list (NULL_TREE
, basetype_path
);
1754 TREE_VIA_PUBLIC (basetype_chain
) = TREE_VIA_PUBLIC (basetype_path
);
1755 TREE_VIA_PROTECTED (basetype_chain
) = TREE_VIA_PROTECTED (basetype_path
);
1756 TREE_VIA_VIRTUAL (basetype_chain
) = TREE_VIA_VIRTUAL (basetype_path
);
1759 /* The ambiguity check relies upon breadth first searching. */
1761 search_stack
= push_search_level (search_stack
, &search_obstack
);
1762 binfo
= basetype_path
;
1767 tree binfos
= BINFO_BASETYPES (binfo
);
1768 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1771 /* Process and/or queue base types. */
1772 for (i
= 0; i
< n_baselinks
; i
++)
1774 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1775 if (BINFO_FIELDS_MARKED (base_binfo
) == 0)
1779 SET_BINFO_FIELDS_MARKED (base_binfo
);
1780 btypes
= my_tree_cons (NULL_TREE
, base_binfo
, basetype_chain
);
1781 TREE_VIA_PUBLIC (btypes
) = TREE_VIA_PUBLIC (base_binfo
);
1782 TREE_VIA_PROTECTED (btypes
) = TREE_VIA_PROTECTED (base_binfo
);
1783 TREE_VIA_VIRTUAL (btypes
) = TREE_VIA_VIRTUAL (base_binfo
);
1784 if (TREE_VIA_VIRTUAL (base_binfo
))
1785 btypes
= tree_cons (NULL_TREE
,
1786 TYPE_BINFO (BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo_h
), i
))),
1789 btypes
= tree_cons (NULL_TREE
,
1790 TREE_VEC_ELT (BINFO_BASETYPES (binfo_h
), i
),
1792 obstack_ptr_grow (&search_obstack
, btypes
);
1794 if (tail
>= search_stack
->limit
)
1795 my_friendly_abort (99);
1799 /* Process head of queue, if one exists. */
1803 basetype_chain
= search_stack
->first
[head
++];
1804 binfo_h
= TREE_VALUE (basetype_chain
);
1805 basetype_chain
= TREE_CHAIN (basetype_chain
);
1806 basetype_path
= TREE_VALUE (basetype_chain
);
1807 if (TREE_CHAIN (basetype_chain
))
1808 BINFO_INHERITANCE_CHAIN (basetype_path
) = TREE_VALUE (TREE_CHAIN (basetype_chain
));
1810 BINFO_INHERITANCE_CHAIN (basetype_path
) = NULL_TREE
;
1812 binfo
= basetype_path
;
1813 type
= BINFO_TYPE (binfo
);
1815 /* See if we can find NAME in TYPE. If RVAL is nonzero,
1816 and we do find NAME in TYPE, verify that such a second
1817 sighting is in fact valid. */
1819 idx
= lookup_fnfields_here (type
, name
);
1821 if (idx
>= 0 || (lookup_field_1 (type
, name
)!=NULL_TREE
&& !find_all
))
1823 if (rval_binfo
&& !find_all
&& hides (rval_binfo_h
, binfo_h
))
1825 /* This is ok, the member found is in rval_binfo, not
1828 else if (rval_binfo
==NULL_TREE
|| find_all
|| hides (binfo_h
, rval_binfo_h
))
1830 /* This is ok, the member found is here (binfo), not in
1834 rval
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), idx
);
1835 /* Note, rvals can only be previously set if find_all is
1837 rvals
= my_tree_cons (basetype_path
, rval
, rvals
);
1838 if (TYPE_BINFO_BASETYPES (type
)
1839 && CLASSTYPE_BASELINK_VEC (type
))
1840 TREE_TYPE (rvals
) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type
), idx
);
1844 /* Undo finding it before, as something else hides it. */
1849 rval_binfo_h
= binfo_h
;
1853 /* This is ambiguous. */
1854 errstr
= "request for method `%D' is ambiguous";
1855 rvals
= error_mark_node
;
1861 tree
*tp
= search_stack
->first
;
1862 tree
*search_tail
= tp
+ tail
;
1864 while (tp
< search_tail
)
1866 CLEAR_BINFO_FIELDS_MARKED (TREE_VALUE (TREE_CHAIN (*tp
)));
1870 search_stack
= pop_search_level (search_stack
);
1876 tree error_string
= my_build_string (errstr
);
1877 /* Save error message with entry. */
1878 TREE_TYPE (entry
) = error_string
;
1882 /* Mark entry as having no error string. */
1883 TREE_TYPE (entry
) = NULL_TREE
;
1884 TREE_VALUE (entry
) = rvals
;
1888 if (errstr
&& protect
)
1890 cp_error (errstr
, name
);
1891 rvals
= error_mark_node
;
1897 /* BREADTH-FIRST SEARCH ROUTINES. */
1899 /* Search a multiple inheritance hierarchy by breadth-first search.
1901 BINFO is an aggregate type, possibly in a multiple-inheritance hierarchy.
1902 TESTFN is a function, which, if true, means that our condition has been met,
1903 and its return value should be returned.
1904 QFN, if non-NULL, is a predicate dictating whether the type should
1907 static HOST_WIDE_INT
1908 breadth_first_search (binfo
, testfn
, qfn
)
1913 int head
= 0, tail
= 0;
1916 search_stack
= push_search_level (search_stack
, &search_obstack
);
1920 tree binfos
= BINFO_BASETYPES (binfo
);
1921 int n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
1924 /* Process and/or queue base types. */
1925 for (i
= 0; i
< n_baselinks
; i
++)
1927 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
1929 if (BINFO_MARKED (base_binfo
) == 0
1930 && (qfn
== 0 || (*qfn
) (binfo
, i
)))
1932 SET_BINFO_MARKED (base_binfo
);
1933 obstack_ptr_grow (&search_obstack
, binfo
);
1934 obstack_ptr_grow (&search_obstack
, (HOST_WIDE_INT
) i
);
1936 if (tail
>= search_stack
->limit
)
1937 my_friendly_abort (100);
1940 /* Process head of queue, if one exists. */
1947 binfo
= search_stack
->first
[head
++];
1948 i
= (HOST_WIDE_INT
) search_stack
->first
[head
++];
1949 if (rval
= (*testfn
) (binfo
, i
))
1951 binfo
= BINFO_BASETYPE (binfo
, i
);
1954 tree
*tp
= search_stack
->first
;
1955 tree
*search_tail
= tp
+ tail
;
1956 while (tp
< search_tail
)
1959 int i
= (HOST_WIDE_INT
)(*tp
++);
1960 CLEAR_BINFO_MARKED (BINFO_BASETYPE (binfo
, i
));
1964 search_stack
= pop_search_level (search_stack
);
1968 /* Functions to use in breadth first searches. */
1969 typedef tree (*pft
)();
1970 typedef int (*pfi
)();
1972 static tree declarator
;
1975 get_virtuals_named_this (binfo
)
1980 fields
= lookup_fnfields (binfo
, declarator
, -1);
1981 /* fields cannot be error_mark_node */
1986 /* Get to the function decls, and return the first virtual function
1987 with this name, if there is one. */
1992 for (fndecl
= TREE_VALUE (fields
); fndecl
; fndecl
= DECL_CHAIN (fndecl
))
1993 if (DECL_VINDEX (fndecl
))
1995 fields
= next_baselink (fields
);
2001 get_virtual_destructor (binfo
, i
)
2005 tree type
= BINFO_TYPE (binfo
);
2007 type
= BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo
), i
));
2008 if (TYPE_HAS_DESTRUCTOR (type
)
2009 && DECL_VINDEX (TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), 1)))
2010 return TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), 1);
2015 tree_has_any_destructor_p (binfo
, i
)
2019 tree type
= BINFO_TYPE (binfo
);
2021 type
= BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (binfo
), i
));
2022 return TYPE_NEEDS_DESTRUCTOR (type
);
2025 /* Given a class type TYPE, and a function decl FNDECL, look for a
2026 virtual function in TYPE's hierarchy which FNDECL could match as a
2027 virtual function. It doesn't matter which one we find.
2029 DTORP is nonzero if we are looking for a destructor. Destructors
2030 need special treatment because they do not match by name. */
2033 get_matching_virtual (binfo
, fndecl
, dtorp
)
2037 tree tmp
= NULL_TREE
;
2039 /* Breadth first search routines start searching basetypes
2040 of TYPE, so we must perform first ply of search here. */
2043 if (tree_has_any_destructor_p (binfo
, -1))
2044 tmp
= get_virtual_destructor (binfo
, -1);
2049 tmp
= (tree
) breadth_first_search (binfo
,
2050 (pfi
) get_virtual_destructor
,
2051 tree_has_any_destructor_p
);
2056 tree drettype
, dtypes
, btypes
, instptr_type
;
2057 tree basetype
= DECL_CLASS_CONTEXT (fndecl
);
2058 tree baselink
, best
= NULL_TREE
;
2059 tree name
= DECL_ASSEMBLER_NAME (fndecl
);
2061 declarator
= DECL_NAME (fndecl
);
2062 if (IDENTIFIER_VIRTUAL_P (declarator
) == 0)
2065 baselink
= get_virtuals_named_this (binfo
);
2066 if (baselink
== NULL_TREE
)
2069 drettype
= TREE_TYPE (TREE_TYPE (fndecl
));
2070 dtypes
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
2071 if (DECL_STATIC_FUNCTION_P (fndecl
))
2072 instptr_type
= NULL_TREE
;
2074 instptr_type
= TREE_TYPE (TREE_VALUE (dtypes
));
2076 for (; baselink
; baselink
= next_baselink (baselink
))
2078 for (tmp
= TREE_VALUE (baselink
); tmp
; tmp
= DECL_CHAIN (tmp
))
2080 if (! DECL_VINDEX (tmp
))
2083 btypes
= TYPE_ARG_TYPES (TREE_TYPE (tmp
));
2084 if (instptr_type
== NULL_TREE
)
2086 if (compparms (TREE_CHAIN (btypes
), dtypes
, 3))
2087 /* Caller knows to give error in this case. */
2092 if ((TYPE_READONLY (TREE_TYPE (TREE_VALUE (btypes
)))
2093 == TYPE_READONLY (instptr_type
))
2094 && compparms (TREE_CHAIN (btypes
), TREE_CHAIN (dtypes
), 3))
2096 tree brettype
= TREE_TYPE (TREE_TYPE (tmp
));
2097 if (comptypes (brettype
, drettype
, 1))
2100 (TREE_CODE (brettype
) == TREE_CODE (drettype
)
2101 && (TREE_CODE (brettype
) == POINTER_TYPE
2102 || TREE_CODE (brettype
) == REFERENCE_TYPE
)
2103 && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (brettype
)),
2104 TYPE_MAIN_VARIANT (TREE_TYPE (drettype
)),
2106 /* covariant return type */
2108 tree b
= TREE_TYPE (brettype
), d
= TREE_TYPE (drettype
);
2109 if (TYPE_MAIN_VARIANT (b
) != TYPE_MAIN_VARIANT (d
))
2111 tree binfo
= get_binfo (b
, d
, 1);
2112 if (binfo
!= error_mark_node
2113 && ! BINFO_OFFSET_ZEROP (binfo
))
2114 sorry ("adjusting pointers for covariant returns");
2116 if (TYPE_READONLY (d
) > TYPE_READONLY (b
))
2118 cp_error_at ("return type of `%#D' adds const", fndecl
);
2119 cp_error_at (" overriding definition as `%#D'",
2122 else if (TYPE_VOLATILE (d
) > TYPE_VOLATILE (b
))
2124 cp_error_at ("return type of `%#D' adds volatile",
2126 cp_error_at (" overriding definition as `%#D'",
2130 else if (IS_AGGR_TYPE_2 (brettype
, drettype
)
2131 && comptypes (brettype
, drettype
, 0))
2133 error ("invalid covariant return type (must use pointer or reference)");
2134 cp_error_at (" overriding `%#D'", tmp
);
2135 cp_error_at (" with `%#D'", fndecl
);
2137 else if (IDENTIFIER_ERROR_LOCUS (name
) == NULL_TREE
)
2139 cp_error_at ("conflicting return type specified for virtual function `%#D'", fndecl
);
2140 cp_error_at (" overriding definition as `%#D'", tmp
);
2141 SET_IDENTIFIER_ERROR_LOCUS (name
, basetype
);
2157 /* Return the list of virtual functions which are abstract in type
2158 TYPE that come from non virtual base classes. See
2159 expand_direct_vtbls_init for the style of search we do. */
2162 get_abstract_virtuals_1 (binfo
, do_self
, abstract_virtuals
)
2165 tree abstract_virtuals
;
2167 tree binfos
= BINFO_BASETYPES (binfo
);
2168 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
2170 for (i
= 0; i
< n_baselinks
; i
++)
2172 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
2173 int is_not_base_vtable
=
2174 i
!= CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo
));
2175 if (! TREE_VIA_VIRTUAL (base_binfo
))
2177 = get_abstract_virtuals_1 (base_binfo
, is_not_base_vtable
,
2180 /* Should we use something besides CLASSTYPE_VFIELDS? */
2181 if (do_self
&& CLASSTYPE_VFIELDS (BINFO_TYPE (binfo
)))
2183 tree virtuals
= BINFO_VIRTUALS (binfo
);
2185 skip_rtti_stuff (&virtuals
);
2189 tree base_pfn
= FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
));
2190 tree base_fndecl
= TREE_OPERAND (base_pfn
, 0);
2191 if (DECL_ABSTRACT_VIRTUAL_P (base_fndecl
))
2192 abstract_virtuals
= tree_cons (NULL_TREE
, base_fndecl
, abstract_virtuals
);
2193 virtuals
= TREE_CHAIN (virtuals
);
2196 return abstract_virtuals
;
2199 /* Return the list of virtual functions which are abstract in type TYPE.
2200 This information is cached, and so must be built on a
2201 non-temporary obstack. */
2204 get_abstract_virtuals (type
)
2208 tree abstract_virtuals
= CLASSTYPE_ABSTRACT_VIRTUALS (type
);
2210 /* First get all from non-virtual bases. */
2212 = get_abstract_virtuals_1 (TYPE_BINFO (type
), 1, abstract_virtuals
);
2214 for (vbases
= CLASSTYPE_VBASECLASSES (type
); vbases
; vbases
= TREE_CHAIN (vbases
))
2216 tree virtuals
= BINFO_VIRTUALS (vbases
);
2218 skip_rtti_stuff (&virtuals
);
2222 tree base_pfn
= FNADDR_FROM_VTABLE_ENTRY (TREE_VALUE (virtuals
));
2223 tree base_fndecl
= TREE_OPERAND (base_pfn
, 0);
2224 if (DECL_ABSTRACT_VIRTUAL_P (base_fndecl
))
2225 abstract_virtuals
= tree_cons (NULL_TREE
, base_fndecl
, abstract_virtuals
);
2226 virtuals
= TREE_CHAIN (virtuals
);
2229 return nreverse (abstract_virtuals
);
2232 /* For the type TYPE, return a list of member functions available from
2233 base classes with name NAME. The TREE_VALUE of the list is a chain of
2234 member functions with name NAME. The TREE_PURPOSE of the list is a
2235 basetype, or a list of base types (in reverse order) which were
2236 traversed to reach the chain of member functions. If we reach a base
2237 type which provides a member function of name NAME, and which has at
2238 most one base type itself, then we can terminate the search. */
2241 get_baselinks (type_as_binfo_list
, type
, name
)
2242 tree type_as_binfo_list
;
2245 int head
= 0, tail
= 0, idx
;
2246 tree rval
= 0, nval
= 0;
2247 tree basetypes
= type_as_binfo_list
;
2248 tree binfo
= TYPE_BINFO (type
);
2250 search_stack
= push_search_level (search_stack
, &search_obstack
);
2254 tree binfos
= BINFO_BASETYPES (binfo
);
2255 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
2257 /* Process and/or queue base types. */
2258 for (i
= 0; i
< n_baselinks
; i
++)
2260 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
2263 btypes
= hash_tree_cons (TREE_VIA_PUBLIC (base_binfo
),
2264 TREE_VIA_VIRTUAL (base_binfo
),
2265 TREE_VIA_PROTECTED (base_binfo
),
2266 NULL_TREE
, base_binfo
,
2268 obstack_ptr_grow (&search_obstack
, btypes
);
2269 search_stack
->first
= (tree
*)obstack_base (&search_obstack
);
2274 /* Process head of queue, if one exists. */
2278 basetypes
= search_stack
->first
[head
++];
2279 binfo
= TREE_VALUE (basetypes
);
2280 type
= BINFO_TYPE (binfo
);
2281 idx
= lookup_fnfields_1 (type
, name
);
2284 nval
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (type
), idx
);
2285 rval
= hash_tree_cons (0, 0, 0, basetypes
, nval
, rval
);
2286 if (TYPE_BINFO_BASETYPES (type
) == 0)
2288 else if (TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type
)) == 1)
2290 if (CLASSTYPE_BASELINK_VEC (type
))
2291 TREE_TYPE (rval
) = TREE_VEC_ELT (CLASSTYPE_BASELINK_VEC (type
), idx
);
2298 search_stack
= pop_search_level (search_stack
);
2303 next_baselink (baselink
)
2306 tree tmp
= TREE_TYPE (baselink
);
2307 baselink
= TREE_CHAIN (baselink
);
2310 /* @@ does not yet add previous base types. */
2311 baselink
= tree_cons (TREE_PURPOSE (tmp
), TREE_VALUE (tmp
),
2313 TREE_TYPE (baselink
) = TREE_TYPE (tmp
);
2314 tmp
= TREE_CHAIN (tmp
);
2319 /* DEPTH-FIRST SEARCH ROUTINES. */
2321 /* Assign unique numbers to _CLASSTYPE members of the lattice
2322 specified by TYPE. The root nodes are marked first; the nodes
2323 are marked depth-fisrt, left-right. */
2327 /* Matrix implementing a relation from CLASSTYPE X CLASSTYPE => INT.
2328 Relation yields 1 if C1 <= C2, 0 otherwise. */
2329 typedef char mi_boolean
;
2330 static mi_boolean
*mi_matrix
;
2332 /* Type for which this matrix is defined. */
2333 static tree mi_type
;
2335 /* Size of the matrix for indexing purposes. */
2338 /* Return nonzero if class C2 derives from class C1. */
2339 #define BINFO_DERIVES_FROM(C1, C2) \
2340 ((mi_matrix+mi_size*(BINFO_CID (C1)-1))[BINFO_CID (C2)-1])
2341 #define TYPE_DERIVES_FROM(C1, C2) \
2342 ((mi_matrix+mi_size*(CLASSTYPE_CID (C1)-1))[CLASSTYPE_CID (C2)-1])
2343 #define BINFO_DERIVES_FROM_STAR(C) \
2344 (mi_matrix+(BINFO_CID (C)-1))
2346 /* This routine converts a pointer to be a pointer of an immediate
2347 base class. The normal convert_pointer_to routine would diagnose
2348 the conversion as ambiguous, under MI code that has the base class
2349 as an ambiguous base class. */
2352 convert_pointer_to_single_level (to_type
, expr
)
2355 tree binfo_of_derived
;
2358 binfo_of_derived
= TYPE_BINFO (TREE_TYPE (TREE_TYPE (expr
)));
2359 last
= get_binfo (to_type
, TREE_TYPE (TREE_TYPE (expr
)), 0);
2360 BINFO_INHERITANCE_CHAIN (last
) = binfo_of_derived
;
2361 BINFO_INHERITANCE_CHAIN (binfo_of_derived
) = NULL_TREE
;
2362 return build_vbase_path (PLUS_EXPR
, build_pointer_type (to_type
), expr
, last
, 1);
2365 /* The main function which implements depth first search.
2367 This routine has to remember the path it walked up, when
2368 dfs_init_vbase_pointers is the work function, as otherwise there
2369 would be no record. */
2372 dfs_walk (binfo
, fn
, qfn
)
2377 tree binfos
= BINFO_BASETYPES (binfo
);
2378 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
2380 for (i
= 0; i
< n_baselinks
; i
++)
2382 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
2384 if (qfn
== 0 || (*qfn
)(base_binfo
))
2386 if (TREE_CODE (BINFO_TYPE (base_binfo
)) == TEMPLATE_TYPE_PARM
)
2388 else if (fn
== dfs_init_vbase_pointers
)
2390 /* When traversing an arbitrary MI hierarchy, we need to keep
2391 a record of the path we took to get down to the final base
2392 type, as otherwise there would be no record of it, and just
2393 trying to blindly convert at the bottom would be ambiguous.
2395 The easiest way is to do the conversions one step at a time,
2396 as we know we want the immediate base class at each step.
2398 The only special trick to converting one step at a time,
2399 is that when we hit the last virtual base class, we must
2400 use the SLOT value for it, and not use the normal convert
2401 routine. We use the last virtual base class, as in our
2402 implementation, we have pointers to all virtual base
2403 classes in the base object. */
2405 tree saved_vbase_decl_ptr_intermediate
2406 = vbase_decl_ptr_intermediate
;
2408 if (TREE_VIA_VIRTUAL (base_binfo
))
2410 /* No need for the conversion here, as we know it is the
2412 vbase_decl_ptr_intermediate
2413 = CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (base_binfo
));
2417 vbase_decl_ptr_intermediate
2418 = convert_pointer_to_single_level (BINFO_TYPE (base_binfo
),
2419 vbase_decl_ptr_intermediate
);
2422 dfs_walk (base_binfo
, fn
, qfn
);
2424 vbase_decl_ptr_intermediate
= saved_vbase_decl_ptr_intermediate
;
2427 dfs_walk (base_binfo
, fn
, qfn
);
2434 /* Predicate functions which serve for dfs_walk. */
2435 static int numberedp (binfo
) tree binfo
;
2436 { return BINFO_CID (binfo
); }
2437 static int unnumberedp (binfo
) tree binfo
;
2438 { return BINFO_CID (binfo
) == 0; }
2440 static int markedp (binfo
) tree binfo
;
2441 { return BINFO_MARKED (binfo
); }
2442 static int unmarkedp (binfo
) tree binfo
;
2443 { return BINFO_MARKED (binfo
) == 0; }
2446 static int bfs_markedp (binfo
, i
) tree binfo
; int i
;
2447 { return BINFO_MARKED (BINFO_BASETYPE (binfo
, i
)); }
2448 static int bfs_unmarkedp (binfo
, i
) tree binfo
; int i
;
2449 { return BINFO_MARKED (BINFO_BASETYPE (binfo
, i
)) == 0; }
2450 static int bfs_marked_vtable_pathp (binfo
, i
) tree binfo
; int i
;
2451 { return BINFO_VTABLE_PATH_MARKED (BINFO_BASETYPE (binfo
, i
)); }
2452 static int bfs_unmarked_vtable_pathp (binfo
, i
) tree binfo
; int i
;
2453 { return BINFO_VTABLE_PATH_MARKED (BINFO_BASETYPE (binfo
, i
)) == 0; }
2454 static int bfs_marked_new_vtablep (binfo
, i
) tree binfo
; int i
;
2455 { return BINFO_NEW_VTABLE_MARKED (BINFO_BASETYPE (binfo
, i
)); }
2456 static int bfs_unmarked_new_vtablep (binfo
, i
) tree binfo
; int i
;
2457 { return BINFO_NEW_VTABLE_MARKED (BINFO_BASETYPE (binfo
, i
)) == 0; }
2460 static int marked_vtable_pathp (binfo
) tree binfo
;
2461 { return BINFO_VTABLE_PATH_MARKED (binfo
); }
2462 static int unmarked_vtable_pathp (binfo
) tree binfo
;
2463 { return BINFO_VTABLE_PATH_MARKED (binfo
) == 0; }
2464 static int marked_new_vtablep (binfo
) tree binfo
;
2465 { return BINFO_NEW_VTABLE_MARKED (binfo
); }
2466 static int unmarked_new_vtablep (binfo
) tree binfo
;
2467 { return BINFO_NEW_VTABLE_MARKED (binfo
) == 0; }
2470 static int dfs_search_slot_nonempty_p (binfo
) tree binfo
;
2471 { return CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (binfo
)) != 0; }
2474 static int dfs_debug_unmarkedp (binfo
) tree binfo
;
2475 { return CLASSTYPE_DEBUG_REQUESTED (BINFO_TYPE (binfo
)) == 0; }
2477 /* The worker functions for `dfs_walk'. These do not need to
2478 test anything (vis a vis marking) if they are paired with
2479 a predicate function (above). */
2481 /* Assign each type within the lattice a number which is unique
2482 in the lattice. The first number assigned is 1. */
2488 BINFO_CID (binfo
) = ++cid
;
2492 dfs_unnumber (binfo
)
2495 BINFO_CID (binfo
) = 0;
2500 dfs_mark (binfo
) tree binfo
;
2501 { SET_BINFO_MARKED (binfo
); }
2505 dfs_unmark (binfo
) tree binfo
;
2506 { CLEAR_BINFO_MARKED (binfo
); }
2510 dfs_mark_vtable_path (binfo
) tree binfo
;
2511 { SET_BINFO_VTABLE_PATH_MARKED (binfo
); }
2514 dfs_unmark_vtable_path (binfo
) tree binfo
;
2515 { CLEAR_BINFO_VTABLE_PATH_MARKED (binfo
); }
2518 dfs_mark_new_vtable (binfo
) tree binfo
;
2519 { SET_BINFO_NEW_VTABLE_MARKED (binfo
); }
2522 dfs_unmark_new_vtable (binfo
) tree binfo
;
2523 { CLEAR_BINFO_NEW_VTABLE_MARKED (binfo
); }
2526 dfs_clear_search_slot (binfo
) tree binfo
;
2527 { CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (binfo
)) = 0; }
2531 dfs_debug_mark (binfo
)
2534 tree t
= BINFO_TYPE (binfo
);
2536 /* Use heuristic that if there are virtual functions,
2537 ignore until we see a non-inline virtual function. */
2538 tree methods
= CLASSTYPE_METHOD_VEC (t
);
2540 CLASSTYPE_DEBUG_REQUESTED (t
) = 1;
2542 /* If interface info is known, the value of (?@@?) is correct. */
2544 || CLASSTYPE_INTERFACE_KNOWN (t
)
2545 || (write_virtuals
== 2 && TYPE_VIRTUAL_P (t
)))
2548 /* If debug info is requested from this context for this type, supply it.
2549 If debug info is requested from another context for this type,
2550 see if some third context can supply it. */
2551 if (current_function_decl
== NULL_TREE
2552 || DECL_CLASS_CONTEXT (current_function_decl
) != t
)
2554 if (TREE_VEC_ELT (methods
, 1))
2555 methods
= TREE_VEC_ELT (methods
, 1);
2556 else if (TREE_VEC_ELT (methods
, 0))
2557 methods
= TREE_VEC_ELT (methods
, 0);
2559 methods
= TREE_VEC_ELT (methods
, 2);
2562 if (DECL_VINDEX (methods
)
2563 && DECL_THIS_INLINE (methods
) == 0
2564 && DECL_ABSTRACT_VIRTUAL_P (methods
) == 0)
2566 /* Somebody, somewhere is going to have to define this
2567 virtual function. When they do, they will provide
2568 the debugging info. */
2571 methods
= TREE_CHAIN (methods
);
2574 /* We cannot rely on some alien method to solve our problems,
2575 so we must write out the debug info ourselves. */
2576 TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t
)) = 0;
2577 rest_of_type_compilation (t
, global_bindings_p ());
2580 /* Attach to the type of the virtual base class, the pointer to the
2581 virtual base class, given the global pointer vbase_decl_ptr.
2583 We use the global vbase_types. ICK! */
2586 dfs_find_vbases (binfo
)
2589 tree binfos
= BINFO_BASETYPES (binfo
);
2590 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
2592 for (i
= n_baselinks
-1; i
>= 0; i
--)
2594 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
2596 if (TREE_VIA_VIRTUAL (base_binfo
)
2597 && CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (base_binfo
)) == 0)
2599 tree vbase
= BINFO_TYPE (base_binfo
);
2600 tree binfo
= binfo_member (vbase
, vbase_types
);
2602 CLASSTYPE_SEARCH_SLOT (vbase
)
2603 = build (PLUS_EXPR
, build_pointer_type (vbase
),
2604 vbase_decl_ptr
, BINFO_OFFSET (binfo
));
2607 SET_BINFO_VTABLE_PATH_MARKED (binfo
);
2608 SET_BINFO_NEW_VTABLE_MARKED (binfo
);
2612 dfs_init_vbase_pointers (binfo
)
2615 tree type
= BINFO_TYPE (binfo
);
2616 tree fields
= TYPE_FIELDS (type
);
2617 tree this_vbase_ptr
;
2619 CLEAR_BINFO_VTABLE_PATH_MARKED (binfo
);
2622 /* See finish_struct_1 for when we can enable this. */
2623 /* If we have a vtable pointer first, skip it. */
2624 if (VFIELD_NAME_P (DECL_NAME (fields
)))
2625 fields
= TREE_CHAIN (fields
);
2628 if (fields
== NULL_TREE
2629 || DECL_NAME (fields
) == NULL_TREE
2630 || ! VBASE_NAME_P (DECL_NAME (fields
)))
2633 this_vbase_ptr
= vbase_decl_ptr_intermediate
;
2635 if (build_pointer_type (type
) != TYPE_MAIN_VARIANT (TREE_TYPE (this_vbase_ptr
)))
2636 my_friendly_abort (125);
2638 while (fields
&& DECL_NAME (fields
)
2639 && VBASE_NAME_P (DECL_NAME (fields
)))
2641 tree ref
= build (COMPONENT_REF
, TREE_TYPE (fields
),
2642 build_indirect_ref (this_vbase_ptr
, NULL_PTR
), fields
);
2643 tree init
= CLASSTYPE_SEARCH_SLOT (TREE_TYPE (TREE_TYPE (fields
)));
2644 vbase_init_result
= tree_cons (binfo_member (TREE_TYPE (TREE_TYPE (fields
)),
2646 build_modify_expr (ref
, NOP_EXPR
, init
),
2648 fields
= TREE_CHAIN (fields
);
2652 /* Sometimes this needs to clear both VTABLE_PATH and NEW_VTABLE. Other
2653 times, just NEW_VTABLE, but optimizer should make both with equal
2654 efficiency (though it does not currently). */
2657 dfs_clear_vbase_slots (binfo
)
2660 tree type
= BINFO_TYPE (binfo
);
2661 CLASSTYPE_SEARCH_SLOT (type
) = 0;
2662 CLEAR_BINFO_VTABLE_PATH_MARKED (binfo
);
2663 CLEAR_BINFO_NEW_VTABLE_MARKED (binfo
);
2667 init_vbase_pointers (type
, decl_ptr
)
2671 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
2673 int old_flag
= flag_this_is_variable
;
2674 tree binfo
= TYPE_BINFO (type
);
2675 flag_this_is_variable
= -2;
2676 vbase_types
= CLASSTYPE_VBASECLASSES (type
);
2677 vbase_decl_ptr
= vbase_decl_ptr_intermediate
= decl_ptr
;
2678 vbase_init_result
= NULL_TREE
;
2679 dfs_walk (binfo
, dfs_find_vbases
, unmarked_vtable_pathp
);
2680 dfs_walk (binfo
, dfs_init_vbase_pointers
, marked_vtable_pathp
);
2681 dfs_walk (binfo
, dfs_clear_vbase_slots
, marked_new_vtablep
);
2682 flag_this_is_variable
= old_flag
;
2683 return vbase_init_result
;
2688 /* get the virtual context (the vbase that directly contains the
2689 DECL_CLASS_CONTEXT of the FNDECL) that the given FNDECL is declared in,
2690 or NULL_TREE if there is none.
2692 FNDECL must come from a virtual table from a virtual base to ensure that
2693 there is only one possible DECL_CLASS_CONTEXT.
2695 We know that if there is more than one place (binfo) the fndecl that the
2696 declared, they all refer to the same binfo. See get_class_offset_1 for
2697 the check that ensures this. */
2700 virtual_context (fndecl
, t
, vbase
)
2701 tree fndecl
, t
, vbase
;
2704 if (get_base_distance (DECL_CLASS_CONTEXT (fndecl
), t
, 0, &path
) < 0)
2706 /* DECL_CLASS_CONTEXT can be ambiguous in t. */
2707 if (get_base_distance (DECL_CLASS_CONTEXT (fndecl
), vbase
, 0, &path
) >= 0)
2711 /* Not sure if checking path == vbase is necessary here, but just in
2713 if (TREE_VIA_VIRTUAL (path
) || path
== vbase
)
2714 return binfo_member (BINFO_TYPE (path
), CLASSTYPE_VBASECLASSES (t
));
2715 path
= BINFO_INHERITANCE_CHAIN (path
);
2718 /* This shouldn't happen, I don't want errors! */
2719 warning ("recoverable compiler error, fixups for virtual function");
2724 if (TREE_VIA_VIRTUAL (path
))
2725 return binfo_member (BINFO_TYPE (path
), CLASSTYPE_VBASECLASSES (t
));
2726 path
= BINFO_INHERITANCE_CHAIN (path
);
2731 /* Fixups upcast offsets for one vtable.
2732 Entries may stay within the VBASE given, or
2733 they may upcast into a direct base, or
2734 they may upcast into a different vbase.
2736 We only need to do fixups in case 2 and 3. In case 2, we add in
2737 the virtual base offset to effect an upcast, in case 3, we add in
2738 the virtual base offset to effect an upcast, then subtract out the
2739 offset for the other virtual base, to effect a downcast into it.
2741 This routine mirrors fixup_vtable_deltas in functionality, though
2742 this one is runtime based, and the other is compile time based.
2743 Conceivably that routine could be removed entirely, and all fixups
2746 VBASE_OFFSETS is an association list of virtual bases that contains
2747 offset information for the virtual bases, so the offsets are only
2748 calculated once. The offsets are computed by where we think the
2749 vbase should be (as noted by the CLASSTYPE_SEARCH_SLOT) minus where
2750 the vbase really is. */
2753 expand_upcast_fixups (binfo
, addr
, orig_addr
, vbase
, vbase_addr
, t
,
2755 tree binfo
, addr
, orig_addr
, vbase
, vbase_addr
, t
, *vbase_offsets
;
2757 tree virtuals
= BINFO_VIRTUALS (binfo
);
2760 unsigned HOST_WIDE_INT n
;
2762 delta
= purpose_member (vbase
, *vbase_offsets
);
2765 delta
= CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (vbase
));
2766 delta
= build (MINUS_EXPR
, ptrdiff_type_node
, delta
, vbase_addr
);
2767 delta
= save_expr (delta
);
2768 delta
= tree_cons (vbase
, delta
, *vbase_offsets
);
2769 *vbase_offsets
= delta
;
2772 n
= skip_rtti_stuff (&virtuals
);
2776 tree current_fndecl
= TREE_VALUE (virtuals
);
2777 current_fndecl
= FNADDR_FROM_VTABLE_ENTRY (current_fndecl
);
2778 current_fndecl
= TREE_OPERAND (current_fndecl
, 0);
2780 && current_fndecl
!= abort_fndecl
2781 && (vc
=virtual_context (current_fndecl
, t
, vbase
)) != vbase
)
2783 /* This may in fact need a runtime fixup. */
2784 tree idx
= DECL_VINDEX (current_fndecl
);
2785 tree vtbl
= BINFO_VTABLE (binfo
);
2786 tree nvtbl
= lookup_name (DECL_NAME (vtbl
), 0);
2787 tree aref
, ref
, naref
;
2788 tree old_delta
, new_delta
;
2791 if (nvtbl
== NULL_TREE
2792 || nvtbl
== IDENTIFIER_GLOBAL_VALUE (DECL_NAME (vtbl
)))
2794 /* Dup it if it isn't in local scope yet. */
2795 nvtbl
= build_decl (VAR_DECL
,
2797 TYPE_MAIN_VARIANT (TREE_TYPE (BINFO_VTABLE (binfo
))));
2798 DECL_ALIGN (nvtbl
) = MAX (TYPE_ALIGN (double_type_node
),
2799 DECL_ALIGN (nvtbl
));
2800 TREE_READONLY (nvtbl
) = 0;
2801 DECL_ARTIFICIAL (nvtbl
) = 1;
2802 nvtbl
= pushdecl (nvtbl
);
2804 cp_finish_decl (nvtbl
, init
, NULL_TREE
, 0, LOOKUP_ONLYCONVERTING
);
2805 DECL_VIRTUAL_P (nvtbl
) = 1;
2806 DECL_CONTEXT (nvtbl
) = t
;
2807 init
= build (MODIFY_EXPR
, TREE_TYPE (nvtbl
),
2809 TREE_SIDE_EFFECTS (init
) = 1;
2810 expand_expr_stmt (init
);
2811 /* Update the vtable pointers as necessary. */
2812 ref
= build_vfield_ref (build_indirect_ref (addr
, NULL_PTR
), DECL_CONTEXT (CLASSTYPE_VFIELD (BINFO_TYPE (binfo
))));
2813 expand_expr_stmt (build_modify_expr (ref
, NOP_EXPR
,
2814 build_unary_op (ADDR_EXPR
, nvtbl
, 0)));
2816 assemble_external (vtbl
);
2817 aref
= build_array_ref (vtbl
, idx
);
2818 naref
= build_array_ref (nvtbl
, idx
);
2819 old_delta
= build_component_ref (aref
, delta_identifier
, NULL_TREE
, 0);
2820 new_delta
= build_component_ref (naref
, delta_identifier
, NULL_TREE
, 0);
2822 /* This is a upcast, so we have to add the offset for the
2824 old_delta
= build_binary_op (PLUS_EXPR
, old_delta
,
2825 TREE_VALUE (delta
), 0);
2828 /* If this is set, we need to subtract out the delta
2829 adjustments for the other virtual base that we
2831 tree vc_delta
= purpose_member (vc
, *vbase_offsets
);
2834 tree vc_addr
= convert_pointer_to_real (vc
, orig_addr
);
2835 vc_delta
= CLASSTYPE_SEARCH_SLOT (BINFO_TYPE (vc
));
2836 vc_delta
= build (MINUS_EXPR
, ptrdiff_type_node
,
2838 vc_delta
= save_expr (vc_delta
);
2839 *vbase_offsets
= tree_cons (vc
, vc_delta
, *vbase_offsets
);
2842 vc_delta
= TREE_VALUE (vc_delta
);
2844 /* This is a downcast, so we have to subtract the offset
2845 for the virtual base. */
2846 old_delta
= build_binary_op (MINUS_EXPR
, old_delta
, vc_delta
, 0);
2849 TREE_READONLY (new_delta
) = 0;
2850 expand_expr_stmt (build_modify_expr (new_delta
, NOP_EXPR
,
2854 virtuals
= TREE_CHAIN (virtuals
);
2858 /* Fixup upcast offsets for all direct vtables. Patterned after
2859 expand_direct_vtbls_init. */
2862 fixup_virtual_upcast_offsets (real_binfo
, binfo
, init_self
, can_elide
, addr
, orig_addr
, type
, vbase
, vbase_offsets
)
2863 tree real_binfo
, binfo
;
2864 int init_self
, can_elide
;
2865 tree addr
, orig_addr
, type
, vbase
, *vbase_offsets
;
2867 tree real_binfos
= BINFO_BASETYPES (real_binfo
);
2868 tree binfos
= BINFO_BASETYPES (binfo
);
2869 int i
, n_baselinks
= real_binfos
? TREE_VEC_LENGTH (real_binfos
) : 0;
2871 for (i
= 0; i
< n_baselinks
; i
++)
2873 tree real_base_binfo
= TREE_VEC_ELT (real_binfos
, i
);
2874 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
2875 int is_not_base_vtable
=
2876 i
!= CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (real_binfo
));
2877 if (! TREE_VIA_VIRTUAL (real_base_binfo
))
2878 fixup_virtual_upcast_offsets (real_base_binfo
, base_binfo
,
2879 is_not_base_vtable
, can_elide
, addr
,
2880 orig_addr
, type
, vbase
, vbase_offsets
);
2883 /* Before turning this on, make sure it is correct. */
2884 if (can_elide
&& ! BINFO_MODIFIED (binfo
))
2887 /* Should we use something besides CLASSTYPE_VFIELDS? */
2888 if (init_self
&& CLASSTYPE_VFIELDS (BINFO_TYPE (real_binfo
)))
2890 tree new_addr
= convert_pointer_to_real (binfo
, addr
);
2891 expand_upcast_fixups (real_binfo
, new_addr
, orig_addr
, vbase
, addr
,
2892 type
, vbase_offsets
);
2896 /* Build a COMPOUND_EXPR which when expanded will generate the code
2897 needed to initialize all the virtual function table slots of all
2898 the virtual baseclasses. MAIN_BINFO is the binfo which determines
2899 the virtual baseclasses to use; TYPE is the type of the object to
2900 which the initialization applies. TRUE_EXP is the true object we
2901 are initializing, and DECL_PTR is the pointer to the sub-object we
2904 When USE_COMPUTED_OFFSETS is non-zero, we can assume that the
2905 object was laid out by a top-level constructor and the computed
2906 offsets are valid to store vtables. When zero, we must store new
2907 vtables through virtual baseclass pointers.
2909 We setup and use the globals: vbase_decl_ptr, vbase_types
2913 expand_indirect_vtbls_init (binfo
, true_exp
, decl_ptr
)
2915 tree true_exp
, decl_ptr
;
2917 tree type
= BINFO_TYPE (binfo
);
2919 if (TYPE_USES_VIRTUAL_BASECLASSES (type
))
2921 rtx fixup_insns
= NULL_RTX
;
2922 tree vbases
= CLASSTYPE_VBASECLASSES (type
);
2923 vbase_types
= vbases
;
2924 vbase_decl_ptr
= true_exp
? build_unary_op (ADDR_EXPR
, true_exp
, 0) : decl_ptr
;
2926 dfs_walk (binfo
, dfs_find_vbases
, unmarked_new_vtablep
);
2928 /* Initialized with vtables of type TYPE. */
2929 for (; vbases
; vbases
= TREE_CHAIN (vbases
))
2933 addr
= convert_pointer_to_vbase (TREE_TYPE (vbases
), vbase_decl_ptr
);
2935 /* Do all vtables from this virtual base. */
2936 /* This assumes that virtual bases can never serve as parent
2937 binfos. (in the CLASSTPE_VFIELD_PARENT sense) */
2938 expand_direct_vtbls_init (vbases
, TYPE_BINFO (BINFO_TYPE (vbases
)),
2941 /* Now we adjust the offsets for virtual functions that
2942 cross virtual boundaries on an implicit upcast on vf call
2943 so that the layout of the most complete type is used,
2944 instead of assuming the layout of the virtual bases from
2945 our current type. */
2947 if (flag_vtable_thunks
)
2949 /* We don't have dynamic thunks yet!
2950 So for now, just fail silently. */
2954 tree vbase_offsets
= NULL_TREE
;
2955 push_to_sequence (fixup_insns
);
2956 fixup_virtual_upcast_offsets (vbases
,
2957 TYPE_BINFO (BINFO_TYPE (vbases
)),
2958 1, 0, addr
, vbase_decl_ptr
,
2959 type
, vbases
, &vbase_offsets
);
2960 fixup_insns
= get_insns ();
2967 extern tree in_charge_identifier
;
2968 tree in_charge_node
= lookup_name (in_charge_identifier
, 0);
2969 if (! in_charge_node
)
2971 warning ("recoverable internal compiler error, nobody's in charge!");
2972 in_charge_node
= integer_zero_node
;
2974 in_charge_node
= build_binary_op (EQ_EXPR
, in_charge_node
, integer_zero_node
, 1);
2975 expand_start_cond (in_charge_node
, 0);
2976 emit_insns (fixup_insns
);
2980 dfs_walk (binfo
, dfs_clear_vbase_slots
, marked_new_vtablep
);
2984 /* get virtual base class types.
2985 This adds type to the vbase_types list in reverse dfs order.
2986 Ordering is very important, so don't change it. */
2989 dfs_get_vbase_types (binfo
)
2992 if (TREE_VIA_VIRTUAL (binfo
) && ! BINFO_VBASE_MARKED (binfo
))
2994 vbase_types
= make_binfo (integer_zero_node
, binfo
,
2995 BINFO_VTABLE (binfo
),
2996 BINFO_VIRTUALS (binfo
), vbase_types
);
2997 TREE_VIA_VIRTUAL (vbase_types
) = 1;
2998 SET_BINFO_VBASE_MARKED (binfo
);
3000 SET_BINFO_MARKED (binfo
);
3003 /* get a list of virtual base classes in dfs order. */
3006 get_vbase_types (type
)
3012 if (TREE_CODE (type
) == TREE_VEC
)
3015 binfo
= TYPE_BINFO (type
);
3017 vbase_types
= NULL_TREE
;
3018 dfs_walk (binfo
, dfs_get_vbase_types
, unmarkedp
);
3019 dfs_walk (binfo
, dfs_unmark
, markedp
);
3020 /* Rely upon the reverse dfs ordering from dfs_get_vbase_types, and now
3021 reverse it so that we get normal dfs ordering. */
3022 vbase_types
= nreverse (vbase_types
);
3024 /* unmark marked vbases */
3025 for (vbases
= vbase_types
; vbases
; vbases
= TREE_CHAIN (vbases
))
3026 CLEAR_BINFO_VBASE_MARKED (vbases
);
3032 dfs_record_inheritance (binfo
)
3035 tree binfos
= BINFO_BASETYPES (binfo
);
3036 int i
, n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
3037 mi_boolean
*derived_row
= BINFO_DERIVES_FROM_STAR (binfo
);
3039 for (i
= n_baselinks
-1; i
>= 0; i
--)
3042 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
3043 tree baseclass
= BINFO_TYPE (base_binfo
);
3044 mi_boolean
*base_row
= BINFO_DERIVES_FROM_STAR (base_binfo
);
3046 /* Don't search if there's nothing there! MI_SIZE can be
3047 zero as a result of parse errors. */
3048 if (TYPE_BINFO_BASETYPES (baseclass
) && mi_size
> 0)
3049 for (j
= mi_size
*(CLASSTYPE_CID (baseclass
)-1); j
>= 0; j
-= mi_size
)
3050 derived_row
[j
] |= base_row
[j
];
3051 TYPE_DERIVES_FROM (baseclass
, BINFO_TYPE (binfo
)) = 1;
3054 SET_BINFO_MARKED (binfo
);
3057 /* Given a _CLASSTYPE node in a multiple inheritance lattice,
3058 convert the lattice into a simple relation such that,
3059 given to CIDs, C1 and C2, one can determine if C1 <= C2
3060 or C2 <= C1 or C1 <> C2.
3062 Once constructed, we walk the lattice depth fisrt,
3063 applying various functions to elements as they are encountered.
3065 We use xmalloc here, in case we want to randomly free these tables. */
3067 #define SAVE_MI_MATRIX
3070 build_mi_matrix (type
)
3073 tree binfo
= TYPE_BINFO (type
);
3076 #ifdef SAVE_MI_MATRIX
3077 if (CLASSTYPE_MI_MATRIX (type
))
3079 mi_size
= CLASSTYPE_N_SUPERCLASSES (type
) + CLASSTYPE_N_VBASECLASSES (type
);
3080 mi_matrix
= CLASSTYPE_MI_MATRIX (type
);
3082 dfs_walk (binfo
, dfs_number
, unnumberedp
);
3087 dfs_walk (binfo
, dfs_number
, unnumberedp
);
3089 mi_size
= CLASSTYPE_N_SUPERCLASSES (type
) + CLASSTYPE_N_VBASECLASSES (type
);
3092 mi_matrix
= (char *)xmalloc ((mi_size
+ 1) * (mi_size
+ 1));
3094 bzero (mi_matrix
, (mi_size
+ 1) * (mi_size
+ 1));
3095 dfs_walk (binfo
, dfs_record_inheritance
, unmarkedp
);
3096 dfs_walk (binfo
, dfs_unmark
, markedp
);
3102 dfs_walk (TYPE_BINFO (mi_type
), dfs_unnumber
, numberedp
);
3104 #ifdef SAVE_MI_MATRIX
3105 CLASSTYPE_MI_MATRIX (mi_type
) = mi_matrix
;
3113 /* If we want debug info for a type TYPE, make sure all its base types
3114 are also marked as being potentially interesting. This avoids
3115 the problem of not writing any debug info for intermediate basetypes
3116 that have abstract virtual functions. Also mark member types. */
3119 note_debug_info_needed (type
)
3123 dfs_walk (TYPE_BINFO (type
), dfs_debug_mark
, dfs_debug_unmarkedp
);
3124 for (field
= TYPE_FIELDS (type
); field
; field
= TREE_CHAIN (field
))
3127 if (TREE_CODE (field
) == FIELD_DECL
3128 && IS_AGGR_TYPE (ttype
= target_type (TREE_TYPE (field
)))
3129 && dfs_debug_unmarkedp (TYPE_BINFO (ttype
)))
3130 note_debug_info_needed (ttype
);
3134 /* Subroutines of push_class_decls (). */
3136 /* Add in a decl to the envelope. */
3139 envelope_add_decl (type
, decl
, values
)
3140 tree type
, decl
, *values
;
3143 tree name
= DECL_NAME (decl
);
3146 /* virtual base names are always unique. */
3147 if (VBASE_NAME_P (name
))
3148 *values
= NULL_TREE
;
3150 /* Possible ambiguity. If its defining type(s)
3151 is (are all) derived from us, no problem. */
3152 else if (*values
&& TREE_CODE (*values
) != TREE_LIST
)
3154 tree value
= *values
;
3155 /* Only complain if we shadow something we can access. */
3156 if (warn_shadow
&& TREE_CODE (decl
) == FUNCTION_DECL
3157 && ((DECL_LANG_SPECIFIC (*values
)
3158 && DECL_CLASS_CONTEXT (value
) == current_class_type
)
3159 || ! TREE_PRIVATE (value
)))
3160 /* Should figure out access control more accurately. */
3162 cp_warning_at ("member `%#D' is shadowed", value
);
3163 cp_warning_at ("by member function `%#D'", decl
);
3164 warning ("in this context");
3167 context
= (TREE_CODE (value
) == FUNCTION_DECL
3168 && DECL_VIRTUAL_P (value
))
3169 ? DECL_CLASS_CONTEXT (value
)
3170 : DECL_CONTEXT (value
);
3172 if (context
== type
)
3174 if (TREE_CODE (value
) == TYPE_DECL
3175 && DECL_ARTIFICIAL (value
))
3176 *values
= NULL_TREE
;
3180 else if (context
&& TYPE_DERIVES_FROM (context
, type
))
3182 /* Don't add in *values to list */
3183 *values
= NULL_TREE
;
3186 *values
= build_tree_list (NULL_TREE
, value
);
3189 for (tmp
= values
; *tmp
;)
3191 tree value
= TREE_VALUE (*tmp
);
3192 my_friendly_assert (TREE_CODE (value
) != TREE_LIST
, 999);
3193 context
= (TREE_CODE (value
) == FUNCTION_DECL
3194 && DECL_VIRTUAL_P (value
))
3195 ? DECL_CLASS_CONTEXT (value
)
3196 : DECL_CONTEXT (value
);
3198 if (context
&& TYPE_DERIVES_FROM (context
, type
))
3200 /* remove *tmp from list */
3201 *tmp
= TREE_CHAIN (*tmp
);
3204 tmp
= &TREE_CHAIN (*tmp
);
3209 /* Put the new contents in our envelope. */
3210 if (TREE_CODE (decl
) == FUNCTION_DECL
)
3212 *values
= tree_cons (name
, decl
, *values
);
3213 TREE_NONLOCAL_FLAG (*values
) = 1;
3214 TREE_TYPE (*values
) = unknown_type_node
;
3220 *values
= tree_cons (NULL_TREE
, decl
, *values
);
3221 /* Mark this as a potentially ambiguous member. */
3222 /* Leaving TREE_TYPE blank is intentional.
3223 We cannot use `error_mark_node' (lookup_name)
3224 or `unknown_type_node' (all member functions use this). */
3225 TREE_NONLOCAL_FLAG (*values
) = 1;
3233 /* Add the instance variables which this class contributed to the
3234 current class binding contour. When a redefinition occurs, if the
3235 redefinition is strictly within a single inheritance path, we just
3236 overwrite the old declaration with the new. If the fields are not
3237 within a single inheritance path, we must cons them.
3239 In order to know what decls are new (stemming from the current
3240 invocation of push_class_decls) we enclose them in an "envelope",
3241 which is a TREE_LIST node where the TREE_PURPOSE slot contains the
3242 new decl (or possibly a list of competing ones), the TREE_VALUE slot
3243 points to the old value and the TREE_CHAIN slot chains together all
3244 envelopes which needs to be "opened" in push_class_decls. Opening an
3245 envelope means: push the old value onto the class_shadowed list,
3246 install the new one and if it's a TYPE_DECL do the same to the
3247 IDENTIFIER_TYPE_VALUE. Such an envelope is recognized by seeing that
3248 the TREE_PURPOSE slot is non-null, and that it is not an identifier.
3249 Because if it is, it could be a set of overloaded methods from an
3253 dfs_pushdecls (binfo
)
3256 tree type
= BINFO_TYPE (binfo
);
3257 tree fields
, *methods
, *end
;
3260 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
3262 /* Unmark so that if we are in a constructor, and then find that
3263 this field was initialized by a base initializer,
3264 we can emit an error message. */
3265 if (TREE_CODE (fields
) == FIELD_DECL
)
3266 TREE_USED (fields
) = 0;
3268 /* Recurse into anonymous unions. */
3269 if (DECL_NAME (fields
) == NULL_TREE
3270 && TREE_CODE (TREE_TYPE (fields
)) == UNION_TYPE
)
3272 dfs_pushdecls (TYPE_BINFO (TREE_TYPE (fields
)));
3276 if (DECL_NAME (fields
))
3278 tree name
= DECL_NAME (fields
);
3279 tree class_value
= IDENTIFIER_CLASS_VALUE (name
);
3281 /* If the class value is not an envelope of the kind described in
3282 the comment above, we create a new envelope. */
3283 if (class_value
== NULL_TREE
|| TREE_CODE (class_value
) != TREE_LIST
3284 || TREE_PURPOSE (class_value
) == NULL_TREE
3285 || TREE_CODE (TREE_PURPOSE (class_value
)) == IDENTIFIER_NODE
)
3287 /* See comment above for a description of envelopes. */
3288 closed_envelopes
= tree_cons (NULL_TREE
, class_value
,
3290 IDENTIFIER_CLASS_VALUE (name
) = closed_envelopes
;
3291 class_value
= IDENTIFIER_CLASS_VALUE (name
);
3294 envelope_add_decl (type
, fields
, &TREE_PURPOSE (class_value
));
3298 method_vec
= CLASSTYPE_METHOD_VEC (type
);
3301 /* Farm out constructors and destructors. */
3302 methods
= &TREE_VEC_ELT (method_vec
, 2);
3303 end
= TREE_VEC_END (method_vec
);
3305 while (methods
!= end
)
3307 /* This will cause lookup_name to return a pointer
3308 to the tree_list of possible methods of this name. */
3309 tree name
= DECL_NAME (*methods
);
3310 tree class_value
= IDENTIFIER_CLASS_VALUE (name
);
3312 /* If the class value is not an envelope of the kind described in
3313 the comment above, we create a new envelope. */
3314 if (class_value
== NULL_TREE
|| TREE_CODE (class_value
) != TREE_LIST
3315 || TREE_PURPOSE (class_value
) == NULL_TREE
3316 || TREE_CODE (TREE_PURPOSE (class_value
)) == IDENTIFIER_NODE
)
3318 /* See comment above for a description of envelopes. */
3319 closed_envelopes
= tree_cons (NULL_TREE
, class_value
,
3321 IDENTIFIER_CLASS_VALUE (name
) = closed_envelopes
;
3322 class_value
= IDENTIFIER_CLASS_VALUE (name
);
3325 /* Here we try to rule out possible ambiguities.
3326 If we can't do that, keep a TREE_LIST with possibly ambiguous
3328 maybe_push_cache_obstack ();
3329 envelope_add_decl (type
, *methods
, &TREE_PURPOSE (class_value
));
3335 SET_BINFO_MARKED (binfo
);
3338 /* Consolidate unique (by name) member functions. */
3341 dfs_compress_decls (binfo
)
3344 tree type
= BINFO_TYPE (binfo
);
3345 tree method_vec
= CLASSTYPE_METHOD_VEC (type
);
3347 if (method_vec
!= 0)
3349 /* Farm out constructors and destructors. */
3350 tree
*methods
= &TREE_VEC_ELT (method_vec
, 2);
3351 tree
*end
= TREE_VEC_END (method_vec
);
3353 for (; methods
!= end
; methods
++)
3355 /* This is known to be an envelope of the kind described before
3357 tree class_value
= IDENTIFIER_CLASS_VALUE (DECL_NAME (*methods
));
3358 tree tmp
= TREE_PURPOSE (class_value
);
3360 /* This was replaced in scope by somebody else. Just leave it
3362 if (TREE_CODE (tmp
) != TREE_LIST
)
3365 if (TREE_CHAIN (tmp
) == NULL_TREE
3367 && DECL_CHAIN (TREE_VALUE (tmp
)) == NULL_TREE
)
3369 TREE_PURPOSE (class_value
) = TREE_VALUE (tmp
);
3373 CLEAR_BINFO_MARKED (binfo
);
3376 /* When entering the scope of a class, we cache all of the
3377 fields that that class provides within its inheritance
3378 lattice. Where ambiguities result, we mark them
3379 with `error_mark_node' so that if they are encountered
3380 without explicit qualification, we can emit an error
3384 push_class_decls (type
)
3387 struct obstack
*ambient_obstack
= current_obstack
;
3388 search_stack
= push_search_level (search_stack
, &search_obstack
);
3390 /* Push class fields into CLASS_VALUE scope, and mark. */
3391 dfs_walk (TYPE_BINFO (type
), dfs_pushdecls
, unmarkedp
);
3393 /* Compress fields which have only a single entry
3394 by a given name, and unmark. */
3395 dfs_walk (TYPE_BINFO (type
), dfs_compress_decls
, markedp
);
3397 /* Open up all the closed envelopes and push the contained decls into
3399 while (closed_envelopes
)
3401 tree
new = TREE_PURPOSE (closed_envelopes
);
3404 /* This is messy because the class value may be a *_DECL, or a
3405 TREE_LIST of overloaded *_DECLs or even a TREE_LIST of ambiguous
3406 *_DECLs. The name is stored at different places in these three
3408 if (TREE_CODE (new) == TREE_LIST
)
3410 if (TREE_PURPOSE (new) != NULL_TREE
)
3411 id
= TREE_PURPOSE (new);
3414 tree node
= TREE_VALUE (new);
3416 while (TREE_CODE (node
) == TREE_LIST
)
3417 node
= TREE_VALUE (node
);
3418 id
= DECL_NAME (node
);
3422 id
= DECL_NAME (new);
3424 /* Install the original class value in order to make
3425 pushdecl_class_level work correctly. */
3426 IDENTIFIER_CLASS_VALUE (id
) = TREE_VALUE (closed_envelopes
);
3427 if (TREE_CODE (new) == TREE_LIST
)
3428 push_class_level_binding (id
, new);
3430 pushdecl_class_level (new);
3431 closed_envelopes
= TREE_CHAIN (closed_envelopes
);
3433 current_obstack
= ambient_obstack
;
3436 /* Here's a subroutine we need because C lacks lambdas. */
3439 dfs_unuse_fields (binfo
)
3442 tree type
= TREE_TYPE (binfo
);
3445 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
3447 if (TREE_CODE (fields
) != FIELD_DECL
)
3450 TREE_USED (fields
) = 0;
3451 if (DECL_NAME (fields
) == NULL_TREE
3452 && TREE_CODE (TREE_TYPE (fields
)) == UNION_TYPE
)
3453 unuse_fields (TREE_TYPE (fields
));
3461 dfs_walk (TYPE_BINFO (type
), dfs_unuse_fields
, unmarkedp
);
3467 /* We haven't pushed a search level when dealing with cached classes,
3468 so we'd better not try to pop it. */
3470 search_stack
= pop_search_level (search_stack
);
3474 print_search_statistics ()
3476 #ifdef GATHER_STATISTICS
3477 if (flag_memoize_lookups
)
3479 fprintf (stderr
, "%d memoized contexts saved\n",
3481 fprintf (stderr
, "%d local tree nodes made\n", my_tree_node_counter
);
3482 fprintf (stderr
, "%d local hash nodes made\n", my_memoized_entry_counter
);
3483 fprintf (stderr
, "fields statistics:\n");
3484 fprintf (stderr
, " memoized finds = %d; rejects = %d; (searches = %d)\n",
3485 memoized_fast_finds
[0], memoized_fast_rejects
[0],
3486 memoized_fields_searched
[0]);
3487 fprintf (stderr
, " memoized_adds = %d\n", memoized_adds
[0]);
3488 fprintf (stderr
, "fnfields statistics:\n");
3489 fprintf (stderr
, " memoized finds = %d; rejects = %d; (searches = %d)\n",
3490 memoized_fast_finds
[1], memoized_fast_rejects
[1],
3491 memoized_fields_searched
[1]);
3492 fprintf (stderr
, " memoized_adds = %d\n", memoized_adds
[1]);
3494 fprintf (stderr
, "%d fields searched in %d[%d] calls to lookup_field[_1]\n",
3495 n_fields_searched
, n_calls_lookup_field
, n_calls_lookup_field_1
);
3496 fprintf (stderr
, "%d fnfields searched in %d calls to lookup_fnfields\n",
3497 n_outer_fields_searched
, n_calls_lookup_fnfields
);
3498 fprintf (stderr
, "%d calls to get_base_type\n", n_calls_get_base_type
);
3499 #else /* GATHER_STATISTICS */
3500 fprintf (stderr
, "no search statistics\n");
3501 #endif /* GATHER_STATISTICS */
3505 init_search_processing ()
3507 gcc_obstack_init (&search_obstack
);
3508 gcc_obstack_init (&type_obstack
);
3509 gcc_obstack_init (&type_obstack_entries
);
3511 /* This gives us room to build our chains of basetypes,
3512 whether or not we decide to memoize them. */
3513 type_stack
= push_type_level ((struct stack_level
*)0, &type_obstack
);
3514 _vptr_name
= get_identifier ("_vptr");
3518 reinit_search_statistics ()
3520 my_memoized_entry_counter
= 0;
3521 memoized_fast_finds
[0] = 0;
3522 memoized_fast_finds
[1] = 0;
3523 memoized_adds
[0] = 0;
3524 memoized_adds
[1] = 0;
3525 memoized_fast_rejects
[0] = 0;
3526 memoized_fast_rejects
[1] = 0;
3527 memoized_fields_searched
[0] = 0;
3528 memoized_fields_searched
[1] = 0;
3529 #ifdef GATHER_STATISTICS
3530 n_fields_searched
= 0;
3531 n_calls_lookup_field
= 0, n_calls_lookup_field_1
= 0;
3532 n_calls_lookup_fnfields
= 0, n_calls_lookup_fnfields_1
= 0;
3533 n_calls_get_base_type
= 0;
3534 n_outer_fields_searched
= 0;
3535 n_contexts_saved
= 0;
3536 #endif /* GATHER_STATISTICS */
3539 static tree conversions
;
3541 add_conversions (binfo
)
3545 tree method_vec
= CLASSTYPE_METHOD_VEC (BINFO_TYPE (binfo
));
3547 for (i
= 2; i
< TREE_VEC_LENGTH (method_vec
); ++i
)
3549 tree tmp
= TREE_VEC_ELT (method_vec
, i
);
3550 if (! IDENTIFIER_TYPENAME_P (DECL_NAME (tmp
)))
3552 conversions
= tree_cons (binfo
, tmp
, conversions
);
3557 lookup_conversions (type
)
3560 conversions
= NULL_TREE
;
3561 if (TYPE_SIZE (type
))
3562 dfs_walk (TYPE_BINFO (type
), add_conversions
, 0);
3566 /* Subroutine of get_template_base. */
3569 get_template_base_recursive (binfo
, rval
, template, via_virtual
)
3570 tree binfo
, template, rval
;
3575 tree type
= BINFO_TYPE (binfo
);
3577 if (CLASSTYPE_TEMPLATE_INFO (type
)
3578 && CLASSTYPE_TI_TEMPLATE (type
) == template)
3580 if (rval
== NULL_TREE
|| rval
== type
)
3583 return error_mark_node
;
3586 binfos
= BINFO_BASETYPES (binfo
);
3587 n_baselinks
= binfos
? TREE_VEC_LENGTH (binfos
) : 0;
3589 /* Process base types. */
3590 for (i
= 0; i
< n_baselinks
; i
++)
3592 tree base_binfo
= TREE_VEC_ELT (binfos
, i
);
3594 /* Find any specific instance of a virtual base, when searching with
3596 if (BINFO_MARKED (base_binfo
) == 0)
3598 int this_virtual
= via_virtual
|| TREE_VIA_VIRTUAL (base_binfo
);
3600 /* When searching for a non-virtual, we cannot mark
3601 virtually found binfos. */
3603 SET_BINFO_MARKED (base_binfo
);
3605 rval
= get_template_base_recursive
3606 (base_binfo
, rval
, template, this_virtual
);
3607 if (rval
== error_mark_node
)
3615 /* Given a class template TEMPLATE and a class type or binfo node BINFO,
3616 find the unique base type in BINFO that is an instance of TEMPLATE.
3617 If there are more than one, return error_mark_node. Used by unify. */
3620 get_template_base (template, binfo
)
3621 register tree
template, binfo
;
3625 if (TREE_CODE (binfo
) == TREE_VEC
)
3626 type
= BINFO_TYPE (binfo
);
3627 else if (IS_AGGR_TYPE_CODE (TREE_CODE (binfo
)))
3629 type
= complete_type (binfo
);
3630 binfo
= TYPE_BINFO (type
);
3633 my_friendly_abort (92);
3635 if (CLASSTYPE_TEMPLATE_INFO (type
)
3636 && CLASSTYPE_TI_TEMPLATE (type
) == template)
3639 rval
= get_template_base_recursive (binfo
, NULL_TREE
, template, 0);
3640 dfs_walk (binfo
, dfs_unmark
, markedp
);