1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Mostly written by Jason Merrill (jason@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. */
33 /* Accessors for the type_info objects. We need to remember several things
34 about each of the type_info types. The global tree nodes such as
35 bltn_desc_type_node are TREE_LISTs, and these macros are used to access
36 the required information. */
37 /* The RECORD_TYPE of a type_info derived class. */
38 #define TINFO_PSEUDO_TYPE(NODE) TREE_TYPE (NODE)
39 /* The VAR_DECL of the vtable for the type_info derived class. */
40 #define TINFO_VTABLE_DECL(NODE) TREE_VALUE (NODE)
42 extern struct obstack permanent_obstack
;
44 static tree build_headof
PARAMS((tree
));
45 static tree ifnonnull
PARAMS((tree
, tree
));
46 static tree tinfo_name
PARAMS((tree
));
47 static tree build_dynamic_cast_1
PARAMS((tree
, tree
));
48 static tree throw_bad_cast
PARAMS((void));
49 static tree throw_bad_typeid
PARAMS((void));
50 static tree get_tinfo_decl_dynamic
PARAMS((tree
));
51 static bool typeid_ok_p
PARAMS ((void));
52 static int qualifier_flags
PARAMS((tree
));
53 static int target_incomplete_p
PARAMS((tree
));
54 static tree tinfo_base_init
PARAMS((tree
, tree
));
55 static tree generic_initializer
PARAMS((tree
, tree
));
56 static tree ptr_initializer
PARAMS((tree
, tree
, int *));
57 static tree ptm_initializer
PARAMS((tree
, tree
, int *));
58 static tree dfs_class_hint_mark
PARAMS ((tree
, void *));
59 static tree dfs_class_hint_unmark
PARAMS ((tree
, void *));
60 static int class_hint_flags
PARAMS((tree
));
61 static tree class_initializer
PARAMS((tree
, tree
, tree
));
62 static tree synthesize_tinfo_var
PARAMS((tree
, tree
));
63 static tree create_real_tinfo_var
PARAMS((tree
, tree
, tree
, tree
, int));
64 static tree create_pseudo_type_info
PARAMS((const char *, int, ...));
65 static tree get_vmi_pseudo_type_info
PARAMS((int));
66 static void create_tinfo_types
PARAMS((void));
67 static int typeinfo_in_lib_p
PARAMS((tree
));
69 static int doing_runtime
= 0;
72 init_rtti_processing ()
74 push_namespace (std_identifier
);
75 type_info_type_node
= xref_tag
76 (class_type_node
, get_identifier ("type_info"), 1);
79 build_qualified_type (type_info_type_node
, TYPE_QUAL_CONST
);
82 /* Given the expression EXP of type `class *', return the head of the
83 object pointed to by EXP with type cv void*, if the class has any
84 virtual functions (TYPE_POLYMORPHIC_P), else just return the
91 tree type
= TREE_TYPE (exp
);
95 my_friendly_assert (TREE_CODE (type
) == POINTER_TYPE
, 20000112);
96 type
= TREE_TYPE (type
);
98 if (!TYPE_POLYMORPHIC_P (type
))
101 /* We use this a couple of times below, protect it. */
102 exp
= save_expr (exp
);
104 /* The offset-to-top field is at index -2 from the vptr. */
105 index
= build_int_2 (-2, -1);
107 offset
= build_vtbl_ref (build_indirect_ref (exp
, NULL
), index
);
109 type
= build_qualified_type (ptr_type_node
,
110 cp_type_quals (TREE_TYPE (exp
)));
111 return build (PLUS_EXPR
, type
, exp
,
112 cp_convert (ptrdiff_type_node
, offset
));
115 /* Get a bad_cast node for the program to throw...
117 See libstdc++/exception.cc for __throw_bad_cast */
122 tree fn
= get_identifier ("__cxa_bad_cast");
123 if (IDENTIFIER_GLOBAL_VALUE (fn
))
124 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
126 fn
= push_throw_library_fn (fn
, build_function_type (ptr_type_node
,
129 return build_call (fn
, NULL_TREE
);
135 tree fn
= get_identifier ("__cxa_bad_typeid");
136 if (IDENTIFIER_GLOBAL_VALUE (fn
))
137 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
140 tree t
= build_qualified_type (type_info_type_node
, TYPE_QUAL_CONST
);
141 t
= build_function_type (build_reference_type (t
), void_list_node
);
142 fn
= push_throw_library_fn (fn
, t
);
145 return build_call (fn
, NULL_TREE
);
148 /* Return a pointer to type_info function associated with the expression EXP.
149 If EXP is a reference to a polymorphic class, return the dynamic type;
150 otherwise return the static type of the expression. */
153 get_tinfo_decl_dynamic (exp
)
158 if (exp
== error_mark_node
)
159 return error_mark_node
;
161 type
= TREE_TYPE (exp
);
163 /* peel back references, so they match. */
164 if (TREE_CODE (type
) == REFERENCE_TYPE
)
165 type
= TREE_TYPE (type
);
167 /* Peel off cv qualifiers. */
168 type
= TYPE_MAIN_VARIANT (type
);
170 if (!VOID_TYPE_P (type
))
171 type
= complete_type_or_else (type
, exp
);
174 return error_mark_node
;
176 /* If exp is a reference to polymorphic type, get the real type_info. */
177 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
179 /* build reference to type_info from vtable. */
183 /* The RTTI information is at index -1. */
184 index
= integer_minus_one_node
;
185 t
= build_vtbl_ref (exp
, index
);
186 TREE_TYPE (t
) = build_pointer_type (tinfo_decl_type
);
190 /* otherwise return the type_info for the static type of the expr. */
191 exp
= get_tinfo_decl (TYPE_MAIN_VARIANT (type
));
192 return build_unary_op (ADDR_EXPR
, exp
, 0);
200 error ("cannot use typeid with -fno-rtti");
204 if (!COMPLETE_TYPE_P (type_info_type_node
))
206 error ("must #include <typeinfo> before using typeid");
217 tree cond
= NULL_TREE
;
220 if (exp
== error_mark_node
|| !typeid_ok_p ())
221 return error_mark_node
;
223 if (processing_template_decl
)
224 return build_min_nt (TYPEID_EXPR
, exp
);
226 if (TREE_CODE (exp
) == INDIRECT_REF
227 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
228 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
229 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
232 exp
= stabilize_reference (exp
);
233 cond
= cp_convert (boolean_type_node
, TREE_OPERAND (exp
, 0));
236 exp
= get_tinfo_decl_dynamic (exp
);
238 if (exp
== error_mark_node
)
239 return error_mark_node
;
241 exp
= build_indirect_ref (exp
, NULL
);
245 tree bad
= throw_bad_typeid ();
247 exp
= build (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
250 return convert_from_reference (exp
);
253 /* Generate the NTBS name of a type. */
261 name
= mangle_type_string (type
);
262 name_string
= combine_strings (build_string (strlen (name
) + 1, name
));
266 /* Returns a decl for the type_info variable for TYPE. You must
267 arrange that the decl is mark_used, if actually use it --- decls in
268 vtables are only used if the vtable is output. */
271 get_tinfo_decl (type
)
277 if (COMPLETE_TYPE_P (type
)
278 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
280 error ("cannot create type information for type `%T' because its size is variable",
282 return error_mark_node
;
285 if (TREE_CODE (type
) == OFFSET_TYPE
)
286 type
= TREE_TYPE (type
);
287 if (TREE_CODE (type
) == METHOD_TYPE
)
288 type
= build_function_type (TREE_TYPE (type
),
289 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
291 name
= mangle_typeinfo_for_type (type
);
293 d
= IDENTIFIER_GLOBAL_VALUE (name
);
298 /* The tinfo decl is the type_info object itself. We make all
299 tinfo objects look as type_info, even though they will end up
300 being a subclass of that when emitted. This means that we'll
301 erroneously think we know the dynamic type -- be careful in the
303 d
= build_lang_decl (VAR_DECL
, name
, tinfo_decl_type
);
305 DECL_ARTIFICIAL (d
) = 1;
306 DECL_ALIGN (d
) = TYPE_ALIGN (ptr_type_node
);
307 DECL_USER_ALIGN (d
) = 0;
308 TREE_READONLY (d
) = 1;
310 DECL_EXTERNAL (d
) = 1;
312 if (flag_weak
|| !typeinfo_in_lib_p (type
))
314 SET_DECL_ASSEMBLER_NAME (d
, name
);
315 cp_finish_decl (d
, NULL_TREE
, NULL_TREE
, 0);
317 pushdecl_top_level (d
);
318 /* Remember the type it is for. */
319 TREE_TYPE (name
) = type
;
320 TREE_USED (name
) = 1;
325 /* Return the type_info object for TYPE. */
331 if (type
== error_mark_node
|| !typeid_ok_p ())
332 return error_mark_node
;
334 if (processing_template_decl
)
335 return build_min_nt (TYPEID_EXPR
, type
);
337 /* If the type of the type-id is a reference type, the result of the
338 typeid expression refers to a type_info object representing the
340 if (TREE_CODE (type
) == REFERENCE_TYPE
)
341 type
= TREE_TYPE (type
);
343 /* The top-level cv-qualifiers of the lvalue expression or the type-id
344 that is the operand of typeid are always ignored. */
345 type
= TYPE_MAIN_VARIANT (type
);
347 if (!VOID_TYPE_P (type
))
348 type
= complete_type_or_else (type
, NULL_TREE
);
351 return error_mark_node
;
353 return get_tinfo_decl (type
);
356 /* Check whether TEST is null before returning RESULT. If TEST is used in
357 RESULT, it must have previously had a save_expr applied to it. */
360 ifnonnull (test
, result
)
363 return build (COND_EXPR
, TREE_TYPE (result
),
364 build (EQ_EXPR
, boolean_type_node
, test
, integer_zero_node
),
365 cp_convert (TREE_TYPE (result
), integer_zero_node
),
369 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
373 build_dynamic_cast_1 (type
, expr
)
376 enum tree_code tc
= TREE_CODE (type
);
377 tree exprtype
= TREE_TYPE (expr
);
379 tree old_expr
= expr
;
380 const char *errstr
= NULL
;
382 /* T shall be a pointer or reference to a complete class type, or
383 `pointer to cv void''. */
387 if (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
)
390 if (! IS_AGGR_TYPE (TREE_TYPE (type
)))
392 errstr
= "target is not pointer or reference to class";
395 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
397 errstr
= "target is not pointer or reference to complete type";
403 errstr
= "target is not pointer or reference";
407 if (TREE_CODE (expr
) == OFFSET_REF
)
409 expr
= resolve_offset_ref (expr
);
410 exprtype
= TREE_TYPE (expr
);
413 if (tc
== POINTER_TYPE
)
414 expr
= convert_from_reference (expr
);
415 else if (TREE_CODE (exprtype
) != REFERENCE_TYPE
)
417 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
418 exprtype
= build_reference_type (exprtype
);
419 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
420 LOOKUP_NORMAL
, NULL_TREE
);
423 exprtype
= TREE_TYPE (expr
);
425 if (tc
== POINTER_TYPE
)
427 /* If T is a pointer type, v shall be an rvalue of a pointer to
428 complete class type, and the result is an rvalue of type T. */
430 if (TREE_CODE (exprtype
) != POINTER_TYPE
)
432 errstr
= "source is not a pointer";
435 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype
)))
437 errstr
= "source is not a pointer to class";
440 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
442 errstr
= "source is a pointer to incomplete type";
448 /* T is a reference type, v shall be an lvalue of a complete class
449 type, and the result is an lvalue of the type referred to by T. */
451 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype
)))
453 errstr
= "source is not of class type";
456 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
458 errstr
= "source is of incomplete class type";
464 /* The dynamic_cast operator shall not cast away constness. */
465 if (!at_least_as_qualified_p (TREE_TYPE (type
),
466 TREE_TYPE (exprtype
)))
468 errstr
= "conversion casts away constness";
472 /* If *type is an unambiguous accessible base class of *exprtype,
473 convert statically. */
477 binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
478 ba_not_special
, NULL
);
482 expr
= build_base_path (PLUS_EXPR
, convert_from_reference (expr
),
484 if (TREE_CODE (exprtype
) == POINTER_TYPE
)
485 expr
= non_lvalue (expr
);
490 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
491 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
494 /* if TYPE is `void *', return pointer to complete object. */
495 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
497 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
498 if (TREE_CODE (expr
) == ADDR_EXPR
499 && TREE_CODE (TREE_OPERAND (expr
, 0)) == VAR_DECL
500 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
501 return build1 (NOP_EXPR
, type
, expr
);
503 /* Since expr is used twice below, save it. */
504 expr
= save_expr (expr
);
506 expr1
= build_headof (expr
);
507 if (TREE_TYPE (expr1
) != type
)
508 expr1
= build1 (NOP_EXPR
, type
, expr1
);
509 return ifnonnull (expr
, expr1
);
514 tree result
, td2
, td3
, elems
;
515 tree static_type
, target_type
, boff
;
517 /* If we got here, we can't convert statically. Therefore,
518 dynamic_cast<D&>(b) (b an object) cannot succeed. */
519 if (tc
== REFERENCE_TYPE
)
521 if (TREE_CODE (old_expr
) == VAR_DECL
522 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
524 tree expr
= throw_bad_cast ();
525 warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
527 /* Bash it to the expected type. */
528 TREE_TYPE (expr
) = type
;
532 /* Ditto for dynamic_cast<D*>(&b). */
533 else if (TREE_CODE (expr
) == ADDR_EXPR
)
535 tree op
= TREE_OPERAND (expr
, 0);
536 if (TREE_CODE (op
) == VAR_DECL
537 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
539 warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
541 retval
= build_int_2 (0, 0);
542 TREE_TYPE (retval
) = type
;
547 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
548 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
549 td2
= build_unary_op (ADDR_EXPR
, get_tinfo_decl (target_type
), 0);
550 td3
= build_unary_op (ADDR_EXPR
, get_tinfo_decl (static_type
), 0);
552 /* Determine how T and V are related. */
553 boff
= get_dynamic_cast_base_type (static_type
, target_type
);
555 /* Since expr is used twice below, save it. */
556 expr
= save_expr (expr
);
559 if (tc
== REFERENCE_TYPE
)
560 expr1
= build_unary_op (ADDR_EXPR
, expr1
, 0);
563 (NULL_TREE
, expr1
, tree_cons
564 (NULL_TREE
, td3
, tree_cons
565 (NULL_TREE
, td2
, tree_cons
566 (NULL_TREE
, boff
, NULL_TREE
))));
568 dcast_fn
= dynamic_cast_node
;
576 push_nested_namespace (ns
);
577 tinfo_ptr
= xref_tag (class_type_node
,
578 get_identifier ("__class_type_info"),
581 tinfo_ptr
= build_pointer_type
582 (build_qualified_type
583 (tinfo_ptr
, TYPE_QUAL_CONST
));
584 name
= "__dynamic_cast";
586 (NULL_TREE
, const_ptr_type_node
, tree_cons
587 (NULL_TREE
, tinfo_ptr
, tree_cons
588 (NULL_TREE
, tinfo_ptr
, tree_cons
589 (NULL_TREE
, ptrdiff_type_node
, void_list_node
))));
590 tmp
= build_function_type (ptr_type_node
, tmp
);
591 dcast_fn
= build_library_fn_ptr (name
, tmp
);
592 pop_nested_namespace (ns
);
593 dynamic_cast_node
= dcast_fn
;
595 result
= build_call (dcast_fn
, elems
);
597 if (tc
== REFERENCE_TYPE
)
599 tree bad
= throw_bad_cast ();
601 result
= save_expr (result
);
602 return build (COND_EXPR
, type
, result
, result
, bad
);
605 /* Now back to the type we want from a void*. */
606 result
= cp_convert (type
, result
);
607 return ifnonnull (expr
, result
);
611 errstr
= "source type is not polymorphic";
614 error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
615 expr
, exprtype
, type
, errstr
);
616 return error_mark_node
;
620 build_dynamic_cast (type
, expr
)
623 if (type
== error_mark_node
|| expr
== error_mark_node
)
624 return error_mark_node
;
626 if (processing_template_decl
)
627 return build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
629 return convert_from_reference (build_dynamic_cast_1 (type
, expr
));
632 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
635 qualifier_flags (type
)
639 /* we want the qualifiers on this type, not any array core, it might have */
640 int quals
= TYPE_QUALS (type
);
642 if (quals
& TYPE_QUAL_CONST
)
644 if (quals
& TYPE_QUAL_VOLATILE
)
646 if (quals
& TYPE_QUAL_RESTRICT
)
651 /* Return non-zero, if the pointer chain TYPE ends at an incomplete type, or
652 contains a pointer to member of an incomplete class. */
655 target_incomplete_p (type
)
658 while (TREE_CODE (type
) == POINTER_TYPE
)
659 if (TYPE_PTRMEM_P (type
))
661 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
663 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
666 type
= TREE_TYPE (type
);
667 if (!COMPLETE_OR_VOID_TYPE_P (type
))
673 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
674 is the vtable pointer and NTBS name. The NTBS name is emitted as a
675 comdat const char array, so it becomes a unique key for the type. Generate
676 and emit that VAR_DECL here. (We can't always emit the type_info itself
677 as comdat, because of pointers to incomplete.) */
680 tinfo_base_init (desc
, target
)
684 tree init
= NULL_TREE
;
690 /* Generate the NTBS array variable. */
691 tree name_type
= build_cplus_array_type
692 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
694 tree name_string
= tinfo_name (target
);
696 name_name
= mangle_typeinfo_string_for_type (target
);
697 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
699 DECL_ARTIFICIAL (name_decl
) = 1;
700 TREE_READONLY (name_decl
) = 1;
701 TREE_STATIC (name_decl
) = 1;
702 DECL_EXTERNAL (name_decl
) = 0;
703 TREE_PUBLIC (name_decl
) = 1;
704 comdat_linkage (name_decl
);
705 /* External name of the string containing the type's name has a
707 SET_DECL_ASSEMBLER_NAME (name_decl
,
708 mangle_typeinfo_string_for_type (target
));
709 DECL_INITIAL (name_decl
) = name_string
;
710 cp_finish_decl (name_decl
, name_string
, NULL_TREE
, 0);
711 pushdecl_top_level (name_decl
);
714 if (TINFO_VTABLE_DECL (desc
))
716 tree vtbl_ptr
= TINFO_VTABLE_DECL (desc
);
717 init
= tree_cons (NULL_TREE
, vtbl_ptr
, init
);
720 init
= tree_cons (NULL_TREE
, decay_conversion (name_decl
), init
);
722 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, nreverse (init
));
723 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
724 init
= tree_cons (NULL_TREE
, init
, NULL_TREE
);
729 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
730 information about the particular type_info derivation, which adds no
731 additional fields to the type_info base. */
734 generic_initializer (desc
, target
)
738 tree init
= tinfo_base_init (desc
, target
);
740 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, init
);
741 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
745 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
746 DESC provides information about the particular type_info derivation,
747 which adds target type and qualifier flags members to the type_info base. */
750 ptr_initializer (desc
, target
, non_public_ptr
)
755 tree init
= tinfo_base_init (desc
, target
);
756 tree to
= TREE_TYPE (target
);
757 int flags
= qualifier_flags (to
);
758 int incomplete
= target_incomplete_p (to
);
765 init
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), init
);
766 init
= tree_cons (NULL_TREE
,
767 build_unary_op (ADDR_EXPR
,
768 get_tinfo_decl (TYPE_MAIN_VARIANT (to
)), 0),
771 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, nreverse (init
));
772 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
776 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
777 DESC provides information about the particular type_info derivation,
778 which adds class, target type and qualifier flags members to the type_info
782 ptm_initializer (desc
, target
, non_public_ptr
)
787 tree init
= tinfo_base_init (desc
, target
);
788 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
789 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
790 int flags
= qualifier_flags (to
);
791 int incomplete
= target_incomplete_p (to
);
798 if (!COMPLETE_TYPE_P (klass
))
803 init
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), init
);
804 init
= tree_cons (NULL_TREE
,
805 build_unary_op (ADDR_EXPR
,
806 get_tinfo_decl (TYPE_MAIN_VARIANT (to
)), 0),
808 init
= tree_cons (NULL_TREE
,
809 build_unary_op (ADDR_EXPR
, get_tinfo_decl (klass
), 0),
812 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, nreverse (init
));
813 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
817 /* Check base BINFO to set hint flags in *DATA, which is really an int.
818 We use CLASSTYPE_MARKED to tag types we've found as non-virtual bases and
819 CLASSTYPE_MARKED2 to tag those which are virtual bases. Remember it is
820 possible for a type to be both a virtual and non-virtual base. */
823 dfs_class_hint_mark (binfo
, data
)
827 tree basetype
= BINFO_TYPE (binfo
);
828 int *hint
= (int *) data
;
830 if (TREE_VIA_VIRTUAL (binfo
))
832 if (CLASSTYPE_MARKED (basetype
))
834 if (CLASSTYPE_MARKED2 (basetype
))
836 SET_CLASSTYPE_MARKED2 (basetype
);
840 if (CLASSTYPE_MARKED (basetype
) || CLASSTYPE_MARKED2 (basetype
))
842 SET_CLASSTYPE_MARKED (basetype
);
844 if (!TREE_VIA_PUBLIC (binfo
) && TYPE_BINFO (basetype
) != binfo
)
849 /* Clear the base's dfs marks, after searching for duplicate bases. */
852 dfs_class_hint_unmark (binfo
, data
)
854 void *data ATTRIBUTE_UNUSED
;
856 tree basetype
= BINFO_TYPE (binfo
);
858 CLEAR_CLASSTYPE_MARKED (basetype
);
859 CLEAR_CLASSTYPE_MARKED2 (basetype
);
863 /* Determine the hint flags describing the features of a class's hierarchy. */
866 class_hint_flags (type
)
872 dfs_walk (TYPE_BINFO (type
), dfs_class_hint_mark
, NULL
, &hint_flags
);
873 dfs_walk (TYPE_BINFO (type
), dfs_class_hint_unmark
, NULL
, NULL
);
875 for (i
= 0; i
< CLASSTYPE_N_BASECLASSES (type
); ++i
)
877 tree base_binfo
= BINFO_BASETYPE (TYPE_BINFO (type
), i
);
879 if (TREE_VIA_PUBLIC (base_binfo
))
885 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
886 DESC provides information about the particular __class_type_info derivation,
887 which adds hint flags and TRAIL initializers to the type_info base. */
890 class_initializer (desc
, target
, trail
)
895 tree init
= tinfo_base_init (desc
, target
);
897 TREE_CHAIN (init
) = trail
;
898 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, init
);
899 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
903 /* Returns non-zero if the typeinfo for type should be placed in
904 the runtime library. */
907 typeinfo_in_lib_p (type
)
910 /* The typeinfo objects for `T*' and `const T*' are in the runtime
911 library for simple types T. */
912 if (TREE_CODE (type
) == POINTER_TYPE
913 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
914 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
915 type
= TREE_TYPE (type
);
917 switch (TREE_CODE (type
))
931 /* Generate a pseudo_type_info VAR_DECL suitable for the supplied
932 TARGET_TYPE and given the REAL_NAME. This is the structure expected by
933 the runtime, and therefore has additional fields. If we need not emit a
934 definition (because the runtime must contain it), return NULL_TREE,
935 otherwise return the VAR_DECL. */
938 synthesize_tinfo_var (target_type
, real_name
)
942 tree var_init
= NULL_TREE
;
943 tree var_type
= NULL_TREE
;
946 switch (TREE_CODE (target_type
))
949 if (TYPE_PTRMEM_P (target_type
))
951 var_type
= ptm_desc_type_node
;
952 var_init
= ptm_initializer (var_type
, target_type
, &non_public
);
956 if (typeinfo_in_lib_p (target_type
) && !doing_runtime
)
957 /* These are in the runtime. */
959 var_type
= ptr_desc_type_node
;
960 var_init
= ptr_initializer (var_type
, target_type
, &non_public
);
964 var_type
= enum_desc_type_node
;
965 var_init
= generic_initializer (var_type
, target_type
);
968 var_type
= func_desc_type_node
;
969 var_init
= generic_initializer (var_type
, target_type
);
972 var_type
= ary_desc_type_node
;
973 var_init
= generic_initializer (var_type
, target_type
);
977 if (TYPE_PTRMEMFUNC_P (target_type
))
979 var_type
= ptm_desc_type_node
;
980 var_init
= ptm_initializer (var_type
, target_type
, &non_public
);
982 else if (!COMPLETE_TYPE_P (target_type
))
984 /* Emit a non-public class_type_info. */
986 var_type
= class_desc_type_node
;
987 var_init
= class_initializer (var_type
, target_type
, NULL_TREE
);
989 else if (!CLASSTYPE_N_BASECLASSES (target_type
))
991 var_type
= class_desc_type_node
;
992 var_init
= class_initializer (var_type
, target_type
, NULL_TREE
);
996 /* if this has a single public non-virtual base, it's easier */
997 tree binfo
= TYPE_BINFO (target_type
);
998 int nbases
= BINFO_N_BASETYPES (binfo
);
999 tree base_binfos
= BINFO_BASETYPES (binfo
);
1000 tree base_inits
= NULL_TREE
;
1001 int is_simple
= nbases
== 1;
1004 /* Generate the base information initializer. */
1005 for (ix
= nbases
; ix
--;)
1007 tree base_binfo
= TREE_VEC_ELT (base_binfos
, ix
);
1008 tree base_init
= NULL_TREE
;
1013 if (TREE_PUBLIC (base_binfo
))
1015 tinfo
= get_tinfo_decl (BINFO_TYPE (base_binfo
));
1016 tinfo
= build_unary_op (ADDR_EXPR
, tinfo
, 0);
1017 if (TREE_VIA_VIRTUAL (base_binfo
))
1019 /* We store the vtable offset at which the virtual
1020 base offset can be found. */
1021 offset
= BINFO_VPTR_FIELD (binfo_for_vbase (BINFO_TYPE (base_binfo
),
1023 offset
= convert (sizetype
, offset
);
1027 offset
= BINFO_OFFSET (base_binfo
);
1029 /* is it a single public inheritance? */
1030 if (is_simple
&& flags
== 2 && integer_zerop (offset
))
1032 base_inits
= tree_cons (NULL_TREE
, tinfo
, NULL_TREE
);
1037 /* combine offset and flags into one field */
1038 offset
= cp_build_binary_op (LSHIFT_EXPR
, offset
,
1039 build_int_2 (8, 0));
1040 offset
= cp_build_binary_op (BIT_IOR_EXPR
, offset
,
1041 build_int_2 (flags
, 0));
1042 base_init
= tree_cons (NULL_TREE
, offset
, base_init
);
1043 base_init
= tree_cons (NULL_TREE
, tinfo
, base_init
);
1044 base_init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, base_init
);
1045 base_inits
= tree_cons (NULL_TREE
, base_init
, base_inits
);
1049 var_type
= si_class_desc_type_node
;
1052 int hint
= class_hint_flags (target_type
);
1054 base_inits
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, base_inits
);
1055 base_inits
= tree_cons (NULL_TREE
, base_inits
, NULL_TREE
);
1056 /* Prepend the number of bases. */
1057 base_inits
= tree_cons (NULL_TREE
,
1058 build_int_2 (nbases
, 0), base_inits
);
1059 /* Prepend the hint flags. */
1060 base_inits
= tree_cons (NULL_TREE
,
1061 build_int_2 (hint
, 0), base_inits
);
1062 var_type
= get_vmi_pseudo_type_info (nbases
);
1064 var_init
= class_initializer (var_type
, target_type
, base_inits
);
1069 if (typeinfo_in_lib_p (target_type
))
1072 /* These are guaranteed to be in the runtime. */
1074 var_type
= bltn_desc_type_node
;
1075 var_init
= generic_initializer (var_type
, target_type
);
1078 my_friendly_abort (20000117);
1081 return create_real_tinfo_var (target_type
,
1082 real_name
, TINFO_PSEUDO_TYPE (var_type
),
1083 var_init
, non_public
);
1086 /* Create the real typeinfo variable. NON_PUBLIC indicates that we cannot
1087 make this variable public (comdat). */
1090 create_real_tinfo_var (target_type
, name
, type
, init
, non_public
)
1097 static int count
= 0;
1102 /* We cannot give this the name NAME, as that already is globally
1103 bound to the tinfo_decl we originally created for this type in
1105 sprintf (hidden
, "__ti_%d", count
++);
1106 hidden_name
= get_identifier (hidden
);
1108 decl
= build_lang_decl (VAR_DECL
, hidden_name
,
1109 build_qualified_type (type
, TYPE_QUAL_CONST
));
1110 DECL_ARTIFICIAL (decl
) = 1;
1111 TREE_READONLY (decl
) = 1;
1112 TREE_STATIC (decl
) = 1;
1113 DECL_EXTERNAL (decl
) = 0;
1117 TREE_PUBLIC (decl
) = 1;
1118 if (flag_weak
|| !typeinfo_in_lib_p (target_type
))
1119 comdat_linkage (decl
);
1121 SET_DECL_ASSEMBLER_NAME (decl
, name
);
1122 DECL_INITIAL (decl
) = init
;
1123 cp_finish_decl (decl
, init
, NULL_TREE
, 0);
1124 pushdecl_top_level (decl
);
1125 TREE_USED (decl
) = 1;
1129 /* Generate the RECORD_TYPE containing the data layout of a type_info
1130 derivative as used by the runtime. This layout must be consistent with
1131 that defined in the runtime support. Also generate the VAR_DECL for the
1132 type's vtable. We explicitly manage the vtable member, and name it for
1133 real type as used in the runtime. The RECORD type has a different name,
1134 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1135 is the generated type and TINFO_VTABLE_DECL is the vtable decl.
1137 REAL_NAME is the runtime's name of the type. Trailing arguments are
1138 additional FIELD_DECL's for the structure. The final argument must be
1142 create_pseudo_type_info
VPARAMS((const char *real_name
, int ident
, ...))
1144 tree real_type
, pseudo_type
;
1152 VA_OPEN (ap
, ident
);
1153 VA_FIXEDARG (ap
, const char *, real_name
);
1154 VA_FIXEDARG (ap
, int, ident
);
1156 /* Generate the pseudo type name. */
1157 pseudo_name
= (char *)alloca (strlen (real_name
) + 30);
1158 strcpy (pseudo_name
, real_name
);
1159 strcat (pseudo_name
, "_pseudo");
1161 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", ident
);
1163 /* Get the vtable decl. */
1164 real_type
= xref_tag (class_type_node
, get_identifier (real_name
), 1);
1165 if (! TYPE_SIZE (real_type
))
1167 /* We never saw a definition of this type, so we need to tell the
1168 compiler that this is an exported class, as indeed all of the
1169 __*_type_info classes are. */
1170 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
1171 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
1174 vtable_decl
= get_vtable_decl (real_type
, /*complete=*/1);
1175 vtable_decl
= build_unary_op (ADDR_EXPR
, vtable_decl
, 0);
1177 /* We need to point into the middle of the vtable. */
1178 vtable_decl
= build (PLUS_EXPR
,
1179 TREE_TYPE (vtable_decl
),
1181 size_binop (MULT_EXPR
,
1183 TYPE_SIZE_UNIT (vtable_entry_type
)));
1184 TREE_CONSTANT (vtable_decl
) = 1;
1186 /* First field is the pseudo type_info base class. */
1187 fields
[0] = build_decl (FIELD_DECL
, NULL_TREE
, ti_desc_type_node
);
1189 /* Now add the derived fields. */
1190 for (ix
= 0; (field_decl
= va_arg (ap
, tree
));)
1191 fields
[++ix
] = field_decl
;
1193 /* Create the pseudo type. */
1194 pseudo_type
= make_aggr_type (RECORD_TYPE
);
1195 finish_builtin_type (pseudo_type
, pseudo_name
, fields
, ix
, ptr_type_node
);
1196 TYPE_HAS_CONSTRUCTOR (pseudo_type
) = 1;
1198 result
= tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
);
1199 TINFO_VTABLE_DECL (result
) = vtable_decl
;
1200 TINFO_PSEUDO_TYPE (result
) = pseudo_type
;
1206 /* Return a descriptor for a vmi type with NUM_BASES bases. */
1209 get_vmi_pseudo_type_info (num_bases
)
1213 tree array_domain
, base_array
;
1215 if (TREE_VEC_LENGTH (vmi_class_desc_type_node
) <= num_bases
)
1218 tree extend
= make_tree_vec (num_bases
+ 5);
1220 for (ix
= TREE_VEC_LENGTH (vmi_class_desc_type_node
); ix
--;)
1221 TREE_VEC_ELT (extend
, ix
) = TREE_VEC_ELT (vmi_class_desc_type_node
, ix
);
1222 vmi_class_desc_type_node
= extend
;
1224 desc
= TREE_VEC_ELT (vmi_class_desc_type_node
, num_bases
);
1229 /* Add number of bases and trailing array of base_class_type_info. */
1230 array_domain
= build_index_type (size_int (num_bases
));
1231 base_array
= build_array_type (base_desc_type_node
, array_domain
);
1233 push_nested_namespace (abi_node
);
1235 desc
= create_pseudo_type_info
1236 ("__vmi_class_type_info", num_bases
,
1237 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1238 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1239 build_decl (FIELD_DECL
, NULL_TREE
, base_array
),
1242 pop_nested_namespace (abi_node
);
1244 TREE_VEC_ELT (vmi_class_desc_type_node
, num_bases
) = desc
;
1248 /* Make sure the required builtin types exist for generating the type_info
1249 varable definitions. */
1252 create_tinfo_types ()
1256 if (bltn_desc_type_node
)
1258 push_nested_namespace (abi_node
);
1260 ptr_type_info
= build_pointer_type
1261 (build_qualified_type
1262 (type_info_type_node
, TYPE_QUAL_CONST
));
1264 /* Create the internal type_info structure. This is used as a base for
1265 the other structures. */
1269 ti_desc_type_node
= make_aggr_type (RECORD_TYPE
);
1270 fields
[0] = build_decl (FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1271 fields
[1] = build_decl (FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1272 finish_builtin_type (ti_desc_type_node
, "__type_info_pseudo",
1273 fields
, 1, ptr_type_node
);
1274 TYPE_HAS_CONSTRUCTOR (ti_desc_type_node
) = 1;
1277 /* Fundamental type_info */
1278 bltn_desc_type_node
= create_pseudo_type_info
1279 ("__fundamental_type_info", 0,
1282 /* Array, function and enum type_info. No additional fields. */
1283 ary_desc_type_node
= create_pseudo_type_info
1284 ("__array_type_info", 0,
1286 func_desc_type_node
= create_pseudo_type_info
1287 ("__function_type_info", 0,
1289 enum_desc_type_node
= create_pseudo_type_info
1290 ("__enum_type_info", 0,
1293 /* Class type_info. Add a flags field. */
1294 class_desc_type_node
= create_pseudo_type_info
1295 ("__class_type_info", 0,
1298 /* Single public non-virtual base class. Add pointer to base class.
1299 This is really a descendant of __class_type_info. */
1300 si_class_desc_type_node
= create_pseudo_type_info
1301 ("__si_class_type_info", 0,
1302 build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1305 /* Base class internal helper. Pointer to base type, offset to base,
1310 fields
[0] = build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
);
1311 fields
[1] = build_decl (FIELD_DECL
, NULL_TREE
, integer_types
[itk_long
]);
1312 base_desc_type_node
= make_aggr_type (RECORD_TYPE
);
1313 finish_builtin_type (base_desc_type_node
, "__base_class_type_info_pseudo",
1314 fields
, 1, ptr_type_node
);
1315 TYPE_HAS_CONSTRUCTOR (base_desc_type_node
) = 1;
1318 /* General hierarchy is created as necessary in this vector. */
1319 vmi_class_desc_type_node
= make_tree_vec (10);
1321 /* Pointer type_info. Adds two fields, qualification mask
1322 and pointer to the pointed to type. This is really a descendant of
1323 __pbase_type_info. */
1324 ptr_desc_type_node
= create_pseudo_type_info
1325 ("__pointer_type_info", 0,
1326 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1327 build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1330 /* Pointer to member data type_info. Add qualifications flags,
1331 pointer to the member's type info and pointer to the class.
1332 This is really a descendant of __pbase_type_info. */
1333 ptm_desc_type_node
= create_pseudo_type_info
1334 ("__pointer_to_member_type_info", 0,
1335 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1336 build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1337 build_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1340 pop_nested_namespace (abi_node
);
1343 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1344 support. Generating them here guarantees consistency with the other
1345 structures. We use the following heuristic to determine when the runtime
1346 is being generated. If std::__fundamental_type_info is defined, and its
1347 destructor is defined, then the runtime is being built. */
1350 emit_support_tinfos ()
1352 static tree
*const fundamentals
[] =
1357 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1358 &short_integer_type_node
, &short_unsigned_type_node
,
1359 &integer_type_node
, &unsigned_type_node
,
1360 &long_integer_type_node
, &long_unsigned_type_node
,
1361 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1362 &float_type_node
, &double_type_node
, &long_double_type_node
,
1366 tree bltn_type
, dtor
;
1368 push_nested_namespace (abi_node
);
1369 bltn_type
= xref_tag (class_type_node
,
1370 get_identifier ("__fundamental_type_info"), 1);
1371 pop_nested_namespace (abi_node
);
1372 if (!COMPLETE_TYPE_P (bltn_type
))
1374 dtor
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type
), 1);
1375 if (DECL_EXTERNAL (dtor
))
1378 for (ix
= 0; fundamentals
[ix
]; ix
++)
1380 tree bltn
= *fundamentals
[ix
];
1381 tree bltn_ptr
= build_pointer_type (bltn
);
1382 tree bltn_const_ptr
= build_pointer_type
1383 (build_qualified_type (bltn
, TYPE_QUAL_CONST
));
1386 tinfo
= get_tinfo_decl (bltn
);
1387 TREE_USED (tinfo
) = 1;
1388 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1390 tinfo
= get_tinfo_decl (bltn_ptr
);
1391 TREE_USED (tinfo
) = 1;
1392 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1394 tinfo
= get_tinfo_decl (bltn_const_ptr
);
1395 TREE_USED (tinfo
) = 1;
1396 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1400 /* Return non-zero, iff T is a type_info variable which has not had a
1401 definition emitted for it. */
1404 tinfo_decl_p (t
, data
)
1406 void *data ATTRIBUTE_UNUSED
;
1408 return TREE_CODE (t
) == VAR_DECL
1409 && IDENTIFIER_GLOBAL_VALUE (DECL_NAME (t
)) == (t
)
1410 && TREE_TYPE (t
) == tinfo_decl_type
1411 && TREE_TYPE (DECL_NAME (t
));
1414 /* Emit a suitable type_info definition for the type_info decl pointed to by
1415 DECL_PTR. We emit a completely new variable, of the correct type for the
1416 actual type this is describing. The DECL_ASSEMBLER_NAME of the generated
1417 definition is set to that of the supplied decl, so that they can be tied
1418 up. Mark the supplied decl as having been dealt with. Emitting one
1419 definition might cause other definitions to be required.
1421 We need to do things this way, because we're trying to do something like
1427 extern const A tinfo_var;
1429 const B tinfo_var = {...};
1431 which is not permitted. Also, we've not necessarily seen the definition of B.
1432 So we do something like the following,
1434 extern const A tinfo_var;
1437 const void *vtable_ptr;
1445 const pseudo_B proxy_tinfo_var attribute((assembler_name="tinfo_var")) =
1447 {&B::vtable, "..."},
1451 pseudo_A and pseudo_B must be layout equivalent to the real definitions in
1455 emit_tinfo_decl (decl_ptr
, data
)
1457 void *data ATTRIBUTE_UNUSED
;
1459 tree tinfo_decl
= *decl_ptr
;
1460 tree tinfo_type
, decl
;
1462 my_friendly_assert (TREE_TYPE (tinfo_decl
) == tinfo_decl_type
, 20000121);
1463 tinfo_type
= TREE_TYPE (DECL_NAME (tinfo_decl
));
1464 my_friendly_assert (tinfo_type
!= NULL_TREE
, 20000120);
1466 if (!DECL_NEEDED_P (tinfo_decl
))
1468 /* Say we've dealt with it. */
1469 TREE_TYPE (DECL_NAME (tinfo_decl
)) = NULL_TREE
;
1471 create_tinfo_types ();
1472 decl
= synthesize_tinfo_var (tinfo_type
, DECL_ASSEMBLER_NAME (tinfo_decl
));