1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 Free Software Foundation, Inc.
5 Mostly written by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
26 #include "coretypes.h"
37 /* C++ returns type information to the user in struct type_info
38 objects. We also use type information to implement dynamic_cast and
39 exception handlers. Type information for a particular type is
40 indicated with an ABI defined structure derived from type_info.
41 This would all be very straight forward, but for the fact that the
42 runtime library provides the definitions of the type_info structure
43 and the ABI defined derived classes. We cannot build declarations
44 of them directly in the compiler, but we need to layout objects of
45 their type. Somewhere we have to lie.
47 We define layout compatible POD-structs with compiler-defined names
48 and generate the appropriate initializations for them (complete
49 with explicit mention of their vtable). When we have to provide a
50 type_info to the user we reinterpret_cast the internal compiler
51 type to type_info. A well formed program can only explicitly refer
52 to the type_infos of complete types (& cv void). However, we chain
53 pointer type_infos to the pointed-to-type, and that can be
54 incomplete. We only need the addresses of such incomplete
55 type_info objects for static initialization.
57 The type information VAR_DECL of a type is held on the
58 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
59 will be the internal type. It will usually have the correct
60 internal type reflecting the kind of type it represents (pointer,
61 array, function, class, inherited class, etc). When the type it
62 represents is incomplete, it will have the internal type
63 corresponding to type_info. That will only happen at the end of
64 translation, when we are emitting the type info objects. */
66 /* Auxiliary data we hold for each type_info derived object we need. */
67 typedef struct tinfo_s
GTY (())
69 tree type
; /* The RECORD_TYPE for this type_info object */
71 tree vtable
; /* The VAR_DECL of the vtable. Only filled at end of
74 tree name
; /* IDENTIFIER_NODE for the ABI specified name of
75 the type_info derived type. */
79 DEF_VEC_ALLOC_O(tinfo_s
,gc
);
81 typedef enum tinfo_kind
83 TK_TYPE_INFO_TYPE
, /* std::type_info */
84 TK_BASE_TYPE
, /* abi::__base_class_type_info */
85 TK_BUILTIN_TYPE
, /* abi::__fundamental_type_info */
86 TK_ARRAY_TYPE
, /* abi::__array_type_info */
87 TK_FUNCTION_TYPE
, /* abi::__function_type_info */
88 TK_ENUMERAL_TYPE
, /* abi::__enum_type_info */
89 TK_POINTER_TYPE
, /* abi::__pointer_type_info */
90 TK_POINTER_MEMBER_TYPE
, /* abi::__pointer_to_member_type_info */
91 TK_CLASS_TYPE
, /* abi::__class_type_info */
92 TK_SI_CLASS_TYPE
, /* abi::__si_class_type_info */
93 TK_FIXED
/* end of fixed descriptors. */
94 /* ... abi::__vmi_type_info<I> */
97 /* A vector of all tinfo decls that haven't yet been emitted. */
98 VEC(tree
,gc
) *unemitted_tinfo_decls
;
100 /* A vector of all type_info derived types we need. The first few are
101 fixed and created early. The remainder are for multiple inheritance
102 and are generated as needed. */
103 static GTY (()) VEC(tinfo_s
,gc
) *tinfo_descs
;
105 static tree
build_headof (tree
);
106 static tree
ifnonnull (tree
, tree
);
107 static tree
tinfo_name (tree
);
108 static tree
build_dynamic_cast_1 (tree
, tree
);
109 static tree
throw_bad_cast (void);
110 static tree
throw_bad_typeid (void);
111 static tree
get_tinfo_decl_dynamic (tree
);
112 static tree
get_tinfo_ptr (tree
);
113 static bool typeid_ok_p (void);
114 static int qualifier_flags (tree
);
115 static bool target_incomplete_p (tree
);
116 static tree
tinfo_base_init (tinfo_s
*, tree
);
117 static tree
generic_initializer (tinfo_s
*, tree
);
118 static tree
ptr_initializer (tinfo_s
*, tree
);
119 static tree
ptm_initializer (tinfo_s
*, tree
);
120 static tree
class_initializer (tinfo_s
*, tree
, tree
);
121 static void create_pseudo_type_info (int, const char *, ...);
122 static tree
get_pseudo_ti_init (tree
, unsigned);
123 static unsigned get_pseudo_ti_index (tree
);
124 static void create_tinfo_types (void);
125 static bool typeinfo_in_lib_p (tree
);
127 static int doing_runtime
= 0;
130 /* Declare language defined type_info type and a pointer to const
131 type_info. This is incomplete here, and will be completed when
132 the user #includes <typeinfo>. There are language defined
133 restrictions on what can be done until that is included. Create
134 the internal versions of the ABI types. */
137 init_rtti_processing (void)
141 push_namespace (std_identifier
);
142 type_info_type
= xref_tag (class_type
, get_identifier ("type_info"),
143 /*tag_scope=*/ts_current
, false);
145 const_type_info_type_node
146 = build_qualified_type (type_info_type
, TYPE_QUAL_CONST
);
147 type_info_ptr_type
= build_pointer_type (const_type_info_type_node
);
149 unemitted_tinfo_decls
= VEC_alloc (tree
, gc
, 124);
151 create_tinfo_types ();
154 /* Given the expression EXP of type `class *', return the head of the
155 object pointed to by EXP with type cv void*, if the class has any
156 virtual functions (TYPE_POLYMORPHIC_P), else just return the
160 build_headof (tree exp
)
162 tree type
= TREE_TYPE (exp
);
166 gcc_assert (TREE_CODE (type
) == POINTER_TYPE
);
167 type
= TREE_TYPE (type
);
169 if (!TYPE_POLYMORPHIC_P (type
))
172 /* We use this a couple of times below, protect it. */
173 exp
= save_expr (exp
);
175 /* The offset-to-top field is at index -2 from the vptr. */
176 index
= build_int_cst (NULL_TREE
,
177 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
179 offset
= build_vtbl_ref (build_indirect_ref (exp
, NULL
), index
);
181 type
= build_qualified_type (ptr_type_node
,
182 cp_type_quals (TREE_TYPE (exp
)));
183 return build2 (PLUS_EXPR
, type
, exp
,
184 convert_to_integer (ptrdiff_type_node
, offset
));
187 /* Get a bad_cast node for the program to throw...
189 See libstdc++/exception.cc for __throw_bad_cast */
192 throw_bad_cast (void)
194 tree fn
= get_identifier ("__cxa_bad_cast");
195 if (!get_global_value_if_present (fn
, &fn
))
196 fn
= push_throw_library_fn (fn
, build_function_type (ptr_type_node
,
199 return build_cxx_call (fn
, 0, NULL
);
202 /* Return an expression for "__cxa_bad_typeid()". The expression
203 returned is an lvalue of type "const std::type_info". */
206 throw_bad_typeid (void)
208 tree fn
= get_identifier ("__cxa_bad_typeid");
209 if (!get_global_value_if_present (fn
, &fn
))
213 t
= build_reference_type (const_type_info_type_node
);
214 t
= build_function_type (t
, void_list_node
);
215 fn
= push_throw_library_fn (fn
, t
);
218 return build_cxx_call (fn
, 0, NULL
);
221 /* Return an lvalue expression whose type is "const std::type_info"
222 and whose value indicates the type of the expression EXP. If EXP
223 is a reference to a polymorphic class, return the dynamic type;
224 otherwise return the static type of the expression. */
227 get_tinfo_decl_dynamic (tree exp
)
232 if (error_operand_p (exp
))
233 return error_mark_node
;
235 /* peel back references, so they match. */
236 type
= non_reference (TREE_TYPE (exp
));
238 /* Peel off cv qualifiers. */
239 type
= TYPE_MAIN_VARIANT (type
);
241 if (CLASS_TYPE_P (type
))
242 type
= complete_type_or_else (type
, exp
);
245 return error_mark_node
;
247 /* If exp is a reference to polymorphic type, get the real type_info. */
248 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
250 /* build reference to type_info from vtable. */
253 /* The RTTI information is at index -1. */
254 index
= build_int_cst (NULL_TREE
,
255 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
256 t
= build_vtbl_ref (exp
, index
);
257 t
= convert (type_info_ptr_type
, t
);
260 /* Otherwise return the type_info for the static type of the expr. */
261 t
= get_tinfo_ptr (TYPE_MAIN_VARIANT (type
));
263 return build_indirect_ref (t
, NULL
);
271 error ("cannot use typeid with -fno-rtti");
275 if (!COMPLETE_TYPE_P (const_type_info_type_node
))
277 error ("must #include <typeinfo> before using typeid");
284 /* Return an expression for "typeid(EXP)". The expression returned is
285 an lvalue of type "const std::type_info". */
288 build_typeid (tree exp
)
290 tree cond
= NULL_TREE
;
293 if (exp
== error_mark_node
|| !typeid_ok_p ())
294 return error_mark_node
;
296 if (processing_template_decl
)
297 return build_min (TYPEID_EXPR
, const_type_info_type_node
, exp
);
299 if (TREE_CODE (exp
) == INDIRECT_REF
300 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
301 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
302 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
305 exp
= stabilize_reference (exp
);
306 cond
= cp_convert (boolean_type_node
, TREE_OPERAND (exp
, 0));
309 exp
= get_tinfo_decl_dynamic (exp
);
311 if (exp
== error_mark_node
)
312 return error_mark_node
;
316 tree bad
= throw_bad_typeid ();
318 exp
= build3 (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
324 /* Generate the NTBS name of a type. */
326 tinfo_name (tree type
)
331 name
= mangle_type_string (type
);
332 name_string
= fix_string_type (build_string (strlen (name
) + 1, name
));
336 /* Return a VAR_DECL for the internal ABI defined type_info object for
337 TYPE. You must arrange that the decl is mark_used, if actually use
338 it --- decls in vtables are only used if the vtable is output. */
341 get_tinfo_decl (tree type
)
346 if (variably_modified_type_p (type
, /*fn=*/NULL_TREE
))
348 error ("cannot create type information for type %qT because "
349 "it involves types of variable size",
351 return error_mark_node
;
354 if (TREE_CODE (type
) == METHOD_TYPE
)
355 type
= build_function_type (TREE_TYPE (type
),
356 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
358 /* For a class type, the variable is cached in the type node
360 if (CLASS_TYPE_P (type
))
362 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
367 name
= mangle_typeinfo_for_type (type
);
369 d
= IDENTIFIER_GLOBAL_VALUE (name
);
372 int ix
= get_pseudo_ti_index (type
);
373 tinfo_s
*ti
= VEC_index (tinfo_s
, tinfo_descs
, ix
);
375 d
= build_lang_decl (VAR_DECL
, name
, ti
->type
);
376 SET_DECL_ASSEMBLER_NAME (d
, name
);
377 /* Remember the type it is for. */
378 TREE_TYPE (name
) = type
;
379 DECL_TINFO_P (d
) = 1;
380 DECL_ARTIFICIAL (d
) = 1;
381 DECL_IGNORED_P (d
) = 1;
382 TREE_READONLY (d
) = 1;
384 /* Mark the variable as undefined -- but remember that we can
385 define it later if we need to do so. */
386 DECL_EXTERNAL (d
) = 1;
387 DECL_NOT_REALLY_EXTERN (d
) = 1;
388 set_linkage_according_to_type (type
, d
);
390 d
= pushdecl_top_level_and_finish (d
, NULL_TREE
);
391 if (CLASS_TYPE_P (type
))
392 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
394 /* Add decl to the global array of tinfo decls. */
395 VEC_safe_push (tree
, gc
, unemitted_tinfo_decls
, d
);
401 /* Return a pointer to a type_info object describing TYPE, suitably
402 cast to the language defined type. */
405 get_tinfo_ptr (tree type
)
407 tree decl
= get_tinfo_decl (type
);
410 return build_nop (type_info_ptr_type
,
411 build_address (decl
));
414 /* Return the type_info object for TYPE. */
417 get_typeid (tree type
)
419 if (type
== error_mark_node
|| !typeid_ok_p ())
420 return error_mark_node
;
422 if (processing_template_decl
)
423 return build_min (TYPEID_EXPR
, const_type_info_type_node
, type
);
425 /* If the type of the type-id is a reference type, the result of the
426 typeid expression refers to a type_info object representing the
428 type
= non_reference (type
);
430 /* The top-level cv-qualifiers of the lvalue expression or the type-id
431 that is the operand of typeid are always ignored. */
432 type
= TYPE_MAIN_VARIANT (type
);
434 if (CLASS_TYPE_P (type
))
435 type
= complete_type_or_else (type
, NULL_TREE
);
438 return error_mark_node
;
440 return build_indirect_ref (get_tinfo_ptr (type
), NULL
);
443 /* Check whether TEST is null before returning RESULT. If TEST is used in
444 RESULT, it must have previously had a save_expr applied to it. */
447 ifnonnull (tree test
, tree result
)
449 return build3 (COND_EXPR
, TREE_TYPE (result
),
450 build2 (EQ_EXPR
, boolean_type_node
, test
,
451 cp_convert (TREE_TYPE (test
), integer_zero_node
)),
452 cp_convert (TREE_TYPE (result
), integer_zero_node
),
456 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
460 build_dynamic_cast_1 (tree type
, tree expr
)
462 enum tree_code tc
= TREE_CODE (type
);
463 tree exprtype
= TREE_TYPE (expr
);
465 tree old_expr
= expr
;
466 const char *errstr
= NULL
;
468 /* Save casted types in the function's used types hash table. */
469 used_types_insert (type
);
471 /* T shall be a pointer or reference to a complete class type, or
472 `pointer to cv void''. */
476 if (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
)
480 if (! IS_AGGR_TYPE (TREE_TYPE (type
)))
482 errstr
= "target is not pointer or reference to class";
485 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
487 errstr
= "target is not pointer or reference to complete type";
493 errstr
= "target is not pointer or reference";
497 if (tc
== POINTER_TYPE
)
499 /* If T is a pointer type, v shall be an rvalue of a pointer to
500 complete class type, and the result is an rvalue of type T. */
502 if (TREE_CODE (exprtype
) != POINTER_TYPE
)
504 errstr
= "source is not a pointer";
507 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype
)))
509 errstr
= "source is not a pointer to class";
512 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
514 errstr
= "source is a pointer to incomplete type";
520 exprtype
= build_reference_type (exprtype
);
522 /* T is a reference type, v shall be an lvalue of a complete class
523 type, and the result is an lvalue of the type referred to by T. */
525 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype
)))
527 errstr
= "source is not of class type";
530 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
532 errstr
= "source is of incomplete class type";
536 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
537 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
538 LOOKUP_NORMAL
, NULL_TREE
);
541 /* The dynamic_cast operator shall not cast away constness. */
542 if (!at_least_as_qualified_p (TREE_TYPE (type
),
543 TREE_TYPE (exprtype
)))
545 errstr
= "conversion casts away constness";
549 /* If *type is an unambiguous accessible base class of *exprtype,
550 convert statically. */
554 binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
559 expr
= build_base_path (PLUS_EXPR
, convert_from_reference (expr
),
561 if (TREE_CODE (exprtype
) == POINTER_TYPE
)
562 expr
= rvalue (expr
);
567 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
568 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
571 /* if TYPE is `void *', return pointer to complete object. */
572 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
574 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
575 if (TREE_CODE (expr
) == ADDR_EXPR
576 && TREE_CODE (TREE_OPERAND (expr
, 0)) == VAR_DECL
577 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
578 return build1 (NOP_EXPR
, type
, expr
);
580 /* Since expr is used twice below, save it. */
581 expr
= save_expr (expr
);
583 expr1
= build_headof (expr
);
584 if (TREE_TYPE (expr1
) != type
)
585 expr1
= build1 (NOP_EXPR
, type
, expr1
);
586 return ifnonnull (expr
, expr1
);
591 tree result
, td2
, td3
;
593 tree static_type
, target_type
, boff
;
595 /* If we got here, we can't convert statically. Therefore,
596 dynamic_cast<D&>(b) (b an object) cannot succeed. */
597 if (tc
== REFERENCE_TYPE
)
599 if (TREE_CODE (old_expr
) == VAR_DECL
600 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
602 tree expr
= throw_bad_cast ();
603 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
605 /* Bash it to the expected type. */
606 TREE_TYPE (expr
) = type
;
610 /* Ditto for dynamic_cast<D*>(&b). */
611 else if (TREE_CODE (expr
) == ADDR_EXPR
)
613 tree op
= TREE_OPERAND (expr
, 0);
614 if (TREE_CODE (op
) == VAR_DECL
615 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
617 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
619 retval
= build_int_cst (type
, 0);
624 /* Use of dynamic_cast when -fno-rtti is prohibited. */
627 error ("%<dynamic_cast%> not permitted with -fno-rtti");
628 return error_mark_node
;
631 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
632 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
633 td2
= get_tinfo_decl (target_type
);
635 td2
= build_unary_op (ADDR_EXPR
, td2
, 0);
636 td3
= get_tinfo_decl (static_type
);
638 td3
= build_unary_op (ADDR_EXPR
, td3
, 0);
640 /* Determine how T and V are related. */
641 boff
= dcast_base_hint (static_type
, target_type
);
643 /* Since expr is used twice below, save it. */
644 expr
= save_expr (expr
);
647 if (tc
== REFERENCE_TYPE
)
648 expr1
= build_unary_op (ADDR_EXPR
, expr1
, 0);
655 dcast_fn
= dynamic_cast_node
;
663 push_nested_namespace (ns
);
664 tinfo_ptr
= xref_tag (class_type
,
665 get_identifier ("__class_type_info"),
666 /*tag_scope=*/ts_current
, false);
668 tinfo_ptr
= build_pointer_type
669 (build_qualified_type
670 (tinfo_ptr
, TYPE_QUAL_CONST
));
671 name
= "__dynamic_cast";
673 (NULL_TREE
, const_ptr_type_node
, tree_cons
674 (NULL_TREE
, tinfo_ptr
, tree_cons
675 (NULL_TREE
, tinfo_ptr
, tree_cons
676 (NULL_TREE
, ptrdiff_type_node
, void_list_node
))));
677 tmp
= build_function_type (ptr_type_node
, tmp
);
678 dcast_fn
= build_library_fn_ptr (name
, tmp
);
679 DECL_IS_PURE (dcast_fn
) = 1;
680 pop_nested_namespace (ns
);
681 dynamic_cast_node
= dcast_fn
;
683 result
= build_cxx_call (dcast_fn
, 4, elems
);
685 if (tc
== REFERENCE_TYPE
)
687 tree bad
= throw_bad_cast ();
690 result
= save_expr (result
);
691 neq
= c_common_truthvalue_conversion (result
);
692 return build3 (COND_EXPR
, type
, neq
, result
, bad
);
695 /* Now back to the type we want from a void*. */
696 result
= cp_convert (type
, result
);
697 return ifnonnull (expr
, result
);
701 errstr
= "source type is not polymorphic";
704 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
705 expr
, exprtype
, type
, errstr
);
706 return error_mark_node
;
710 build_dynamic_cast (tree type
, tree expr
)
712 if (type
== error_mark_node
|| expr
== error_mark_node
)
713 return error_mark_node
;
715 if (processing_template_decl
)
717 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
718 TREE_SIDE_EFFECTS (expr
) = 1;
723 return convert_from_reference (build_dynamic_cast_1 (type
, expr
));
726 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
729 qualifier_flags (tree type
)
732 int quals
= cp_type_quals (type
);
734 if (quals
& TYPE_QUAL_CONST
)
736 if (quals
& TYPE_QUAL_VOLATILE
)
738 if (quals
& TYPE_QUAL_RESTRICT
)
743 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
744 contains a pointer to member of an incomplete class. */
747 target_incomplete_p (tree type
)
750 if (TYPE_PTRMEM_P (type
))
752 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
754 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
756 else if (TREE_CODE (type
) == POINTER_TYPE
)
757 type
= TREE_TYPE (type
);
759 return !COMPLETE_OR_VOID_TYPE_P (type
);
762 /* Returns true if TYPE involves an incomplete class type; in that
763 case, typeinfo variables for TYPE should be emitted with internal
767 involves_incomplete_p (tree type
)
769 switch (TREE_CODE (type
))
772 return target_incomplete_p (TREE_TYPE (type
));
777 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
778 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
781 if (TYPE_PTRMEMFUNC_P (type
))
785 if (!COMPLETE_TYPE_P (type
))
789 /* All other types do not involve incomplete class types. */
794 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
795 is the vtable pointer and NTBS name. The NTBS name is emitted as a
796 comdat const char array, so it becomes a unique key for the type. Generate
797 and emit that VAR_DECL here. (We can't always emit the type_info itself
798 as comdat, because of pointers to incomplete.) */
801 tinfo_base_init (tinfo_s
*ti
, tree target
)
803 tree init
= NULL_TREE
;
810 /* Generate the NTBS array variable. */
811 tree name_type
= build_cplus_array_type
812 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
814 tree name_string
= tinfo_name (target
);
816 /* Determine the name of the variable -- and remember with which
817 type it is associated. */
818 name_name
= mangle_typeinfo_string_for_type (target
);
819 TREE_TYPE (name_name
) = target
;
821 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
822 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
823 DECL_ARTIFICIAL (name_decl
) = 1;
824 DECL_IGNORED_P (name_decl
) = 1;
825 TREE_READONLY (name_decl
) = 1;
826 TREE_STATIC (name_decl
) = 1;
827 DECL_EXTERNAL (name_decl
) = 0;
828 DECL_TINFO_P (name_decl
) = 1;
829 set_linkage_according_to_type (target
, name_decl
);
830 import_export_decl (name_decl
);
831 DECL_INITIAL (name_decl
) = name_string
;
832 mark_used (name_decl
);
833 pushdecl_top_level_and_finish (name_decl
, name_string
);
836 vtable_ptr
= ti
->vtable
;
840 push_nested_namespace (abi_node
);
841 real_type
= xref_tag (class_type
, ti
->name
,
842 /*tag_scope=*/ts_current
, false);
843 pop_nested_namespace (abi_node
);
845 if (!COMPLETE_TYPE_P (real_type
))
847 /* We never saw a definition of this type, so we need to
848 tell the compiler that this is an exported class, as
849 indeed all of the __*_type_info classes are. */
850 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
851 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
854 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
855 vtable_ptr
= build_unary_op (ADDR_EXPR
, vtable_ptr
, 0);
857 /* We need to point into the middle of the vtable. */
859 (PLUS_EXPR
, TREE_TYPE (vtable_ptr
), vtable_ptr
,
860 size_binop (MULT_EXPR
,
861 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
862 TYPE_SIZE_UNIT (vtable_entry_type
)));
864 ti
->vtable
= vtable_ptr
;
867 init
= tree_cons (NULL_TREE
, vtable_ptr
, init
);
869 init
= tree_cons (NULL_TREE
, decay_conversion (name_decl
), init
);
871 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
872 TREE_CONSTANT (init
) = 1;
873 TREE_INVARIANT (init
) = 1;
874 TREE_STATIC (init
) = 1;
875 init
= tree_cons (NULL_TREE
, init
, NULL_TREE
);
880 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
881 information about the particular type_info derivation, which adds no
882 additional fields to the type_info base. */
885 generic_initializer (tinfo_s
*ti
, tree target
)
887 tree init
= tinfo_base_init (ti
, target
);
889 init
= build_constructor_from_list (NULL_TREE
, init
);
890 TREE_CONSTANT (init
) = 1;
891 TREE_INVARIANT (init
) = 1;
892 TREE_STATIC (init
) = 1;
896 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
897 TI provides information about the particular type_info derivation,
898 which adds target type and qualifier flags members to the type_info base. */
901 ptr_initializer (tinfo_s
*ti
, tree target
)
903 tree init
= tinfo_base_init (ti
, target
);
904 tree to
= TREE_TYPE (target
);
905 int flags
= qualifier_flags (to
);
906 bool incomplete
= target_incomplete_p (to
);
910 init
= tree_cons (NULL_TREE
, build_int_cst (NULL_TREE
, flags
), init
);
911 init
= tree_cons (NULL_TREE
,
912 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)),
915 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
916 TREE_CONSTANT (init
) = 1;
917 TREE_INVARIANT (init
) = 1;
918 TREE_STATIC (init
) = 1;
922 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
923 TI provides information about the particular type_info derivation,
924 which adds class, target type and qualifier flags members to the type_info
928 ptm_initializer (tinfo_s
*ti
, tree target
)
930 tree init
= tinfo_base_init (ti
, target
);
931 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
932 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
933 int flags
= qualifier_flags (to
);
934 bool incomplete
= target_incomplete_p (to
);
938 if (!COMPLETE_TYPE_P (klass
))
940 init
= tree_cons (NULL_TREE
, build_int_cst (NULL_TREE
, flags
), init
);
941 init
= tree_cons (NULL_TREE
,
942 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)),
944 init
= tree_cons (NULL_TREE
,
945 get_tinfo_ptr (klass
),
948 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
949 TREE_CONSTANT (init
) = 1;
950 TREE_INVARIANT (init
) = 1;
951 TREE_STATIC (init
) = 1;
955 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
956 TI provides information about the particular __class_type_info derivation,
957 which adds hint flags and TRAIL initializers to the type_info base. */
960 class_initializer (tinfo_s
*ti
, tree target
, tree trail
)
962 tree init
= tinfo_base_init (ti
, target
);
964 TREE_CHAIN (init
) = trail
;
965 init
= build_constructor_from_list (NULL_TREE
, init
);
966 TREE_CONSTANT (init
) = 1;
967 TREE_INVARIANT (init
) = 1;
968 TREE_STATIC (init
) = 1;
972 /* Returns true if the typeinfo for type should be placed in
973 the runtime library. */
976 typeinfo_in_lib_p (tree type
)
978 /* The typeinfo objects for `T*' and `const T*' are in the runtime
979 library for simple types T. */
980 if (TREE_CODE (type
) == POINTER_TYPE
981 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
982 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
983 type
= TREE_TYPE (type
);
985 switch (TREE_CODE (type
))
998 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
999 the index of the descriptor in the tinfo_desc vector. */
1002 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1004 tinfo_s
*ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1006 gcc_assert (at_eof
);
1009 case TK_POINTER_MEMBER_TYPE
:
1010 return ptm_initializer (ti
, type
);
1012 case TK_POINTER_TYPE
:
1013 return ptr_initializer (ti
, type
);
1015 case TK_BUILTIN_TYPE
:
1016 case TK_ENUMERAL_TYPE
:
1017 case TK_FUNCTION_TYPE
:
1019 return generic_initializer (ti
, type
);
1022 return class_initializer (ti
, type
, NULL_TREE
);
1024 case TK_SI_CLASS_TYPE
:
1026 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1027 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1028 tree base_inits
= tree_cons (NULL_TREE
, tinfo
, NULL_TREE
);
1030 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1031 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1032 return class_initializer (ti
, type
, base_inits
);
1037 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1038 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1039 tree binfo
= TYPE_BINFO (type
);
1040 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1041 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1042 tree offset_type
= integer_types
[itk_long
];
1043 tree base_inits
= NULL_TREE
;
1046 gcc_assert (tk_index
>= TK_FIXED
);
1048 /* Generate the base information initializer. */
1049 for (ix
= nbases
; ix
--;)
1051 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1052 tree base_init
= NULL_TREE
;
1057 if (VEC_index (tree
, base_accesses
, ix
) == access_public_node
)
1059 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1060 if (BINFO_VIRTUAL_P (base_binfo
))
1062 /* We store the vtable offset at which the virtual
1063 base offset can be found. */
1064 offset
= BINFO_VPTR_FIELD (base_binfo
);
1068 offset
= BINFO_OFFSET (base_binfo
);
1070 /* Combine offset and flags into one field. */
1071 offset
= fold_convert (offset_type
, offset
);
1072 offset
= fold_build2 (LSHIFT_EXPR
, offset_type
, offset
,
1073 build_int_cst (offset_type
, 8));
1074 offset
= fold_build2 (BIT_IOR_EXPR
, offset_type
, offset
,
1075 build_int_cst (offset_type
, flags
));
1076 base_init
= tree_cons (NULL_TREE
, offset
, base_init
);
1077 base_init
= tree_cons (NULL_TREE
, tinfo
, base_init
);
1078 base_init
= build_constructor_from_list (NULL_TREE
, base_init
);
1079 base_inits
= tree_cons (NULL_TREE
, base_init
, base_inits
);
1081 base_inits
= build_constructor_from_list (NULL_TREE
, base_inits
);
1082 base_inits
= tree_cons (NULL_TREE
, base_inits
, NULL_TREE
);
1083 /* Prepend the number of bases. */
1084 base_inits
= tree_cons (NULL_TREE
,
1085 build_int_cst (NULL_TREE
, nbases
),
1087 /* Prepend the hint flags. */
1088 base_inits
= tree_cons (NULL_TREE
,
1089 build_int_cst (NULL_TREE
, hint
),
1092 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1093 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1094 return class_initializer (ti
, type
, base_inits
);
1099 /* Generate the RECORD_TYPE containing the data layout of a type_info
1100 derivative as used by the runtime. This layout must be consistent with
1101 that defined in the runtime support. Also generate the VAR_DECL for the
1102 type's vtable. We explicitly manage the vtable member, and name it for
1103 real type as used in the runtime. The RECORD type has a different name,
1104 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1105 is the generated type and TINFO_VTABLE_NAME is the name of the
1106 vtable. We have to delay generating the VAR_DECL of the vtable
1107 until the end of the translation, when we'll have seen the library
1108 definition, if there was one.
1110 REAL_NAME is the runtime's name of the type. Trailing arguments are
1111 additional FIELD_DECL's for the structure. The final argument must be
1115 create_pseudo_type_info (int tk
, const char *real_name
, ...)
1124 va_start (ap
, real_name
);
1126 /* Generate the pseudo type name. */
1127 pseudo_name
= (char *) alloca (strlen (real_name
) + 30);
1128 strcpy (pseudo_name
, real_name
);
1129 strcat (pseudo_name
, "_pseudo");
1131 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", tk
- TK_FIXED
);
1133 /* First field is the pseudo type_info base class. */
1134 fields
= build_decl (FIELD_DECL
, NULL_TREE
,
1135 VEC_index (tinfo_s
, tinfo_descs
,
1136 TK_TYPE_INFO_TYPE
)->type
);
1138 /* Now add the derived fields. */
1139 while ((field_decl
= va_arg (ap
, tree
)))
1141 TREE_CHAIN (field_decl
) = fields
;
1142 fields
= field_decl
;
1145 /* Create the pseudo type. */
1146 pseudo_type
= make_aggr_type (RECORD_TYPE
);
1147 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1148 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1150 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk
);
1151 ti
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1152 ti
->name
= get_identifier (real_name
);
1153 ti
->vtable
= NULL_TREE
;
1155 /* Pretend this is public so determine_visibility doesn't give vtables
1156 internal linkage. */
1157 TREE_PUBLIC (TYPE_MAIN_DECL (ti
->type
)) = 1;
1162 /* Return the index of a pseudo type info type node used to describe
1163 TYPE. TYPE must be a complete type (or cv void), except at the end
1164 of the translation unit. */
1167 get_pseudo_ti_index (tree type
)
1171 switch (TREE_CODE (type
))
1174 ix
= TK_POINTER_MEMBER_TYPE
;
1178 ix
= TK_POINTER_TYPE
;
1182 ix
= TK_ENUMERAL_TYPE
;
1186 ix
= TK_FUNCTION_TYPE
;
1195 if (TYPE_PTRMEMFUNC_P (type
))
1197 ix
= TK_POINTER_MEMBER_TYPE
;
1200 else if (!COMPLETE_TYPE_P (type
))
1203 cxx_incomplete_type_error (NULL_TREE
, type
);
1207 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1214 tree binfo
= TYPE_BINFO (type
);
1215 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1216 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1217 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1220 && VEC_index (tree
, base_accesses
, 0) == access_public_node
1221 && !BINFO_VIRTUAL_P (base_binfo
)
1222 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1224 /* single non-virtual public. */
1225 ix
= TK_SI_CLASS_TYPE
;
1231 tree array_domain
, base_array
;
1233 ix
= TK_FIXED
+ num_bases
;
1234 if (VEC_length (tinfo_s
, tinfo_descs
) <= ix
)
1236 /* too short, extend. */
1237 unsigned len
= VEC_length (tinfo_s
, tinfo_descs
);
1239 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, ix
+ 1);
1240 while (VEC_iterate (tinfo_s
, tinfo_descs
, len
++, ti
))
1241 ti
->type
= ti
->vtable
= ti
->name
= NULL_TREE
;
1243 else if (VEC_index (tinfo_s
, tinfo_descs
, ix
)->type
)
1244 /* already created. */
1247 /* Create the array of __base_class_type_info entries.
1248 G++ 3.2 allocated an array that had one too many
1249 entries, and then filled that extra entries with
1251 if (abi_version_at_least (2))
1252 array_domain
= build_index_type (size_int (num_bases
- 1));
1254 array_domain
= build_index_type (size_int (num_bases
));
1256 build_array_type (VEC_index (tinfo_s
, tinfo_descs
,
1257 TK_BASE_TYPE
)->type
,
1260 push_nested_namespace (abi_node
);
1261 create_pseudo_type_info
1262 (ix
, "__vmi_class_type_info",
1263 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1264 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1265 build_decl (FIELD_DECL
, NULL_TREE
, base_array
),
1267 pop_nested_namespace (abi_node
);
1272 ix
= TK_BUILTIN_TYPE
;
1278 /* Make sure the required builtin types exist for generating the type_info
1279 variable definitions. */
1282 create_tinfo_types (void)
1286 gcc_assert (!tinfo_descs
);
1288 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, TK_FIXED
);
1290 push_nested_namespace (abi_node
);
1292 /* Create the internal type_info structure. This is used as a base for
1293 the other structures. */
1297 field
= build_decl (FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1300 field
= build_decl (FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1301 TREE_CHAIN (field
) = fields
;
1304 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_TYPE_INFO_TYPE
);
1305 ti
->type
= make_aggr_type (RECORD_TYPE
);
1306 ti
->vtable
= NULL_TREE
;
1307 ti
->name
= NULL_TREE
;
1308 finish_builtin_struct (ti
->type
, "__type_info_pseudo",
1310 TYPE_HAS_CONSTRUCTOR (ti
->type
) = 1;
1313 /* Fundamental type_info */
1314 create_pseudo_type_info (TK_BUILTIN_TYPE
, "__fundamental_type_info", NULL
);
1316 /* Array, function and enum type_info. No additional fields. */
1317 create_pseudo_type_info (TK_ARRAY_TYPE
, "__array_type_info", NULL
);
1318 create_pseudo_type_info (TK_FUNCTION_TYPE
, "__function_type_info", NULL
);
1319 create_pseudo_type_info (TK_ENUMERAL_TYPE
, "__enum_type_info", NULL
);
1321 /* Class type_info. No additional fields. */
1322 create_pseudo_type_info (TK_CLASS_TYPE
, "__class_type_info", NULL
);
1324 /* Single public non-virtual base class. Add pointer to base class.
1325 This is really a descendant of __class_type_info. */
1326 create_pseudo_type_info (TK_SI_CLASS_TYPE
, "__si_class_type_info",
1327 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1330 /* Base class internal helper. Pointer to base type, offset to base,
1335 field
= build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
);
1338 field
= build_decl (FIELD_DECL
, NULL_TREE
, integer_types
[itk_long
]);
1339 TREE_CHAIN (field
) = fields
;
1342 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_BASE_TYPE
);
1344 ti
->type
= make_aggr_type (RECORD_TYPE
);
1345 ti
->vtable
= NULL_TREE
;
1346 ti
->name
= NULL_TREE
;
1347 finish_builtin_struct (ti
->type
, "__base_class_type_info_pseudo",
1349 TYPE_HAS_CONSTRUCTOR (ti
->type
) = 1;
1352 /* Pointer type_info. Adds two fields, qualification mask
1353 and pointer to the pointed to type. This is really a descendant of
1354 __pbase_type_info. */
1355 create_pseudo_type_info (TK_POINTER_TYPE
, "__pointer_type_info",
1356 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1357 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1360 /* Pointer to member data type_info. Add qualifications flags,
1361 pointer to the member's type info and pointer to the class.
1362 This is really a descendant of __pbase_type_info. */
1363 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE
,
1364 "__pointer_to_member_type_info",
1365 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1366 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1367 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1370 pop_nested_namespace (abi_node
);
1373 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1374 support. Generating them here guarantees consistency with the other
1375 structures. We use the following heuristic to determine when the runtime
1376 is being generated. If std::__fundamental_type_info is defined, and its
1377 destructor is defined, then the runtime is being built. */
1380 emit_support_tinfos (void)
1382 static tree
*const fundamentals
[] =
1387 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1388 &short_integer_type_node
, &short_unsigned_type_node
,
1389 &integer_type_node
, &unsigned_type_node
,
1390 &long_integer_type_node
, &long_unsigned_type_node
,
1391 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1392 &float_type_node
, &double_type_node
, &long_double_type_node
,
1396 tree bltn_type
, dtor
;
1398 push_nested_namespace (abi_node
);
1399 bltn_type
= xref_tag (class_type
,
1400 get_identifier ("__fundamental_type_info"),
1401 /*tag_scope=*/ts_current
, false);
1402 pop_nested_namespace (abi_node
);
1403 if (!COMPLETE_TYPE_P (bltn_type
))
1405 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1406 if (!dtor
|| DECL_EXTERNAL (dtor
))
1409 for (ix
= 0; fundamentals
[ix
]; ix
++)
1411 tree bltn
= *fundamentals
[ix
];
1416 types
[1] = build_pointer_type (bltn
);
1417 types
[2] = build_pointer_type (build_qualified_type (bltn
,
1420 for (i
= 0; i
< 3; ++i
)
1424 tinfo
= get_tinfo_decl (types
[i
]);
1425 TREE_USED (tinfo
) = 1;
1426 mark_needed (tinfo
);
1427 /* The C++ ABI requires that these objects be COMDAT. But,
1428 On systems without weak symbols, initialized COMDAT
1429 objects are emitted with internal linkage. (See
1430 comdat_linkage for details.) Since we want these objects
1431 to have external linkage so that copies do not have to be
1432 emitted in code outside the runtime library, we make them
1435 It might also not be necessary to follow this detail of the
1437 if (!flag_weak
|| ! targetm
.cxx
.library_rtti_comdat ())
1439 gcc_assert (TREE_PUBLIC (tinfo
) && !DECL_COMDAT (tinfo
));
1440 DECL_INTERFACE_KNOWN (tinfo
) = 1;
1446 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1447 tinfo decl. Determine whether it needs emitting, and if so
1448 generate the initializer. */
1451 emit_tinfo_decl (tree decl
)
1453 tree type
= TREE_TYPE (DECL_NAME (decl
));
1454 int in_library
= typeinfo_in_lib_p (type
);
1456 gcc_assert (DECL_TINFO_P (decl
));
1461 DECL_EXTERNAL (decl
) = 0;
1464 /* If we're not in the runtime, then DECL (which is already
1465 DECL_EXTERNAL) will not be defined here. */
1466 DECL_INTERFACE_KNOWN (decl
) = 1;
1470 else if (involves_incomplete_p (type
))
1472 if (!decl_needed_p (decl
))
1474 /* If TYPE involves an incomplete class type, then the typeinfo
1475 object will be emitted with internal linkage. There is no
1476 way to know whether or not types are incomplete until the end
1477 of the compilation, so this determination must be deferred
1478 until this point. */
1479 TREE_PUBLIC (decl
) = 0;
1480 DECL_EXTERNAL (decl
) = 0;
1481 DECL_INTERFACE_KNOWN (decl
) = 1;
1484 import_export_decl (decl
);
1485 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1489 DECL_EXTERNAL (decl
) = 0;
1490 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1491 DECL_INITIAL (decl
) = init
;
1493 finish_decl (decl
, init
, NULL_TREE
);
1500 #include "gt-cp-rtti.h"