1 /* RunTime Type Identification
2 Copyright (C) 1995-2014 Free Software Foundation, Inc.
3 Mostly written by Jason Merrill (jason@cygnus.com).
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "stringpool.h"
29 #include "stor-layout.h"
34 #include "c-family/c-pragma.h"
36 /* C++ returns type information to the user in struct type_info
37 objects. We also use type information to implement dynamic_cast and
38 exception handlers. Type information for a particular type is
39 indicated with an ABI defined structure derived from type_info.
40 This would all be very straight forward, but for the fact that the
41 runtime library provides the definitions of the type_info structure
42 and the ABI defined derived classes. We cannot build declarations
43 of them directly in the compiler, but we need to layout objects of
44 their type. Somewhere we have to lie.
46 We define layout compatible POD-structs with compiler-defined names
47 and generate the appropriate initializations for them (complete
48 with explicit mention of their vtable). When we have to provide a
49 type_info to the user we reinterpret_cast the internal compiler
50 type to type_info. A well formed program can only explicitly refer
51 to the type_infos of complete types (& cv void). However, we chain
52 pointer type_infos to the pointed-to-type, and that can be
53 incomplete. We only need the addresses of such incomplete
54 type_info objects for static initialization.
56 The type information VAR_DECL of a type is held on the
57 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
58 will be the internal type. It will usually have the correct
59 internal type reflecting the kind of type it represents (pointer,
60 array, function, class, inherited class, etc). When the type it
61 represents is incomplete, it will have the internal type
62 corresponding to type_info. That will only happen at the end of
63 translation, when we are emitting the type info objects. */
65 /* Auxiliary data we hold for each type_info derived object we need. */
66 typedef struct GTY (()) tinfo_s
{
67 tree type
; /* The RECORD_TYPE for this type_info object */
69 tree vtable
; /* The VAR_DECL of the vtable. Only filled at end of
72 tree name
; /* IDENTIFIER_NODE for the ABI specified name of
73 the type_info derived type. */
77 typedef enum tinfo_kind
79 TK_TYPE_INFO_TYPE
, /* abi::__type_info_pseudo */
80 TK_BASE_TYPE
, /* abi::__base_class_type_info */
81 TK_BUILTIN_TYPE
, /* abi::__fundamental_type_info */
82 TK_ARRAY_TYPE
, /* abi::__array_type_info */
83 TK_FUNCTION_TYPE
, /* abi::__function_type_info */
84 TK_ENUMERAL_TYPE
, /* abi::__enum_type_info */
85 TK_POINTER_TYPE
, /* abi::__pointer_type_info */
86 TK_POINTER_MEMBER_TYPE
, /* abi::__pointer_to_member_type_info */
87 TK_CLASS_TYPE
, /* abi::__class_type_info */
88 TK_SI_CLASS_TYPE
, /* abi::__si_class_type_info */
89 TK_FIXED
/* end of fixed descriptors. */
90 /* ... abi::__vmi_type_info<I> */
93 /* Helper macro to get maximum scalar-width of pointer or of the 'long'-type.
94 This of interest for llp64 targets. */
96 integer_types[(POINTER_SIZE <= TYPE_PRECISION (integer_types[itk_long]) \
97 ? itk_long : itk_long_long)]
99 /* A vector of all tinfo decls that haven't yet been emitted. */
100 vec
<tree
, va_gc
> *unemitted_tinfo_decls
;
102 /* A vector of all type_info derived types we need. The first few are
103 fixed and created early. The remainder are for multiple inheritance
104 and are generated as needed. */
105 static GTY (()) vec
<tinfo_s
, va_gc
> *tinfo_descs
;
107 static tree
ifnonnull (tree
, tree
, tsubst_flags_t
);
108 static tree
tinfo_name (tree
, bool);
109 static tree
build_dynamic_cast_1 (tree
, tree
, tsubst_flags_t
);
110 static tree
throw_bad_cast (void);
111 static tree
throw_bad_typeid (void);
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
, unsigned, ...);
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 push_abi_namespace (void)
132 push_nested_namespace (abi_node
);
133 push_visibility ("default", 2);
137 pop_abi_namespace (void)
140 pop_nested_namespace (abi_node
);
143 /* Declare language defined type_info type and a pointer to const
144 type_info. This is incomplete here, and will be completed when
145 the user #includes <typeinfo>. There are language defined
146 restrictions on what can be done until that is included. Create
147 the internal versions of the ABI types. */
150 init_rtti_processing (void)
154 push_namespace (std_identifier
);
155 type_info_type
= xref_tag (class_type
, get_identifier ("type_info"),
156 /*tag_scope=*/ts_current
, false);
158 const_type_info_type_node
159 = cp_build_qualified_type (type_info_type
, TYPE_QUAL_CONST
);
160 type_info_ptr_type
= build_pointer_type (const_type_info_type_node
);
162 vec_alloc (unemitted_tinfo_decls
, 124);
164 create_tinfo_types ();
167 /* Given the expression EXP of type `class *', return the head of the
168 object pointed to by EXP with type cv void*, if the class has any
169 virtual functions (TYPE_POLYMORPHIC_P), else just return the
173 build_headof (tree exp
)
175 tree type
= TREE_TYPE (exp
);
179 gcc_assert (TYPE_PTR_P (type
));
180 type
= TREE_TYPE (type
);
182 if (!TYPE_POLYMORPHIC_P (type
))
185 /* We use this a couple of times below, protect it. */
186 exp
= save_expr (exp
);
188 /* The offset-to-top field is at index -2 from the vptr. */
189 index
= build_int_cst (NULL_TREE
,
190 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
192 offset
= build_vtbl_ref (cp_build_indirect_ref (exp
, RO_NULL
,
193 tf_warning_or_error
),
196 type
= cp_build_qualified_type (ptr_type_node
,
197 cp_type_quals (TREE_TYPE (exp
)));
198 return fold_build_pointer_plus (exp
, offset
);
201 /* Get a bad_cast node for the program to throw...
203 See libstdc++/exception.cc for __throw_bad_cast */
206 throw_bad_cast (void)
208 tree fn
= get_identifier ("__cxa_bad_cast");
209 if (!get_global_value_if_present (fn
, &fn
))
210 fn
= push_throw_library_fn (fn
, build_function_type_list (ptr_type_node
,
213 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
216 /* Return an expression for "__cxa_bad_typeid()". The expression
217 returned is an lvalue of type "const std::type_info". */
220 throw_bad_typeid (void)
222 tree fn
= get_identifier ("__cxa_bad_typeid");
223 if (!get_global_value_if_present (fn
, &fn
))
227 t
= build_reference_type (const_type_info_type_node
);
228 t
= build_function_type_list (t
, NULL_TREE
);
229 fn
= push_throw_library_fn (fn
, t
);
232 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
235 /* Return an lvalue expression whose type is "const std::type_info"
236 and whose value indicates the type of the expression EXP. If EXP
237 is a reference to a polymorphic class, return the dynamic type;
238 otherwise return the static type of the expression. */
241 get_tinfo_decl_dynamic (tree exp
, tsubst_flags_t complain
)
246 if (error_operand_p (exp
))
247 return error_mark_node
;
249 exp
= resolve_nondeduced_context (exp
);
251 /* peel back references, so they match. */
252 type
= non_reference (TREE_TYPE (exp
));
254 /* Peel off cv qualifiers. */
255 type
= TYPE_MAIN_VARIANT (type
);
257 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
258 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
259 || type
== init_list_type_node
)
260 type
= complete_type_or_maybe_complain (type
, exp
, complain
);
263 return error_mark_node
;
265 /* If exp is a reference to polymorphic type, get the real type_info. */
266 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
268 /* build reference to type_info from vtable. */
271 /* The RTTI information is at index -1. */
272 index
= build_int_cst (NULL_TREE
,
273 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
274 t
= build_vtbl_ref (exp
, index
);
275 t
= convert (type_info_ptr_type
, t
);
278 /* Otherwise return the type_info for the static type of the expr. */
279 t
= get_tinfo_ptr (TYPE_MAIN_VARIANT (type
));
281 return cp_build_indirect_ref (t
, RO_NULL
, complain
);
287 tree pseudo_type_info
, type_info_type
;
291 error ("cannot use typeid with -fno-rtti");
295 if (!COMPLETE_TYPE_P (const_type_info_type_node
))
297 error ("must #include <typeinfo> before using typeid");
301 pseudo_type_info
= (*tinfo_descs
)[TK_TYPE_INFO_TYPE
].type
;
302 type_info_type
= TYPE_MAIN_VARIANT (const_type_info_type_node
);
304 /* Make sure abi::__type_info_pseudo has the same alias set
305 as std::type_info. */
306 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info
))
307 TYPE_ALIAS_SET (pseudo_type_info
) = get_alias_set (type_info_type
);
309 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info
)
310 == get_alias_set (type_info_type
));
315 /* Return an expression for "typeid(EXP)". The expression returned is
316 an lvalue of type "const std::type_info". */
319 build_typeid (tree exp
, tsubst_flags_t complain
)
321 tree cond
= NULL_TREE
, initial_expr
= exp
;
324 if (exp
== error_mark_node
|| !typeid_ok_p ())
325 return error_mark_node
;
327 if (processing_template_decl
)
328 return build_min (TYPEID_EXPR
, const_type_info_type_node
, exp
);
330 /* FIXME when integrating with c_fully_fold, mark
331 resolves_to_fixed_type_p case as a non-constant expression. */
332 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
333 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
336 /* So we need to look into the vtable of the type of exp.
337 Make sure it isn't a null lvalue. */
338 exp
= cp_build_addr_expr (exp
, complain
);
339 exp
= stabilize_reference (exp
);
340 cond
= cp_convert (boolean_type_node
, exp
, complain
);
341 exp
= cp_build_indirect_ref (exp
, RO_NULL
, complain
);
344 exp
= get_tinfo_decl_dynamic (exp
, complain
);
346 if (exp
== error_mark_node
)
347 return error_mark_node
;
351 tree bad
= throw_bad_typeid ();
353 exp
= build3 (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
356 mark_type_use (initial_expr
);
361 /* Generate the NTBS name of a type. If MARK_PRIVATE, put a '*' in front so that
362 comparisons will be done by pointer rather than string comparison. */
364 tinfo_name (tree type
, bool mark_private
)
370 name
= mangle_type_string (type
);
371 length
= strlen (name
);
375 /* Inject '*' at beginning of name to force pointer comparison. */
376 char* buf
= (char*) XALLOCAVEC (char, length
+ 2);
378 memcpy (buf
+ 1, name
, length
+ 1);
379 name_string
= build_string (length
+ 2, buf
);
382 name_string
= build_string (length
+ 1, name
);
384 return fix_string_type (name_string
);
387 /* Return a VAR_DECL for the internal ABI defined type_info object for
388 TYPE. You must arrange that the decl is mark_used, if actually use
389 it --- decls in vtables are only used if the vtable is output. */
392 get_tinfo_decl (tree type
)
397 if (variably_modified_type_p (type
, /*fn=*/NULL_TREE
))
399 if (array_of_runtime_bound_p (type
))
400 error ("typeid of array of runtime bound");
402 error ("cannot create type information for type %qT because "
403 "it involves types of variable size",
405 return error_mark_node
;
408 if (TREE_CODE (type
) == METHOD_TYPE
)
409 type
= build_function_type (TREE_TYPE (type
),
410 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
412 type
= complete_type (type
);
414 /* For a class type, the variable is cached in the type node
416 if (CLASS_TYPE_P (type
))
418 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
423 name
= mangle_typeinfo_for_type (type
);
425 d
= IDENTIFIER_GLOBAL_VALUE (name
);
428 int ix
= get_pseudo_ti_index (type
);
429 tinfo_s
*ti
= &(*tinfo_descs
)[ix
];
431 d
= build_lang_decl (VAR_DECL
, name
, ti
->type
);
432 SET_DECL_ASSEMBLER_NAME (d
, name
);
433 /* Remember the type it is for. */
434 TREE_TYPE (name
) = type
;
435 DECL_TINFO_P (d
) = 1;
436 DECL_ARTIFICIAL (d
) = 1;
437 DECL_IGNORED_P (d
) = 1;
438 TREE_READONLY (d
) = 1;
440 /* Mark the variable as undefined -- but remember that we can
441 define it later if we need to do so. */
442 DECL_EXTERNAL (d
) = 1;
443 DECL_NOT_REALLY_EXTERN (d
) = 1;
444 set_linkage_according_to_type (type
, d
);
446 d
= pushdecl_top_level_and_finish (d
, NULL_TREE
);
447 if (CLASS_TYPE_P (type
))
448 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
450 /* Add decl to the global array of tinfo decls. */
451 vec_safe_push (unemitted_tinfo_decls
, d
);
457 /* Return a pointer to a type_info object describing TYPE, suitably
458 cast to the language defined type. */
461 get_tinfo_ptr (tree type
)
463 tree decl
= get_tinfo_decl (type
);
466 return build_nop (type_info_ptr_type
,
467 build_address (decl
));
470 /* Return the type_info object for TYPE. */
473 get_typeid (tree type
, tsubst_flags_t complain
)
475 if (type
== error_mark_node
|| !typeid_ok_p ())
476 return error_mark_node
;
478 if (processing_template_decl
)
479 return build_min (TYPEID_EXPR
, const_type_info_type_node
, type
);
481 /* If the type of the type-id is a reference type, the result of the
482 typeid expression refers to a type_info object representing the
484 type
= non_reference (type
);
486 /* This is not one of the uses of a qualified function type in 8.3.5. */
487 if (TREE_CODE (type
) == FUNCTION_TYPE
488 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
489 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
491 if (complain
& tf_error
)
492 error ("typeid of qualified function type %qT", type
);
493 return error_mark_node
;
496 /* The top-level cv-qualifiers of the lvalue expression or the type-id
497 that is the operand of typeid are always ignored. */
498 type
= TYPE_MAIN_VARIANT (type
);
500 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
501 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
502 || type
== init_list_type_node
)
503 type
= complete_type_or_maybe_complain (type
, NULL_TREE
, complain
);
506 return error_mark_node
;
508 return cp_build_indirect_ref (get_tinfo_ptr (type
), RO_NULL
, complain
);
511 /* Check whether TEST is null before returning RESULT. If TEST is used in
512 RESULT, it must have previously had a save_expr applied to it. */
515 ifnonnull (tree test
, tree result
, tsubst_flags_t complain
)
517 return build3 (COND_EXPR
, TREE_TYPE (result
),
518 build2 (EQ_EXPR
, boolean_type_node
, test
,
519 cp_convert (TREE_TYPE (test
), nullptr_node
,
521 cp_convert (TREE_TYPE (result
), nullptr_node
, complain
),
525 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
529 build_dynamic_cast_1 (tree type
, tree expr
, tsubst_flags_t complain
)
531 enum tree_code tc
= TREE_CODE (type
);
534 tree old_expr
= expr
;
535 const char *errstr
= NULL
;
537 /* Save casted types in the function's used types hash table. */
538 used_types_insert (type
);
540 /* T shall be a pointer or reference to a complete class type, or
541 `pointer to cv void''. */
545 if (VOID_TYPE_P (TREE_TYPE (type
)))
549 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
551 errstr
= _("target is not pointer or reference to class");
554 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
556 errstr
= _("target is not pointer or reference to complete type");
562 errstr
= _("target is not pointer or reference");
566 if (tc
== POINTER_TYPE
)
568 expr
= decay_conversion (expr
, complain
);
569 exprtype
= TREE_TYPE (expr
);
571 /* If T is a pointer type, v shall be an rvalue of a pointer to
572 complete class type, and the result is an rvalue of type T. */
574 expr
= mark_rvalue_use (expr
);
576 if (!TYPE_PTR_P (exprtype
))
578 errstr
= _("source is not a pointer");
581 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
583 errstr
= _("source is not a pointer to class");
586 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
588 errstr
= _("source is a pointer to incomplete type");
594 expr
= mark_lvalue_use (expr
);
596 exprtype
= build_reference_type (TREE_TYPE (expr
));
598 /* T is a reference type, v shall be an lvalue of a complete class
599 type, and the result is an lvalue of the type referred to by T. */
601 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
603 errstr
= _("source is not of class type");
606 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
608 errstr
= _("source is of incomplete class type");
613 /* The dynamic_cast operator shall not cast away constness. */
614 if (!at_least_as_qualified_p (TREE_TYPE (type
),
615 TREE_TYPE (exprtype
)))
617 errstr
= _("conversion casts away constness");
621 /* If *type is an unambiguous accessible base class of *exprtype,
622 convert statically. */
624 tree binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
625 ba_check
, NULL
, complain
);
627 return build_static_cast (type
, expr
, complain
);
630 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
631 if (tc
== REFERENCE_TYPE
)
632 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
633 LOOKUP_NORMAL
, NULL_TREE
, complain
);
635 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
636 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
639 /* if TYPE is `void *', return pointer to complete object. */
640 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
642 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
643 if (TREE_CODE (expr
) == ADDR_EXPR
644 && VAR_P (TREE_OPERAND (expr
, 0))
645 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
646 return build1 (NOP_EXPR
, type
, expr
);
648 /* Since expr is used twice below, save it. */
649 expr
= save_expr (expr
);
651 expr1
= build_headof (expr
);
652 if (TREE_TYPE (expr1
) != type
)
653 expr1
= build1 (NOP_EXPR
, type
, expr1
);
654 return ifnonnull (expr
, expr1
, complain
);
659 tree result
, td2
, td3
;
661 tree static_type
, target_type
, boff
;
663 /* If we got here, we can't convert statically. Therefore,
664 dynamic_cast<D&>(b) (b an object) cannot succeed. */
665 if (tc
== REFERENCE_TYPE
)
668 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
670 tree expr
= throw_bad_cast ();
671 if (complain
& tf_warning
)
672 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
674 /* Bash it to the expected type. */
675 TREE_TYPE (expr
) = type
;
679 /* Ditto for dynamic_cast<D*>(&b). */
680 else if (TREE_CODE (expr
) == ADDR_EXPR
)
682 tree op
= TREE_OPERAND (expr
, 0);
684 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
686 if (complain
& tf_warning
)
687 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
689 retval
= build_int_cst (type
, 0);
694 /* Use of dynamic_cast when -fno-rtti is prohibited. */
697 if (complain
& tf_error
)
698 error ("%<dynamic_cast%> not permitted with -fno-rtti");
699 return error_mark_node
;
702 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
703 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
704 td2
= get_tinfo_decl (target_type
);
706 td2
= cp_build_addr_expr (td2
, complain
);
707 td3
= get_tinfo_decl (static_type
);
709 td3
= cp_build_addr_expr (td3
, complain
);
711 /* Determine how T and V are related. */
712 boff
= dcast_base_hint (static_type
, target_type
);
714 /* Since expr is used twice below, save it. */
715 expr
= save_expr (expr
);
718 if (tc
== REFERENCE_TYPE
)
719 expr1
= cp_build_addr_expr (expr1
, complain
);
726 dcast_fn
= dynamic_cast_node
;
733 push_abi_namespace ();
734 tinfo_ptr
= xref_tag (class_type
,
735 get_identifier ("__class_type_info"),
736 /*tag_scope=*/ts_current
, false);
738 tinfo_ptr
= build_pointer_type
739 (cp_build_qualified_type
740 (tinfo_ptr
, TYPE_QUAL_CONST
));
741 name
= "__dynamic_cast";
742 tmp
= build_function_type_list (ptr_type_node
,
744 tinfo_ptr
, tinfo_ptr
,
745 ptrdiff_type_node
, NULL_TREE
);
746 dcast_fn
= build_library_fn_ptr (name
, tmp
,
747 ECF_LEAF
| ECF_PURE
| ECF_NOTHROW
);
748 pop_abi_namespace ();
749 dynamic_cast_node
= dcast_fn
;
751 result
= build_cxx_call (dcast_fn
, 4, elems
, complain
);
753 if (tc
== REFERENCE_TYPE
)
755 tree bad
= throw_bad_cast ();
758 result
= save_expr (result
);
759 neq
= cp_truthvalue_conversion (result
);
760 return cp_convert (type
,
761 build3 (COND_EXPR
, TREE_TYPE (result
),
762 neq
, result
, bad
), complain
);
765 /* Now back to the type we want from a void*. */
766 result
= cp_convert (type
, result
, complain
);
767 return ifnonnull (expr
, result
, complain
);
771 errstr
= _("source type is not polymorphic");
774 if (complain
& tf_error
)
775 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
776 old_expr
, TREE_TYPE (old_expr
), type
, errstr
);
777 return error_mark_node
;
781 build_dynamic_cast (tree type
, tree expr
, tsubst_flags_t complain
)
785 if (type
== error_mark_node
|| expr
== error_mark_node
)
786 return error_mark_node
;
788 if (processing_template_decl
)
790 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
791 TREE_SIDE_EFFECTS (expr
) = 1;
792 return convert_from_reference (expr
);
795 r
= convert_from_reference (build_dynamic_cast_1 (type
, expr
, complain
));
796 if (r
!= error_mark_node
)
797 maybe_warn_about_useless_cast (type
, expr
, complain
);
801 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
804 qualifier_flags (tree type
)
807 int quals
= cp_type_quals (type
);
809 if (quals
& TYPE_QUAL_CONST
)
811 if (quals
& TYPE_QUAL_VOLATILE
)
813 if (quals
& TYPE_QUAL_RESTRICT
)
818 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
819 contains a pointer to member of an incomplete class. */
822 target_incomplete_p (tree type
)
825 if (TYPE_PTRDATAMEM_P (type
))
827 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
829 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
831 else if (TYPE_PTR_P (type
))
832 type
= TREE_TYPE (type
);
834 return !COMPLETE_OR_VOID_TYPE_P (type
);
837 /* Returns true if TYPE involves an incomplete class type; in that
838 case, typeinfo variables for TYPE should be emitted with internal
842 involves_incomplete_p (tree type
)
844 switch (TREE_CODE (type
))
847 return target_incomplete_p (TREE_TYPE (type
));
852 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
853 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
856 if (TYPE_PTRMEMFUNC_P (type
))
860 if (!COMPLETE_TYPE_P (type
))
864 /* All other types do not involve incomplete class types. */
869 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
870 is the vtable pointer and NTBS name. The NTBS name is emitted as a
871 comdat const char array, so it becomes a unique key for the type. Generate
872 and emit that VAR_DECL here. (We can't always emit the type_info itself
873 as comdat, because of pointers to incomplete.) */
876 tinfo_base_init (tinfo_s
*ti
, tree target
)
881 vec
<constructor_elt
, va_gc
> *v
;
884 tree name_name
, name_string
;
886 /* Generate the NTBS array variable. */
887 tree name_type
= build_cplus_array_type
888 (cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
891 /* Determine the name of the variable -- and remember with which
892 type it is associated. */
893 name_name
= mangle_typeinfo_string_for_type (target
);
894 TREE_TYPE (name_name
) = target
;
896 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
897 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
898 DECL_ARTIFICIAL (name_decl
) = 1;
899 DECL_IGNORED_P (name_decl
) = 1;
900 TREE_READONLY (name_decl
) = 1;
901 TREE_STATIC (name_decl
) = 1;
902 DECL_EXTERNAL (name_decl
) = 0;
903 DECL_TINFO_P (name_decl
) = 1;
904 set_linkage_according_to_type (target
, name_decl
);
905 import_export_decl (name_decl
);
906 name_string
= tinfo_name (target
, !TREE_PUBLIC (name_decl
));
907 DECL_INITIAL (name_decl
) = name_string
;
908 mark_used (name_decl
);
909 pushdecl_top_level_and_finish (name_decl
, name_string
);
912 vtable_ptr
= ti
->vtable
;
916 push_abi_namespace ();
917 real_type
= xref_tag (class_type
, ti
->name
,
918 /*tag_scope=*/ts_current
, false);
919 pop_abi_namespace ();
921 if (!COMPLETE_TYPE_P (real_type
))
923 /* We never saw a definition of this type, so we need to
924 tell the compiler that this is an exported class, as
925 indeed all of the __*_type_info classes are. */
926 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
927 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
930 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
931 vtable_ptr
= cp_build_addr_expr (vtable_ptr
, tf_warning_or_error
);
933 /* We need to point into the middle of the vtable. */
934 vtable_ptr
= fold_build_pointer_plus
936 size_binop (MULT_EXPR
,
937 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
938 TYPE_SIZE_UNIT (vtable_entry_type
)));
940 ti
->vtable
= vtable_ptr
;
944 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, vtable_ptr
);
945 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
946 decay_conversion (name_decl
, tf_warning_or_error
));
948 init
= build_constructor (init_list_type_node
, v
);
949 TREE_CONSTANT (init
) = 1;
950 TREE_STATIC (init
) = 1;
955 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
956 information about the particular type_info derivation, which adds no
957 additional fields to the type_info base. */
960 generic_initializer (tinfo_s
*ti
, tree target
)
962 tree init
= tinfo_base_init (ti
, target
);
964 init
= build_constructor_single (init_list_type_node
, NULL_TREE
, init
);
965 TREE_CONSTANT (init
) = 1;
966 TREE_STATIC (init
) = 1;
970 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
971 TI provides information about the particular type_info derivation,
972 which adds target type and qualifier flags members to the type_info base. */
975 ptr_initializer (tinfo_s
*ti
, tree target
)
977 tree init
= tinfo_base_init (ti
, target
);
978 tree to
= TREE_TYPE (target
);
979 int flags
= qualifier_flags (to
);
980 bool incomplete
= target_incomplete_p (to
);
981 vec
<constructor_elt
, va_gc
> *v
;
986 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
987 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
988 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
989 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
991 init
= build_constructor (init_list_type_node
, v
);
992 TREE_CONSTANT (init
) = 1;
993 TREE_STATIC (init
) = 1;
997 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
998 TI provides information about the particular type_info derivation,
999 which adds class, target type and qualifier flags members to the type_info
1003 ptm_initializer (tinfo_s
*ti
, tree target
)
1005 tree init
= tinfo_base_init (ti
, target
);
1006 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
1007 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
1008 int flags
= qualifier_flags (to
);
1009 bool incomplete
= target_incomplete_p (to
);
1010 vec
<constructor_elt
, va_gc
> *v
;
1015 if (!COMPLETE_TYPE_P (klass
))
1017 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1018 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
1019 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
1020 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
1021 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, get_tinfo_ptr (klass
));
1023 init
= build_constructor (init_list_type_node
, v
);
1024 TREE_CONSTANT (init
) = 1;
1025 TREE_STATIC (init
) = 1;
1029 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1030 TI provides information about the particular __class_type_info derivation,
1031 which adds hint flags and N extra initializers to the type_info base. */
1034 class_initializer (tinfo_s
*ti
, tree target
, unsigned n
, ...)
1036 tree init
= tinfo_base_init (ti
, target
);
1037 va_list extra_inits
;
1039 vec
<constructor_elt
, va_gc
> *v
;
1042 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1043 va_start (extra_inits
, n
);
1044 for (i
= 0; i
< n
; i
++)
1045 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, va_arg (extra_inits
, tree
));
1046 va_end (extra_inits
);
1048 init
= build_constructor (init_list_type_node
, v
);
1049 TREE_CONSTANT (init
) = 1;
1050 TREE_STATIC (init
) = 1;
1054 /* Returns true if the typeinfo for type should be placed in
1055 the runtime library. */
1058 typeinfo_in_lib_p (tree type
)
1060 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1061 library for simple types T. */
1062 if (TYPE_PTR_P (type
)
1063 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
1064 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
1065 type
= TREE_TYPE (type
);
1067 switch (TREE_CODE (type
))
1084 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1085 the index of the descriptor in the tinfo_desc vector. */
1088 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1090 tinfo_s
*ti
= &(*tinfo_descs
)[tk_index
];
1092 gcc_assert (at_eof
);
1095 case TK_POINTER_MEMBER_TYPE
:
1096 return ptm_initializer (ti
, type
);
1098 case TK_POINTER_TYPE
:
1099 return ptr_initializer (ti
, type
);
1101 case TK_BUILTIN_TYPE
:
1102 case TK_ENUMERAL_TYPE
:
1103 case TK_FUNCTION_TYPE
:
1105 return generic_initializer (ti
, type
);
1108 return class_initializer (ti
, type
, 0);
1110 case TK_SI_CLASS_TYPE
:
1112 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1113 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1115 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1116 ti
= &(*tinfo_descs
)[tk_index
];
1117 return class_initializer (ti
, type
, 1, tinfo
);
1122 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1123 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1124 tree binfo
= TYPE_BINFO (type
);
1125 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1126 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1127 tree offset_type
= LONGPTR_T
;
1128 tree base_inits
= NULL_TREE
;
1130 vec
<constructor_elt
, va_gc
> *init_vec
= NULL
;
1133 gcc_assert (tk_index
>= TK_FIXED
);
1135 vec_safe_grow (init_vec
, nbases
);
1136 /* Generate the base information initializer. */
1137 for (ix
= nbases
; ix
--;)
1139 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1144 vec
<constructor_elt
, va_gc
> *v
;
1146 if ((*base_accesses
)[ix
] == access_public_node
)
1148 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1149 if (BINFO_VIRTUAL_P (base_binfo
))
1151 /* We store the vtable offset at which the virtual
1152 base offset can be found. */
1153 offset
= BINFO_VPTR_FIELD (base_binfo
);
1157 offset
= BINFO_OFFSET (base_binfo
);
1159 /* Combine offset and flags into one field. */
1160 offset
= fold_convert (offset_type
, offset
);
1161 offset
= fold_build2_loc (input_location
,
1162 LSHIFT_EXPR
, offset_type
, offset
,
1163 build_int_cst (offset_type
, 8));
1164 offset
= fold_build2_loc (input_location
,
1165 BIT_IOR_EXPR
, offset_type
, offset
,
1166 build_int_cst (offset_type
, flags
));
1168 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, tinfo
);
1169 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, offset
);
1170 base_init
= build_constructor (init_list_type_node
, v
);
1171 e
= &(*init_vec
)[ix
];
1172 e
->index
= NULL_TREE
;
1173 e
->value
= base_init
;
1175 base_inits
= build_constructor (init_list_type_node
, init_vec
);
1177 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1178 ti
= &(*tinfo_descs
)[tk_index
];
1179 return class_initializer (ti
, type
, 3,
1180 build_int_cst (NULL_TREE
, hint
),
1181 build_int_cst (NULL_TREE
, nbases
),
1187 /* Generate the RECORD_TYPE containing the data layout of a type_info
1188 derivative as used by the runtime. This layout must be consistent with
1189 that defined in the runtime support. Also generate the VAR_DECL for the
1190 type's vtable. We explicitly manage the vtable member, and name it for
1191 real type as used in the runtime. The RECORD type has a different name,
1192 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1193 is the generated type and TINFO_VTABLE_NAME is the name of the
1194 vtable. We have to delay generating the VAR_DECL of the vtable
1195 until the end of the translation, when we'll have seen the library
1196 definition, if there was one.
1198 REAL_NAME is the runtime's name of the type. Trailing arguments are
1199 additional FIELD_DECL's for the structure. The final argument must be
1203 create_pseudo_type_info (int tk
, const char *real_name
, ...)
1212 va_start (ap
, real_name
);
1214 /* Generate the pseudo type name. */
1215 pseudo_name
= (char *) alloca (strlen (real_name
) + 30);
1216 strcpy (pseudo_name
, real_name
);
1217 strcat (pseudo_name
, "_pseudo");
1219 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", tk
- TK_FIXED
);
1221 /* First field is the pseudo type_info base class. */
1222 fields
= build_decl (input_location
,
1223 FIELD_DECL
, NULL_TREE
,
1224 (*tinfo_descs
)[TK_TYPE_INFO_TYPE
].type
);
1226 /* Now add the derived fields. */
1227 while ((field_decl
= va_arg (ap
, tree
)))
1229 DECL_CHAIN (field_decl
) = fields
;
1230 fields
= field_decl
;
1233 /* Create the pseudo type. */
1234 pseudo_type
= make_class_type (RECORD_TYPE
);
1235 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1236 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1238 ti
= &(*tinfo_descs
)[tk
];
1239 ti
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1240 ti
->name
= get_identifier (real_name
);
1241 ti
->vtable
= NULL_TREE
;
1243 /* Pretend this is public so determine_visibility doesn't give vtables
1244 internal linkage. */
1245 TREE_PUBLIC (TYPE_MAIN_DECL (ti
->type
)) = 1;
1250 /* Return the index of a pseudo type info type node used to describe
1251 TYPE. TYPE must be a complete type (or cv void), except at the end
1252 of the translation unit. */
1255 get_pseudo_ti_index (tree type
)
1259 switch (TREE_CODE (type
))
1262 ix
= TK_POINTER_MEMBER_TYPE
;
1266 ix
= TK_POINTER_TYPE
;
1270 ix
= TK_ENUMERAL_TYPE
;
1274 ix
= TK_FUNCTION_TYPE
;
1283 if (TYPE_PTRMEMFUNC_P (type
))
1285 ix
= TK_POINTER_MEMBER_TYPE
;
1288 else if (!COMPLETE_TYPE_P (type
))
1291 cxx_incomplete_type_error (NULL_TREE
, type
);
1295 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1302 tree binfo
= TYPE_BINFO (type
);
1303 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1304 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1305 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1308 && (*base_accesses
)[0] == access_public_node
1309 && !BINFO_VIRTUAL_P (base_binfo
)
1310 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1312 /* single non-virtual public. */
1313 ix
= TK_SI_CLASS_TYPE
;
1319 tree array_domain
, base_array
;
1321 ix
= TK_FIXED
+ num_bases
;
1322 if (vec_safe_length (tinfo_descs
) <= ix
)
1324 /* too short, extend. */
1325 unsigned len
= vec_safe_length (tinfo_descs
);
1327 vec_safe_grow (tinfo_descs
, ix
+ 1);
1328 while (tinfo_descs
->iterate (len
++, &ti
))
1329 ti
->type
= ti
->vtable
= ti
->name
= NULL_TREE
;
1331 else if ((*tinfo_descs
)[ix
].type
)
1332 /* already created. */
1335 /* Create the array of __base_class_type_info entries. */
1336 array_domain
= build_index_type (size_int (num_bases
- 1));
1337 base_array
= build_array_type ((*tinfo_descs
)[TK_BASE_TYPE
].type
,
1340 push_abi_namespace ();
1341 create_pseudo_type_info
1342 (ix
, "__vmi_class_type_info",
1343 build_decl (input_location
,
1344 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1345 build_decl (input_location
,
1346 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1347 build_decl (input_location
,
1348 FIELD_DECL
, NULL_TREE
, base_array
),
1350 pop_abi_namespace ();
1355 ix
= TK_BUILTIN_TYPE
;
1361 /* Make sure the required builtin types exist for generating the type_info
1362 variable definitions. */
1365 create_tinfo_types (void)
1369 gcc_assert (!tinfo_descs
);
1371 vec_safe_grow (tinfo_descs
, TK_FIXED
);
1373 push_abi_namespace ();
1375 /* Create the internal type_info structure. This is used as a base for
1376 the other structures. */
1380 field
= build_decl (BUILTINS_LOCATION
,
1381 FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1384 field
= build_decl (BUILTINS_LOCATION
,
1385 FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1386 DECL_CHAIN (field
) = fields
;
1389 ti
= &(*tinfo_descs
)[TK_TYPE_INFO_TYPE
];
1390 ti
->type
= make_class_type (RECORD_TYPE
);
1391 ti
->vtable
= NULL_TREE
;
1392 ti
->name
= NULL_TREE
;
1393 finish_builtin_struct (ti
->type
, "__type_info_pseudo",
1397 /* Fundamental type_info */
1398 create_pseudo_type_info (TK_BUILTIN_TYPE
, "__fundamental_type_info", NULL
);
1400 /* Array, function and enum type_info. No additional fields. */
1401 create_pseudo_type_info (TK_ARRAY_TYPE
, "__array_type_info", NULL
);
1402 create_pseudo_type_info (TK_FUNCTION_TYPE
, "__function_type_info", NULL
);
1403 create_pseudo_type_info (TK_ENUMERAL_TYPE
, "__enum_type_info", NULL
);
1405 /* Class type_info. No additional fields. */
1406 create_pseudo_type_info (TK_CLASS_TYPE
, "__class_type_info", NULL
);
1408 /* Single public non-virtual base class. Add pointer to base class.
1409 This is really a descendant of __class_type_info. */
1410 create_pseudo_type_info (TK_SI_CLASS_TYPE
, "__si_class_type_info",
1411 build_decl (BUILTINS_LOCATION
,
1412 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1415 /* Base class internal helper. Pointer to base type, offset to base,
1420 field
= build_decl (BUILTINS_LOCATION
,
1421 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
);
1424 field
= build_decl (BUILTINS_LOCATION
,
1425 FIELD_DECL
, NULL_TREE
, LONGPTR_T
);
1426 DECL_CHAIN (field
) = fields
;
1429 ti
= &(*tinfo_descs
)[TK_BASE_TYPE
];
1431 ti
->type
= make_class_type (RECORD_TYPE
);
1432 ti
->vtable
= NULL_TREE
;
1433 ti
->name
= NULL_TREE
;
1434 finish_builtin_struct (ti
->type
, "__base_class_type_info_pseudo",
1438 /* Pointer type_info. Adds two fields, qualification mask
1439 and pointer to the pointed to type. This is really a descendant of
1440 __pbase_type_info. */
1441 create_pseudo_type_info (TK_POINTER_TYPE
, "__pointer_type_info",
1442 build_decl (BUILTINS_LOCATION
,
1443 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1444 build_decl (BUILTINS_LOCATION
,
1445 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1448 /* Pointer to member data type_info. Add qualifications flags,
1449 pointer to the member's type info and pointer to the class.
1450 This is really a descendant of __pbase_type_info. */
1451 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE
,
1452 "__pointer_to_member_type_info",
1453 build_decl (BUILTINS_LOCATION
,
1454 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1455 build_decl (BUILTINS_LOCATION
,
1456 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1457 build_decl (BUILTINS_LOCATION
,
1458 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1461 pop_abi_namespace ();
1464 /* Helper for emit_support_tinfos. Emits the type_info descriptor of
1468 emit_support_tinfo_1 (tree bltn
)
1472 if (bltn
== NULL_TREE
)
1475 types
[1] = build_pointer_type (bltn
);
1476 types
[2] = build_pointer_type (cp_build_qualified_type (bltn
,
1479 for (int i
= 0; i
< 3; ++i
)
1481 tree tinfo
= get_tinfo_decl (types
[i
]);
1482 TREE_USED (tinfo
) = 1;
1483 mark_needed (tinfo
);
1484 /* The C++ ABI requires that these objects be COMDAT. But,
1485 On systems without weak symbols, initialized COMDAT
1486 objects are emitted with internal linkage. (See
1487 comdat_linkage for details.) Since we want these objects
1488 to have external linkage so that copies do not have to be
1489 emitted in code outside the runtime library, we make them
1492 It might also not be necessary to follow this detail of the
1494 if (!flag_weak
|| ! targetm
.cxx
.library_rtti_comdat ())
1496 gcc_assert (TREE_PUBLIC (tinfo
) && !DECL_COMDAT (tinfo
));
1497 DECL_INTERFACE_KNOWN (tinfo
) = 1;
1502 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1503 support. Generating them here guarantees consistency with the other
1504 structures. We use the following heuristic to determine when the runtime
1505 is being generated. If std::__fundamental_type_info is defined, and its
1506 destructor is defined, then the runtime is being built. */
1509 emit_support_tinfos (void)
1511 /* Dummy static variable so we can put nullptr in the array; it will be
1512 set before we actually start to walk the array. */
1513 static tree
*const fundamentals
[] =
1517 &wchar_type_node
, &char16_type_node
, &char32_type_node
,
1518 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1519 &short_integer_type_node
, &short_unsigned_type_node
,
1520 &integer_type_node
, &unsigned_type_node
,
1521 &long_integer_type_node
, &long_unsigned_type_node
,
1522 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1523 &float_type_node
, &double_type_node
, &long_double_type_node
,
1524 &dfloat32_type_node
, &dfloat64_type_node
, &dfloat128_type_node
,
1529 tree bltn_type
, dtor
;
1531 push_abi_namespace ();
1532 bltn_type
= xref_tag (class_type
,
1533 get_identifier ("__fundamental_type_info"),
1534 /*tag_scope=*/ts_current
, false);
1535 pop_abi_namespace ();
1536 if (!COMPLETE_TYPE_P (bltn_type
))
1538 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1539 if (!dtor
|| DECL_EXTERNAL (dtor
))
1542 for (ix
= 0; fundamentals
[ix
]; ix
++)
1543 emit_support_tinfo_1 (*fundamentals
[ix
]);
1544 for (ix
= 0; ix
< NUM_INT_N_ENTS
; ix
++)
1545 if (int_n_enabled_p
[ix
])
1547 emit_support_tinfo_1 (int_n_trees
[ix
].signed_type
);
1548 emit_support_tinfo_1 (int_n_trees
[ix
].unsigned_type
);
1550 for (tree t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1551 emit_support_tinfo_1 (TREE_VALUE (t
));
1554 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1555 tinfo decl. Determine whether it needs emitting, and if so
1556 generate the initializer. */
1559 emit_tinfo_decl (tree decl
)
1561 tree type
= TREE_TYPE (DECL_NAME (decl
));
1562 int in_library
= typeinfo_in_lib_p (type
);
1564 gcc_assert (DECL_TINFO_P (decl
));
1569 DECL_EXTERNAL (decl
) = 0;
1572 /* If we're not in the runtime, then DECL (which is already
1573 DECL_EXTERNAL) will not be defined here. */
1574 DECL_INTERFACE_KNOWN (decl
) = 1;
1578 else if (involves_incomplete_p (type
))
1580 if (!decl_needed_p (decl
))
1582 /* If TYPE involves an incomplete class type, then the typeinfo
1583 object will be emitted with internal linkage. There is no
1584 way to know whether or not types are incomplete until the end
1585 of the compilation, so this determination must be deferred
1586 until this point. */
1587 TREE_PUBLIC (decl
) = 0;
1588 DECL_EXTERNAL (decl
) = 0;
1589 DECL_INTERFACE_KNOWN (decl
) = 1;
1592 import_export_decl (decl
);
1593 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1597 DECL_EXTERNAL (decl
) = 0;
1598 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1599 DECL_INITIAL (decl
) = init
;
1601 cp_finish_decl (decl
, init
, false, NULL_TREE
, 0);
1602 /* Avoid targets optionally bumping up the alignment to improve
1603 vector instruction accesses, tinfo are never accessed this way. */
1604 #ifdef DATA_ABI_ALIGNMENT
1605 DECL_ALIGN (decl
) = DATA_ABI_ALIGNMENT (decl
, TYPE_ALIGN (TREE_TYPE (decl
)));
1606 DECL_USER_ALIGN (decl
) = true;
1614 #include "gt-cp-rtti.h"