1 /* RunTime Type Identification
2 Copyright (C) 1995-2016 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"
27 #include "stringpool.h"
29 #include "stor-layout.h"
30 #include "c-family/c-pragma.h"
32 /* C++ returns type information to the user in struct type_info
33 objects. We also use type information to implement dynamic_cast and
34 exception handlers. Type information for a particular type is
35 indicated with an ABI defined structure derived from type_info.
36 This would all be very straight forward, but for the fact that the
37 runtime library provides the definitions of the type_info structure
38 and the ABI defined derived classes. We cannot build declarations
39 of them directly in the compiler, but we need to layout objects of
40 their type. Somewhere we have to lie.
42 We define layout compatible POD-structs with compiler-defined names
43 and generate the appropriate initializations for them (complete
44 with explicit mention of their vtable). When we have to provide a
45 type_info to the user we reinterpret_cast the internal compiler
46 type to type_info. A well formed program can only explicitly refer
47 to the type_infos of complete types (& cv void). However, we chain
48 pointer type_infos to the pointed-to-type, and that can be
49 incomplete. We only need the addresses of such incomplete
50 type_info objects for static initialization.
52 The type information VAR_DECL of a type is held on the
53 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
54 will be the internal type. It will usually have the correct
55 internal type reflecting the kind of type it represents (pointer,
56 array, function, class, inherited class, etc). When the type it
57 represents is incomplete, it will have the internal type
58 corresponding to type_info. That will only happen at the end of
59 translation, when we are emitting the type info objects. */
61 /* Auxiliary data we hold for each type_info derived object we need. */
62 struct GTY (()) tinfo_s
{
63 tree type
; /* The RECORD_TYPE for this type_info object */
65 tree vtable
; /* The VAR_DECL of the vtable. Only filled at end of
68 tree name
; /* IDENTIFIER_NODE for the ABI specified name of
69 the type_info derived type. */
75 TK_TYPE_INFO_TYPE
, /* abi::__type_info_pseudo */
76 TK_BASE_TYPE
, /* abi::__base_class_type_info */
77 TK_BUILTIN_TYPE
, /* abi::__fundamental_type_info */
78 TK_ARRAY_TYPE
, /* abi::__array_type_info */
79 TK_FUNCTION_TYPE
, /* abi::__function_type_info */
80 TK_ENUMERAL_TYPE
, /* abi::__enum_type_info */
81 TK_POINTER_TYPE
, /* abi::__pointer_type_info */
82 TK_POINTER_MEMBER_TYPE
, /* abi::__pointer_to_member_type_info */
83 TK_CLASS_TYPE
, /* abi::__class_type_info */
84 TK_SI_CLASS_TYPE
, /* abi::__si_class_type_info */
85 TK_FIXED
/* end of fixed descriptors. */
86 /* ... abi::__vmi_type_info<I> */
89 /* Helper macro to get maximum scalar-width of pointer or of the 'long'-type.
90 This of interest for llp64 targets. */
92 integer_types[(POINTER_SIZE <= TYPE_PRECISION (integer_types[itk_long]) \
93 ? itk_long : itk_long_long)]
95 /* A vector of all tinfo decls that haven't yet been emitted. */
96 vec
<tree
, va_gc
> *unemitted_tinfo_decls
;
98 /* A vector of all type_info derived types we need. The first few are
99 fixed and created early. The remainder are for multiple inheritance
100 and are generated as needed. */
101 static GTY (()) vec
<tinfo_s
, va_gc
> *tinfo_descs
;
103 static tree
ifnonnull (tree
, tree
, tsubst_flags_t
);
104 static tree
tinfo_name (tree
, bool);
105 static tree
build_dynamic_cast_1 (tree
, tree
, tsubst_flags_t
);
106 static tree
throw_bad_cast (void);
107 static tree
throw_bad_typeid (void);
108 static tree
get_tinfo_ptr (tree
);
109 static bool typeid_ok_p (void);
110 static int qualifier_flags (tree
);
111 static bool target_incomplete_p (tree
);
112 static tree
tinfo_base_init (tinfo_s
*, tree
);
113 static tree
generic_initializer (tinfo_s
*, tree
);
114 static tree
ptr_initializer (tinfo_s
*, tree
);
115 static tree
ptm_initializer (tinfo_s
*, tree
);
116 static tree
class_initializer (tinfo_s
*, tree
, unsigned, ...);
117 static void create_pseudo_type_info (int, const char *, ...);
118 static tree
get_pseudo_ti_init (tree
, unsigned);
119 static unsigned get_pseudo_ti_index (tree
);
120 static void create_tinfo_types (void);
121 static bool typeinfo_in_lib_p (tree
);
123 static int doing_runtime
= 0;
126 push_abi_namespace (void)
128 push_nested_namespace (abi_node
);
129 push_visibility ("default", 2);
133 pop_abi_namespace (void)
136 pop_nested_namespace (abi_node
);
139 /* Declare language defined type_info type and a pointer to const
140 type_info. This is incomplete here, and will be completed when
141 the user #includes <typeinfo>. There are language defined
142 restrictions on what can be done until that is included. Create
143 the internal versions of the ABI types. */
146 init_rtti_processing (void)
150 push_namespace (std_identifier
);
151 type_info_type
= xref_tag (class_type
, get_identifier ("type_info"),
152 /*tag_scope=*/ts_current
, false);
154 const_type_info_type_node
155 = cp_build_qualified_type (type_info_type
, TYPE_QUAL_CONST
);
156 type_info_ptr_type
= build_pointer_type (const_type_info_type_node
);
158 vec_alloc (unemitted_tinfo_decls
, 124);
160 create_tinfo_types ();
163 /* Given the expression EXP of type `class *', return the head of the
164 object pointed to by EXP with type cv void*, if the class has any
165 virtual functions (TYPE_POLYMORPHIC_P), else just return the
169 build_headof (tree exp
)
171 tree type
= TREE_TYPE (exp
);
175 gcc_assert (TYPE_PTR_P (type
));
176 type
= TREE_TYPE (type
);
178 if (!TYPE_POLYMORPHIC_P (type
))
181 /* We use this a couple of times below, protect it. */
182 exp
= save_expr (exp
);
184 /* The offset-to-top field is at index -2 from the vptr. */
185 index
= build_int_cst (NULL_TREE
,
186 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
188 offset
= build_vtbl_ref (cp_build_indirect_ref (exp
, RO_NULL
,
189 tf_warning_or_error
),
192 type
= cp_build_qualified_type (ptr_type_node
,
193 cp_type_quals (TREE_TYPE (exp
)));
194 return fold_build_pointer_plus (exp
, offset
);
197 /* Get a bad_cast node for the program to throw...
199 See libstdc++/exception.cc for __throw_bad_cast */
202 throw_bad_cast (void)
204 tree fn
= get_identifier ("__cxa_bad_cast");
205 if (!get_global_value_if_present (fn
, &fn
))
206 fn
= push_throw_library_fn (fn
, build_function_type_list (ptr_type_node
,
209 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
212 /* Return an expression for "__cxa_bad_typeid()". The expression
213 returned is an lvalue of type "const std::type_info". */
216 throw_bad_typeid (void)
218 tree fn
= get_identifier ("__cxa_bad_typeid");
219 if (!get_global_value_if_present (fn
, &fn
))
223 t
= build_reference_type (const_type_info_type_node
);
224 t
= build_function_type_list (t
, NULL_TREE
);
225 fn
= push_throw_library_fn (fn
, t
);
228 return build_cxx_call (fn
, 0, NULL
, tf_warning_or_error
);
231 /* Return an lvalue expression whose type is "const std::type_info"
232 and whose value indicates the type of the expression EXP. If EXP
233 is a reference to a polymorphic class, return the dynamic type;
234 otherwise return the static type of the expression. */
237 get_tinfo_decl_dynamic (tree exp
, tsubst_flags_t complain
)
242 if (error_operand_p (exp
))
243 return error_mark_node
;
245 exp
= resolve_nondeduced_context (exp
, complain
);
247 /* peel back references, so they match. */
248 type
= non_reference (TREE_TYPE (exp
));
250 /* Peel off cv qualifiers. */
251 type
= TYPE_MAIN_VARIANT (type
);
253 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
254 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
255 || type
== init_list_type_node
)
256 type
= complete_type_or_maybe_complain (type
, exp
, complain
);
259 return error_mark_node
;
261 /* If exp is a reference to polymorphic type, get the real type_info. */
262 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
264 /* build reference to type_info from vtable. */
267 /* The RTTI information is at index -1. */
268 index
= build_int_cst (NULL_TREE
,
269 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
270 t
= build_vtbl_ref (exp
, index
);
271 t
= convert (type_info_ptr_type
, t
);
274 /* Otherwise return the type_info for the static type of the expr. */
275 t
= get_tinfo_ptr (TYPE_MAIN_VARIANT (type
));
277 return cp_build_indirect_ref (t
, RO_NULL
, complain
);
283 tree pseudo_type_info
, type_info_type
;
287 error ("cannot use typeid with -fno-rtti");
291 if (!COMPLETE_TYPE_P (const_type_info_type_node
))
293 error ("must #include <typeinfo> before using typeid");
297 pseudo_type_info
= (*tinfo_descs
)[TK_TYPE_INFO_TYPE
].type
;
298 type_info_type
= TYPE_MAIN_VARIANT (const_type_info_type_node
);
300 /* Make sure abi::__type_info_pseudo has the same alias set
301 as std::type_info. */
302 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info
))
303 TYPE_ALIAS_SET (pseudo_type_info
) = get_alias_set (type_info_type
);
305 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info
)
306 == get_alias_set (type_info_type
));
311 /* Return an expression for "typeid(EXP)". The expression returned is
312 an lvalue of type "const std::type_info". */
315 build_typeid (tree exp
, tsubst_flags_t complain
)
317 tree cond
= NULL_TREE
, initial_expr
= exp
;
320 if (exp
== error_mark_node
|| !typeid_ok_p ())
321 return error_mark_node
;
323 if (processing_template_decl
)
324 return build_min (TYPEID_EXPR
, const_type_info_type_node
, exp
);
326 /* FIXME when integrating with c_fully_fold, mark
327 resolves_to_fixed_type_p case as a non-constant expression. */
328 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
329 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
332 /* So we need to look into the vtable of the type of exp.
333 Make sure it isn't a null lvalue. */
334 exp
= cp_build_addr_expr (exp
, complain
);
335 exp
= save_expr (exp
);
336 cond
= cp_convert (boolean_type_node
, exp
, complain
);
337 exp
= cp_build_indirect_ref (exp
, RO_NULL
, complain
);
340 exp
= get_tinfo_decl_dynamic (exp
, complain
);
342 if (exp
== error_mark_node
)
343 return error_mark_node
;
347 tree bad
= throw_bad_typeid ();
349 exp
= build3 (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
352 mark_type_use (initial_expr
);
357 /* Generate the NTBS name of a type. If MARK_PRIVATE, put a '*' in front so that
358 comparisons will be done by pointer rather than string comparison. */
360 tinfo_name (tree type
, bool mark_private
)
366 name
= mangle_type_string (type
);
367 length
= strlen (name
);
371 /* Inject '*' at beginning of name to force pointer comparison. */
372 char* buf
= (char*) XALLOCAVEC (char, length
+ 2);
374 memcpy (buf
+ 1, name
, length
+ 1);
375 name_string
= build_string (length
+ 2, buf
);
378 name_string
= build_string (length
+ 1, name
);
380 return fix_string_type (name_string
);
383 /* Return a VAR_DECL for the internal ABI defined type_info object for
384 TYPE. You must arrange that the decl is mark_used, if actually use
385 it --- decls in vtables are only used if the vtable is output. */
388 get_tinfo_decl (tree type
)
393 if (variably_modified_type_p (type
, /*fn=*/NULL_TREE
))
395 error ("cannot create type information for type %qT because "
396 "it involves types of variable size",
398 return error_mark_node
;
401 if (TREE_CODE (type
) == METHOD_TYPE
)
402 type
= build_function_type (TREE_TYPE (type
),
403 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
405 type
= complete_type (type
);
407 /* For a class type, the variable is cached in the type node
409 if (CLASS_TYPE_P (type
))
411 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
416 name
= mangle_typeinfo_for_type (type
);
418 d
= IDENTIFIER_GLOBAL_VALUE (name
);
421 int ix
= get_pseudo_ti_index (type
);
422 tinfo_s
*ti
= &(*tinfo_descs
)[ix
];
424 d
= build_lang_decl (VAR_DECL
, name
, ti
->type
);
425 SET_DECL_ASSEMBLER_NAME (d
, name
);
426 /* Remember the type it is for. */
427 TREE_TYPE (name
) = type
;
428 DECL_TINFO_P (d
) = 1;
429 DECL_ARTIFICIAL (d
) = 1;
430 DECL_IGNORED_P (d
) = 1;
431 TREE_READONLY (d
) = 1;
433 /* Mark the variable as undefined -- but remember that we can
434 define it later if we need to do so. */
435 DECL_EXTERNAL (d
) = 1;
436 DECL_NOT_REALLY_EXTERN (d
) = 1;
437 set_linkage_according_to_type (type
, d
);
439 d
= pushdecl_top_level_and_finish (d
, NULL_TREE
);
440 if (CLASS_TYPE_P (type
))
441 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
443 /* Add decl to the global array of tinfo decls. */
444 vec_safe_push (unemitted_tinfo_decls
, d
);
450 /* Return a pointer to a type_info object describing TYPE, suitably
451 cast to the language defined type. */
454 get_tinfo_ptr (tree type
)
456 tree decl
= get_tinfo_decl (type
);
459 return build_nop (type_info_ptr_type
,
460 build_address (decl
));
463 /* Return the type_info object for TYPE. */
466 get_typeid (tree type
, tsubst_flags_t complain
)
468 if (type
== error_mark_node
|| !typeid_ok_p ())
469 return error_mark_node
;
471 if (processing_template_decl
)
472 return build_min (TYPEID_EXPR
, const_type_info_type_node
, type
);
474 /* If the type of the type-id is a reference type, the result of the
475 typeid expression refers to a type_info object representing the
477 type
= non_reference (type
);
479 /* This is not one of the uses of a qualified function type in 8.3.5. */
480 if (TREE_CODE (type
) == FUNCTION_TYPE
481 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
482 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
484 if (complain
& tf_error
)
485 error ("typeid of qualified function type %qT", type
);
486 return error_mark_node
;
489 /* The top-level cv-qualifiers of the lvalue expression or the type-id
490 that is the operand of typeid are always ignored. */
491 type
= TYPE_MAIN_VARIANT (type
);
493 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
494 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
495 || type
== init_list_type_node
)
496 type
= complete_type_or_maybe_complain (type
, NULL_TREE
, complain
);
499 return error_mark_node
;
501 return cp_build_indirect_ref (get_tinfo_ptr (type
), RO_NULL
, complain
);
504 /* Check whether TEST is null before returning RESULT. If TEST is used in
505 RESULT, it must have previously had a save_expr applied to it. */
508 ifnonnull (tree test
, tree result
, tsubst_flags_t complain
)
510 tree cond
= build2 (NE_EXPR
, boolean_type_node
, test
,
511 cp_convert (TREE_TYPE (test
), nullptr_node
, complain
));
512 /* This is a compiler generated comparison, don't emit
513 e.g. -Wnonnull-compare warning for it. */
514 TREE_NO_WARNING (cond
) = 1;
515 return build3 (COND_EXPR
, TREE_TYPE (result
), cond
, result
,
516 cp_convert (TREE_TYPE (result
), nullptr_node
, complain
));
519 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
523 build_dynamic_cast_1 (tree type
, tree expr
, tsubst_flags_t complain
)
525 enum tree_code tc
= TREE_CODE (type
);
528 tree old_expr
= expr
;
529 const char *errstr
= NULL
;
531 /* Save casted types in the function's used types hash table. */
532 used_types_insert (type
);
534 /* T shall be a pointer or reference to a complete class type, or
535 `pointer to cv void''. */
539 if (VOID_TYPE_P (TREE_TYPE (type
)))
543 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
545 errstr
= _("target is not pointer or reference to class");
548 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
550 errstr
= _("target is not pointer or reference to complete type");
556 errstr
= _("target is not pointer or reference");
560 if (tc
== POINTER_TYPE
)
562 expr
= decay_conversion (expr
, complain
);
563 exprtype
= TREE_TYPE (expr
);
565 /* If T is a pointer type, v shall be an rvalue of a pointer to
566 complete class type, and the result is an rvalue of type T. */
568 expr
= mark_rvalue_use (expr
);
570 if (!TYPE_PTR_P (exprtype
))
572 errstr
= _("source is not a pointer");
575 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
577 errstr
= _("source is not a pointer to class");
580 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
582 errstr
= _("source is a pointer to incomplete type");
588 expr
= mark_lvalue_use (expr
);
590 exprtype
= build_reference_type (TREE_TYPE (expr
));
592 /* T is a reference type, v shall be an lvalue of a complete class
593 type, and the result is an lvalue of the type referred to by T. */
595 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
597 errstr
= _("source is not of class type");
600 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
602 errstr
= _("source is of incomplete class type");
607 /* The dynamic_cast operator shall not cast away constness. */
608 if (!at_least_as_qualified_p (TREE_TYPE (type
),
609 TREE_TYPE (exprtype
)))
611 errstr
= _("conversion casts away constness");
615 /* If *type is an unambiguous accessible base class of *exprtype,
616 convert statically. */
618 tree binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
619 ba_check
, NULL
, complain
);
621 return build_static_cast (type
, expr
, complain
);
624 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
625 if (tc
== REFERENCE_TYPE
)
626 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
627 LOOKUP_NORMAL
, NULL_TREE
, complain
);
629 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
630 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
633 /* if TYPE is `void *', return pointer to complete object. */
634 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
636 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
637 if (TREE_CODE (expr
) == ADDR_EXPR
638 && VAR_P (TREE_OPERAND (expr
, 0))
639 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
640 return build1 (NOP_EXPR
, type
, expr
);
642 /* Since expr is used twice below, save it. */
643 expr
= save_expr (expr
);
645 expr1
= build_headof (expr
);
646 if (TREE_TYPE (expr1
) != type
)
647 expr1
= build1 (NOP_EXPR
, type
, expr1
);
648 return ifnonnull (expr
, expr1
, complain
);
653 tree result
, td2
, td3
;
655 tree static_type
, target_type
, boff
;
657 /* If we got here, we can't convert statically. Therefore,
658 dynamic_cast<D&>(b) (b an object) cannot succeed. */
659 if (tc
== REFERENCE_TYPE
)
662 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
664 tree expr
= throw_bad_cast ();
665 if (complain
& tf_warning
)
666 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
668 /* Bash it to the expected type. */
669 TREE_TYPE (expr
) = type
;
673 /* Ditto for dynamic_cast<D*>(&b). */
674 else if (TREE_CODE (expr
) == ADDR_EXPR
)
676 tree op
= TREE_OPERAND (expr
, 0);
678 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
680 if (complain
& tf_warning
)
681 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
683 retval
= build_int_cst (type
, 0);
688 /* Use of dynamic_cast when -fno-rtti is prohibited. */
691 if (complain
& tf_error
)
692 error ("%<dynamic_cast%> not permitted with -fno-rtti");
693 return error_mark_node
;
696 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
697 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
698 td2
= get_tinfo_decl (target_type
);
699 if (!mark_used (td2
, complain
) && !(complain
& tf_error
))
700 return error_mark_node
;
701 td2
= cp_build_addr_expr (td2
, complain
);
702 td3
= get_tinfo_decl (static_type
);
703 if (!mark_used (td3
, complain
) && !(complain
& tf_error
))
704 return error_mark_node
;
705 td3
= cp_build_addr_expr (td3
, complain
);
707 /* Determine how T and V are related. */
708 boff
= dcast_base_hint (static_type
, target_type
);
710 /* Since expr is used twice below, save it. */
711 expr
= save_expr (expr
);
714 if (tc
== REFERENCE_TYPE
)
715 expr1
= cp_build_addr_expr (expr1
, complain
);
722 dcast_fn
= dynamic_cast_node
;
729 push_abi_namespace ();
730 tinfo_ptr
= xref_tag (class_type
,
731 get_identifier ("__class_type_info"),
732 /*tag_scope=*/ts_current
, false);
734 tinfo_ptr
= build_pointer_type
735 (cp_build_qualified_type
736 (tinfo_ptr
, TYPE_QUAL_CONST
));
737 name
= "__dynamic_cast";
738 tmp
= build_function_type_list (ptr_type_node
,
740 tinfo_ptr
, tinfo_ptr
,
741 ptrdiff_type_node
, NULL_TREE
);
742 dcast_fn
= build_library_fn_ptr (name
, tmp
,
743 ECF_LEAF
| ECF_PURE
| ECF_NOTHROW
);
744 pop_abi_namespace ();
745 dynamic_cast_node
= dcast_fn
;
747 result
= build_cxx_call (dcast_fn
, 4, elems
, complain
);
749 if (tc
== REFERENCE_TYPE
)
751 tree bad
= throw_bad_cast ();
754 result
= save_expr (result
);
755 neq
= cp_truthvalue_conversion (result
);
756 return cp_convert (type
,
757 build3 (COND_EXPR
, TREE_TYPE (result
),
758 neq
, result
, bad
), complain
);
761 /* Now back to the type we want from a void*. */
762 result
= cp_convert (type
, result
, complain
);
763 return ifnonnull (expr
, result
, complain
);
767 errstr
= _("source type is not polymorphic");
770 if (complain
& tf_error
)
771 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
772 old_expr
, TREE_TYPE (old_expr
), type
, errstr
);
773 return error_mark_node
;
777 build_dynamic_cast (tree type
, tree expr
, tsubst_flags_t complain
)
781 if (type
== error_mark_node
|| expr
== error_mark_node
)
782 return error_mark_node
;
784 if (processing_template_decl
)
786 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
787 TREE_SIDE_EFFECTS (expr
) = 1;
788 return convert_from_reference (expr
);
791 r
= convert_from_reference (build_dynamic_cast_1 (type
, expr
, complain
));
792 if (r
!= error_mark_node
)
793 maybe_warn_about_useless_cast (type
, expr
, complain
);
797 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
800 qualifier_flags (tree type
)
803 int quals
= cp_type_quals (type
);
805 if (quals
& TYPE_QUAL_CONST
)
807 if (quals
& TYPE_QUAL_VOLATILE
)
809 if (quals
& TYPE_QUAL_RESTRICT
)
814 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
815 contains a pointer to member of an incomplete class. */
818 target_incomplete_p (tree type
)
821 if (TYPE_PTRDATAMEM_P (type
))
823 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
825 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
827 else if (TYPE_PTR_P (type
))
828 type
= TREE_TYPE (type
);
830 return !COMPLETE_OR_VOID_TYPE_P (type
);
833 /* Returns true if TYPE involves an incomplete class type; in that
834 case, typeinfo variables for TYPE should be emitted with internal
838 involves_incomplete_p (tree type
)
840 switch (TREE_CODE (type
))
843 return target_incomplete_p (TREE_TYPE (type
));
848 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
849 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
852 if (TYPE_PTRMEMFUNC_P (type
))
856 if (!COMPLETE_TYPE_P (type
))
860 /* All other types do not involve incomplete class types. */
865 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
866 is the vtable pointer and NTBS name. The NTBS name is emitted as a
867 comdat const char array, so it becomes a unique key for the type. Generate
868 and emit that VAR_DECL here. (We can't always emit the type_info itself
869 as comdat, because of pointers to incomplete.) */
872 tinfo_base_init (tinfo_s
*ti
, tree target
)
877 vec
<constructor_elt
, va_gc
> *v
;
880 tree name_name
, name_string
;
882 /* Generate the NTBS array variable. */
883 tree name_type
= build_cplus_array_type
884 (cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
887 /* Determine the name of the variable -- and remember with which
888 type it is associated. */
889 name_name
= mangle_typeinfo_string_for_type (target
);
890 TREE_TYPE (name_name
) = target
;
892 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
893 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
894 DECL_ARTIFICIAL (name_decl
) = 1;
895 DECL_IGNORED_P (name_decl
) = 1;
896 TREE_READONLY (name_decl
) = 1;
897 TREE_STATIC (name_decl
) = 1;
898 DECL_EXTERNAL (name_decl
) = 0;
899 DECL_TINFO_P (name_decl
) = 1;
900 set_linkage_according_to_type (target
, name_decl
);
901 import_export_decl (name_decl
);
902 name_string
= tinfo_name (target
, !TREE_PUBLIC (name_decl
));
903 DECL_INITIAL (name_decl
) = name_string
;
904 mark_used (name_decl
);
905 pushdecl_top_level_and_finish (name_decl
, name_string
);
908 vtable_ptr
= ti
->vtable
;
912 push_abi_namespace ();
913 real_type
= xref_tag (class_type
, ti
->name
,
914 /*tag_scope=*/ts_current
, false);
915 pop_abi_namespace ();
917 if (!COMPLETE_TYPE_P (real_type
))
919 /* We never saw a definition of this type, so we need to
920 tell the compiler that this is an exported class, as
921 indeed all of the __*_type_info classes are. */
922 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
923 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
926 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
927 vtable_ptr
= cp_build_addr_expr (vtable_ptr
, tf_warning_or_error
);
929 /* We need to point into the middle of the vtable. */
930 vtable_ptr
= fold_build_pointer_plus
932 size_binop (MULT_EXPR
,
933 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
934 TYPE_SIZE_UNIT (vtable_entry_type
)));
936 ti
->vtable
= vtable_ptr
;
940 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, vtable_ptr
);
941 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
942 decay_conversion (name_decl
, tf_warning_or_error
));
944 init
= build_constructor (init_list_type_node
, v
);
945 TREE_CONSTANT (init
) = 1;
946 TREE_STATIC (init
) = 1;
951 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
952 information about the particular type_info derivation, which adds no
953 additional fields to the type_info base. */
956 generic_initializer (tinfo_s
*ti
, tree target
)
958 tree init
= tinfo_base_init (ti
, target
);
960 init
= build_constructor_single (init_list_type_node
, NULL_TREE
, init
);
961 TREE_CONSTANT (init
) = 1;
962 TREE_STATIC (init
) = 1;
966 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
967 TI provides information about the particular type_info derivation,
968 which adds target type and qualifier flags members to the type_info base. */
971 ptr_initializer (tinfo_s
*ti
, tree target
)
973 tree init
= tinfo_base_init (ti
, target
);
974 tree to
= TREE_TYPE (target
);
975 int flags
= qualifier_flags (to
);
976 bool incomplete
= target_incomplete_p (to
);
977 vec
<constructor_elt
, va_gc
> *v
;
982 if (tx_safe_fn_type_p (to
))
985 to
= tx_unsafe_fn_variant (to
);
987 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
988 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
989 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
990 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
992 init
= build_constructor (init_list_type_node
, v
);
993 TREE_CONSTANT (init
) = 1;
994 TREE_STATIC (init
) = 1;
998 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
999 TI provides information about the particular type_info derivation,
1000 which adds class, target type and qualifier flags members to the type_info
1004 ptm_initializer (tinfo_s
*ti
, tree target
)
1006 tree init
= tinfo_base_init (ti
, target
);
1007 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
1008 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
1009 int flags
= qualifier_flags (to
);
1010 bool incomplete
= target_incomplete_p (to
);
1011 vec
<constructor_elt
, va_gc
> *v
;
1016 if (!COMPLETE_TYPE_P (klass
))
1018 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1019 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
1020 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
1021 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
1022 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, get_tinfo_ptr (klass
));
1024 init
= build_constructor (init_list_type_node
, v
);
1025 TREE_CONSTANT (init
) = 1;
1026 TREE_STATIC (init
) = 1;
1030 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1031 TI provides information about the particular __class_type_info derivation,
1032 which adds hint flags and N extra initializers to the type_info base. */
1035 class_initializer (tinfo_s
*ti
, tree target
, unsigned n
, ...)
1037 tree init
= tinfo_base_init (ti
, target
);
1038 va_list extra_inits
;
1040 vec
<constructor_elt
, va_gc
> *v
;
1043 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1044 va_start (extra_inits
, n
);
1045 for (i
= 0; i
< n
; i
++)
1046 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, va_arg (extra_inits
, tree
));
1047 va_end (extra_inits
);
1049 init
= build_constructor (init_list_type_node
, v
);
1050 TREE_CONSTANT (init
) = 1;
1051 TREE_STATIC (init
) = 1;
1055 /* Returns true if the typeinfo for type should be placed in
1056 the runtime library. */
1059 typeinfo_in_lib_p (tree type
)
1061 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1062 library for simple types T. */
1063 if (TYPE_PTR_P (type
)
1064 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
1065 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
1066 type
= TREE_TYPE (type
);
1068 switch (TREE_CODE (type
))
1085 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1086 the index of the descriptor in the tinfo_desc vector. */
1089 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1091 tinfo_s
*ti
= &(*tinfo_descs
)[tk_index
];
1093 gcc_assert (at_eof
);
1096 case TK_POINTER_MEMBER_TYPE
:
1097 return ptm_initializer (ti
, type
);
1099 case TK_POINTER_TYPE
:
1100 return ptr_initializer (ti
, type
);
1102 case TK_BUILTIN_TYPE
:
1103 case TK_ENUMERAL_TYPE
:
1104 case TK_FUNCTION_TYPE
:
1106 return generic_initializer (ti
, type
);
1109 return class_initializer (ti
, type
, 0);
1111 case TK_SI_CLASS_TYPE
:
1113 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1114 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1116 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1117 ti
= &(*tinfo_descs
)[tk_index
];
1118 return class_initializer (ti
, type
, 1, tinfo
);
1123 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1124 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1125 tree binfo
= TYPE_BINFO (type
);
1126 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1127 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1128 tree offset_type
= LONGPTR_T
;
1129 tree base_inits
= NULL_TREE
;
1131 vec
<constructor_elt
, va_gc
> *init_vec
= NULL
;
1134 gcc_assert (tk_index
>= TK_FIXED
);
1136 vec_safe_grow (init_vec
, nbases
);
1137 /* Generate the base information initializer. */
1138 for (ix
= nbases
; ix
--;)
1140 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1145 vec
<constructor_elt
, va_gc
> *v
;
1147 if ((*base_accesses
)[ix
] == access_public_node
)
1149 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1150 if (BINFO_VIRTUAL_P (base_binfo
))
1152 /* We store the vtable offset at which the virtual
1153 base offset can be found. */
1154 offset
= BINFO_VPTR_FIELD (base_binfo
);
1158 offset
= BINFO_OFFSET (base_binfo
);
1160 /* Combine offset and flags into one field. */
1161 offset
= fold_convert (offset_type
, offset
);
1162 offset
= fold_build2_loc (input_location
,
1163 LSHIFT_EXPR
, offset_type
, offset
,
1164 build_int_cst (offset_type
, 8));
1165 offset
= fold_build2_loc (input_location
,
1166 BIT_IOR_EXPR
, offset_type
, offset
,
1167 build_int_cst (offset_type
, flags
));
1169 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, tinfo
);
1170 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, offset
);
1171 base_init
= build_constructor (init_list_type_node
, v
);
1172 e
= &(*init_vec
)[ix
];
1173 e
->index
= NULL_TREE
;
1174 e
->value
= base_init
;
1176 base_inits
= build_constructor (init_list_type_node
, init_vec
);
1178 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1179 ti
= &(*tinfo_descs
)[tk_index
];
1180 return class_initializer (ti
, type
, 3,
1181 build_int_cst (NULL_TREE
, hint
),
1182 build_int_cst (NULL_TREE
, nbases
),
1188 /* Generate the RECORD_TYPE containing the data layout of a type_info
1189 derivative as used by the runtime. This layout must be consistent with
1190 that defined in the runtime support. Also generate the VAR_DECL for the
1191 type's vtable. We explicitly manage the vtable member, and name it for
1192 real type as used in the runtime. The RECORD type has a different name,
1193 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1194 is the generated type and TINFO_VTABLE_NAME is the name of the
1195 vtable. We have to delay generating the VAR_DECL of the vtable
1196 until the end of the translation, when we'll have seen the library
1197 definition, if there was one.
1199 REAL_NAME is the runtime's name of the type. Trailing arguments are
1200 additional FIELD_DECL's for the structure. The final argument must be
1204 create_pseudo_type_info (int tk
, const char *real_name
, ...)
1213 va_start (ap
, real_name
);
1215 /* Generate the pseudo type name. */
1216 pseudo_name
= (char *) alloca (strlen (real_name
) + 30);
1217 strcpy (pseudo_name
, real_name
);
1218 strcat (pseudo_name
, "_pseudo");
1220 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", tk
- TK_FIXED
);
1222 /* First field is the pseudo type_info base class. */
1223 fields
= build_decl (input_location
,
1224 FIELD_DECL
, NULL_TREE
,
1225 (*tinfo_descs
)[TK_TYPE_INFO_TYPE
].type
);
1227 /* Now add the derived fields. */
1228 while ((field_decl
= va_arg (ap
, tree
)))
1230 DECL_CHAIN (field_decl
) = fields
;
1231 fields
= field_decl
;
1234 /* Create the pseudo type. */
1235 pseudo_type
= make_class_type (RECORD_TYPE
);
1236 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1237 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1239 ti
= &(*tinfo_descs
)[tk
];
1240 ti
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1241 ti
->name
= get_identifier (real_name
);
1242 ti
->vtable
= NULL_TREE
;
1244 /* Pretend this is public so determine_visibility doesn't give vtables
1245 internal linkage. */
1246 TREE_PUBLIC (TYPE_MAIN_DECL (ti
->type
)) = 1;
1251 /* Return the index of a pseudo type info type node used to describe
1252 TYPE. TYPE must be a complete type (or cv void), except at the end
1253 of the translation unit. */
1256 get_pseudo_ti_index (tree type
)
1260 switch (TREE_CODE (type
))
1263 ix
= TK_POINTER_MEMBER_TYPE
;
1267 ix
= TK_POINTER_TYPE
;
1271 ix
= TK_ENUMERAL_TYPE
;
1275 ix
= TK_FUNCTION_TYPE
;
1284 if (TYPE_PTRMEMFUNC_P (type
))
1286 ix
= TK_POINTER_MEMBER_TYPE
;
1289 else if (!COMPLETE_TYPE_P (type
))
1292 cxx_incomplete_type_error (NULL_TREE
, type
);
1296 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1303 tree binfo
= TYPE_BINFO (type
);
1304 vec
<tree
, va_gc
> *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1305 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1306 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1309 && (*base_accesses
)[0] == access_public_node
1310 && !BINFO_VIRTUAL_P (base_binfo
)
1311 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1313 /* single non-virtual public. */
1314 ix
= TK_SI_CLASS_TYPE
;
1320 tree array_domain
, base_array
;
1322 ix
= TK_FIXED
+ num_bases
;
1323 if (vec_safe_length (tinfo_descs
) <= ix
)
1325 /* too short, extend. */
1326 unsigned len
= vec_safe_length (tinfo_descs
);
1328 vec_safe_grow (tinfo_descs
, ix
+ 1);
1329 while (tinfo_descs
->iterate (len
++, &ti
))
1330 ti
->type
= ti
->vtable
= ti
->name
= NULL_TREE
;
1332 else if ((*tinfo_descs
)[ix
].type
)
1333 /* already created. */
1336 /* Create the array of __base_class_type_info entries. */
1337 array_domain
= build_index_type (size_int (num_bases
- 1));
1338 base_array
= build_array_type ((*tinfo_descs
)[TK_BASE_TYPE
].type
,
1341 push_abi_namespace ();
1342 create_pseudo_type_info
1343 (ix
, "__vmi_class_type_info",
1344 build_decl (input_location
,
1345 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1346 build_decl (input_location
,
1347 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1348 build_decl (input_location
,
1349 FIELD_DECL
, NULL_TREE
, base_array
),
1351 pop_abi_namespace ();
1356 ix
= TK_BUILTIN_TYPE
;
1362 /* Make sure the required builtin types exist for generating the type_info
1363 variable definitions. */
1366 create_tinfo_types (void)
1370 gcc_assert (!tinfo_descs
);
1372 vec_safe_grow (tinfo_descs
, TK_FIXED
);
1374 push_abi_namespace ();
1376 /* Create the internal type_info structure. This is used as a base for
1377 the other structures. */
1381 field
= build_decl (BUILTINS_LOCATION
,
1382 FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1385 field
= build_decl (BUILTINS_LOCATION
,
1386 FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1387 DECL_CHAIN (field
) = fields
;
1390 ti
= &(*tinfo_descs
)[TK_TYPE_INFO_TYPE
];
1391 ti
->type
= make_class_type (RECORD_TYPE
);
1392 ti
->vtable
= NULL_TREE
;
1393 ti
->name
= NULL_TREE
;
1394 finish_builtin_struct (ti
->type
, "__type_info_pseudo",
1398 /* Fundamental type_info */
1399 create_pseudo_type_info (TK_BUILTIN_TYPE
, "__fundamental_type_info", NULL
);
1401 /* Array, function and enum type_info. No additional fields. */
1402 create_pseudo_type_info (TK_ARRAY_TYPE
, "__array_type_info", NULL
);
1403 create_pseudo_type_info (TK_FUNCTION_TYPE
, "__function_type_info", NULL
);
1404 create_pseudo_type_info (TK_ENUMERAL_TYPE
, "__enum_type_info", NULL
);
1406 /* Class type_info. No additional fields. */
1407 create_pseudo_type_info (TK_CLASS_TYPE
, "__class_type_info", NULL
);
1409 /* Single public non-virtual base class. Add pointer to base class.
1410 This is really a descendant of __class_type_info. */
1411 create_pseudo_type_info (TK_SI_CLASS_TYPE
, "__si_class_type_info",
1412 build_decl (BUILTINS_LOCATION
,
1413 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1416 /* Base class internal helper. Pointer to base type, offset to base,
1421 field
= build_decl (BUILTINS_LOCATION
,
1422 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
);
1425 field
= build_decl (BUILTINS_LOCATION
,
1426 FIELD_DECL
, NULL_TREE
, LONGPTR_T
);
1427 DECL_CHAIN (field
) = fields
;
1430 ti
= &(*tinfo_descs
)[TK_BASE_TYPE
];
1432 ti
->type
= make_class_type (RECORD_TYPE
);
1433 ti
->vtable
= NULL_TREE
;
1434 ti
->name
= NULL_TREE
;
1435 finish_builtin_struct (ti
->type
, "__base_class_type_info_pseudo",
1439 /* Pointer type_info. Adds two fields, qualification mask
1440 and pointer to the pointed to type. This is really a descendant of
1441 __pbase_type_info. */
1442 create_pseudo_type_info (TK_POINTER_TYPE
, "__pointer_type_info",
1443 build_decl (BUILTINS_LOCATION
,
1444 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1445 build_decl (BUILTINS_LOCATION
,
1446 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1449 /* Pointer to member data type_info. Add qualifications flags,
1450 pointer to the member's type info and pointer to the class.
1451 This is really a descendant of __pbase_type_info. */
1452 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE
,
1453 "__pointer_to_member_type_info",
1454 build_decl (BUILTINS_LOCATION
,
1455 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1456 build_decl (BUILTINS_LOCATION
,
1457 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1458 build_decl (BUILTINS_LOCATION
,
1459 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1462 pop_abi_namespace ();
1465 /* Helper for emit_support_tinfos. Emits the type_info descriptor of
1469 emit_support_tinfo_1 (tree bltn
)
1473 if (bltn
== NULL_TREE
)
1476 types
[1] = build_pointer_type (bltn
);
1477 types
[2] = build_pointer_type (cp_build_qualified_type (bltn
,
1480 for (int i
= 0; i
< 3; ++i
)
1482 tree tinfo
= get_tinfo_decl (types
[i
]);
1483 TREE_USED (tinfo
) = 1;
1484 mark_needed (tinfo
);
1485 /* The C++ ABI requires that these objects be COMDAT. But,
1486 On systems without weak symbols, initialized COMDAT
1487 objects are emitted with internal linkage. (See
1488 comdat_linkage for details.) Since we want these objects
1489 to have external linkage so that copies do not have to be
1490 emitted in code outside the runtime library, we make them
1493 It might also not be necessary to follow this detail of the
1495 if (!flag_weak
|| ! targetm
.cxx
.library_rtti_comdat ())
1497 gcc_assert (TREE_PUBLIC (tinfo
) && !DECL_COMDAT (tinfo
));
1498 DECL_INTERFACE_KNOWN (tinfo
) = 1;
1503 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1504 support. Generating them here guarantees consistency with the other
1505 structures. We use the following heuristic to determine when the runtime
1506 is being generated. If std::__fundamental_type_info is defined, and its
1507 destructor is defined, then the runtime is being built. */
1510 emit_support_tinfos (void)
1512 /* Dummy static variable so we can put nullptr in the array; it will be
1513 set before we actually start to walk the array. */
1514 static tree
*const fundamentals
[] =
1518 &wchar_type_node
, &char16_type_node
, &char32_type_node
,
1519 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1520 &short_integer_type_node
, &short_unsigned_type_node
,
1521 &integer_type_node
, &unsigned_type_node
,
1522 &long_integer_type_node
, &long_unsigned_type_node
,
1523 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1524 &float_type_node
, &double_type_node
, &long_double_type_node
,
1525 &dfloat32_type_node
, &dfloat64_type_node
, &dfloat128_type_node
,
1530 tree bltn_type
, dtor
;
1532 push_abi_namespace ();
1533 bltn_type
= xref_tag (class_type
,
1534 get_identifier ("__fundamental_type_info"),
1535 /*tag_scope=*/ts_current
, false);
1536 pop_abi_namespace ();
1537 if (!COMPLETE_TYPE_P (bltn_type
))
1539 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1540 if (!dtor
|| DECL_EXTERNAL (dtor
))
1543 for (ix
= 0; fundamentals
[ix
]; ix
++)
1544 emit_support_tinfo_1 (*fundamentals
[ix
]);
1545 for (ix
= 0; ix
< NUM_INT_N_ENTS
; ix
++)
1546 if (int_n_enabled_p
[ix
])
1548 emit_support_tinfo_1 (int_n_trees
[ix
].signed_type
);
1549 emit_support_tinfo_1 (int_n_trees
[ix
].unsigned_type
);
1551 for (tree t
= registered_builtin_types
; t
; t
= TREE_CHAIN (t
))
1552 emit_support_tinfo_1 (TREE_VALUE (t
));
1555 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1556 tinfo decl. Determine whether it needs emitting, and if so
1557 generate the initializer. */
1560 emit_tinfo_decl (tree decl
)
1562 tree type
= TREE_TYPE (DECL_NAME (decl
));
1563 int in_library
= typeinfo_in_lib_p (type
);
1565 gcc_assert (DECL_TINFO_P (decl
));
1570 DECL_EXTERNAL (decl
) = 0;
1573 /* If we're not in the runtime, then DECL (which is already
1574 DECL_EXTERNAL) will not be defined here. */
1575 DECL_INTERFACE_KNOWN (decl
) = 1;
1579 else if (involves_incomplete_p (type
))
1581 if (!decl_needed_p (decl
))
1583 /* If TYPE involves an incomplete class type, then the typeinfo
1584 object will be emitted with internal linkage. There is no
1585 way to know whether or not types are incomplete until the end
1586 of the compilation, so this determination must be deferred
1587 until this point. */
1588 TREE_PUBLIC (decl
) = 0;
1589 DECL_EXTERNAL (decl
) = 0;
1590 DECL_INTERFACE_KNOWN (decl
) = 1;
1593 import_export_decl (decl
);
1594 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1598 DECL_EXTERNAL (decl
) = 0;
1599 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1600 DECL_INITIAL (decl
) = init
;
1602 cp_finish_decl (decl
, init
, false, NULL_TREE
, 0);
1603 /* Avoid targets optionally bumping up the alignment to improve
1604 vector instruction accesses, tinfo are never accessed this way. */
1605 #ifdef DATA_ABI_ALIGNMENT
1606 SET_DECL_ALIGN (decl
, DATA_ABI_ALIGNMENT (decl
, TYPE_ALIGN (TREE_TYPE (decl
))));
1607 DECL_USER_ALIGN (decl
) = true;
1615 #include "gt-cp-rtti.h"