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"
27 #include "stringpool.h"
28 #include "stor-layout.h"
33 #include "c-family/c-pragma.h"
35 /* C++ returns type information to the user in struct type_info
36 objects. We also use type information to implement dynamic_cast and
37 exception handlers. Type information for a particular type is
38 indicated with an ABI defined structure derived from type_info.
39 This would all be very straight forward, but for the fact that the
40 runtime library provides the definitions of the type_info structure
41 and the ABI defined derived classes. We cannot build declarations
42 of them directly in the compiler, but we need to layout objects of
43 their type. Somewhere we have to lie.
45 We define layout compatible POD-structs with compiler-defined names
46 and generate the appropriate initializations for them (complete
47 with explicit mention of their vtable). When we have to provide a
48 type_info to the user we reinterpret_cast the internal compiler
49 type to type_info. A well formed program can only explicitly refer
50 to the type_infos of complete types (& cv void). However, we chain
51 pointer type_infos to the pointed-to-type, and that can be
52 incomplete. We only need the addresses of such incomplete
53 type_info objects for static initialization.
55 The type information VAR_DECL of a type is held on the
56 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
57 will be the internal type. It will usually have the correct
58 internal type reflecting the kind of type it represents (pointer,
59 array, function, class, inherited class, etc). When the type it
60 represents is incomplete, it will have the internal type
61 corresponding to type_info. That will only happen at the end of
62 translation, when we are emitting the type info objects. */
64 /* Auxiliary data we hold for each type_info derived object we need. */
65 typedef struct GTY (()) tinfo_s
{
66 tree type
; /* The RECORD_TYPE for this type_info object */
68 tree vtable
; /* The VAR_DECL of the vtable. Only filled at end of
71 tree name
; /* IDENTIFIER_NODE for the ABI specified name of
72 the type_info derived type. */
76 typedef enum tinfo_kind
78 TK_TYPE_INFO_TYPE
, /* abi::__type_info_pseudo */
79 TK_BASE_TYPE
, /* abi::__base_class_type_info */
80 TK_BUILTIN_TYPE
, /* 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_FIXED
/* end of fixed descriptors. */
89 /* ... abi::__vmi_type_info<I> */
92 /* Helper macro to get maximum scalar-width of pointer or of the 'long'-type.
93 This of interest for llp64 targets. */
95 integer_types[(POINTER_SIZE <= TYPE_PRECISION (integer_types[itk_long]) \
96 ? itk_long : itk_long_long)]
98 /* A vector of all tinfo decls that haven't yet been emitted. */
99 vec
<tree
, va_gc
> *unemitted_tinfo_decls
;
101 /* A vector of all type_info derived types we need. The first few are
102 fixed and created early. The remainder are for multiple inheritance
103 and are generated as needed. */
104 static GTY (()) vec
<tinfo_s
, va_gc
> *tinfo_descs
;
106 static tree
ifnonnull (tree
, tree
, tsubst_flags_t
);
107 static tree
tinfo_name (tree
, bool);
108 static tree
build_dynamic_cast_1 (tree
, tree
, tsubst_flags_t
);
109 static tree
throw_bad_cast (void);
110 static tree
throw_bad_typeid (void);
111 static tree
get_tinfo_ptr (tree
);
112 static bool typeid_ok_p (void);
113 static int qualifier_flags (tree
);
114 static bool target_incomplete_p (tree
);
115 static tree
tinfo_base_init (tinfo_s
*, tree
);
116 static tree
generic_initializer (tinfo_s
*, tree
);
117 static tree
ptr_initializer (tinfo_s
*, tree
);
118 static tree
ptm_initializer (tinfo_s
*, tree
);
119 static tree
class_initializer (tinfo_s
*, tree
, unsigned, ...);
120 static void create_pseudo_type_info (int, const char *, ...);
121 static tree
get_pseudo_ti_init (tree
, unsigned);
122 static unsigned get_pseudo_ti_index (tree
);
123 static void create_tinfo_types (void);
124 static bool typeinfo_in_lib_p (tree
);
126 static int doing_runtime
= 0;
129 push_abi_namespace (void)
131 push_nested_namespace (abi_node
);
132 push_visibility ("default", 2);
136 pop_abi_namespace (void)
139 pop_nested_namespace (abi_node
);
142 /* Declare language defined type_info type and a pointer to const
143 type_info. This is incomplete here, and will be completed when
144 the user #includes <typeinfo>. There are language defined
145 restrictions on what can be done until that is included. Create
146 the internal versions of the ABI types. */
149 init_rtti_processing (void)
153 push_namespace (std_identifier
);
154 type_info_type
= xref_tag (class_type
, get_identifier ("type_info"),
155 /*tag_scope=*/ts_current
, false);
157 const_type_info_type_node
158 = cp_build_qualified_type (type_info_type
, TYPE_QUAL_CONST
);
159 type_info_ptr_type
= build_pointer_type (const_type_info_type_node
);
161 vec_alloc (unemitted_tinfo_decls
, 124);
163 create_tinfo_types ();
166 /* Given the expression EXP of type `class *', return the head of the
167 object pointed to by EXP with type cv void*, if the class has any
168 virtual functions (TYPE_POLYMORPHIC_P), else just return the
172 build_headof (tree exp
)
174 tree type
= TREE_TYPE (exp
);
178 gcc_assert (TYPE_PTR_P (type
));
179 type
= TREE_TYPE (type
);
181 if (!TYPE_POLYMORPHIC_P (type
))
184 /* We use this a couple of times below, protect it. */
185 exp
= save_expr (exp
);
187 /* The offset-to-top field is at index -2 from the vptr. */
188 index
= build_int_cst (NULL_TREE
,
189 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
191 offset
= build_vtbl_ref (cp_build_indirect_ref (exp
, RO_NULL
,
192 tf_warning_or_error
),
195 type
= cp_build_qualified_type (ptr_type_node
,
196 cp_type_quals (TREE_TYPE (exp
)));
197 return fold_build_pointer_plus (exp
, offset
);
200 /* Get a bad_cast node for the program to throw...
202 See libstdc++/exception.cc for __throw_bad_cast */
205 throw_bad_cast (void)
207 tree fn
= get_identifier ("__cxa_bad_cast");
208 if (!get_global_value_if_present (fn
, &fn
))
209 fn
= push_throw_library_fn (fn
, build_function_type_list (ptr_type_node
,
212 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
215 /* Return an expression for "__cxa_bad_typeid()". The expression
216 returned is an lvalue of type "const std::type_info". */
219 throw_bad_typeid (void)
221 tree fn
= get_identifier ("__cxa_bad_typeid");
222 if (!get_global_value_if_present (fn
, &fn
))
226 t
= build_reference_type (const_type_info_type_node
);
227 t
= build_function_type_list (t
, NULL_TREE
);
228 fn
= push_throw_library_fn (fn
, t
);
231 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
234 /* Return an lvalue expression whose type is "const std::type_info"
235 and whose value indicates the type of the expression EXP. If EXP
236 is a reference to a polymorphic class, return the dynamic type;
237 otherwise return the static type of the expression. */
240 get_tinfo_decl_dynamic (tree exp
, tsubst_flags_t complain
)
245 if (error_operand_p (exp
))
246 return error_mark_node
;
248 exp
= resolve_nondeduced_context (exp
);
250 /* peel back references, so they match. */
251 type
= non_reference (TREE_TYPE (exp
));
253 /* Peel off cv qualifiers. */
254 type
= TYPE_MAIN_VARIANT (type
);
256 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
257 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
258 || type
== init_list_type_node
)
259 type
= complete_type_or_maybe_complain (type
, exp
, complain
);
262 return error_mark_node
;
264 /* If exp is a reference to polymorphic type, get the real type_info. */
265 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
267 /* build reference to type_info from vtable. */
270 /* The RTTI information is at index -1. */
271 index
= build_int_cst (NULL_TREE
,
272 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
273 t
= build_vtbl_ref (exp
, index
);
274 t
= convert (type_info_ptr_type
, t
);
277 /* Otherwise return the type_info for the static type of the expr. */
278 t
= get_tinfo_ptr (TYPE_MAIN_VARIANT (type
));
280 return cp_build_indirect_ref (t
, RO_NULL
, complain
);
286 tree pseudo_type_info
, type_info_type
;
290 error ("cannot use typeid with -fno-rtti");
294 if (!COMPLETE_TYPE_P (const_type_info_type_node
))
296 error ("must #include <typeinfo> before using typeid");
300 pseudo_type_info
= (*tinfo_descs
)[TK_TYPE_INFO_TYPE
].type
;
301 type_info_type
= TYPE_MAIN_VARIANT (const_type_info_type_node
);
303 /* Make sure abi::__type_info_pseudo has the same alias set
304 as std::type_info. */
305 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info
))
306 TYPE_ALIAS_SET (pseudo_type_info
) = get_alias_set (type_info_type
);
308 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info
)
309 == get_alias_set (type_info_type
));
314 /* Return an expression for "typeid(EXP)". The expression returned is
315 an lvalue of type "const std::type_info". */
318 build_typeid (tree exp
, tsubst_flags_t complain
)
320 tree cond
= NULL_TREE
, initial_expr
= exp
;
323 if (exp
== error_mark_node
|| !typeid_ok_p ())
324 return error_mark_node
;
326 if (processing_template_decl
)
327 return build_min (TYPEID_EXPR
, const_type_info_type_node
, exp
);
329 /* FIXME when integrating with c_fully_fold, mark
330 resolves_to_fixed_type_p case as a non-constant expression. */
331 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
332 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
335 /* So we need to look into the vtable of the type of exp.
336 Make sure it isn't a null lvalue. */
337 exp
= cp_build_addr_expr (exp
, complain
);
338 exp
= stabilize_reference (exp
);
339 cond
= cp_convert (boolean_type_node
, exp
, complain
);
340 exp
= cp_build_indirect_ref (exp
, RO_NULL
, complain
);
343 exp
= get_tinfo_decl_dynamic (exp
, complain
);
345 if (exp
== error_mark_node
)
346 return error_mark_node
;
350 tree bad
= throw_bad_typeid ();
352 exp
= build3 (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
355 mark_type_use (initial_expr
);
360 /* Generate the NTBS name of a type. If MARK_PRIVATE, put a '*' in front so that
361 comparisons will be done by pointer rather than string comparison. */
363 tinfo_name (tree type
, bool mark_private
)
369 name
= mangle_type_string (type
);
370 length
= strlen (name
);
374 /* Inject '*' at beginning of name to force pointer comparison. */
375 char* buf
= (char*) XALLOCAVEC (char, length
+ 2);
377 memcpy (buf
+ 1, name
, length
+ 1);
378 name_string
= build_string (length
+ 2, buf
);
381 name_string
= build_string (length
+ 1, name
);
383 return fix_string_type (name_string
);
386 /* Return a VAR_DECL for the internal ABI defined type_info object for
387 TYPE. You must arrange that the decl is mark_used, if actually use
388 it --- decls in vtables are only used if the vtable is output. */
391 get_tinfo_decl (tree type
)
396 if (variably_modified_type_p (type
, /*fn=*/NULL_TREE
))
398 if (array_of_runtime_bound_p (type
))
399 error ("typeid of array of runtime bound");
401 error ("cannot create type information for type %qT because "
402 "it involves types of variable size",
404 return error_mark_node
;
407 if (TREE_CODE (type
) == METHOD_TYPE
)
408 type
= build_function_type (TREE_TYPE (type
),
409 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
411 type
= complete_type (type
);
413 /* For a class type, the variable is cached in the type node
415 if (CLASS_TYPE_P (type
))
417 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
422 name
= mangle_typeinfo_for_type (type
);
424 d
= IDENTIFIER_GLOBAL_VALUE (name
);
427 int ix
= get_pseudo_ti_index (type
);
428 tinfo_s
*ti
= &(*tinfo_descs
)[ix
];
430 d
= build_lang_decl (VAR_DECL
, name
, ti
->type
);
431 SET_DECL_ASSEMBLER_NAME (d
, name
);
432 /* Remember the type it is for. */
433 TREE_TYPE (name
) = type
;
434 DECL_TINFO_P (d
) = 1;
435 DECL_ARTIFICIAL (d
) = 1;
436 DECL_IGNORED_P (d
) = 1;
437 TREE_READONLY (d
) = 1;
439 /* Mark the variable as undefined -- but remember that we can
440 define it later if we need to do so. */
441 DECL_EXTERNAL (d
) = 1;
442 DECL_NOT_REALLY_EXTERN (d
) = 1;
443 set_linkage_according_to_type (type
, d
);
445 d
= pushdecl_top_level_and_finish (d
, NULL_TREE
);
446 if (CLASS_TYPE_P (type
))
447 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
449 /* Add decl to the global array of tinfo decls. */
450 vec_safe_push (unemitted_tinfo_decls
, d
);
456 /* Return a pointer to a type_info object describing TYPE, suitably
457 cast to the language defined type. */
460 get_tinfo_ptr (tree type
)
462 tree decl
= get_tinfo_decl (type
);
465 return build_nop (type_info_ptr_type
,
466 build_address (decl
));
469 /* Return the type_info object for TYPE. */
472 get_typeid (tree type
, tsubst_flags_t complain
)
474 if (type
== error_mark_node
|| !typeid_ok_p ())
475 return error_mark_node
;
477 if (processing_template_decl
)
478 return build_min (TYPEID_EXPR
, const_type_info_type_node
, type
);
480 /* If the type of the type-id is a reference type, the result of the
481 typeid expression refers to a type_info object representing the
483 type
= non_reference (type
);
485 /* This is not one of the uses of a qualified function type in 8.3.5. */
486 if (TREE_CODE (type
) == FUNCTION_TYPE
487 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
488 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
490 if (complain
& tf_error
)
491 error ("typeid of qualified function type %qT", type
);
492 return error_mark_node
;
495 /* The top-level cv-qualifiers of the lvalue expression or the type-id
496 that is the operand of typeid are always ignored. */
497 type
= TYPE_MAIN_VARIANT (type
);
499 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
500 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
501 || type
== init_list_type_node
)
502 type
= complete_type_or_maybe_complain (type
, NULL_TREE
, complain
);
505 return error_mark_node
;
507 return cp_build_indirect_ref (get_tinfo_ptr (type
), RO_NULL
, complain
);
510 /* Check whether TEST is null before returning RESULT. If TEST is used in
511 RESULT, it must have previously had a save_expr applied to it. */
514 ifnonnull (tree test
, tree result
, tsubst_flags_t complain
)
516 return build3 (COND_EXPR
, TREE_TYPE (result
),
517 build2 (EQ_EXPR
, boolean_type_node
, test
,
518 cp_convert (TREE_TYPE (test
), nullptr_node
,
520 cp_convert (TREE_TYPE (result
), nullptr_node
, complain
),
524 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
528 build_dynamic_cast_1 (tree type
, tree expr
, tsubst_flags_t complain
)
530 enum tree_code tc
= TREE_CODE (type
);
533 tree old_expr
= expr
;
534 const char *errstr
= NULL
;
536 /* Save casted types in the function's used types hash table. */
537 used_types_insert (type
);
539 /* T shall be a pointer or reference to a complete class type, or
540 `pointer to cv void''. */
544 if (VOID_TYPE_P (TREE_TYPE (type
)))
548 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
550 errstr
= _("target is not pointer or reference to class");
553 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
555 errstr
= _("target is not pointer or reference to complete type");
561 errstr
= _("target is not pointer or reference");
565 if (tc
== POINTER_TYPE
)
567 expr
= decay_conversion (expr
, complain
);
568 exprtype
= TREE_TYPE (expr
);
570 /* If T is a pointer type, v shall be an rvalue of a pointer to
571 complete class type, and the result is an rvalue of type T. */
573 expr
= mark_rvalue_use (expr
);
575 if (!TYPE_PTR_P (exprtype
))
577 errstr
= _("source is not a pointer");
580 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
582 errstr
= _("source is not a pointer to class");
585 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
587 errstr
= _("source is a pointer to incomplete type");
593 expr
= mark_lvalue_use (expr
);
595 exprtype
= build_reference_type (TREE_TYPE (expr
));
597 /* T is a reference type, v shall be an lvalue of a complete class
598 type, and the result is an lvalue of the type referred to by T. */
600 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
602 errstr
= _("source is not of class type");
605 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
607 errstr
= _("source is of incomplete class type");
611 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
612 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
613 LOOKUP_NORMAL
, NULL_TREE
, complain
);
616 /* The dynamic_cast operator shall not cast away constness. */
617 if (!at_least_as_qualified_p (TREE_TYPE (type
),
618 TREE_TYPE (exprtype
)))
620 errstr
= _("conversion casts away constness");
624 /* If *type is an unambiguous accessible base class of *exprtype,
625 convert statically. */
627 tree binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
628 ba_check
, NULL
, complain
);
630 return build_static_cast (type
, expr
, complain
);
633 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
634 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
637 /* if TYPE is `void *', return pointer to complete object. */
638 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
640 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
641 if (TREE_CODE (expr
) == ADDR_EXPR
642 && VAR_P (TREE_OPERAND (expr
, 0))
643 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
644 return build1 (NOP_EXPR
, type
, expr
);
646 /* Since expr is used twice below, save it. */
647 expr
= save_expr (expr
);
649 expr1
= build_headof (expr
);
650 if (TREE_TYPE (expr1
) != type
)
651 expr1
= build1 (NOP_EXPR
, type
, expr1
);
652 return ifnonnull (expr
, expr1
, complain
);
657 tree result
, td2
, td3
;
659 tree static_type
, target_type
, boff
;
661 /* If we got here, we can't convert statically. Therefore,
662 dynamic_cast<D&>(b) (b an object) cannot succeed. */
663 if (tc
== REFERENCE_TYPE
)
666 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
668 tree expr
= throw_bad_cast ();
669 if (complain
& tf_warning
)
670 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
672 /* Bash it to the expected type. */
673 TREE_TYPE (expr
) = type
;
677 /* Ditto for dynamic_cast<D*>(&b). */
678 else if (TREE_CODE (expr
) == ADDR_EXPR
)
680 tree op
= TREE_OPERAND (expr
, 0);
682 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
684 if (complain
& tf_warning
)
685 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
687 retval
= build_int_cst (type
, 0);
692 /* Use of dynamic_cast when -fno-rtti is prohibited. */
695 if (complain
& tf_error
)
696 error ("%<dynamic_cast%> not permitted with -fno-rtti");
697 return error_mark_node
;
700 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
701 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
702 td2
= get_tinfo_decl (target_type
);
704 td2
= cp_build_addr_expr (td2
, complain
);
705 td3
= get_tinfo_decl (static_type
);
707 td3
= cp_build_addr_expr (td3
, complain
);
709 /* Determine how T and V are related. */
710 boff
= dcast_base_hint (static_type
, target_type
);
712 /* Since expr is used twice below, save it. */
713 expr
= save_expr (expr
);
716 if (tc
== REFERENCE_TYPE
)
717 expr1
= cp_build_addr_expr (expr1
, complain
);
724 dcast_fn
= dynamic_cast_node
;
731 push_abi_namespace ();
732 tinfo_ptr
= xref_tag (class_type
,
733 get_identifier ("__class_type_info"),
734 /*tag_scope=*/ts_current
, false);
736 tinfo_ptr
= build_pointer_type
737 (cp_build_qualified_type
738 (tinfo_ptr
, TYPE_QUAL_CONST
));
739 name
= "__dynamic_cast";
740 tmp
= build_function_type_list (ptr_type_node
,
742 tinfo_ptr
, tinfo_ptr
,
743 ptrdiff_type_node
, NULL_TREE
);
744 dcast_fn
= build_library_fn_ptr (name
, tmp
,
745 ECF_LEAF
| ECF_PURE
| ECF_NOTHROW
);
746 pop_abi_namespace ();
747 dynamic_cast_node
= dcast_fn
;
749 result
= build_cxx_call (dcast_fn
, 4, elems
, complain
);
751 if (tc
== REFERENCE_TYPE
)
753 tree bad
= throw_bad_cast ();
756 result
= save_expr (result
);
757 neq
= cp_truthvalue_conversion (result
);
758 return cp_convert (type
,
759 build3 (COND_EXPR
, TREE_TYPE (result
),
760 neq
, result
, bad
), complain
);
763 /* Now back to the type we want from a void*. */
764 result
= cp_convert (type
, result
, complain
);
765 return ifnonnull (expr
, result
, complain
);
769 errstr
= _("source type is not polymorphic");
772 if (complain
& tf_error
)
773 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
774 old_expr
, TREE_TYPE (old_expr
), type
, errstr
);
775 return error_mark_node
;
779 build_dynamic_cast (tree type
, tree expr
, tsubst_flags_t complain
)
783 if (type
== error_mark_node
|| expr
== error_mark_node
)
784 return error_mark_node
;
786 if (processing_template_decl
)
788 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
789 TREE_SIDE_EFFECTS (expr
) = 1;
790 return convert_from_reference (expr
);
793 r
= convert_from_reference (build_dynamic_cast_1 (type
, expr
, complain
));
794 if (r
!= error_mark_node
)
795 maybe_warn_about_useless_cast (type
, expr
, complain
);
799 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
802 qualifier_flags (tree type
)
805 int quals
= cp_type_quals (type
);
807 if (quals
& TYPE_QUAL_CONST
)
809 if (quals
& TYPE_QUAL_VOLATILE
)
811 if (quals
& TYPE_QUAL_RESTRICT
)
816 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
817 contains a pointer to member of an incomplete class. */
820 target_incomplete_p (tree type
)
823 if (TYPE_PTRDATAMEM_P (type
))
825 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
827 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
829 else if (TYPE_PTR_P (type
))
830 type
= TREE_TYPE (type
);
832 return !COMPLETE_OR_VOID_TYPE_P (type
);
835 /* Returns true if TYPE involves an incomplete class type; in that
836 case, typeinfo variables for TYPE should be emitted with internal
840 involves_incomplete_p (tree type
)
842 switch (TREE_CODE (type
))
845 return target_incomplete_p (TREE_TYPE (type
));
850 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
851 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
854 if (TYPE_PTRMEMFUNC_P (type
))
858 if (!COMPLETE_TYPE_P (type
))
862 /* All other types do not involve incomplete class types. */
867 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
868 is the vtable pointer and NTBS name. The NTBS name is emitted as a
869 comdat const char array, so it becomes a unique key for the type. Generate
870 and emit that VAR_DECL here. (We can't always emit the type_info itself
871 as comdat, because of pointers to incomplete.) */
874 tinfo_base_init (tinfo_s
*ti
, tree target
)
879 vec
<constructor_elt
, va_gc
> *v
;
882 tree name_name
, name_string
;
884 /* Generate the NTBS array variable. */
885 tree name_type
= build_cplus_array_type
886 (cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
889 /* Determine the name of the variable -- and remember with which
890 type it is associated. */
891 name_name
= mangle_typeinfo_string_for_type (target
);
892 TREE_TYPE (name_name
) = target
;
894 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
895 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
896 DECL_ARTIFICIAL (name_decl
) = 1;
897 DECL_IGNORED_P (name_decl
) = 1;
898 TREE_READONLY (name_decl
) = 1;
899 TREE_STATIC (name_decl
) = 1;
900 DECL_EXTERNAL (name_decl
) = 0;
901 DECL_TINFO_P (name_decl
) = 1;
902 set_linkage_according_to_type (target
, name_decl
);
903 import_export_decl (name_decl
);
904 name_string
= tinfo_name (target
, !TREE_PUBLIC (name_decl
));
905 DECL_INITIAL (name_decl
) = name_string
;
906 mark_used (name_decl
);
907 pushdecl_top_level_and_finish (name_decl
, name_string
);
910 vtable_ptr
= ti
->vtable
;
914 push_abi_namespace ();
915 real_type
= xref_tag (class_type
, ti
->name
,
916 /*tag_scope=*/ts_current
, false);
917 pop_abi_namespace ();
919 if (!COMPLETE_TYPE_P (real_type
))
921 /* We never saw a definition of this type, so we need to
922 tell the compiler that this is an exported class, as
923 indeed all of the __*_type_info classes are. */
924 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
925 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
928 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
929 vtable_ptr
= cp_build_addr_expr (vtable_ptr
, tf_warning_or_error
);
931 /* We need to point into the middle of the vtable. */
932 vtable_ptr
= fold_build_pointer_plus
934 size_binop (MULT_EXPR
,
935 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
936 TYPE_SIZE_UNIT (vtable_entry_type
)));
938 ti
->vtable
= vtable_ptr
;
942 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, vtable_ptr
);
943 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
944 decay_conversion (name_decl
, tf_warning_or_error
));
946 init
= build_constructor (init_list_type_node
, v
);
947 TREE_CONSTANT (init
) = 1;
948 TREE_STATIC (init
) = 1;
953 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
954 information about the particular type_info derivation, which adds no
955 additional fields to the type_info base. */
958 generic_initializer (tinfo_s
*ti
, tree target
)
960 tree init
= tinfo_base_init (ti
, target
);
962 init
= build_constructor_single (init_list_type_node
, NULL_TREE
, init
);
963 TREE_CONSTANT (init
) = 1;
964 TREE_STATIC (init
) = 1;
968 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
969 TI provides information about the particular type_info derivation,
970 which adds target type and qualifier flags members to the type_info base. */
973 ptr_initializer (tinfo_s
*ti
, tree target
)
975 tree init
= tinfo_base_init (ti
, target
);
976 tree to
= TREE_TYPE (target
);
977 int flags
= qualifier_flags (to
);
978 bool incomplete
= target_incomplete_p (to
);
979 vec
<constructor_elt
, va_gc
> *v
;
984 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
985 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
986 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
987 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
989 init
= build_constructor (init_list_type_node
, v
);
990 TREE_CONSTANT (init
) = 1;
991 TREE_STATIC (init
) = 1;
995 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
996 TI provides information about the particular type_info derivation,
997 which adds class, target type and qualifier flags members to the type_info
1001 ptm_initializer (tinfo_s
*ti
, tree target
)
1003 tree init
= tinfo_base_init (ti
, target
);
1004 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
1005 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
1006 int flags
= qualifier_flags (to
);
1007 bool incomplete
= target_incomplete_p (to
);
1008 vec
<constructor_elt
, va_gc
> *v
;
1013 if (!COMPLETE_TYPE_P (klass
))
1015 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1016 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
1017 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
1018 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
1019 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, get_tinfo_ptr (klass
));
1021 init
= build_constructor (init_list_type_node
, v
);
1022 TREE_CONSTANT (init
) = 1;
1023 TREE_STATIC (init
) = 1;
1027 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1028 TI provides information about the particular __class_type_info derivation,
1029 which adds hint flags and N extra initializers to the type_info base. */
1032 class_initializer (tinfo_s
*ti
, tree target
, unsigned n
, ...)
1034 tree init
= tinfo_base_init (ti
, target
);
1035 va_list extra_inits
;
1037 vec
<constructor_elt
, va_gc
> *v
;
1040 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1041 va_start (extra_inits
, n
);
1042 for (i
= 0; i
< n
; i
++)
1043 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, va_arg (extra_inits
, tree
));
1044 va_end (extra_inits
);
1046 init
= build_constructor (init_list_type_node
, v
);
1047 TREE_CONSTANT (init
) = 1;
1048 TREE_STATIC (init
) = 1;
1052 /* Returns true if the typeinfo for type should be placed in
1053 the runtime library. */
1056 typeinfo_in_lib_p (tree type
)
1058 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1059 library for simple types T. */
1060 if (TYPE_PTR_P (type
)
1061 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
1062 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
1063 type
= TREE_TYPE (type
);
1065 switch (TREE_CODE (type
))
1082 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1083 the index of the descriptor in the tinfo_desc vector. */
1086 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1088 tinfo_s
*ti
= &(*tinfo_descs
)[tk_index
];
1090 gcc_assert (at_eof
);
1093 case TK_POINTER_MEMBER_TYPE
:
1094 return ptm_initializer (ti
, type
);
1096 case TK_POINTER_TYPE
:
1097 return ptr_initializer (ti
, type
);
1099 case TK_BUILTIN_TYPE
:
1100 case TK_ENUMERAL_TYPE
:
1101 case TK_FUNCTION_TYPE
:
1103 return generic_initializer (ti
, type
);
1106 return class_initializer (ti
, type
, 0);
1108 case TK_SI_CLASS_TYPE
:
1110 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1111 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1113 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1114 ti
= &(*tinfo_descs
)[tk_index
];
1115 return class_initializer (ti
, type
, 1, tinfo
);
1120 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1121 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1122 tree binfo
= TYPE_BINFO (type
);
1123 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1124 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1125 tree offset_type
= LONGPTR_T
;
1126 tree base_inits
= NULL_TREE
;
1128 vec
<constructor_elt
, va_gc
> *init_vec
= NULL
;
1131 gcc_assert (tk_index
>= TK_FIXED
);
1133 vec_safe_grow (init_vec
, nbases
);
1134 /* Generate the base information initializer. */
1135 for (ix
= nbases
; ix
--;)
1137 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1142 vec
<constructor_elt
, va_gc
> *v
;
1144 if ((*base_accesses
)[ix
] == access_public_node
)
1146 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1147 if (BINFO_VIRTUAL_P (base_binfo
))
1149 /* We store the vtable offset at which the virtual
1150 base offset can be found. */
1151 offset
= BINFO_VPTR_FIELD (base_binfo
);
1155 offset
= BINFO_OFFSET (base_binfo
);
1157 /* Combine offset and flags into one field. */
1158 offset
= fold_convert (offset_type
, offset
);
1159 offset
= fold_build2_loc (input_location
,
1160 LSHIFT_EXPR
, offset_type
, offset
,
1161 build_int_cst (offset_type
, 8));
1162 offset
= fold_build2_loc (input_location
,
1163 BIT_IOR_EXPR
, offset_type
, offset
,
1164 build_int_cst (offset_type
, flags
));
1166 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, tinfo
);
1167 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, offset
);
1168 base_init
= build_constructor (init_list_type_node
, v
);
1169 e
= &(*init_vec
)[ix
];
1170 e
->index
= NULL_TREE
;
1171 e
->value
= base_init
;
1173 base_inits
= build_constructor (init_list_type_node
, init_vec
);
1175 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1176 ti
= &(*tinfo_descs
)[tk_index
];
1177 return class_initializer (ti
, type
, 3,
1178 build_int_cst (NULL_TREE
, hint
),
1179 build_int_cst (NULL_TREE
, nbases
),
1185 /* Generate the RECORD_TYPE containing the data layout of a type_info
1186 derivative as used by the runtime. This layout must be consistent with
1187 that defined in the runtime support. Also generate the VAR_DECL for the
1188 type's vtable. We explicitly manage the vtable member, and name it for
1189 real type as used in the runtime. The RECORD type has a different name,
1190 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1191 is the generated type and TINFO_VTABLE_NAME is the name of the
1192 vtable. We have to delay generating the VAR_DECL of the vtable
1193 until the end of the translation, when we'll have seen the library
1194 definition, if there was one.
1196 REAL_NAME is the runtime's name of the type. Trailing arguments are
1197 additional FIELD_DECL's for the structure. The final argument must be
1201 create_pseudo_type_info (int tk
, const char *real_name
, ...)
1210 va_start (ap
, real_name
);
1212 /* Generate the pseudo type name. */
1213 pseudo_name
= (char *) alloca (strlen (real_name
) + 30);
1214 strcpy (pseudo_name
, real_name
);
1215 strcat (pseudo_name
, "_pseudo");
1217 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", tk
- TK_FIXED
);
1219 /* First field is the pseudo type_info base class. */
1220 fields
= build_decl (input_location
,
1221 FIELD_DECL
, NULL_TREE
,
1222 (*tinfo_descs
)[TK_TYPE_INFO_TYPE
].type
);
1224 /* Now add the derived fields. */
1225 while ((field_decl
= va_arg (ap
, tree
)))
1227 DECL_CHAIN (field_decl
) = fields
;
1228 fields
= field_decl
;
1231 /* Create the pseudo type. */
1232 pseudo_type
= make_class_type (RECORD_TYPE
);
1233 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1234 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1236 ti
= &(*tinfo_descs
)[tk
];
1237 ti
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1238 ti
->name
= get_identifier (real_name
);
1239 ti
->vtable
= NULL_TREE
;
1241 /* Pretend this is public so determine_visibility doesn't give vtables
1242 internal linkage. */
1243 TREE_PUBLIC (TYPE_MAIN_DECL (ti
->type
)) = 1;
1248 /* Return the index of a pseudo type info type node used to describe
1249 TYPE. TYPE must be a complete type (or cv void), except at the end
1250 of the translation unit. */
1253 get_pseudo_ti_index (tree type
)
1257 switch (TREE_CODE (type
))
1260 ix
= TK_POINTER_MEMBER_TYPE
;
1264 ix
= TK_POINTER_TYPE
;
1268 ix
= TK_ENUMERAL_TYPE
;
1272 ix
= TK_FUNCTION_TYPE
;
1281 if (TYPE_PTRMEMFUNC_P (type
))
1283 ix
= TK_POINTER_MEMBER_TYPE
;
1286 else if (!COMPLETE_TYPE_P (type
))
1289 cxx_incomplete_type_error (NULL_TREE
, type
);
1293 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1300 tree binfo
= TYPE_BINFO (type
);
1301 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1302 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1303 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1306 && (*base_accesses
)[0] == access_public_node
1307 && !BINFO_VIRTUAL_P (base_binfo
)
1308 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1310 /* single non-virtual public. */
1311 ix
= TK_SI_CLASS_TYPE
;
1317 tree array_domain
, base_array
;
1319 ix
= TK_FIXED
+ num_bases
;
1320 if (vec_safe_length (tinfo_descs
) <= ix
)
1322 /* too short, extend. */
1323 unsigned len
= vec_safe_length (tinfo_descs
);
1325 vec_safe_grow (tinfo_descs
, ix
+ 1);
1326 while (tinfo_descs
->iterate (len
++, &ti
))
1327 ti
->type
= ti
->vtable
= ti
->name
= NULL_TREE
;
1329 else if ((*tinfo_descs
)[ix
].type
)
1330 /* already created. */
1333 /* Create the array of __base_class_type_info entries.
1334 G++ 3.2 allocated an array that had one too many
1335 entries, and then filled that extra entries with
1337 if (abi_version_at_least (2))
1338 array_domain
= build_index_type (size_int (num_bases
- 1));
1340 array_domain
= build_index_type (size_int (num_bases
));
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 &int128_integer_type_node
, &int128_unsigned_type_node
,
1528 &float_type_node
, &double_type_node
, &long_double_type_node
,
1529 &dfloat32_type_node
, &dfloat64_type_node
, &dfloat128_type_node
,
1534 tree bltn_type
, dtor
;
1536 push_abi_namespace ();
1537 bltn_type
= xref_tag (class_type
,
1538 get_identifier ("__fundamental_type_info"),
1539 /*tag_scope=*/ts_current
, false);
1540 pop_abi_namespace ();
1541 if (!COMPLETE_TYPE_P (bltn_type
))
1543 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1544 if (!dtor
|| DECL_EXTERNAL (dtor
))
1547 for (ix
= 0; fundamentals
[ix
]; ix
++)
1548 emit_support_tinfo_1 (*fundamentals
[ix
]);
1551 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1552 tinfo decl. Determine whether it needs emitting, and if so
1553 generate the initializer. */
1556 emit_tinfo_decl (tree decl
)
1558 tree type
= TREE_TYPE (DECL_NAME (decl
));
1559 int in_library
= typeinfo_in_lib_p (type
);
1561 gcc_assert (DECL_TINFO_P (decl
));
1566 DECL_EXTERNAL (decl
) = 0;
1569 /* If we're not in the runtime, then DECL (which is already
1570 DECL_EXTERNAL) will not be defined here. */
1571 DECL_INTERFACE_KNOWN (decl
) = 1;
1575 else if (involves_incomplete_p (type
))
1577 if (!decl_needed_p (decl
))
1579 /* If TYPE involves an incomplete class type, then the typeinfo
1580 object will be emitted with internal linkage. There is no
1581 way to know whether or not types are incomplete until the end
1582 of the compilation, so this determination must be deferred
1583 until this point. */
1584 TREE_PUBLIC (decl
) = 0;
1585 DECL_EXTERNAL (decl
) = 0;
1586 DECL_INTERFACE_KNOWN (decl
) = 1;
1589 import_export_decl (decl
);
1590 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1594 DECL_EXTERNAL (decl
) = 0;
1595 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1596 DECL_INITIAL (decl
) = init
;
1598 cp_finish_decl (decl
, init
, false, NULL_TREE
, 0);
1605 #include "gt-cp-rtti.h"