1 /* RunTime Type Identification
2 Copyright (C) 1995-2015 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/>. */
23 #include "coretypes.h"
28 #include "stringpool.h"
31 #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 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. */
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 error ("cannot create type information for type %qT because "
400 "it involves types of variable size",
402 return error_mark_node
;
405 if (TREE_CODE (type
) == METHOD_TYPE
)
406 type
= build_function_type (TREE_TYPE (type
),
407 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
409 type
= complete_type (type
);
411 /* For a class type, the variable is cached in the type node
413 if (CLASS_TYPE_P (type
))
415 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
420 name
= mangle_typeinfo_for_type (type
);
422 d
= IDENTIFIER_GLOBAL_VALUE (name
);
425 int ix
= get_pseudo_ti_index (type
);
426 tinfo_s
*ti
= &(*tinfo_descs
)[ix
];
428 d
= build_lang_decl (VAR_DECL
, name
, ti
->type
);
429 SET_DECL_ASSEMBLER_NAME (d
, name
);
430 /* Remember the type it is for. */
431 TREE_TYPE (name
) = type
;
432 DECL_TINFO_P (d
) = 1;
433 DECL_ARTIFICIAL (d
) = 1;
434 DECL_IGNORED_P (d
) = 1;
435 TREE_READONLY (d
) = 1;
437 /* Mark the variable as undefined -- but remember that we can
438 define it later if we need to do so. */
439 DECL_EXTERNAL (d
) = 1;
440 DECL_NOT_REALLY_EXTERN (d
) = 1;
441 set_linkage_according_to_type (type
, d
);
443 d
= pushdecl_top_level_and_finish (d
, NULL_TREE
);
444 if (CLASS_TYPE_P (type
))
445 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
447 /* Add decl to the global array of tinfo decls. */
448 vec_safe_push (unemitted_tinfo_decls
, d
);
454 /* Return a pointer to a type_info object describing TYPE, suitably
455 cast to the language defined type. */
458 get_tinfo_ptr (tree type
)
460 tree decl
= get_tinfo_decl (type
);
463 return build_nop (type_info_ptr_type
,
464 build_address (decl
));
467 /* Return the type_info object for TYPE. */
470 get_typeid (tree type
, tsubst_flags_t complain
)
472 if (type
== error_mark_node
|| !typeid_ok_p ())
473 return error_mark_node
;
475 if (processing_template_decl
)
476 return build_min (TYPEID_EXPR
, const_type_info_type_node
, type
);
478 /* If the type of the type-id is a reference type, the result of the
479 typeid expression refers to a type_info object representing the
481 type
= non_reference (type
);
483 /* This is not one of the uses of a qualified function type in 8.3.5. */
484 if (TREE_CODE (type
) == FUNCTION_TYPE
485 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
486 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
488 if (complain
& tf_error
)
489 error ("typeid of qualified function type %qT", type
);
490 return error_mark_node
;
493 /* The top-level cv-qualifiers of the lvalue expression or the type-id
494 that is the operand of typeid are always ignored. */
495 type
= TYPE_MAIN_VARIANT (type
);
497 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
498 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
499 || type
== init_list_type_node
)
500 type
= complete_type_or_maybe_complain (type
, NULL_TREE
, complain
);
503 return error_mark_node
;
505 return cp_build_indirect_ref (get_tinfo_ptr (type
), RO_NULL
, complain
);
508 /* Check whether TEST is null before returning RESULT. If TEST is used in
509 RESULT, it must have previously had a save_expr applied to it. */
512 ifnonnull (tree test
, tree result
, tsubst_flags_t complain
)
514 return build3 (COND_EXPR
, TREE_TYPE (result
),
515 build2 (EQ_EXPR
, boolean_type_node
, test
,
516 cp_convert (TREE_TYPE (test
), nullptr_node
,
518 cp_convert (TREE_TYPE (result
), nullptr_node
, complain
),
522 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
526 build_dynamic_cast_1 (tree type
, tree expr
, tsubst_flags_t complain
)
528 enum tree_code tc
= TREE_CODE (type
);
531 tree old_expr
= expr
;
532 const char *errstr
= NULL
;
534 /* Save casted types in the function's used types hash table. */
535 used_types_insert (type
);
537 /* T shall be a pointer or reference to a complete class type, or
538 `pointer to cv void''. */
542 if (VOID_TYPE_P (TREE_TYPE (type
)))
546 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
548 errstr
= _("target is not pointer or reference to class");
551 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
553 errstr
= _("target is not pointer or reference to complete type");
559 errstr
= _("target is not pointer or reference");
563 if (tc
== POINTER_TYPE
)
565 expr
= decay_conversion (expr
, complain
);
566 exprtype
= TREE_TYPE (expr
);
568 /* If T is a pointer type, v shall be an rvalue of a pointer to
569 complete class type, and the result is an rvalue of type T. */
571 expr
= mark_rvalue_use (expr
);
573 if (!TYPE_PTR_P (exprtype
))
575 errstr
= _("source is not a pointer");
578 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
580 errstr
= _("source is not a pointer to class");
583 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
585 errstr
= _("source is a pointer to incomplete type");
591 expr
= mark_lvalue_use (expr
);
593 exprtype
= build_reference_type (TREE_TYPE (expr
));
595 /* T is a reference type, v shall be an lvalue of a complete class
596 type, and the result is an lvalue of the type referred to by T. */
598 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
600 errstr
= _("source is not of class type");
603 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
605 errstr
= _("source is of incomplete class type");
610 /* The dynamic_cast operator shall not cast away constness. */
611 if (!at_least_as_qualified_p (TREE_TYPE (type
),
612 TREE_TYPE (exprtype
)))
614 errstr
= _("conversion casts away constness");
618 /* If *type is an unambiguous accessible base class of *exprtype,
619 convert statically. */
621 tree binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
622 ba_check
, NULL
, complain
);
624 return build_static_cast (type
, expr
, complain
);
627 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
628 if (tc
== REFERENCE_TYPE
)
629 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
630 LOOKUP_NORMAL
, NULL_TREE
, complain
);
632 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
633 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
636 /* if TYPE is `void *', return pointer to complete object. */
637 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
639 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
640 if (TREE_CODE (expr
) == ADDR_EXPR
641 && VAR_P (TREE_OPERAND (expr
, 0))
642 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
643 return build1 (NOP_EXPR
, type
, expr
);
645 /* Since expr is used twice below, save it. */
646 expr
= save_expr (expr
);
648 expr1
= build_headof (expr
);
649 if (TREE_TYPE (expr1
) != type
)
650 expr1
= build1 (NOP_EXPR
, type
, expr1
);
651 return ifnonnull (expr
, expr1
, complain
);
656 tree result
, td2
, td3
;
658 tree static_type
, target_type
, boff
;
660 /* If we got here, we can't convert statically. Therefore,
661 dynamic_cast<D&>(b) (b an object) cannot succeed. */
662 if (tc
== REFERENCE_TYPE
)
665 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
667 tree expr
= throw_bad_cast ();
668 if (complain
& tf_warning
)
669 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
671 /* Bash it to the expected type. */
672 TREE_TYPE (expr
) = type
;
676 /* Ditto for dynamic_cast<D*>(&b). */
677 else if (TREE_CODE (expr
) == ADDR_EXPR
)
679 tree op
= TREE_OPERAND (expr
, 0);
681 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
683 if (complain
& tf_warning
)
684 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
686 retval
= build_int_cst (type
, 0);
691 /* Use of dynamic_cast when -fno-rtti is prohibited. */
694 if (complain
& tf_error
)
695 error ("%<dynamic_cast%> not permitted with -fno-rtti");
696 return error_mark_node
;
699 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
700 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
701 td2
= get_tinfo_decl (target_type
);
702 if (!mark_used (td2
, complain
) && !(complain
& tf_error
))
703 return error_mark_node
;
704 td2
= cp_build_addr_expr (td2
, complain
);
705 td3
= get_tinfo_decl (static_type
);
706 if (!mark_used (td3
, complain
) && !(complain
& tf_error
))
707 return error_mark_node
;
708 td3
= cp_build_addr_expr (td3
, complain
);
710 /* Determine how T and V are related. */
711 boff
= dcast_base_hint (static_type
, target_type
);
713 /* Since expr is used twice below, save it. */
714 expr
= save_expr (expr
);
717 if (tc
== REFERENCE_TYPE
)
718 expr1
= cp_build_addr_expr (expr1
, complain
);
725 dcast_fn
= dynamic_cast_node
;
732 push_abi_namespace ();
733 tinfo_ptr
= xref_tag (class_type
,
734 get_identifier ("__class_type_info"),
735 /*tag_scope=*/ts_current
, false);
737 tinfo_ptr
= build_pointer_type
738 (cp_build_qualified_type
739 (tinfo_ptr
, TYPE_QUAL_CONST
));
740 name
= "__dynamic_cast";
741 tmp
= build_function_type_list (ptr_type_node
,
743 tinfo_ptr
, tinfo_ptr
,
744 ptrdiff_type_node
, NULL_TREE
);
745 dcast_fn
= build_library_fn_ptr (name
, tmp
,
746 ECF_LEAF
| ECF_PURE
| ECF_NOTHROW
);
747 pop_abi_namespace ();
748 dynamic_cast_node
= dcast_fn
;
750 result
= build_cxx_call (dcast_fn
, 4, elems
, complain
);
752 if (tc
== REFERENCE_TYPE
)
754 tree bad
= throw_bad_cast ();
757 result
= save_expr (result
);
758 neq
= cp_truthvalue_conversion (result
);
759 return cp_convert (type
,
760 build3 (COND_EXPR
, TREE_TYPE (result
),
761 neq
, result
, bad
), complain
);
764 /* Now back to the type we want from a void*. */
765 result
= cp_convert (type
, result
, complain
);
766 return ifnonnull (expr
, result
, complain
);
770 errstr
= _("source type is not polymorphic");
773 if (complain
& tf_error
)
774 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
775 old_expr
, TREE_TYPE (old_expr
), type
, errstr
);
776 return error_mark_node
;
780 build_dynamic_cast (tree type
, tree expr
, tsubst_flags_t complain
)
784 if (type
== error_mark_node
|| expr
== error_mark_node
)
785 return error_mark_node
;
787 if (processing_template_decl
)
789 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
790 TREE_SIDE_EFFECTS (expr
) = 1;
791 return convert_from_reference (expr
);
794 r
= convert_from_reference (build_dynamic_cast_1 (type
, expr
, complain
));
795 if (r
!= error_mark_node
)
796 maybe_warn_about_useless_cast (type
, expr
, complain
);
800 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
803 qualifier_flags (tree type
)
806 int quals
= cp_type_quals (type
);
808 if (quals
& TYPE_QUAL_CONST
)
810 if (quals
& TYPE_QUAL_VOLATILE
)
812 if (quals
& TYPE_QUAL_RESTRICT
)
817 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
818 contains a pointer to member of an incomplete class. */
821 target_incomplete_p (tree type
)
824 if (TYPE_PTRDATAMEM_P (type
))
826 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
828 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
830 else if (TYPE_PTR_P (type
))
831 type
= TREE_TYPE (type
);
833 return !COMPLETE_OR_VOID_TYPE_P (type
);
836 /* Returns true if TYPE involves an incomplete class type; in that
837 case, typeinfo variables for TYPE should be emitted with internal
841 involves_incomplete_p (tree type
)
843 switch (TREE_CODE (type
))
846 return target_incomplete_p (TREE_TYPE (type
));
851 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
852 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
855 if (TYPE_PTRMEMFUNC_P (type
))
859 if (!COMPLETE_TYPE_P (type
))
863 /* All other types do not involve incomplete class types. */
868 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
869 is the vtable pointer and NTBS name. The NTBS name is emitted as a
870 comdat const char array, so it becomes a unique key for the type. Generate
871 and emit that VAR_DECL here. (We can't always emit the type_info itself
872 as comdat, because of pointers to incomplete.) */
875 tinfo_base_init (tinfo_s
*ti
, tree target
)
880 vec
<constructor_elt
, va_gc
> *v
;
883 tree name_name
, name_string
;
885 /* Generate the NTBS array variable. */
886 tree name_type
= build_cplus_array_type
887 (cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
890 /* Determine the name of the variable -- and remember with which
891 type it is associated. */
892 name_name
= mangle_typeinfo_string_for_type (target
);
893 TREE_TYPE (name_name
) = target
;
895 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
896 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
897 DECL_ARTIFICIAL (name_decl
) = 1;
898 DECL_IGNORED_P (name_decl
) = 1;
899 TREE_READONLY (name_decl
) = 1;
900 TREE_STATIC (name_decl
) = 1;
901 DECL_EXTERNAL (name_decl
) = 0;
902 DECL_TINFO_P (name_decl
) = 1;
903 set_linkage_according_to_type (target
, name_decl
);
904 import_export_decl (name_decl
);
905 name_string
= tinfo_name (target
, !TREE_PUBLIC (name_decl
));
906 DECL_INITIAL (name_decl
) = name_string
;
907 mark_used (name_decl
);
908 pushdecl_top_level_and_finish (name_decl
, name_string
);
911 vtable_ptr
= ti
->vtable
;
915 push_abi_namespace ();
916 real_type
= xref_tag (class_type
, ti
->name
,
917 /*tag_scope=*/ts_current
, false);
918 pop_abi_namespace ();
920 if (!COMPLETE_TYPE_P (real_type
))
922 /* We never saw a definition of this type, so we need to
923 tell the compiler that this is an exported class, as
924 indeed all of the __*_type_info classes are. */
925 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
926 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
929 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
930 vtable_ptr
= cp_build_addr_expr (vtable_ptr
, tf_warning_or_error
);
932 /* We need to point into the middle of the vtable. */
933 vtable_ptr
= fold_build_pointer_plus
935 size_binop (MULT_EXPR
,
936 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
937 TYPE_SIZE_UNIT (vtable_entry_type
)));
939 ti
->vtable
= vtable_ptr
;
943 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, vtable_ptr
);
944 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
945 decay_conversion (name_decl
, tf_warning_or_error
));
947 init
= build_constructor (init_list_type_node
, v
);
948 TREE_CONSTANT (init
) = 1;
949 TREE_STATIC (init
) = 1;
954 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
955 information about the particular type_info derivation, which adds no
956 additional fields to the type_info base. */
959 generic_initializer (tinfo_s
*ti
, tree target
)
961 tree init
= tinfo_base_init (ti
, target
);
963 init
= build_constructor_single (init_list_type_node
, NULL_TREE
, init
);
964 TREE_CONSTANT (init
) = 1;
965 TREE_STATIC (init
) = 1;
969 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
970 TI provides information about the particular type_info derivation,
971 which adds target type and qualifier flags members to the type_info base. */
974 ptr_initializer (tinfo_s
*ti
, tree target
)
976 tree init
= tinfo_base_init (ti
, target
);
977 tree to
= TREE_TYPE (target
);
978 int flags
= qualifier_flags (to
);
979 bool incomplete
= target_incomplete_p (to
);
980 vec
<constructor_elt
, va_gc
> *v
;
985 if (tx_safe_fn_type_p (to
))
988 to
= tx_unsafe_fn_variant (to
);
990 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
991 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
992 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
993 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
995 init
= build_constructor (init_list_type_node
, v
);
996 TREE_CONSTANT (init
) = 1;
997 TREE_STATIC (init
) = 1;
1001 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
1002 TI provides information about the particular type_info derivation,
1003 which adds class, target type and qualifier flags members to the type_info
1007 ptm_initializer (tinfo_s
*ti
, tree target
)
1009 tree init
= tinfo_base_init (ti
, target
);
1010 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
1011 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
1012 int flags
= qualifier_flags (to
);
1013 bool incomplete
= target_incomplete_p (to
);
1014 vec
<constructor_elt
, va_gc
> *v
;
1019 if (!COMPLETE_TYPE_P (klass
))
1021 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1022 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
1023 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
1024 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
1025 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, get_tinfo_ptr (klass
));
1027 init
= build_constructor (init_list_type_node
, v
);
1028 TREE_CONSTANT (init
) = 1;
1029 TREE_STATIC (init
) = 1;
1033 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1034 TI provides information about the particular __class_type_info derivation,
1035 which adds hint flags and N extra initializers to the type_info base. */
1038 class_initializer (tinfo_s
*ti
, tree target
, unsigned n
, ...)
1040 tree init
= tinfo_base_init (ti
, target
);
1041 va_list extra_inits
;
1043 vec
<constructor_elt
, va_gc
> *v
;
1046 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1047 va_start (extra_inits
, n
);
1048 for (i
= 0; i
< n
; i
++)
1049 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, va_arg (extra_inits
, tree
));
1050 va_end (extra_inits
);
1052 init
= build_constructor (init_list_type_node
, v
);
1053 TREE_CONSTANT (init
) = 1;
1054 TREE_STATIC (init
) = 1;
1058 /* Returns true if the typeinfo for type should be placed in
1059 the runtime library. */
1062 typeinfo_in_lib_p (tree type
)
1064 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1065 library for simple types T. */
1066 if (TYPE_PTR_P (type
)
1067 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
1068 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
1069 type
= TREE_TYPE (type
);
1071 switch (TREE_CODE (type
))
1088 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1089 the index of the descriptor in the tinfo_desc vector. */
1092 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1094 tinfo_s
*ti
= &(*tinfo_descs
)[tk_index
];
1096 gcc_assert (at_eof
);
1099 case TK_POINTER_MEMBER_TYPE
:
1100 return ptm_initializer (ti
, type
);
1102 case TK_POINTER_TYPE
:
1103 return ptr_initializer (ti
, type
);
1105 case TK_BUILTIN_TYPE
:
1106 case TK_ENUMERAL_TYPE
:
1107 case TK_FUNCTION_TYPE
:
1109 return generic_initializer (ti
, type
);
1112 return class_initializer (ti
, type
, 0);
1114 case TK_SI_CLASS_TYPE
:
1116 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1117 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1119 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1120 ti
= &(*tinfo_descs
)[tk_index
];
1121 return class_initializer (ti
, type
, 1, tinfo
);
1126 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1127 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1128 tree binfo
= TYPE_BINFO (type
);
1129 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1130 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1131 tree offset_type
= LONGPTR_T
;
1132 tree base_inits
= NULL_TREE
;
1134 vec
<constructor_elt
, va_gc
> *init_vec
= NULL
;
1137 gcc_assert (tk_index
>= TK_FIXED
);
1139 vec_safe_grow (init_vec
, nbases
);
1140 /* Generate the base information initializer. */
1141 for (ix
= nbases
; ix
--;)
1143 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1148 vec
<constructor_elt
, va_gc
> *v
;
1150 if ((*base_accesses
)[ix
] == access_public_node
)
1152 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1153 if (BINFO_VIRTUAL_P (base_binfo
))
1155 /* We store the vtable offset at which the virtual
1156 base offset can be found. */
1157 offset
= BINFO_VPTR_FIELD (base_binfo
);
1161 offset
= BINFO_OFFSET (base_binfo
);
1163 /* Combine offset and flags into one field. */
1164 offset
= fold_convert (offset_type
, offset
);
1165 offset
= fold_build2_loc (input_location
,
1166 LSHIFT_EXPR
, offset_type
, offset
,
1167 build_int_cst (offset_type
, 8));
1168 offset
= fold_build2_loc (input_location
,
1169 BIT_IOR_EXPR
, offset_type
, offset
,
1170 build_int_cst (offset_type
, flags
));
1172 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, tinfo
);
1173 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, offset
);
1174 base_init
= build_constructor (init_list_type_node
, v
);
1175 e
= &(*init_vec
)[ix
];
1176 e
->index
= NULL_TREE
;
1177 e
->value
= base_init
;
1179 base_inits
= build_constructor (init_list_type_node
, init_vec
);
1181 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1182 ti
= &(*tinfo_descs
)[tk_index
];
1183 return class_initializer (ti
, type
, 3,
1184 build_int_cst (NULL_TREE
, hint
),
1185 build_int_cst (NULL_TREE
, nbases
),
1191 /* Generate the RECORD_TYPE containing the data layout of a type_info
1192 derivative as used by the runtime. This layout must be consistent with
1193 that defined in the runtime support. Also generate the VAR_DECL for the
1194 type's vtable. We explicitly manage the vtable member, and name it for
1195 real type as used in the runtime. The RECORD type has a different name,
1196 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1197 is the generated type and TINFO_VTABLE_NAME is the name of the
1198 vtable. We have to delay generating the VAR_DECL of the vtable
1199 until the end of the translation, when we'll have seen the library
1200 definition, if there was one.
1202 REAL_NAME is the runtime's name of the type. Trailing arguments are
1203 additional FIELD_DECL's for the structure. The final argument must be
1207 create_pseudo_type_info (int tk
, const char *real_name
, ...)
1216 va_start (ap
, real_name
);
1218 /* Generate the pseudo type name. */
1219 pseudo_name
= (char *) alloca (strlen (real_name
) + 30);
1220 strcpy (pseudo_name
, real_name
);
1221 strcat (pseudo_name
, "_pseudo");
1223 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", tk
- TK_FIXED
);
1225 /* First field is the pseudo type_info base class. */
1226 fields
= build_decl (input_location
,
1227 FIELD_DECL
, NULL_TREE
,
1228 (*tinfo_descs
)[TK_TYPE_INFO_TYPE
].type
);
1230 /* Now add the derived fields. */
1231 while ((field_decl
= va_arg (ap
, tree
)))
1233 DECL_CHAIN (field_decl
) = fields
;
1234 fields
= field_decl
;
1237 /* Create the pseudo type. */
1238 pseudo_type
= make_class_type (RECORD_TYPE
);
1239 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1240 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1242 ti
= &(*tinfo_descs
)[tk
];
1243 ti
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1244 ti
->name
= get_identifier (real_name
);
1245 ti
->vtable
= NULL_TREE
;
1247 /* Pretend this is public so determine_visibility doesn't give vtables
1248 internal linkage. */
1249 TREE_PUBLIC (TYPE_MAIN_DECL (ti
->type
)) = 1;
1254 /* Return the index of a pseudo type info type node used to describe
1255 TYPE. TYPE must be a complete type (or cv void), except at the end
1256 of the translation unit. */
1259 get_pseudo_ti_index (tree type
)
1263 switch (TREE_CODE (type
))
1266 ix
= TK_POINTER_MEMBER_TYPE
;
1270 ix
= TK_POINTER_TYPE
;
1274 ix
= TK_ENUMERAL_TYPE
;
1278 ix
= TK_FUNCTION_TYPE
;
1287 if (TYPE_PTRMEMFUNC_P (type
))
1289 ix
= TK_POINTER_MEMBER_TYPE
;
1292 else if (!COMPLETE_TYPE_P (type
))
1295 cxx_incomplete_type_error (NULL_TREE
, type
);
1299 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1306 tree binfo
= TYPE_BINFO (type
);
1307 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1308 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1309 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1312 && (*base_accesses
)[0] == access_public_node
1313 && !BINFO_VIRTUAL_P (base_binfo
)
1314 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1316 /* single non-virtual public. */
1317 ix
= TK_SI_CLASS_TYPE
;
1323 tree array_domain
, base_array
;
1325 ix
= TK_FIXED
+ num_bases
;
1326 if (vec_safe_length (tinfo_descs
) <= ix
)
1328 /* too short, extend. */
1329 unsigned len
= vec_safe_length (tinfo_descs
);
1331 vec_safe_grow (tinfo_descs
, ix
+ 1);
1332 while (tinfo_descs
->iterate (len
++, &ti
))
1333 ti
->type
= ti
->vtable
= ti
->name
= NULL_TREE
;
1335 else if ((*tinfo_descs
)[ix
].type
)
1336 /* already created. */
1339 /* Create the array of __base_class_type_info entries. */
1340 array_domain
= build_index_type (size_int (num_bases
- 1));
1341 base_array
= build_array_type ((*tinfo_descs
)[TK_BASE_TYPE
].type
,
1344 push_abi_namespace ();
1345 create_pseudo_type_info
1346 (ix
, "__vmi_class_type_info",
1347 build_decl (input_location
,
1348 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1349 build_decl (input_location
,
1350 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1351 build_decl (input_location
,
1352 FIELD_DECL
, NULL_TREE
, base_array
),
1354 pop_abi_namespace ();
1359 ix
= TK_BUILTIN_TYPE
;
1365 /* Make sure the required builtin types exist for generating the type_info
1366 variable definitions. */
1369 create_tinfo_types (void)
1373 gcc_assert (!tinfo_descs
);
1375 vec_safe_grow (tinfo_descs
, TK_FIXED
);
1377 push_abi_namespace ();
1379 /* Create the internal type_info structure. This is used as a base for
1380 the other structures. */
1384 field
= build_decl (BUILTINS_LOCATION
,
1385 FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1388 field
= build_decl (BUILTINS_LOCATION
,
1389 FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1390 DECL_CHAIN (field
) = fields
;
1393 ti
= &(*tinfo_descs
)[TK_TYPE_INFO_TYPE
];
1394 ti
->type
= make_class_type (RECORD_TYPE
);
1395 ti
->vtable
= NULL_TREE
;
1396 ti
->name
= NULL_TREE
;
1397 finish_builtin_struct (ti
->type
, "__type_info_pseudo",
1401 /* Fundamental type_info */
1402 create_pseudo_type_info (TK_BUILTIN_TYPE
, "__fundamental_type_info", NULL
);
1404 /* Array, function and enum type_info. No additional fields. */
1405 create_pseudo_type_info (TK_ARRAY_TYPE
, "__array_type_info", NULL
);
1406 create_pseudo_type_info (TK_FUNCTION_TYPE
, "__function_type_info", NULL
);
1407 create_pseudo_type_info (TK_ENUMERAL_TYPE
, "__enum_type_info", NULL
);
1409 /* Class type_info. No additional fields. */
1410 create_pseudo_type_info (TK_CLASS_TYPE
, "__class_type_info", NULL
);
1412 /* Single public non-virtual base class. Add pointer to base class.
1413 This is really a descendant of __class_type_info. */
1414 create_pseudo_type_info (TK_SI_CLASS_TYPE
, "__si_class_type_info",
1415 build_decl (BUILTINS_LOCATION
,
1416 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1419 /* Base class internal helper. Pointer to base type, offset to base,
1424 field
= build_decl (BUILTINS_LOCATION
,
1425 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
);
1428 field
= build_decl (BUILTINS_LOCATION
,
1429 FIELD_DECL
, NULL_TREE
, LONGPTR_T
);
1430 DECL_CHAIN (field
) = fields
;
1433 ti
= &(*tinfo_descs
)[TK_BASE_TYPE
];
1435 ti
->type
= make_class_type (RECORD_TYPE
);
1436 ti
->vtable
= NULL_TREE
;
1437 ti
->name
= NULL_TREE
;
1438 finish_builtin_struct (ti
->type
, "__base_class_type_info_pseudo",
1442 /* Pointer type_info. Adds two fields, qualification mask
1443 and pointer to the pointed to type. This is really a descendant of
1444 __pbase_type_info. */
1445 create_pseudo_type_info (TK_POINTER_TYPE
, "__pointer_type_info",
1446 build_decl (BUILTINS_LOCATION
,
1447 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1448 build_decl (BUILTINS_LOCATION
,
1449 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1452 /* Pointer to member data type_info. Add qualifications flags,
1453 pointer to the member's type info and pointer to the class.
1454 This is really a descendant of __pbase_type_info. */
1455 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE
,
1456 "__pointer_to_member_type_info",
1457 build_decl (BUILTINS_LOCATION
,
1458 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1459 build_decl (BUILTINS_LOCATION
,
1460 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1461 build_decl (BUILTINS_LOCATION
,
1462 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1465 pop_abi_namespace ();
1468 /* Helper for emit_support_tinfos. Emits the type_info descriptor of
1472 emit_support_tinfo_1 (tree bltn
)
1476 if (bltn
== NULL_TREE
)
1479 types
[1] = build_pointer_type (bltn
);
1480 types
[2] = build_pointer_type (cp_build_qualified_type (bltn
,
1483 for (int i
= 0; i
< 3; ++i
)
1485 tree tinfo
= get_tinfo_decl (types
[i
]);
1486 TREE_USED (tinfo
) = 1;
1487 mark_needed (tinfo
);
1488 /* The C++ ABI requires that these objects be COMDAT. But,
1489 On systems without weak symbols, initialized COMDAT
1490 objects are emitted with internal linkage. (See
1491 comdat_linkage for details.) Since we want these objects
1492 to have external linkage so that copies do not have to be
1493 emitted in code outside the runtime library, we make them
1496 It might also not be necessary to follow this detail of the
1498 if (!flag_weak
|| ! targetm
.cxx
.library_rtti_comdat ())
1500 gcc_assert (TREE_PUBLIC (tinfo
) && !DECL_COMDAT (tinfo
));
1501 DECL_INTERFACE_KNOWN (tinfo
) = 1;
1506 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1507 support. Generating them here guarantees consistency with the other
1508 structures. We use the following heuristic to determine when the runtime
1509 is being generated. If std::__fundamental_type_info is defined, and its
1510 destructor is defined, then the runtime is being built. */
1513 emit_support_tinfos (void)
1515 /* Dummy static variable so we can put nullptr in the array; it will be
1516 set before we actually start to walk the array. */
1517 static tree
*const fundamentals
[] =
1521 &wchar_type_node
, &char16_type_node
, &char32_type_node
,
1522 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1523 &short_integer_type_node
, &short_unsigned_type_node
,
1524 &integer_type_node
, &unsigned_type_node
,
1525 &long_integer_type_node
, &long_unsigned_type_node
,
1526 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1527 &float_type_node
, &double_type_node
, &long_double_type_node
,
1528 &dfloat32_type_node
, &dfloat64_type_node
, &dfloat128_type_node
,
1533 tree bltn_type
, dtor
;
1535 push_abi_namespace ();
1536 bltn_type
= xref_tag (class_type
,
1537 get_identifier ("__fundamental_type_info"),
1538 /*tag_scope=*/ts_current
, false);
1539 pop_abi_namespace ();
1540 if (!COMPLETE_TYPE_P (bltn_type
))
1542 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1543 if (!dtor
|| DECL_EXTERNAL (dtor
))
1546 for (ix
= 0; fundamentals
[ix
]; ix
++)
1547 emit_support_tinfo_1 (*fundamentals
[ix
]);
1548 for (ix
= 0; ix
< NUM_INT_N_ENTS
; ix
++)
1549 if (int_n_enabled_p
[ix
])
1551 emit_support_tinfo_1 (int_n_trees
[ix
].signed_type
);
1552 emit_support_tinfo_1 (int_n_trees
[ix
].unsigned_type
);
1554 for (tree t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1555 emit_support_tinfo_1 (TREE_VALUE (t
));
1558 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1559 tinfo decl. Determine whether it needs emitting, and if so
1560 generate the initializer. */
1563 emit_tinfo_decl (tree decl
)
1565 tree type
= TREE_TYPE (DECL_NAME (decl
));
1566 int in_library
= typeinfo_in_lib_p (type
);
1568 gcc_assert (DECL_TINFO_P (decl
));
1573 DECL_EXTERNAL (decl
) = 0;
1576 /* If we're not in the runtime, then DECL (which is already
1577 DECL_EXTERNAL) will not be defined here. */
1578 DECL_INTERFACE_KNOWN (decl
) = 1;
1582 else if (involves_incomplete_p (type
))
1584 if (!decl_needed_p (decl
))
1586 /* If TYPE involves an incomplete class type, then the typeinfo
1587 object will be emitted with internal linkage. There is no
1588 way to know whether or not types are incomplete until the end
1589 of the compilation, so this determination must be deferred
1590 until this point. */
1591 TREE_PUBLIC (decl
) = 0;
1592 DECL_EXTERNAL (decl
) = 0;
1593 DECL_INTERFACE_KNOWN (decl
) = 1;
1596 import_export_decl (decl
);
1597 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1601 DECL_EXTERNAL (decl
) = 0;
1602 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1603 DECL_INITIAL (decl
) = init
;
1605 cp_finish_decl (decl
, init
, false, NULL_TREE
, 0);
1606 /* Avoid targets optionally bumping up the alignment to improve
1607 vector instruction accesses, tinfo are never accessed this way. */
1608 #ifdef DATA_ABI_ALIGNMENT
1609 DECL_ALIGN (decl
) = DATA_ABI_ALIGNMENT (decl
, TYPE_ALIGN (TREE_TYPE (decl
)));
1610 DECL_USER_ALIGN (decl
) = true;
1618 #include "gt-cp-rtti.h"