1 /* RunTime Type Identification
2 Copyright (C) 1995-2017 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"
30 #include "stor-layout.h"
31 #include "c-family/c-pragma.h"
32 #include "gcc-rich-location.h"
34 /* C++ returns type information to the user in struct type_info
35 objects. We also use type information to implement dynamic_cast and
36 exception handlers. Type information for a particular type is
37 indicated with an ABI defined structure derived from type_info.
38 This would all be very straight forward, but for the fact that the
39 runtime library provides the definitions of the type_info structure
40 and the ABI defined derived classes. We cannot build declarations
41 of them directly in the compiler, but we need to layout objects of
42 their type. Somewhere we have to lie.
44 We define layout compatible POD-structs with compiler-defined names
45 and generate the appropriate initializations for them (complete
46 with explicit mention of their vtable). When we have to provide a
47 type_info to the user we reinterpret_cast the internal compiler
48 type to type_info. A well formed program can only explicitly refer
49 to the type_infos of complete types (& cv void). However, we chain
50 pointer type_infos to the pointed-to-type, and that can be
51 incomplete. We only need the addresses of such incomplete
52 type_info objects for static initialization.
54 The type information VAR_DECL of a type is held on the
55 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
56 will be the internal type. It will usually have the correct
57 internal type reflecting the kind of type it represents (pointer,
58 array, function, class, inherited class, etc). When the type it
59 represents is incomplete, it will have the internal type
60 corresponding to type_info. That will only happen at the end of
61 translation, when we are emitting the type info objects. */
63 /* Auxiliary data we hold for each type_info derived object we need. */
64 struct GTY (()) tinfo_s
{
65 tree type
; /* The RECORD_TYPE for this type_info object */
67 tree vtable
; /* The VAR_DECL of the vtable. Only filled at end of
70 tree name
; /* IDENTIFIER_NODE for the ABI specified name of
71 the type_info derived type. */
77 TK_TYPE_INFO_TYPE
, /* abi::__type_info_pseudo */
78 TK_BASE_TYPE
, /* abi::__base_class_type_info */
79 TK_DERIVED_TYPES
, /* Start of types derived from abi::__type_info */
80 TK_BUILTIN_TYPE
= TK_DERIVED_TYPES
, /* abi::__fundamental_type_info */
81 TK_ARRAY_TYPE
, /* abi::__array_type_info */
82 TK_FUNCTION_TYPE
, /* abi::__function_type_info */
83 TK_ENUMERAL_TYPE
, /* abi::__enum_type_info */
84 TK_POINTER_TYPE
, /* abi::__pointer_type_info */
85 TK_POINTER_MEMBER_TYPE
, /* abi::__pointer_to_member_type_info */
86 TK_CLASS_TYPE
, /* abi::__class_type_info */
87 TK_SI_CLASS_TYPE
, /* abi::__si_class_type_info */
88 TK_VMI_CLASS_TYPES
, /* abi::__vmi_class_type_info<int> */
92 /* Names of the tinfo types. Must be same order as TK enumeration
95 static const char *const tinfo_names
[TK_MAX
] =
98 "__base_class_type_info",
99 "__fundamental_type_info",
101 "__function_type_info",
103 "__pointer_type_info",
104 "__pointer_to_member_type_info",
106 "__si_class_type_info",
107 "__vmi_class_type_info"
110 /* Helper macro to get maximum scalar-width of pointer or of the 'long'-type.
111 This of interest for llp64 targets. */
113 integer_types[(POINTER_SIZE <= TYPE_PRECISION (integer_types[itk_long]) \
114 ? itk_long : itk_long_long)]
116 /* A vector of all tinfo decls that haven't yet been emitted. */
117 vec
<tree
, va_gc
> *unemitted_tinfo_decls
;
119 /* A vector of all type_info derived types we need. The first few are
120 fixed and created early. The remainder are for multiple inheritance
121 and are generated as needed. */
122 static GTY (()) vec
<tinfo_s
, va_gc
> *tinfo_descs
;
124 static tree
ifnonnull (tree
, tree
, tsubst_flags_t
);
125 static tree
tinfo_name (tree
, bool);
126 static tree
build_dynamic_cast_1 (tree
, tree
, tsubst_flags_t
);
127 static tree
throw_bad_cast (void);
128 static tree
throw_bad_typeid (void);
129 static tree
get_tinfo_ptr (tree
);
130 static bool typeid_ok_p (void);
131 static int qualifier_flags (tree
);
132 static bool target_incomplete_p (tree
);
133 static tree
tinfo_base_init (tinfo_s
*, tree
);
134 static tree
generic_initializer (tinfo_s
*, tree
);
135 static tree
ptr_initializer (tinfo_s
*, tree
);
136 static tree
ptm_initializer (tinfo_s
*, tree
);
137 static tree
class_initializer (tinfo_s
*, tree
, unsigned, ...);
138 static tree
get_pseudo_ti_init (tree
, unsigned);
139 static unsigned get_pseudo_ti_index (tree
);
140 static tinfo_s
*get_tinfo_desc (unsigned);
141 static void create_tinfo_types (void);
142 static bool typeinfo_in_lib_p (tree
);
144 static int doing_runtime
= 0;
147 push_abi_namespace (void)
149 push_nested_namespace (abi_node
);
150 push_visibility ("default", 2);
154 pop_abi_namespace (void)
157 pop_nested_namespace (abi_node
);
160 /* Declare language defined type_info type and a pointer to const
161 type_info. This is incomplete here, and will be completed when
162 the user #includes <typeinfo>. There are language defined
163 restrictions on what can be done until that is included. Create
164 the internal versions of the ABI types. */
167 init_rtti_processing (void)
171 push_namespace (std_identifier
);
172 type_info_type
= xref_tag (class_type
, get_identifier ("type_info"),
173 /*tag_scope=*/ts_current
, false);
175 const_type_info_type_node
176 = cp_build_qualified_type (type_info_type
, TYPE_QUAL_CONST
);
177 type_info_ptr_type
= build_pointer_type (const_type_info_type_node
);
179 vec_alloc (unemitted_tinfo_decls
, 124);
181 create_tinfo_types ();
184 /* Given the expression EXP of type `class *', return the head of the
185 object pointed to by EXP with type cv void*, if the class has any
186 virtual functions (TYPE_POLYMORPHIC_P), else just return the
190 build_headof (tree exp
)
192 tree type
= TREE_TYPE (exp
);
196 gcc_assert (TYPE_PTR_P (type
));
197 type
= TREE_TYPE (type
);
199 if (!TYPE_POLYMORPHIC_P (type
))
202 /* We use this a couple of times below, protect it. */
203 exp
= save_expr (exp
);
205 /* The offset-to-top field is at index -2 from the vptr. */
206 index
= build_int_cst (NULL_TREE
,
207 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
209 offset
= build_vtbl_ref (cp_build_indirect_ref (exp
, RO_NULL
,
210 tf_warning_or_error
),
213 type
= cp_build_qualified_type (ptr_type_node
,
214 cp_type_quals (TREE_TYPE (exp
)));
215 return fold_build_pointer_plus (exp
, offset
);
218 /* Get a bad_cast node for the program to throw...
220 See libstdc++/exception.cc for __throw_bad_cast */
223 throw_bad_cast (void)
228 tree name
= get_identifier ("__cxa_bad_cast");
229 fn
= IDENTIFIER_GLOBAL_VALUE (name
);
231 fn
= push_throw_library_fn
232 (name
, build_function_type_list (ptr_type_node
, NULL_TREE
));
235 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
238 /* Return an expression for "__cxa_bad_typeid()". The expression
239 returned is an lvalue of type "const std::type_info". */
242 throw_bad_typeid (void)
247 tree name
= get_identifier ("__cxa_bad_typeid");
248 fn
= IDENTIFIER_GLOBAL_VALUE (name
);
251 tree t
= build_reference_type (const_type_info_type_node
);
252 t
= build_function_type_list (t
, NULL_TREE
);
253 fn
= push_throw_library_fn (name
, t
);
257 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
260 /* Return an lvalue expression whose type is "const std::type_info"
261 and whose value indicates the type of the expression EXP. If EXP
262 is a reference to a polymorphic class, return the dynamic type;
263 otherwise return the static type of the expression. */
266 get_tinfo_decl_dynamic (tree exp
, tsubst_flags_t complain
)
271 if (error_operand_p (exp
))
272 return error_mark_node
;
274 exp
= resolve_nondeduced_context (exp
, complain
);
276 /* peel back references, so they match. */
277 type
= non_reference (TREE_TYPE (exp
));
279 /* Peel off cv qualifiers. */
280 type
= TYPE_MAIN_VARIANT (type
);
282 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
283 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
284 || type
== init_list_type_node
)
285 type
= complete_type_or_maybe_complain (type
, exp
, complain
);
288 return error_mark_node
;
290 /* If exp is a reference to polymorphic type, get the real type_info. */
291 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
293 /* build reference to type_info from vtable. */
296 /* The RTTI information is at index -1. */
297 index
= build_int_cst (NULL_TREE
,
298 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
299 t
= build_vtbl_ref (exp
, index
);
300 t
= convert (type_info_ptr_type
, t
);
303 /* Otherwise return the type_info for the static type of the expr. */
304 t
= get_tinfo_ptr (TYPE_MAIN_VARIANT (type
));
306 return cp_build_indirect_ref (t
, RO_NULL
, complain
);
314 error ("cannot use %<typeid%> with -fno-rtti");
318 if (!COMPLETE_TYPE_P (const_type_info_type_node
))
320 gcc_rich_location
richloc (input_location
);
321 maybe_add_include_fixit (&richloc
, "<typeinfo>");
322 error_at_rich_loc (&richloc
,
323 "must %<#include <typeinfo>%> before using"
329 tree pseudo
= TYPE_MAIN_VARIANT (get_tinfo_desc (TK_TYPE_INFO_TYPE
)->type
);
330 tree real
= TYPE_MAIN_VARIANT (const_type_info_type_node
);
332 /* Make sure abi::__type_info_pseudo has the same alias set
333 as std::type_info. */
334 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo
))
335 TYPE_ALIAS_SET (pseudo
) = get_alias_set (real
);
337 gcc_assert (TYPE_ALIAS_SET (pseudo
) == get_alias_set (real
));
342 /* Return an expression for "typeid(EXP)". The expression returned is
343 an lvalue of type "const std::type_info". */
346 build_typeid (tree exp
, tsubst_flags_t complain
)
348 tree cond
= NULL_TREE
, initial_expr
= exp
;
351 if (exp
== error_mark_node
|| !typeid_ok_p ())
352 return error_mark_node
;
354 if (processing_template_decl
)
355 return build_min (TYPEID_EXPR
, const_type_info_type_node
, exp
);
357 /* FIXME when integrating with c_fully_fold, mark
358 resolves_to_fixed_type_p case as a non-constant expression. */
359 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
360 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
363 /* So we need to look into the vtable of the type of exp.
364 Make sure it isn't a null lvalue. */
365 exp
= cp_build_addr_expr (exp
, complain
);
366 exp
= save_expr (exp
);
367 cond
= cp_convert (boolean_type_node
, exp
, complain
);
368 exp
= cp_build_indirect_ref (exp
, RO_NULL
, complain
);
371 exp
= get_tinfo_decl_dynamic (exp
, complain
);
373 if (exp
== error_mark_node
)
374 return error_mark_node
;
378 tree bad
= throw_bad_typeid ();
380 exp
= build3 (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
383 mark_type_use (initial_expr
);
388 /* Generate the NTBS name of a type. If MARK_PRIVATE, put a '*' in front so that
389 comparisons will be done by pointer rather than string comparison. */
391 tinfo_name (tree type
, bool mark_private
)
397 name
= mangle_type_string (type
);
398 length
= strlen (name
);
402 /* Inject '*' at beginning of name to force pointer comparison. */
403 char* buf
= (char*) XALLOCAVEC (char, length
+ 2);
405 memcpy (buf
+ 1, name
, length
+ 1);
406 name_string
= build_string (length
+ 2, buf
);
409 name_string
= build_string (length
+ 1, name
);
411 return fix_string_type (name_string
);
414 /* Return a VAR_DECL for the internal ABI defined type_info object for
415 TYPE. You must arrange that the decl is mark_used, if actually use
416 it --- decls in vtables are only used if the vtable is output. */
419 get_tinfo_decl (tree type
)
424 if (variably_modified_type_p (type
, /*fn=*/NULL_TREE
))
426 error ("cannot create type information for type %qT because "
427 "it involves types of variable size",
429 return error_mark_node
;
432 if (TREE_CODE (type
) == METHOD_TYPE
)
433 type
= build_function_type (TREE_TYPE (type
),
434 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
436 type
= complete_type (type
);
438 /* For a class type, the variable is cached in the type node
440 if (CLASS_TYPE_P (type
))
442 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
447 name
= mangle_typeinfo_for_type (type
);
449 d
= IDENTIFIER_GLOBAL_VALUE (name
);
452 int ix
= get_pseudo_ti_index (type
);
453 const tinfo_s
*ti
= get_tinfo_desc (ix
);
455 d
= build_lang_decl (VAR_DECL
, name
, ti
->type
);
456 SET_DECL_ASSEMBLER_NAME (d
, name
);
457 /* Remember the type it is for. */
458 TREE_TYPE (name
) = type
;
459 DECL_TINFO_P (d
) = 1;
460 DECL_ARTIFICIAL (d
) = 1;
461 DECL_IGNORED_P (d
) = 1;
462 TREE_READONLY (d
) = 1;
464 /* Mark the variable as undefined -- but remember that we can
465 define it later if we need to do so. */
466 DECL_EXTERNAL (d
) = 1;
467 DECL_NOT_REALLY_EXTERN (d
) = 1;
468 set_linkage_according_to_type (type
, d
);
470 d
= pushdecl_top_level_and_finish (d
, NULL_TREE
);
471 if (CLASS_TYPE_P (type
))
472 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
474 /* Add decl to the global array of tinfo decls. */
475 vec_safe_push (unemitted_tinfo_decls
, d
);
481 /* Return a pointer to a type_info object describing TYPE, suitably
482 cast to the language defined type. */
485 get_tinfo_ptr (tree type
)
487 tree decl
= get_tinfo_decl (type
);
490 return build_nop (type_info_ptr_type
,
491 build_address (decl
));
494 /* Return the type_info object for TYPE. */
497 get_typeid (tree type
, tsubst_flags_t complain
)
499 if (type
== error_mark_node
|| !typeid_ok_p ())
500 return error_mark_node
;
502 if (processing_template_decl
)
503 return build_min (TYPEID_EXPR
, const_type_info_type_node
, type
);
505 /* If the type of the type-id is a reference type, the result of the
506 typeid expression refers to a type_info object representing the
508 type
= non_reference (type
);
510 /* This is not one of the uses of a qualified function type in 8.3.5. */
511 if (TREE_CODE (type
) == FUNCTION_TYPE
512 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
513 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
515 if (complain
& tf_error
)
516 error ("typeid of qualified function type %qT", type
);
517 return error_mark_node
;
520 /* The top-level cv-qualifiers of the lvalue expression or the type-id
521 that is the operand of typeid are always ignored. */
522 type
= TYPE_MAIN_VARIANT (type
);
524 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
525 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
526 || type
== init_list_type_node
)
527 type
= complete_type_or_maybe_complain (type
, NULL_TREE
, complain
);
530 return error_mark_node
;
532 return cp_build_indirect_ref (get_tinfo_ptr (type
), RO_NULL
, complain
);
535 /* Check whether TEST is null before returning RESULT. If TEST is used in
536 RESULT, it must have previously had a save_expr applied to it. */
539 ifnonnull (tree test
, tree result
, tsubst_flags_t complain
)
541 tree cond
= build2 (NE_EXPR
, boolean_type_node
, test
,
542 cp_convert (TREE_TYPE (test
), nullptr_node
, complain
));
543 /* This is a compiler generated comparison, don't emit
544 e.g. -Wnonnull-compare warning for it. */
545 TREE_NO_WARNING (cond
) = 1;
546 return build3 (COND_EXPR
, TREE_TYPE (result
), cond
, result
,
547 cp_convert (TREE_TYPE (result
), nullptr_node
, complain
));
550 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
554 build_dynamic_cast_1 (tree type
, tree expr
, tsubst_flags_t complain
)
556 enum tree_code tc
= TREE_CODE (type
);
559 tree old_expr
= expr
;
560 const char *errstr
= NULL
;
562 /* Save casted types in the function's used types hash table. */
563 used_types_insert (type
);
565 /* T shall be a pointer or reference to a complete class type, or
566 `pointer to cv void''. */
570 if (VOID_TYPE_P (TREE_TYPE (type
)))
574 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
576 errstr
= _("target is not pointer or reference to class");
579 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
581 errstr
= _("target is not pointer or reference to complete type");
587 errstr
= _("target is not pointer or reference");
591 if (tc
== POINTER_TYPE
)
593 expr
= decay_conversion (expr
, complain
);
594 exprtype
= TREE_TYPE (expr
);
596 /* If T is a pointer type, v shall be an rvalue of a pointer to
597 complete class type, and the result is an rvalue of type T. */
599 expr
= mark_rvalue_use (expr
);
601 if (!TYPE_PTR_P (exprtype
))
603 errstr
= _("source is not a pointer");
606 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
608 errstr
= _("source is not a pointer to class");
611 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
613 errstr
= _("source is a pointer to incomplete type");
619 expr
= mark_lvalue_use (expr
);
621 exprtype
= build_reference_type (TREE_TYPE (expr
));
623 /* T is a reference type, v shall be an lvalue of a complete class
624 type, and the result is an lvalue of the type referred to by T. */
626 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
628 errstr
= _("source is not of class type");
631 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
633 errstr
= _("source is of incomplete class type");
638 /* The dynamic_cast operator shall not cast away constness. */
639 if (!at_least_as_qualified_p (TREE_TYPE (type
),
640 TREE_TYPE (exprtype
)))
642 errstr
= _("conversion casts away constness");
646 /* If *type is an unambiguous accessible base class of *exprtype,
647 convert statically. */
649 tree binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
650 ba_check
, NULL
, complain
);
652 return build_static_cast (type
, expr
, complain
);
655 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
656 if (tc
== REFERENCE_TYPE
)
657 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
658 LOOKUP_NORMAL
, NULL_TREE
, complain
);
660 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
661 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
664 /* if TYPE is `void *', return pointer to complete object. */
665 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
667 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
668 if (TREE_CODE (expr
) == ADDR_EXPR
669 && VAR_P (TREE_OPERAND (expr
, 0))
670 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
671 return build1 (NOP_EXPR
, type
, expr
);
673 /* Since expr is used twice below, save it. */
674 expr
= save_expr (expr
);
676 expr1
= build_headof (expr
);
677 if (TREE_TYPE (expr1
) != type
)
678 expr1
= build1 (NOP_EXPR
, type
, expr1
);
679 return ifnonnull (expr
, expr1
, complain
);
684 tree result
, td2
, td3
;
686 tree static_type
, target_type
, boff
;
688 /* If we got here, we can't convert statically. Therefore,
689 dynamic_cast<D&>(b) (b an object) cannot succeed. */
690 if (tc
== REFERENCE_TYPE
)
693 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
695 tree expr
= throw_bad_cast ();
696 if (complain
& tf_warning
)
697 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
699 /* Bash it to the expected type. */
700 TREE_TYPE (expr
) = type
;
704 /* Ditto for dynamic_cast<D*>(&b). */
705 else if (TREE_CODE (expr
) == ADDR_EXPR
)
707 tree op
= TREE_OPERAND (expr
, 0);
709 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
711 if (complain
& tf_warning
)
712 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
714 retval
= build_int_cst (type
, 0);
719 /* Use of dynamic_cast when -fno-rtti is prohibited. */
722 if (complain
& tf_error
)
723 error ("%<dynamic_cast%> not permitted with -fno-rtti");
724 return error_mark_node
;
727 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
728 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
729 td2
= get_tinfo_decl (target_type
);
730 if (!mark_used (td2
, complain
) && !(complain
& tf_error
))
731 return error_mark_node
;
732 td2
= cp_build_addr_expr (td2
, complain
);
733 td3
= get_tinfo_decl (static_type
);
734 if (!mark_used (td3
, complain
) && !(complain
& tf_error
))
735 return error_mark_node
;
736 td3
= cp_build_addr_expr (td3
, complain
);
738 /* Determine how T and V are related. */
739 boff
= dcast_base_hint (static_type
, target_type
);
741 /* Since expr is used twice below, save it. */
742 expr
= save_expr (expr
);
745 if (tc
== REFERENCE_TYPE
)
746 expr1
= cp_build_addr_expr (expr1
, complain
);
753 dcast_fn
= dynamic_cast_node
;
760 push_abi_namespace ();
761 tinfo_ptr
= xref_tag (class_type
,
762 get_identifier ("__class_type_info"),
763 /*tag_scope=*/ts_current
, false);
765 tinfo_ptr
= build_pointer_type
766 (cp_build_qualified_type
767 (tinfo_ptr
, TYPE_QUAL_CONST
));
768 name
= "__dynamic_cast";
769 tmp
= build_function_type_list (ptr_type_node
,
771 tinfo_ptr
, tinfo_ptr
,
772 ptrdiff_type_node
, NULL_TREE
);
773 dcast_fn
= build_library_fn_ptr (name
, tmp
,
774 ECF_LEAF
| ECF_PURE
| ECF_NOTHROW
);
775 pop_abi_namespace ();
776 dynamic_cast_node
= dcast_fn
;
778 result
= build_cxx_call (dcast_fn
, 4, elems
, complain
);
780 if (tc
== REFERENCE_TYPE
)
782 tree bad
= throw_bad_cast ();
785 result
= save_expr (result
);
786 neq
= cp_truthvalue_conversion (result
);
787 return cp_convert (type
,
788 build3 (COND_EXPR
, TREE_TYPE (result
),
789 neq
, result
, bad
), complain
);
792 /* Now back to the type we want from a void*. */
793 result
= cp_convert (type
, result
, complain
);
794 return ifnonnull (expr
, result
, complain
);
798 errstr
= _("source type is not polymorphic");
801 if (complain
& tf_error
)
802 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
803 old_expr
, TREE_TYPE (old_expr
), type
, errstr
);
804 return error_mark_node
;
808 build_dynamic_cast (tree type
, tree expr
, tsubst_flags_t complain
)
812 if (type
== error_mark_node
|| expr
== error_mark_node
)
813 return error_mark_node
;
815 if (processing_template_decl
)
817 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
818 TREE_SIDE_EFFECTS (expr
) = 1;
819 return convert_from_reference (expr
);
822 r
= convert_from_reference (build_dynamic_cast_1 (type
, expr
, complain
));
823 if (r
!= error_mark_node
)
824 maybe_warn_about_useless_cast (type
, expr
, complain
);
828 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
831 qualifier_flags (tree type
)
834 int quals
= cp_type_quals (type
);
836 if (quals
& TYPE_QUAL_CONST
)
838 if (quals
& TYPE_QUAL_VOLATILE
)
840 if (quals
& TYPE_QUAL_RESTRICT
)
845 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
846 contains a pointer to member of an incomplete class. */
849 target_incomplete_p (tree type
)
852 if (TYPE_PTRDATAMEM_P (type
))
854 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
856 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
858 else if (TYPE_PTR_P (type
))
859 type
= TREE_TYPE (type
);
861 return !COMPLETE_OR_VOID_TYPE_P (type
);
864 /* Returns true if TYPE involves an incomplete class type; in that
865 case, typeinfo variables for TYPE should be emitted with internal
869 involves_incomplete_p (tree type
)
871 switch (TREE_CODE (type
))
874 return target_incomplete_p (TREE_TYPE (type
));
879 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
880 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
883 if (TYPE_PTRMEMFUNC_P (type
))
887 if (!COMPLETE_TYPE_P (type
))
891 /* All other types do not involve incomplete class types. */
896 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
897 is the vtable pointer and NTBS name. The NTBS name is emitted as a
898 comdat const char array, so it becomes a unique key for the type. Generate
899 and emit that VAR_DECL here. (We can't always emit the type_info itself
900 as comdat, because of pointers to incomplete.) */
903 tinfo_base_init (tinfo_s
*ti
, tree target
)
908 vec
<constructor_elt
, va_gc
> *v
;
911 tree name_name
, name_string
;
913 /* Generate the NTBS array variable. */
914 tree name_type
= build_cplus_array_type
915 (cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
918 /* Determine the name of the variable -- and remember with which
919 type it is associated. */
920 name_name
= mangle_typeinfo_string_for_type (target
);
921 TREE_TYPE (name_name
) = target
;
923 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
924 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
925 DECL_ARTIFICIAL (name_decl
) = 1;
926 DECL_IGNORED_P (name_decl
) = 1;
927 TREE_READONLY (name_decl
) = 1;
928 TREE_STATIC (name_decl
) = 1;
929 DECL_EXTERNAL (name_decl
) = 0;
930 DECL_TINFO_P (name_decl
) = 1;
931 set_linkage_according_to_type (target
, name_decl
);
932 import_export_decl (name_decl
);
933 name_string
= tinfo_name (target
, !TREE_PUBLIC (name_decl
));
934 DECL_INITIAL (name_decl
) = name_string
;
935 mark_used (name_decl
);
936 pushdecl_top_level_and_finish (name_decl
, name_string
);
939 vtable_ptr
= ti
->vtable
;
943 push_abi_namespace ();
944 real_type
= xref_tag (class_type
, ti
->name
,
945 /*tag_scope=*/ts_current
, false);
946 pop_abi_namespace ();
948 if (!COMPLETE_TYPE_P (real_type
))
950 /* We never saw a definition of this type, so we need to
951 tell the compiler that this is an exported class, as
952 indeed all of the __*_type_info classes are. */
953 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
954 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
957 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
958 vtable_ptr
= cp_build_addr_expr (vtable_ptr
, tf_warning_or_error
);
960 /* We need to point into the middle of the vtable. */
961 vtable_ptr
= fold_build_pointer_plus
963 size_binop (MULT_EXPR
,
964 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
965 TYPE_SIZE_UNIT (vtable_entry_type
)));
967 ti
->vtable
= vtable_ptr
;
971 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, vtable_ptr
);
972 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
973 decay_conversion (name_decl
, tf_warning_or_error
));
975 init
= build_constructor (init_list_type_node
, v
);
976 TREE_CONSTANT (init
) = 1;
977 TREE_STATIC (init
) = 1;
982 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
983 information about the particular type_info derivation, which adds no
984 additional fields to the type_info base. */
987 generic_initializer (tinfo_s
*ti
, tree target
)
989 tree init
= tinfo_base_init (ti
, target
);
991 init
= build_constructor_single (init_list_type_node
, NULL_TREE
, init
);
992 TREE_CONSTANT (init
) = 1;
993 TREE_STATIC (init
) = 1;
997 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
998 TI provides information about the particular type_info derivation,
999 which adds target type and qualifier flags members to the type_info base. */
1002 ptr_initializer (tinfo_s
*ti
, tree target
)
1004 tree init
= tinfo_base_init (ti
, target
);
1005 tree to
= TREE_TYPE (target
);
1006 int flags
= qualifier_flags (to
);
1007 bool incomplete
= target_incomplete_p (to
);
1008 vec
<constructor_elt
, va_gc
> *v
;
1013 if (tx_safe_fn_type_p (to
))
1016 to
= tx_unsafe_fn_variant (to
);
1018 if (flag_noexcept_type
1019 && (TREE_CODE (to
) == FUNCTION_TYPE
1020 || TREE_CODE (to
) == METHOD_TYPE
)
1021 && TYPE_NOTHROW_P (to
))
1024 to
= build_exception_variant (to
, NULL_TREE
);
1026 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1027 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
1028 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
1029 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
1031 init
= build_constructor (init_list_type_node
, v
);
1032 TREE_CONSTANT (init
) = 1;
1033 TREE_STATIC (init
) = 1;
1037 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
1038 TI provides information about the particular type_info derivation,
1039 which adds class, target type and qualifier flags members to the type_info
1043 ptm_initializer (tinfo_s
*ti
, tree target
)
1045 tree init
= tinfo_base_init (ti
, target
);
1046 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
1047 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
1048 int flags
= qualifier_flags (to
);
1049 bool incomplete
= target_incomplete_p (to
);
1050 vec
<constructor_elt
, va_gc
> *v
;
1055 if (!COMPLETE_TYPE_P (klass
))
1057 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1058 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
1059 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
1060 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
1061 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, get_tinfo_ptr (klass
));
1063 init
= build_constructor (init_list_type_node
, v
);
1064 TREE_CONSTANT (init
) = 1;
1065 TREE_STATIC (init
) = 1;
1069 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1070 TI provides information about the particular __class_type_info derivation,
1071 which adds hint flags and N extra initializers to the type_info base. */
1074 class_initializer (tinfo_s
*ti
, tree target
, unsigned n
, ...)
1076 tree init
= tinfo_base_init (ti
, target
);
1077 va_list extra_inits
;
1079 vec
<constructor_elt
, va_gc
> *v
;
1082 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1083 va_start (extra_inits
, n
);
1084 for (i
= 0; i
< n
; i
++)
1085 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, va_arg (extra_inits
, tree
));
1086 va_end (extra_inits
);
1088 init
= build_constructor (init_list_type_node
, v
);
1089 TREE_CONSTANT (init
) = 1;
1090 TREE_STATIC (init
) = 1;
1094 /* Returns true if the typeinfo for type should be placed in
1095 the runtime library. */
1098 typeinfo_in_lib_p (tree type
)
1100 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1101 library for simple types T. */
1102 if (TYPE_PTR_P (type
)
1103 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
1104 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
1105 type
= TREE_TYPE (type
);
1107 switch (TREE_CODE (type
))
1124 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1125 the index of the descriptor in the tinfo_desc vector. */
1128 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1130 tinfo_s
*ti
= get_tinfo_desc (tk_index
);
1132 gcc_assert (at_eof
);
1135 case TK_POINTER_MEMBER_TYPE
:
1136 return ptm_initializer (ti
, type
);
1138 case TK_POINTER_TYPE
:
1139 return ptr_initializer (ti
, type
);
1141 case TK_BUILTIN_TYPE
:
1142 case TK_ENUMERAL_TYPE
:
1143 case TK_FUNCTION_TYPE
:
1145 return generic_initializer (ti
, type
);
1148 return class_initializer (ti
, type
, 0);
1150 case TK_SI_CLASS_TYPE
:
1152 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1153 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1155 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1156 ti
= &(*tinfo_descs
)[tk_index
];
1157 return class_initializer (ti
, type
, 1, tinfo
);
1162 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1163 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1164 tree binfo
= TYPE_BINFO (type
);
1165 unsigned nbases
= BINFO_N_BASE_BINFOS (binfo
);
1166 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1167 tree offset_type
= LONGPTR_T
;
1168 vec
<constructor_elt
, va_gc
> *init_vec
= NULL
;
1170 gcc_assert (tk_index
- TK_VMI_CLASS_TYPES
+ 1 == nbases
);
1172 vec_safe_grow (init_vec
, nbases
);
1173 /* Generate the base information initializer. */
1174 for (unsigned ix
= nbases
; ix
--;)
1176 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1180 vec
<constructor_elt
, va_gc
> *v
;
1182 if ((*base_accesses
)[ix
] == access_public_node
)
1184 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1185 if (BINFO_VIRTUAL_P (base_binfo
))
1187 /* We store the vtable offset at which the virtual
1188 base offset can be found. */
1189 offset
= BINFO_VPTR_FIELD (base_binfo
);
1193 offset
= BINFO_OFFSET (base_binfo
);
1195 /* Combine offset and flags into one field. */
1196 offset
= fold_convert (offset_type
, offset
);
1197 offset
= fold_build2_loc (input_location
,
1198 LSHIFT_EXPR
, offset_type
, offset
,
1199 build_int_cst (offset_type
, 8));
1200 offset
= fold_build2_loc (input_location
,
1201 BIT_IOR_EXPR
, offset_type
, offset
,
1202 build_int_cst (offset_type
, flags
));
1204 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, tinfo
);
1205 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, offset
);
1206 tree base_init
= build_constructor (init_list_type_node
, v
);
1207 constructor_elt
*e
= &(*init_vec
)[ix
];
1208 e
->index
= NULL_TREE
;
1209 e
->value
= base_init
;
1211 tree base_inits
= build_constructor (init_list_type_node
, init_vec
);
1213 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1214 ti
= &(*tinfo_descs
)[tk_index
];
1215 return class_initializer (ti
, type
, 3,
1216 build_int_cst (NULL_TREE
, hint
),
1217 build_int_cst (NULL_TREE
, nbases
),
1223 /* Return the index of a pseudo type info type node used to describe
1224 TYPE. TYPE must be a complete type (or cv void), except at the end
1225 of the translation unit. */
1228 get_pseudo_ti_index (tree type
)
1232 switch (TREE_CODE (type
))
1235 ix
= TK_POINTER_MEMBER_TYPE
;
1239 ix
= TK_POINTER_TYPE
;
1243 ix
= TK_ENUMERAL_TYPE
;
1247 ix
= TK_FUNCTION_TYPE
;
1256 if (TYPE_PTRMEMFUNC_P (type
))
1257 ix
= TK_POINTER_MEMBER_TYPE
;
1258 else if (!COMPLETE_TYPE_P (type
))
1261 cxx_incomplete_type_error (NULL_TREE
, type
);
1264 else if (!TYPE_BINFO (type
)
1265 || !BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1269 tree binfo
= TYPE_BINFO (type
);
1270 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1271 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1272 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1275 && (*base_accesses
)[0] == access_public_node
1276 && !BINFO_VIRTUAL_P (base_binfo
)
1277 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1278 /* single non-virtual public. */
1279 ix
= TK_SI_CLASS_TYPE
;
1281 ix
= TK_VMI_CLASS_TYPES
+ num_bases
- 1;
1286 ix
= TK_BUILTIN_TYPE
;
1292 /* Return pointer to tinfo descriptor. Possibly creating the tinfo
1293 descriptor in the first place. */
1296 get_tinfo_desc (unsigned ix
)
1298 unsigned len
= tinfo_descs
->length ();
1302 /* too short, extend. */
1304 vec_safe_reserve (tinfo_descs
, len
);
1306 elt
.type
= elt
.vtable
= elt
.name
= NULL_TREE
;
1308 tinfo_descs
->quick_push (elt
);
1311 tinfo_s
*res
= &(*tinfo_descs
)[ix
];
1316 /* Ok, we have to create it. This layout must be consistent with
1317 that defined in the runtime support. We explicitly manage the
1318 vtable member, and name it for real type as used in the runtime.
1319 The RECORD type has a different name, to avoid collisions. We
1320 have to delay generating the VAR_DECL of the vtable until the end
1321 of the translation, when we'll have seen the library definition,
1322 if there was one. */
1324 /* Fields to add, chained in reverse order. */
1325 tree fields
= NULL_TREE
;
1327 if (ix
>= TK_DERIVED_TYPES
)
1329 /* First field is the pseudo type_info base class. */
1330 tree fld_base
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
1331 get_tinfo_desc (TK_TYPE_INFO_TYPE
)->type
);
1333 DECL_CHAIN (fld_base
) = fields
;
1339 case TK_TYPE_INFO_TYPE
:
1341 tree fld_ptr
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1342 NULL_TREE
, const_ptr_type_node
);
1345 tree fld_str
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1346 NULL_TREE
, const_string_type_node
);
1347 DECL_CHAIN (fld_str
) = fields
;
1354 /* Base class internal helper. Pointer to base type, offset to
1356 tree fld_ptr
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1357 NULL_TREE
, type_info_ptr_type
);
1358 DECL_CHAIN (fld_ptr
) = fields
;
1361 tree fld_flag
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1362 NULL_TREE
, LONGPTR_T
);
1363 DECL_CHAIN (fld_flag
) = fields
;
1368 case TK_BUILTIN_TYPE
:
1369 /* Fundamental type_info */
1375 case TK_FUNCTION_TYPE
:
1378 case TK_ENUMERAL_TYPE
:
1381 case TK_POINTER_TYPE
:
1382 case TK_POINTER_MEMBER_TYPE
:
1384 /* Pointer type_info. Adds two fields, qualification mask and
1385 pointer to the pointed to type. This is really a
1386 descendant of __pbase_type_info. */
1387 tree fld_mask
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1388 NULL_TREE
, integer_type_node
);
1389 DECL_CHAIN (fld_mask
) = fields
;
1392 tree fld_ptr
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1393 NULL_TREE
, type_info_ptr_type
);
1394 DECL_CHAIN (fld_ptr
) = fields
;
1397 if (ix
== TK_POINTER_MEMBER_TYPE
)
1399 /* Add a pointer to the class too. */
1400 tree fld_cls
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1401 NULL_TREE
, type_info_ptr_type
);
1402 DECL_CHAIN (fld_cls
) = fields
;
1409 /* Class type_info. No additional fields. */
1412 case TK_SI_CLASS_TYPE
:
1414 /* Single public non-virtual base class. Add pointer to base
1415 class. This is really a descendant of
1416 __class_type_info. */
1417 tree fld_ptr
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1418 NULL_TREE
, type_info_ptr_type
);
1419 DECL_CHAIN (fld_ptr
) = fields
;
1424 default: /* Multiple inheritance. */
1426 unsigned num_bases
= ix
- TK_VMI_CLASS_TYPES
+ 1;
1428 tree fld_flg
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1429 NULL_TREE
, integer_type_node
);
1430 DECL_CHAIN (fld_flg
) = fields
;
1433 tree fld_cnt
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1434 NULL_TREE
, integer_type_node
);
1435 DECL_CHAIN (fld_cnt
) = fields
;
1438 /* Create the array of __base_class_type_info entries. */
1439 tree domain
= build_index_type (size_int (num_bases
- 1));
1440 tree array
= build_array_type (get_tinfo_desc (TK_BASE_TYPE
)->type
,
1442 tree fld_ary
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1444 DECL_CHAIN (fld_ary
) = fields
;
1450 push_abi_namespace ();
1452 /* Generate the pseudo type name. */
1453 const char *real_name
= tinfo_names
[ix
< TK_VMI_CLASS_TYPES
1454 ? ix
: unsigned (TK_VMI_CLASS_TYPES
)];
1455 size_t name_len
= strlen (real_name
);
1456 char *pseudo_name
= (char *) alloca (name_len
+ 30);
1457 memcpy (pseudo_name
, real_name
, name_len
);
1458 /* Those >= TK_VMI_CLASS_TYPES need a discriminator, may as well
1459 apply it to all. See get_peudo_tinfo_index where we make use of
1461 sprintf (pseudo_name
+ name_len
, "_pseudo_%d", ix
);
1463 /* Create the pseudo type. */
1464 tree pseudo_type
= make_class_type (RECORD_TYPE
);
1465 /* Pass the fields chained in reverse. */
1466 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1467 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1469 res
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1470 res
->name
= get_identifier (real_name
);
1472 /* Pretend this is public so determine_visibility doesn't give vtables
1473 internal linkage. */
1474 TREE_PUBLIC (TYPE_MAIN_DECL (res
->type
)) = 1;
1476 pop_abi_namespace ();
1480 /* We lazily create the type info types. */
1483 create_tinfo_types (void)
1485 gcc_assert (!tinfo_descs
);
1487 vec_alloc (tinfo_descs
, TK_MAX
+ 20);
1490 /* Helper for emit_support_tinfos. Emits the type_info descriptor of
1494 emit_support_tinfo_1 (tree bltn
)
1498 if (bltn
== NULL_TREE
)
1501 types
[1] = build_pointer_type (bltn
);
1502 types
[2] = build_pointer_type (cp_build_qualified_type (bltn
,
1505 for (int i
= 0; i
< 3; ++i
)
1507 tree tinfo
= get_tinfo_decl (types
[i
]);
1508 TREE_USED (tinfo
) = 1;
1509 mark_needed (tinfo
);
1510 /* The C++ ABI requires that these objects be COMDAT. But,
1511 On systems without weak symbols, initialized COMDAT
1512 objects are emitted with internal linkage. (See
1513 comdat_linkage for details.) Since we want these objects
1514 to have external linkage so that copies do not have to be
1515 emitted in code outside the runtime library, we make them
1518 It might also not be necessary to follow this detail of the
1520 if (!flag_weak
|| ! targetm
.cxx
.library_rtti_comdat ())
1522 gcc_assert (TREE_PUBLIC (tinfo
) && !DECL_COMDAT (tinfo
));
1523 DECL_INTERFACE_KNOWN (tinfo
) = 1;
1528 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1529 support. Generating them here guarantees consistency with the other
1530 structures. We use the following heuristic to determine when the runtime
1531 is being generated. If std::__fundamental_type_info is defined, and its
1532 destructor is defined, then the runtime is being built. */
1535 emit_support_tinfos (void)
1537 /* Dummy static variable so we can put nullptr in the array; it will be
1538 set before we actually start to walk the array. */
1539 static tree
*const fundamentals
[] =
1543 &wchar_type_node
, &char16_type_node
, &char32_type_node
,
1544 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1545 &short_integer_type_node
, &short_unsigned_type_node
,
1546 &integer_type_node
, &unsigned_type_node
,
1547 &long_integer_type_node
, &long_unsigned_type_node
,
1548 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1549 &float_type_node
, &double_type_node
, &long_double_type_node
,
1550 &dfloat32_type_node
, &dfloat64_type_node
, &dfloat128_type_node
,
1556 /* Look for a defined class. */
1557 tree bltn_type
= lookup_qualified_name
1558 (abi_node
, get_identifier ("__fundamental_type_info"), true, false, false);
1559 if (TREE_CODE (bltn_type
) != TYPE_DECL
)
1562 bltn_type
= TREE_TYPE (bltn_type
);
1563 if (!COMPLETE_TYPE_P (bltn_type
))
1565 tree dtor
= CLASSTYPE_DESTRUCTOR (bltn_type
);
1566 if (!dtor
|| DECL_EXTERNAL (dtor
))
1569 /* All these are really builtins. So set the location. */
1570 location_t saved_loc
= input_location
;
1571 input_location
= BUILTINS_LOCATION
;
1573 for (ix
= 0; fundamentals
[ix
]; ix
++)
1574 emit_support_tinfo_1 (*fundamentals
[ix
]);
1575 for (ix
= 0; ix
< NUM_INT_N_ENTS
; ix
++)
1576 if (int_n_enabled_p
[ix
])
1578 emit_support_tinfo_1 (int_n_trees
[ix
].signed_type
);
1579 emit_support_tinfo_1 (int_n_trees
[ix
].unsigned_type
);
1581 for (tree t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1582 emit_support_tinfo_1 (TREE_VALUE (t
));
1583 input_location
= saved_loc
;
1586 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1587 tinfo decl. Determine whether it needs emitting, and if so
1588 generate the initializer. */
1591 emit_tinfo_decl (tree decl
)
1593 tree type
= TREE_TYPE (DECL_NAME (decl
));
1594 int in_library
= typeinfo_in_lib_p (type
);
1596 gcc_assert (DECL_TINFO_P (decl
));
1601 DECL_EXTERNAL (decl
) = 0;
1604 /* If we're not in the runtime, then DECL (which is already
1605 DECL_EXTERNAL) will not be defined here. */
1606 DECL_INTERFACE_KNOWN (decl
) = 1;
1610 else if (involves_incomplete_p (type
))
1612 if (!decl_needed_p (decl
))
1614 /* If TYPE involves an incomplete class type, then the typeinfo
1615 object will be emitted with internal linkage. There is no
1616 way to know whether or not types are incomplete until the end
1617 of the compilation, so this determination must be deferred
1618 until this point. */
1619 TREE_PUBLIC (decl
) = 0;
1620 DECL_EXTERNAL (decl
) = 0;
1621 DECL_INTERFACE_KNOWN (decl
) = 1;
1624 import_export_decl (decl
);
1625 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1629 DECL_EXTERNAL (decl
) = 0;
1630 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1631 DECL_INITIAL (decl
) = init
;
1633 cp_finish_decl (decl
, init
, false, NULL_TREE
, 0);
1634 /* Avoid targets optionally bumping up the alignment to improve
1635 vector instruction accesses, tinfo are never accessed this way. */
1636 #ifdef DATA_ABI_ALIGNMENT
1637 SET_DECL_ALIGN (decl
, DATA_ABI_ALIGNMENT (decl
, TYPE_ALIGN (TREE_TYPE (decl
))));
1638 DECL_USER_ALIGN (decl
) = true;
1646 #include "gt-cp-rtti.h"