1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Mostly written by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "coretypes.h"
35 /* C++ returns type information to the user in struct type_info
36 objects. We also use type information to implement dynamic_cast and
37 exception handlers. Type information for a particular type is
38 indicated with an ABI defined structure derived from type_info.
39 This would all be very straight forward, but for the fact that the
40 runtime library provides the definitions of the type_info structure
41 and the ABI defined derived classes. We cannot build declarations
42 of them directly in the compiler, but we need to layout objects of
43 their type. Somewhere we have to lie.
45 We define layout compatible POD-structs with compiler-defined names
46 and generate the appropriate initializations for them (complete
47 with explicit mention of their vtable). When we have to provide a
48 type_info to the user we reinterpret_cast the internal compiler
49 type to type_info. A well formed program can only explicitly refer
50 to the type_infos of complete types (& cv void). However, we chain
51 pointer type_infos to the pointed-to-type, and that can be
52 incomplete. We only need the addresses of such incomplete
53 type_info objects for static initialization.
55 The type information VAR_DECL of a type is held on the
56 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
57 will be the internal type. It will usually have the correct
58 internal type reflecting the kind of type it represents (pointer,
59 array, function, class, inherited class, etc). When the type it
60 represents is incomplete, it will have the internal type
61 corresponding to type_info. That will only happen at the end of
62 translation, when we are emitting the type info objects. */
64 /* Accessors for the type_info objects. We need to remember several things
65 about each of the type_info types. The global tree nodes such as
66 bltn_desc_type_node are TREE_LISTs, and these macros are used to access
67 the required information. */
68 /* The RECORD_TYPE of a type_info derived class. */
69 #define TINFO_PSEUDO_TYPE(NODE) TREE_TYPE (NODE)
70 /* The VAR_DECL of the vtable for the type_info derived class.
71 This is only filled in at the end of the translation. */
72 #define TINFO_VTABLE_DECL(NODE) TREE_VALUE (NODE)
73 /* The IDENTIFIER_NODE naming the real class. */
74 #define TINFO_REAL_NAME(NODE) TREE_PURPOSE (NODE)
76 /* A varray of all tinfo decls that haven't yet been emitted. */
77 varray_type unemitted_tinfo_decls
;
79 static tree
build_headof (tree
);
80 static tree
ifnonnull (tree
, tree
);
81 static tree
tinfo_name (tree
);
82 static tree
build_dynamic_cast_1 (tree
, tree
);
83 static tree
throw_bad_cast (void);
84 static tree
throw_bad_typeid (void);
85 static tree
get_tinfo_decl_dynamic (tree
);
86 static tree
get_tinfo_ptr (tree
);
87 static bool typeid_ok_p (void);
88 static int qualifier_flags (tree
);
89 static bool target_incomplete_p (tree
);
90 static tree
tinfo_base_init (tree
, tree
);
91 static tree
generic_initializer (tree
, tree
);
92 static tree
dfs_class_hint_mark (tree
, void *);
93 static tree
dfs_class_hint_unmark (tree
, void *);
94 static int class_hint_flags (tree
);
95 static tree
class_initializer (tree
, tree
, tree
);
96 static tree
create_pseudo_type_info (const char *, int, ...);
97 static tree
get_pseudo_ti_init (tree
, tree
);
98 static tree
get_pseudo_ti_desc (tree
);
99 static void create_tinfo_types (void);
100 static bool typeinfo_in_lib_p (tree
);
102 static int doing_runtime
= 0;
105 /* Declare language defined type_info type and a pointer to const
106 type_info. This is incomplete here, and will be completed when
107 the user #includes <typeinfo>. There are language defined
108 restrictions on what can be done until that is included. Create
109 the internal versions of the ABI types. */
112 init_rtti_processing (void)
114 tree const_type_info_type
;
116 push_namespace (std_identifier
);
118 = xref_tag (class_type
, get_identifier ("type_info"),
121 const_type_info_type
= build_qualified_type (type_info_type_node
,
123 type_info_ptr_type
= build_pointer_type (const_type_info_type
);
124 type_info_ref_type
= build_reference_type (const_type_info_type
);
126 VARRAY_TREE_INIT (unemitted_tinfo_decls
, 10, "RTTI decls");
128 create_tinfo_types ();
131 /* Given the expression EXP of type `class *', return the head of the
132 object pointed to by EXP with type cv void*, if the class has any
133 virtual functions (TYPE_POLYMORPHIC_P), else just return the
137 build_headof (tree exp
)
139 tree type
= TREE_TYPE (exp
);
143 my_friendly_assert (TREE_CODE (type
) == POINTER_TYPE
, 20000112);
144 type
= TREE_TYPE (type
);
146 if (!TYPE_POLYMORPHIC_P (type
))
149 /* We use this a couple of times below, protect it. */
150 exp
= save_expr (exp
);
152 /* The offset-to-top field is at index -2 from the vptr. */
153 index
= build_int_2 (-2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
, -1);
155 offset
= build_vtbl_ref (build_indirect_ref (exp
, NULL
), index
);
157 type
= build_qualified_type (ptr_type_node
,
158 cp_type_quals (TREE_TYPE (exp
)));
159 return build (PLUS_EXPR
, type
, exp
,
160 convert_to_integer (ptrdiff_type_node
, offset
));
163 /* Get a bad_cast node for the program to throw...
165 See libstdc++/exception.cc for __throw_bad_cast */
168 throw_bad_cast (void)
170 tree fn
= get_identifier ("__cxa_bad_cast");
171 if (!get_global_value_if_present (fn
, &fn
))
172 fn
= push_throw_library_fn (fn
, build_function_type (ptr_type_node
,
175 return build_cxx_call (fn
, NULL_TREE
);
178 /* Return an expression for "__cxa_bad_typeid()". The expression
179 returned is an lvalue of type "const std::type_info". */
182 throw_bad_typeid (void)
184 tree fn
= get_identifier ("__cxa_bad_typeid");
185 if (!get_global_value_if_present (fn
, &fn
))
187 tree t
= build_qualified_type (type_info_type_node
, TYPE_QUAL_CONST
);
188 t
= build_function_type (build_reference_type (t
), void_list_node
);
189 fn
= push_throw_library_fn (fn
, t
);
192 return convert_from_reference (build_cxx_call (fn
, NULL_TREE
));
195 /* Return an lvalue expression whose type is "const std::type_info"
196 and whose value indicates the type of the expression EXP. If EXP
197 is a reference to a polymorphic class, return the dynamic type;
198 otherwise return the static type of the expression. */
201 get_tinfo_decl_dynamic (tree exp
)
206 if (exp
== error_mark_node
)
207 return error_mark_node
;
209 /* peel back references, so they match. */
210 type
= non_reference (TREE_TYPE (exp
));
212 /* Peel off cv qualifiers. */
213 type
= TYPE_MAIN_VARIANT (type
);
215 if (!VOID_TYPE_P (type
))
216 type
= complete_type_or_else (type
, exp
);
219 return error_mark_node
;
221 /* If exp is a reference to polymorphic type, get the real type_info. */
222 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
224 /* build reference to type_info from vtable. */
227 /* The RTTI information is at index -1. */
228 index
= build_int_2 (-1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
, -1);
229 t
= build_vtbl_ref (exp
, index
);
230 t
= convert (type_info_ptr_type
, t
);
233 /* Otherwise return the type_info for the static type of the expr. */
234 t
= get_tinfo_ptr (TYPE_MAIN_VARIANT (type
));
236 return build_indirect_ref (t
, NULL
);
244 error ("cannot use typeid with -fno-rtti");
248 if (!COMPLETE_TYPE_P (type_info_type_node
))
250 error ("must #include <typeinfo> before using typeid");
257 /* Return an expression for "typeid(EXP)". The expression returned is
258 an lvalue of type "const std::type_info". */
261 build_typeid (tree exp
)
263 tree cond
= NULL_TREE
;
266 if (exp
== error_mark_node
|| !typeid_ok_p ())
267 return error_mark_node
;
269 if (processing_template_decl
)
270 return build_min (TYPEID_EXPR
, type_info_ref_type
, exp
);
272 if (TREE_CODE (exp
) == INDIRECT_REF
273 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
274 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
275 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
278 exp
= stabilize_reference (exp
);
279 cond
= cp_convert (boolean_type_node
, TREE_OPERAND (exp
, 0));
282 exp
= get_tinfo_decl_dynamic (exp
);
284 if (exp
== error_mark_node
)
285 return error_mark_node
;
289 tree bad
= throw_bad_typeid ();
291 exp
= build (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
297 /* Generate the NTBS name of a type. */
299 tinfo_name (tree type
)
304 name
= mangle_type_string (type
);
305 name_string
= fix_string_type (build_string (strlen (name
) + 1, name
));
309 /* Return a VAR_DECL for the internal ABI defined type_info object for
310 TYPE. You must arrange that the decl is mark_used, if actually use
311 it --- decls in vtables are only used if the vtable is output. */
314 get_tinfo_decl (tree type
)
319 if (COMPLETE_TYPE_P (type
)
320 && TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
322 error ("cannot create type information for type `%T' because its size is variable",
324 return error_mark_node
;
327 if (TREE_CODE (type
) == METHOD_TYPE
)
328 type
= build_function_type (TREE_TYPE (type
),
329 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
331 /* For a class type, the variable is cached in the type node
333 if (CLASS_TYPE_P (type
))
335 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
340 name
= mangle_typeinfo_for_type (type
);
342 d
= IDENTIFIER_GLOBAL_VALUE (name
);
345 tree var_desc
= get_pseudo_ti_desc (type
);
347 d
= build_lang_decl (VAR_DECL
, name
, TINFO_PSEUDO_TYPE (var_desc
));
348 SET_DECL_ASSEMBLER_NAME (d
, name
);
349 /* Remember the type it is for. */
350 TREE_TYPE (name
) = type
;
351 DECL_TINFO_P (d
) = 1;
352 DECL_ARTIFICIAL (d
) = 1;
353 TREE_READONLY (d
) = 1;
355 /* Mark the variable as undefined -- but remember that we can
356 define it later if we need to do so. */
357 DECL_EXTERNAL (d
) = 1;
358 DECL_NOT_REALLY_EXTERN (d
) = 1;
359 if (CLASS_TYPE_P (type
))
360 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
361 set_linkage_according_to_type (type
, d
);
362 pushdecl_top_level_and_finish (d
, NULL_TREE
);
364 /* Add decl to the global array of tinfo decls. */
365 my_friendly_assert (unemitted_tinfo_decls
!= 0, 20030312);
366 VARRAY_PUSH_TREE (unemitted_tinfo_decls
, d
);
372 /* Return a pointer to a type_info object describing TYPE, suitably
373 cast to the language defined type. */
376 get_tinfo_ptr (tree type
)
378 tree decl
= get_tinfo_decl (type
);
381 return build_nop (type_info_ptr_type
,
382 build_address (decl
));
385 /* Return the type_info object for TYPE. */
388 get_typeid (tree type
)
390 if (type
== error_mark_node
|| !typeid_ok_p ())
391 return error_mark_node
;
393 if (processing_template_decl
)
394 return build_min (TYPEID_EXPR
, type_info_ref_type
, type
);
396 /* If the type of the type-id is a reference type, the result of the
397 typeid expression refers to a type_info object representing the
399 type
= non_reference (type
);
401 /* The top-level cv-qualifiers of the lvalue expression or the type-id
402 that is the operand of typeid are always ignored. */
403 type
= TYPE_MAIN_VARIANT (type
);
405 if (!VOID_TYPE_P (type
))
406 type
= complete_type_or_else (type
, NULL_TREE
);
409 return error_mark_node
;
411 return build_indirect_ref (get_tinfo_ptr (type
), NULL
);
414 /* Check whether TEST is null before returning RESULT. If TEST is used in
415 RESULT, it must have previously had a save_expr applied to it. */
418 ifnonnull (tree test
, tree result
)
420 return build (COND_EXPR
, TREE_TYPE (result
),
421 build (EQ_EXPR
, boolean_type_node
, test
, integer_zero_node
),
422 cp_convert (TREE_TYPE (result
), integer_zero_node
),
426 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
430 build_dynamic_cast_1 (tree type
, tree expr
)
432 enum tree_code tc
= TREE_CODE (type
);
433 tree exprtype
= TREE_TYPE (expr
);
435 tree old_expr
= expr
;
436 const char *errstr
= NULL
;
438 /* T shall be a pointer or reference to a complete class type, or
439 `pointer to cv void''. */
443 if (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
)
446 if (! IS_AGGR_TYPE (TREE_TYPE (type
)))
448 errstr
= "target is not pointer or reference to class";
451 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
453 errstr
= "target is not pointer or reference to complete type";
459 errstr
= "target is not pointer or reference";
463 if (tc
== POINTER_TYPE
)
464 expr
= convert_from_reference (expr
);
465 else if (TREE_CODE (exprtype
) != REFERENCE_TYPE
)
467 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
468 exprtype
= build_reference_type (exprtype
);
469 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
470 LOOKUP_NORMAL
, NULL_TREE
);
473 exprtype
= TREE_TYPE (expr
);
475 if (tc
== POINTER_TYPE
)
477 /* If T is a pointer type, v shall be an rvalue of a pointer to
478 complete class type, and the result is an rvalue of type T. */
480 if (TREE_CODE (exprtype
) != POINTER_TYPE
)
482 errstr
= "source is not a pointer";
485 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype
)))
487 errstr
= "source is not a pointer to class";
490 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
492 errstr
= "source is a pointer to incomplete type";
498 /* T is a reference type, v shall be an lvalue of a complete class
499 type, and the result is an lvalue of the type referred to by T. */
501 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype
)))
503 errstr
= "source is not of class type";
506 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
508 errstr
= "source is of incomplete class type";
514 /* The dynamic_cast operator shall not cast away constness. */
515 if (!at_least_as_qualified_p (TREE_TYPE (type
),
516 TREE_TYPE (exprtype
)))
518 errstr
= "conversion casts away constness";
522 /* If *type is an unambiguous accessible base class of *exprtype,
523 convert statically. */
527 binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
528 ba_not_special
, NULL
);
532 expr
= build_base_path (PLUS_EXPR
, convert_from_reference (expr
),
534 if (TREE_CODE (exprtype
) == POINTER_TYPE
)
535 expr
= non_lvalue (expr
);
540 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
541 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
544 /* if TYPE is `void *', return pointer to complete object. */
545 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
547 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
548 if (TREE_CODE (expr
) == ADDR_EXPR
549 && TREE_CODE (TREE_OPERAND (expr
, 0)) == VAR_DECL
550 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
551 return build1 (NOP_EXPR
, type
, expr
);
553 /* Since expr is used twice below, save it. */
554 expr
= save_expr (expr
);
556 expr1
= build_headof (expr
);
557 if (TREE_TYPE (expr1
) != type
)
558 expr1
= build1 (NOP_EXPR
, type
, expr1
);
559 return ifnonnull (expr
, expr1
);
564 tree result
, td2
, td3
, elems
;
565 tree static_type
, target_type
, boff
;
567 /* If we got here, we can't convert statically. Therefore,
568 dynamic_cast<D&>(b) (b an object) cannot succeed. */
569 if (tc
== REFERENCE_TYPE
)
571 if (TREE_CODE (old_expr
) == VAR_DECL
572 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
574 tree expr
= throw_bad_cast ();
575 warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
577 /* Bash it to the expected type. */
578 TREE_TYPE (expr
) = type
;
582 /* Ditto for dynamic_cast<D*>(&b). */
583 else if (TREE_CODE (expr
) == ADDR_EXPR
)
585 tree op
= TREE_OPERAND (expr
, 0);
586 if (TREE_CODE (op
) == VAR_DECL
587 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
589 warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
591 retval
= build_int_2 (0, 0);
592 TREE_TYPE (retval
) = type
;
597 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
598 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
599 td2
= get_tinfo_decl (target_type
);
601 td2
= build_unary_op (ADDR_EXPR
, td2
, 0);
602 td3
= get_tinfo_decl (static_type
);
604 td3
= build_unary_op (ADDR_EXPR
, td3
, 0);
606 /* Determine how T and V are related. */
607 boff
= get_dynamic_cast_base_type (static_type
, target_type
);
609 /* Since expr is used twice below, save it. */
610 expr
= save_expr (expr
);
613 if (tc
== REFERENCE_TYPE
)
614 expr1
= build_unary_op (ADDR_EXPR
, expr1
, 0);
617 (NULL_TREE
, expr1
, tree_cons
618 (NULL_TREE
, td3
, tree_cons
619 (NULL_TREE
, td2
, tree_cons
620 (NULL_TREE
, boff
, NULL_TREE
))));
622 dcast_fn
= dynamic_cast_node
;
630 push_nested_namespace (ns
);
631 tinfo_ptr
= xref_tag (class_type
,
632 get_identifier ("__class_type_info"),
635 tinfo_ptr
= build_pointer_type
636 (build_qualified_type
637 (tinfo_ptr
, TYPE_QUAL_CONST
));
638 name
= "__dynamic_cast";
640 (NULL_TREE
, const_ptr_type_node
, tree_cons
641 (NULL_TREE
, tinfo_ptr
, tree_cons
642 (NULL_TREE
, tinfo_ptr
, tree_cons
643 (NULL_TREE
, ptrdiff_type_node
, void_list_node
))));
644 tmp
= build_function_type (ptr_type_node
, tmp
);
645 dcast_fn
= build_library_fn_ptr (name
, tmp
);
646 DECL_IS_PURE (dcast_fn
) = 1;
647 pop_nested_namespace (ns
);
648 dynamic_cast_node
= dcast_fn
;
650 result
= build_cxx_call (dcast_fn
, elems
);
652 if (tc
== REFERENCE_TYPE
)
654 tree bad
= throw_bad_cast ();
656 result
= save_expr (result
);
657 return build (COND_EXPR
, type
, result
, result
, bad
);
660 /* Now back to the type we want from a void*. */
661 result
= cp_convert (type
, result
);
662 return ifnonnull (expr
, result
);
666 errstr
= "source type is not polymorphic";
669 error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
670 expr
, exprtype
, type
, errstr
);
671 return error_mark_node
;
675 build_dynamic_cast (tree type
, tree expr
)
677 if (type
== error_mark_node
|| expr
== error_mark_node
)
678 return error_mark_node
;
680 if (processing_template_decl
)
682 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
683 TREE_SIDE_EFFECTS (expr
) = 1;
688 return convert_from_reference (build_dynamic_cast_1 (type
, expr
));
691 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
694 qualifier_flags (tree type
)
697 int quals
= cp_type_quals (type
);
699 if (quals
& TYPE_QUAL_CONST
)
701 if (quals
& TYPE_QUAL_VOLATILE
)
703 if (quals
& TYPE_QUAL_RESTRICT
)
708 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
709 contains a pointer to member of an incomplete class. */
712 target_incomplete_p (tree type
)
715 if (TYPE_PTRMEM_P (type
))
717 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
719 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
721 else if (TREE_CODE (type
) == POINTER_TYPE
)
722 type
= TREE_TYPE (type
);
724 return !COMPLETE_OR_VOID_TYPE_P (type
);
727 /* Returns true if TYPE involves an incomplete class type; in that
728 case, typeinfo variables for TYPE should be emitted with internal
732 involves_incomplete_p (tree type
)
734 switch (TREE_CODE (type
))
737 return target_incomplete_p (TREE_TYPE (type
));
742 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
743 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
746 if (TYPE_PTRMEMFUNC_P (type
))
750 if (!COMPLETE_TYPE_P (type
))
754 /* All other types do not involve incomplete class types. */
759 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
760 is the vtable pointer and NTBS name. The NTBS name is emitted as a
761 comdat const char array, so it becomes a unique key for the type. Generate
762 and emit that VAR_DECL here. (We can't always emit the type_info itself
763 as comdat, because of pointers to incomplete.) */
766 tinfo_base_init (tree desc
, tree target
)
768 tree init
= NULL_TREE
;
775 /* Generate the NTBS array variable. */
776 tree name_type
= build_cplus_array_type
777 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
779 tree name_string
= tinfo_name (target
);
781 /* Determine the name of the variable -- and remember with which
782 type it is associated. */
783 name_name
= mangle_typeinfo_string_for_type (target
);
784 TREE_TYPE (name_name
) = target
;
786 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
787 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
788 DECL_ARTIFICIAL (name_decl
) = 1;
789 TREE_READONLY (name_decl
) = 1;
790 TREE_STATIC (name_decl
) = 1;
791 DECL_EXTERNAL (name_decl
) = 0;
792 DECL_TINFO_P (name_decl
) = 1;
793 if (involves_incomplete_p (target
))
795 TREE_PUBLIC (name_decl
) = 0;
796 DECL_INTERFACE_KNOWN (name_decl
) = 1;
799 set_linkage_according_to_type (target
, name_decl
);
800 import_export_decl (name_decl
);
801 DECL_INITIAL (name_decl
) = name_string
;
802 mark_used (name_decl
);
803 pushdecl_top_level_and_finish (name_decl
, name_string
);
806 vtable_ptr
= TINFO_VTABLE_DECL (desc
);
811 push_nested_namespace (abi_node
);
812 real_type
= xref_tag (class_type
, TINFO_REAL_NAME (desc
),
814 pop_nested_namespace (abi_node
);
816 if (!COMPLETE_TYPE_P (real_type
))
818 /* We never saw a definition of this type, so we need to
819 tell the compiler that this is an exported class, as
820 indeed all of the __*_type_info classes are. */
821 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
822 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
825 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
826 vtable_ptr
= build_unary_op (ADDR_EXPR
, vtable_ptr
, 0);
828 /* We need to point into the middle of the vtable. */
830 (PLUS_EXPR
, TREE_TYPE (vtable_ptr
), vtable_ptr
,
831 size_binop (MULT_EXPR
,
832 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
833 TYPE_SIZE_UNIT (vtable_entry_type
)));
835 TINFO_VTABLE_DECL (desc
) = vtable_ptr
;
838 init
= tree_cons (NULL_TREE
, vtable_ptr
, init
);
840 init
= tree_cons (NULL_TREE
, decay_conversion (name_decl
), init
);
842 init
= build_constructor (NULL_TREE
, nreverse (init
));
843 TREE_CONSTANT (init
) = 1;
844 TREE_INVARIANT (init
) = 1;
845 TREE_STATIC (init
) = 1;
846 init
= tree_cons (NULL_TREE
, init
, NULL_TREE
);
851 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
852 information about the particular type_info derivation, which adds no
853 additional fields to the type_info base. */
856 generic_initializer (tree desc
, tree target
)
858 tree init
= tinfo_base_init (desc
, target
);
860 init
= build_constructor (NULL_TREE
, init
);
861 TREE_CONSTANT (init
) = 1;
862 TREE_INVARIANT (init
) = 1;
863 TREE_STATIC (init
) = 1;
867 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
868 DESC provides information about the particular type_info derivation,
869 which adds target type and qualifier flags members to the type_info base. */
872 ptr_initializer (tree desc
, tree target
)
874 tree init
= tinfo_base_init (desc
, target
);
875 tree to
= TREE_TYPE (target
);
876 int flags
= qualifier_flags (to
);
877 bool incomplete
= target_incomplete_p (to
);
881 init
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), init
);
882 init
= tree_cons (NULL_TREE
,
883 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)),
886 init
= build_constructor (NULL_TREE
, nreverse (init
));
887 TREE_CONSTANT (init
) = 1;
888 TREE_INVARIANT (init
) = 1;
889 TREE_STATIC (init
) = 1;
893 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
894 DESC provides information about the particular type_info derivation,
895 which adds class, target type and qualifier flags members to the type_info
899 ptm_initializer (tree desc
, tree target
)
901 tree init
= tinfo_base_init (desc
, target
);
902 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
903 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
904 int flags
= qualifier_flags (to
);
905 bool incomplete
= target_incomplete_p (to
);
909 if (!COMPLETE_TYPE_P (klass
))
911 init
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), init
);
912 init
= tree_cons (NULL_TREE
,
913 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)),
915 init
= tree_cons (NULL_TREE
,
916 get_tinfo_ptr (klass
),
919 init
= build_constructor (NULL_TREE
, nreverse (init
));
920 TREE_CONSTANT (init
) = 1;
921 TREE_INVARIANT (init
) = 1;
922 TREE_STATIC (init
) = 1;
926 /* Check base BINFO to set hint flags in *DATA, which is really an int.
927 We use CLASSTYPE_MARKED to tag types we've found as non-virtual bases and
928 CLASSTYPE_MARKED2 to tag those which are virtual bases. Remember it is
929 possible for a type to be both a virtual and non-virtual base. */
932 dfs_class_hint_mark (tree binfo
, void *data
)
934 tree basetype
= BINFO_TYPE (binfo
);
935 int *hint
= (int *) data
;
937 if (BINFO_VIRTUAL_P (binfo
))
939 if (CLASSTYPE_MARKED (basetype
))
941 if (CLASSTYPE_MARKED2 (basetype
))
943 SET_CLASSTYPE_MARKED2 (basetype
);
947 if (CLASSTYPE_MARKED (basetype
) || CLASSTYPE_MARKED2 (basetype
))
949 SET_CLASSTYPE_MARKED (basetype
);
954 /* Clear the base's dfs marks, after searching for duplicate bases. */
957 dfs_class_hint_unmark (tree binfo
, void *data ATTRIBUTE_UNUSED
)
959 tree basetype
= BINFO_TYPE (binfo
);
961 CLEAR_CLASSTYPE_MARKED (basetype
);
962 CLEAR_CLASSTYPE_MARKED2 (basetype
);
966 /* Determine the hint flags describing the features of a class's hierarchy. */
969 class_hint_flags (tree type
)
973 dfs_walk (TYPE_BINFO (type
), dfs_class_hint_mark
, NULL
, &hint_flags
);
974 dfs_walk (TYPE_BINFO (type
), dfs_class_hint_unmark
, NULL
, NULL
);
979 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
980 DESC provides information about the particular __class_type_info derivation,
981 which adds hint flags and TRAIL initializers to the type_info base. */
984 class_initializer (tree desc
, tree target
, tree trail
)
986 tree init
= tinfo_base_init (desc
, target
);
988 TREE_CHAIN (init
) = trail
;
989 init
= build_constructor (NULL_TREE
, init
);
990 TREE_CONSTANT (init
) = 1;
991 TREE_INVARIANT (init
) = 1;
992 TREE_STATIC (init
) = 1;
996 /* Returns true if the typeinfo for type should be placed in
997 the runtime library. */
1000 typeinfo_in_lib_p (tree type
)
1002 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1003 library for simple types T. */
1004 if (TREE_CODE (type
) == POINTER_TYPE
1005 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
1006 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
1007 type
= TREE_TYPE (type
);
1009 switch (TREE_CODE (type
))
1023 /* Generate the initializer for the type info describing TYPE. */
1026 get_pseudo_ti_init (tree type
, tree var_desc
)
1028 my_friendly_assert (at_eof
, 20021120);
1029 switch (TREE_CODE (type
))
1032 return ptm_initializer (var_desc
, type
);
1034 return ptr_initializer (var_desc
, type
);
1036 return generic_initializer (var_desc
, type
);
1039 return generic_initializer (var_desc
, type
);
1042 return generic_initializer (var_desc
, type
);
1046 if (TYPE_PTRMEMFUNC_P (type
))
1047 return ptm_initializer (var_desc
, type
);
1048 else if (var_desc
== class_desc_type_node
)
1049 return class_initializer (var_desc
, type
, NULL_TREE
);
1050 else if (var_desc
== si_class_desc_type_node
)
1052 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1053 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1054 tree base_inits
= tree_cons (NULL_TREE
, tinfo
, NULL_TREE
);
1056 return class_initializer (var_desc
, type
, base_inits
);
1060 int hint
= class_hint_flags (type
);
1061 tree binfo
= TYPE_BINFO (type
);
1062 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1063 VEC (tree
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1064 tree base_inits
= NULL_TREE
;
1067 /* Generate the base information initializer. */
1068 for (ix
= nbases
; ix
--;)
1070 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1071 tree base_init
= NULL_TREE
;
1076 if (VEC_index (tree
, base_accesses
, ix
) == access_public_node
)
1078 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1079 if (BINFO_VIRTUAL_P (base_binfo
))
1081 /* We store the vtable offset at which the virtual
1082 base offset can be found. */
1083 offset
= BINFO_VPTR_FIELD (base_binfo
);
1084 offset
= convert (sizetype
, offset
);
1088 offset
= BINFO_OFFSET (base_binfo
);
1090 /* Combine offset and flags into one field. */
1091 offset
= cp_build_binary_op (LSHIFT_EXPR
, offset
,
1092 build_int_2 (8, 0));
1093 offset
= cp_build_binary_op (BIT_IOR_EXPR
, offset
,
1094 build_int_2 (flags
, 0));
1095 base_init
= tree_cons (NULL_TREE
, offset
, base_init
);
1096 base_init
= tree_cons (NULL_TREE
, tinfo
, base_init
);
1097 base_init
= build_constructor (NULL_TREE
, base_init
);
1098 base_inits
= tree_cons (NULL_TREE
, base_init
, base_inits
);
1100 base_inits
= build_constructor (NULL_TREE
, base_inits
);
1101 base_inits
= tree_cons (NULL_TREE
, base_inits
, NULL_TREE
);
1102 /* Prepend the number of bases. */
1103 base_inits
= tree_cons (NULL_TREE
,
1104 build_int_2 (nbases
, 0), base_inits
);
1105 /* Prepend the hint flags. */
1106 base_inits
= tree_cons (NULL_TREE
,
1107 build_int_2 (hint
, 0), base_inits
);
1109 return class_initializer (var_desc
, type
, base_inits
);
1114 return generic_initializer (var_desc
, type
);
1118 /* Generate the RECORD_TYPE containing the data layout of a type_info
1119 derivative as used by the runtime. This layout must be consistent with
1120 that defined in the runtime support. Also generate the VAR_DECL for the
1121 type's vtable. We explicitly manage the vtable member, and name it for
1122 real type as used in the runtime. The RECORD type has a different name,
1123 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1124 is the generated type and TINFO_VTABLE_NAME is the name of the
1125 vtable. We have to delay generating the VAR_DECL of the vtable
1126 until the end of the translation, when we'll have seen the library
1127 definition, if there was one.
1129 REAL_NAME is the runtime's name of the type. Trailing arguments are
1130 additional FIELD_DECL's for the structure. The final argument must be
1134 create_pseudo_type_info (const char *real_name
, int ident
, ...)
1143 va_start (ap
, ident
);
1145 /* Generate the pseudo type name. */
1146 pseudo_name
= alloca (strlen (real_name
) + 30);
1147 strcpy (pseudo_name
, real_name
);
1148 strcat (pseudo_name
, "_pseudo");
1150 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", ident
);
1152 /* First field is the pseudo type_info base class. */
1153 fields
= build_decl (FIELD_DECL
, NULL_TREE
, ti_desc_type_node
);
1155 /* Now add the derived fields. */
1156 while ((field_decl
= va_arg (ap
, tree
)))
1158 TREE_CHAIN (field_decl
) = fields
;
1159 fields
= field_decl
;
1162 /* Create the pseudo type. */
1163 pseudo_type
= make_aggr_type (RECORD_TYPE
);
1164 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1165 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1167 result
= tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
);
1168 TINFO_REAL_NAME (result
) = get_identifier (real_name
);
1169 TINFO_PSEUDO_TYPE (result
) =
1170 cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1176 /* Return a pseudo type info type node used to describe TYPE. TYPE
1177 must be a complete type (or cv void), except at the end of the
1178 translation unit. */
1181 get_pseudo_ti_desc (tree type
)
1183 switch (TREE_CODE (type
))
1186 return ptm_desc_type_node
;
1188 return ptr_desc_type_node
;
1190 return enum_desc_type_node
;
1192 return func_desc_type_node
;
1194 return ary_desc_type_node
;
1197 if (TYPE_PTRMEMFUNC_P (type
))
1198 return ptm_desc_type_node
;
1199 else if (!COMPLETE_TYPE_P (type
))
1202 cxx_incomplete_type_error (NULL_TREE
, type
);
1203 return class_desc_type_node
;
1205 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1206 return class_desc_type_node
;
1209 tree binfo
= TYPE_BINFO (type
);
1210 VEC (tree
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1211 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1212 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1215 && VEC_index (tree
, base_accesses
, 0) == access_public_node
1216 && !BINFO_VIRTUAL_P (base_binfo
)
1217 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1218 /* single non-virtual public. */
1219 return si_class_desc_type_node
;
1223 tree array_domain
, base_array
;
1225 if (TREE_VEC_LENGTH (vmi_class_desc_type_node
) <= num_bases
)
1228 tree extend
= make_tree_vec (num_bases
+ 5);
1230 for (ix
= TREE_VEC_LENGTH (vmi_class_desc_type_node
); ix
--;)
1231 TREE_VEC_ELT (extend
, ix
)
1232 = TREE_VEC_ELT (vmi_class_desc_type_node
, ix
);
1233 vmi_class_desc_type_node
= extend
;
1235 var_desc
= TREE_VEC_ELT (vmi_class_desc_type_node
, num_bases
);
1239 /* Create the array of __base_class_type_info entries.
1240 G++ 3.2 allocated an array that had one too many
1241 entries, and then filled that extra entries with
1243 if (abi_version_at_least (2))
1244 array_domain
= build_index_type (size_int (num_bases
- 1));
1246 array_domain
= build_index_type (size_int (num_bases
));
1248 build_array_type (base_desc_type_node
, array_domain
);
1250 push_nested_namespace (abi_node
);
1251 var_desc
= create_pseudo_type_info
1252 ("__vmi_class_type_info", num_bases
,
1253 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1254 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1255 build_decl (FIELD_DECL
, NULL_TREE
, base_array
),
1257 pop_nested_namespace (abi_node
);
1259 TREE_VEC_ELT (vmi_class_desc_type_node
, num_bases
) = var_desc
;
1264 return bltn_desc_type_node
;
1268 /* Make sure the required builtin types exist for generating the type_info
1269 variable definitions. */
1272 create_tinfo_types (void)
1274 my_friendly_assert (!ti_desc_type_node
, 20020609);
1276 push_nested_namespace (abi_node
);
1278 /* Create the internal type_info structure. This is used as a base for
1279 the other structures. */
1283 ti_desc_type_node
= make_aggr_type (RECORD_TYPE
);
1284 field
= build_decl (FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1287 field
= build_decl (FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1288 TREE_CHAIN (field
) = fields
;
1291 finish_builtin_struct (ti_desc_type_node
, "__type_info_pseudo",
1293 TYPE_HAS_CONSTRUCTOR (ti_desc_type_node
) = 1;
1296 /* Fundamental type_info */
1297 bltn_desc_type_node
= create_pseudo_type_info
1298 ("__fundamental_type_info", 0,
1301 /* Array, function and enum type_info. No additional fields. */
1302 ary_desc_type_node
= create_pseudo_type_info
1303 ("__array_type_info", 0,
1305 func_desc_type_node
= create_pseudo_type_info
1306 ("__function_type_info", 0,
1308 enum_desc_type_node
= create_pseudo_type_info
1309 ("__enum_type_info", 0,
1312 /* Class type_info. Add a flags field. */
1313 class_desc_type_node
= create_pseudo_type_info
1314 ("__class_type_info", 0,
1317 /* Single public non-virtual base class. Add pointer to base class.
1318 This is really a descendant of __class_type_info. */
1319 si_class_desc_type_node
= create_pseudo_type_info
1320 ("__si_class_type_info", 0,
1321 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1324 /* Base class internal helper. Pointer to base type, offset to base,
1329 field
= build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
);
1332 field
= build_decl (FIELD_DECL
, NULL_TREE
, integer_types
[itk_long
]);
1333 TREE_CHAIN (field
) = fields
;
1336 base_desc_type_node
= make_aggr_type (RECORD_TYPE
);
1337 finish_builtin_struct (base_desc_type_node
, "__base_class_type_info_pseudo",
1339 TYPE_HAS_CONSTRUCTOR (base_desc_type_node
) = 1;
1342 /* General hierarchy is created as necessary in this vector. */
1343 vmi_class_desc_type_node
= make_tree_vec (10);
1345 /* Pointer type_info. Adds two fields, qualification mask
1346 and pointer to the pointed to type. This is really a descendant of
1347 __pbase_type_info. */
1348 ptr_desc_type_node
= create_pseudo_type_info
1349 ("__pointer_type_info", 0,
1350 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1351 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1354 /* Pointer to member data type_info. Add qualifications flags,
1355 pointer to the member's type info and pointer to the class.
1356 This is really a descendant of __pbase_type_info. */
1357 ptm_desc_type_node
= create_pseudo_type_info
1358 ("__pointer_to_member_type_info", 0,
1359 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1360 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1361 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1364 pop_nested_namespace (abi_node
);
1367 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1368 support. Generating them here guarantees consistency with the other
1369 structures. We use the following heuristic to determine when the runtime
1370 is being generated. If std::__fundamental_type_info is defined, and its
1371 destructor is defined, then the runtime is being built. */
1374 emit_support_tinfos (void)
1376 static tree
*const fundamentals
[] =
1381 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1382 &short_integer_type_node
, &short_unsigned_type_node
,
1383 &integer_type_node
, &unsigned_type_node
,
1384 &long_integer_type_node
, &long_unsigned_type_node
,
1385 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1386 &float_type_node
, &double_type_node
, &long_double_type_node
,
1390 tree bltn_type
, dtor
;
1392 push_nested_namespace (abi_node
);
1393 bltn_type
= xref_tag (class_type
,
1394 get_identifier ("__fundamental_type_info"),
1396 pop_nested_namespace (abi_node
);
1397 if (!COMPLETE_TYPE_P (bltn_type
))
1399 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1400 if (DECL_EXTERNAL (dtor
))
1403 for (ix
= 0; fundamentals
[ix
]; ix
++)
1405 tree bltn
= *fundamentals
[ix
];
1406 tree bltn_ptr
= build_pointer_type (bltn
);
1407 tree bltn_const_ptr
= build_pointer_type
1408 (build_qualified_type (bltn
, TYPE_QUAL_CONST
));
1411 tinfo
= get_tinfo_decl (bltn
);
1412 TREE_USED (tinfo
) = 1;
1413 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1415 tinfo
= get_tinfo_decl (bltn_ptr
);
1416 TREE_USED (tinfo
) = 1;
1417 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1419 tinfo
= get_tinfo_decl (bltn_const_ptr
);
1420 TREE_USED (tinfo
) = 1;
1421 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1425 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1426 tinfo decl. Determine whether it needs emitting, and if so
1427 generate the initializer. */
1430 emit_tinfo_decl (tree decl
)
1432 tree type
= TREE_TYPE (DECL_NAME (decl
));
1433 int in_library
= typeinfo_in_lib_p (type
);
1434 tree var_desc
, var_init
;
1436 my_friendly_assert (DECL_TINFO_P (decl
), 20030307);
1441 DECL_EXTERNAL (decl
) = 0;
1444 /* If we're not in the runtime, then DECL (which is already
1445 DECL_EXTERNAL) will not be defined here. */
1446 DECL_INTERFACE_KNOWN (decl
) = 1;
1450 else if (involves_incomplete_p (type
))
1452 if (!decl_needed_p (decl
))
1454 /* If TYPE involves an incomplete class type, then the typeinfo
1455 object will be emitted with internal linkage. There is no
1456 way to know whether or not types are incomplete until the end
1457 of the compilation, so this determination must be deferred
1458 until this point. */
1459 TREE_PUBLIC (decl
) = 0;
1460 DECL_EXTERNAL (decl
) = 0;
1461 DECL_INTERFACE_KNOWN (decl
) = 1;
1464 import_export_decl (decl
);
1465 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1467 DECL_EXTERNAL (decl
) = 0;
1468 var_desc
= get_pseudo_ti_desc (type
);
1469 var_init
= get_pseudo_ti_init (type
, var_desc
);
1470 DECL_INITIAL (decl
) = var_init
;
1472 cp_finish_decl (decl
, var_init
, NULL_TREE
, 0);