1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Mostly written by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.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 DEF_VEC_ALLOC_O(tinfo_s
,gc
);
78 typedef enum tinfo_kind
80 TK_TYPE_INFO_TYPE
, /* abi::__type_info_pseudo */
81 TK_BASE_TYPE
, /* abi::__base_class_type_info */
82 TK_BUILTIN_TYPE
, /* abi::__fundamental_type_info */
83 TK_ARRAY_TYPE
, /* abi::__array_type_info */
84 TK_FUNCTION_TYPE
, /* abi::__function_type_info */
85 TK_ENUMERAL_TYPE
, /* abi::__enum_type_info */
86 TK_POINTER_TYPE
, /* abi::__pointer_type_info */
87 TK_POINTER_MEMBER_TYPE
, /* abi::__pointer_to_member_type_info */
88 TK_CLASS_TYPE
, /* abi::__class_type_info */
89 TK_SI_CLASS_TYPE
, /* abi::__si_class_type_info */
90 TK_FIXED
/* end of fixed descriptors. */
91 /* ... abi::__vmi_type_info<I> */
94 /* A vector of all tinfo decls that haven't yet been emitted. */
95 VEC(tree
,gc
) *unemitted_tinfo_decls
;
97 /* A vector of all type_info derived types we need. The first few are
98 fixed and created early. The remainder are for multiple inheritance
99 and are generated as needed. */
100 static GTY (()) VEC(tinfo_s
,gc
) *tinfo_descs
;
102 static tree
ifnonnull (tree
, tree
);
103 static tree
tinfo_name (tree
, bool);
104 static tree
build_dynamic_cast_1 (tree
, tree
, tsubst_flags_t
);
105 static tree
throw_bad_cast (void);
106 static tree
throw_bad_typeid (void);
107 static tree
get_tinfo_decl_dynamic (tree
);
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 unemitted_tinfo_decls
= VEC_alloc (tree
, gc
, 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 (TREE_CODE (type
) == POINTER_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
);
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
);
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
)
242 if (error_operand_p (exp
))
243 return error_mark_node
;
245 exp
= resolve_nondeduced_context (exp
);
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_else (type
, exp
);
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
, tf_warning_or_error
);
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");
298 = VEC_index (tinfo_s
, tinfo_descs
, TK_TYPE_INFO_TYPE
)->type
;
299 type_info_type
= TYPE_MAIN_VARIANT (const_type_info_type_node
);
301 /* Make sure abi::__type_info_pseudo has the same alias set
302 as std::type_info. */
303 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info
))
304 TYPE_ALIAS_SET (pseudo_type_info
) = get_alias_set (type_info_type
);
306 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info
)
307 == get_alias_set (type_info_type
));
312 /* Return an expression for "typeid(EXP)". The expression returned is
313 an lvalue of type "const std::type_info". */
316 build_typeid (tree exp
)
318 tree cond
= NULL_TREE
, initial_expr
= exp
;
321 if (exp
== error_mark_node
|| !typeid_ok_p ())
322 return error_mark_node
;
324 if (processing_template_decl
)
325 return build_min (TYPEID_EXPR
, const_type_info_type_node
, exp
);
327 /* FIXME when integrating with c_fully_fold, mark
328 resolves_to_fixed_type_p case as a non-constant expression. */
329 if (TREE_CODE (exp
) == INDIRECT_REF
330 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
331 && 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 This is an lvalue use of expr then. */
337 exp
= mark_lvalue_use (exp
);
338 exp
= stabilize_reference (exp
);
339 cond
= cp_convert (boolean_type_node
, TREE_OPERAND (exp
, 0));
342 exp
= get_tinfo_decl_dynamic (exp
);
344 if (exp
== error_mark_node
)
345 return error_mark_node
;
349 tree bad
= throw_bad_typeid ();
351 exp
= build3 (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
354 mark_type_use (initial_expr
);
359 /* Generate the NTBS name of a type. If MARK_PRIVATE, put a '*' in front so that
360 comparisons will be done by pointer rather than string comparison. */
362 tinfo_name (tree type
, bool mark_private
)
368 name
= mangle_type_string (type
);
369 length
= strlen (name
);
373 /* Inject '*' at beginning of name to force pointer comparison. */
374 char* buf
= (char*) XALLOCAVEC (char, length
+ 2);
376 memcpy (buf
+ 1, name
, length
+ 1);
377 name_string
= build_string (length
+ 2, buf
);
380 name_string
= build_string (length
+ 1, name
);
382 return fix_string_type (name_string
);
385 /* Return a VAR_DECL for the internal ABI defined type_info object for
386 TYPE. You must arrange that the decl is mark_used, if actually use
387 it --- decls in vtables are only used if the vtable is output. */
390 get_tinfo_decl (tree type
)
395 if (variably_modified_type_p (type
, /*fn=*/NULL_TREE
))
397 error ("cannot create type information for type %qT because "
398 "it involves types of variable size",
400 return error_mark_node
;
403 if (TREE_CODE (type
) == METHOD_TYPE
)
404 type
= build_function_type (TREE_TYPE (type
),
405 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
407 type
= complete_type (type
);
409 /* For a class type, the variable is cached in the type node
411 if (CLASS_TYPE_P (type
))
413 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
418 name
= mangle_typeinfo_for_type (type
);
420 d
= IDENTIFIER_GLOBAL_VALUE (name
);
423 int ix
= get_pseudo_ti_index (type
);
424 tinfo_s
*ti
= VEC_index (tinfo_s
, tinfo_descs
, ix
);
426 d
= build_lang_decl (VAR_DECL
, name
, ti
->type
);
427 SET_DECL_ASSEMBLER_NAME (d
, name
);
428 /* Remember the type it is for. */
429 TREE_TYPE (name
) = type
;
430 DECL_TINFO_P (d
) = 1;
431 DECL_ARTIFICIAL (d
) = 1;
432 DECL_IGNORED_P (d
) = 1;
433 TREE_READONLY (d
) = 1;
435 /* Mark the variable as undefined -- but remember that we can
436 define it later if we need to do so. */
437 DECL_EXTERNAL (d
) = 1;
438 DECL_NOT_REALLY_EXTERN (d
) = 1;
439 set_linkage_according_to_type (type
, d
);
441 d
= pushdecl_top_level_and_finish (d
, NULL_TREE
);
442 if (CLASS_TYPE_P (type
))
443 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
445 /* Add decl to the global array of tinfo decls. */
446 VEC_safe_push (tree
, gc
, unemitted_tinfo_decls
, d
);
452 /* Return a pointer to a type_info object describing TYPE, suitably
453 cast to the language defined type. */
456 get_tinfo_ptr (tree type
)
458 tree decl
= get_tinfo_decl (type
);
461 return build_nop (type_info_ptr_type
,
462 build_address (decl
));
465 /* Return the type_info object for TYPE. */
468 get_typeid (tree type
)
470 if (type
== error_mark_node
|| !typeid_ok_p ())
471 return error_mark_node
;
473 if (processing_template_decl
)
474 return build_min (TYPEID_EXPR
, const_type_info_type_node
, type
);
476 /* If the type of the type-id is a reference type, the result of the
477 typeid expression refers to a type_info object representing the
479 type
= non_reference (type
);
481 /* The top-level cv-qualifiers of the lvalue expression or the type-id
482 that is the operand of typeid are always ignored. */
483 type
= TYPE_MAIN_VARIANT (type
);
485 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
486 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
487 || type
== init_list_type_node
)
488 type
= complete_type_or_else (type
, NULL_TREE
);
491 return error_mark_node
;
493 return cp_build_indirect_ref (get_tinfo_ptr (type
), RO_NULL
,
494 tf_warning_or_error
);
497 /* Check whether TEST is null before returning RESULT. If TEST is used in
498 RESULT, it must have previously had a save_expr applied to it. */
501 ifnonnull (tree test
, tree result
)
503 return build3 (COND_EXPR
, TREE_TYPE (result
),
504 build2 (EQ_EXPR
, boolean_type_node
, test
,
505 cp_convert (TREE_TYPE (test
), nullptr_node
)),
506 cp_convert (TREE_TYPE (result
), nullptr_node
),
510 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
514 build_dynamic_cast_1 (tree type
, tree expr
, tsubst_flags_t complain
)
516 enum tree_code tc
= TREE_CODE (type
);
519 tree old_expr
= expr
;
520 const char *errstr
= NULL
;
522 /* Save casted types in the function's used types hash table. */
523 used_types_insert (type
);
525 /* T shall be a pointer or reference to a complete class type, or
526 `pointer to cv void''. */
530 if (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
)
534 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
536 errstr
= _("target is not pointer or reference to class");
539 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
541 errstr
= _("target is not pointer or reference to complete type");
547 errstr
= _("target is not pointer or reference");
551 if (tc
== POINTER_TYPE
)
553 expr
= decay_conversion (expr
, complain
);
554 exprtype
= TREE_TYPE (expr
);
556 /* If T is a pointer type, v shall be an rvalue of a pointer to
557 complete class type, and the result is an rvalue of type T. */
559 expr
= mark_rvalue_use (expr
);
561 if (TREE_CODE (exprtype
) != POINTER_TYPE
)
563 errstr
= _("source is not a pointer");
566 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
568 errstr
= _("source is not a pointer to class");
571 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
573 errstr
= _("source is a pointer to incomplete type");
579 expr
= mark_lvalue_use (expr
);
581 exprtype
= build_reference_type (TREE_TYPE (expr
));
583 /* T is a reference type, v shall be an lvalue of a complete class
584 type, and the result is an lvalue of the type referred to by T. */
586 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
588 errstr
= _("source is not of class type");
591 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
593 errstr
= _("source is of incomplete class type");
597 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
598 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
599 LOOKUP_NORMAL
, NULL_TREE
);
602 /* The dynamic_cast operator shall not cast away constness. */
603 if (!at_least_as_qualified_p (TREE_TYPE (type
),
604 TREE_TYPE (exprtype
)))
606 errstr
= _("conversion casts away constness");
610 /* If *type is an unambiguous accessible base class of *exprtype,
611 convert statically. */
615 binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
620 expr
= build_base_path (PLUS_EXPR
, convert_from_reference (expr
),
622 if (TREE_CODE (exprtype
) == POINTER_TYPE
)
623 expr
= rvalue (expr
);
628 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
629 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
632 /* if TYPE is `void *', return pointer to complete object. */
633 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
635 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
636 if (TREE_CODE (expr
) == ADDR_EXPR
637 && TREE_CODE (TREE_OPERAND (expr
, 0)) == VAR_DECL
638 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
639 return build1 (NOP_EXPR
, type
, expr
);
641 /* Since expr is used twice below, save it. */
642 expr
= save_expr (expr
);
644 expr1
= build_headof (expr
);
645 if (TREE_TYPE (expr1
) != type
)
646 expr1
= build1 (NOP_EXPR
, type
, expr1
);
647 return ifnonnull (expr
, expr1
);
652 tree result
, td2
, td3
;
654 tree static_type
, target_type
, boff
;
656 /* If we got here, we can't convert statically. Therefore,
657 dynamic_cast<D&>(b) (b an object) cannot succeed. */
658 if (tc
== REFERENCE_TYPE
)
660 if (TREE_CODE (old_expr
) == VAR_DECL
661 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
663 tree expr
= throw_bad_cast ();
664 if (complain
& tf_warning
)
665 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
667 /* Bash it to the expected type. */
668 TREE_TYPE (expr
) = type
;
672 /* Ditto for dynamic_cast<D*>(&b). */
673 else if (TREE_CODE (expr
) == ADDR_EXPR
)
675 tree op
= TREE_OPERAND (expr
, 0);
676 if (TREE_CODE (op
) == VAR_DECL
677 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
679 if (complain
& tf_warning
)
680 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
682 retval
= build_int_cst (type
, 0);
687 /* Use of dynamic_cast when -fno-rtti is prohibited. */
690 if (complain
& tf_error
)
691 error ("%<dynamic_cast%> not permitted with -fno-rtti");
692 return error_mark_node
;
695 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
696 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
697 td2
= get_tinfo_decl (target_type
);
699 td2
= cp_build_addr_expr (td2
, complain
);
700 td3
= get_tinfo_decl (static_type
);
702 td3
= cp_build_addr_expr (td3
, complain
);
704 /* Determine how T and V are related. */
705 boff
= dcast_base_hint (static_type
, target_type
);
707 /* Since expr is used twice below, save it. */
708 expr
= save_expr (expr
);
711 if (tc
== REFERENCE_TYPE
)
712 expr1
= cp_build_addr_expr (expr1
, complain
);
719 dcast_fn
= dynamic_cast_node
;
726 push_abi_namespace ();
727 tinfo_ptr
= xref_tag (class_type
,
728 get_identifier ("__class_type_info"),
729 /*tag_scope=*/ts_current
, false);
731 tinfo_ptr
= build_pointer_type
732 (cp_build_qualified_type
733 (tinfo_ptr
, TYPE_QUAL_CONST
));
734 name
= "__dynamic_cast";
735 tmp
= build_function_type_list (ptr_type_node
,
737 tinfo_ptr
, tinfo_ptr
,
738 ptrdiff_type_node
, NULL_TREE
);
739 dcast_fn
= build_library_fn_ptr (name
, tmp
);
740 DECL_PURE_P (dcast_fn
) = 1;
741 pop_abi_namespace ();
742 dynamic_cast_node
= dcast_fn
;
744 result
= build_cxx_call (dcast_fn
, 4, elems
);
746 if (tc
== REFERENCE_TYPE
)
748 tree bad
= throw_bad_cast ();
751 result
= save_expr (result
);
752 neq
= cp_truthvalue_conversion (result
);
753 return cp_convert (type
,
754 build3 (COND_EXPR
, TREE_TYPE (result
),
758 /* Now back to the type we want from a void*. */
759 result
= cp_convert (type
, result
);
760 return ifnonnull (expr
, result
);
764 errstr
= _("source type is not polymorphic");
767 if (complain
& tf_error
)
768 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
769 old_expr
, TREE_TYPE (old_expr
), type
, errstr
);
770 return error_mark_node
;
774 build_dynamic_cast (tree type
, tree expr
, tsubst_flags_t complain
)
778 if (type
== error_mark_node
|| expr
== error_mark_node
)
779 return error_mark_node
;
781 if (processing_template_decl
)
783 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
784 TREE_SIDE_EFFECTS (expr
) = 1;
785 return convert_from_reference (expr
);
788 r
= convert_from_reference (build_dynamic_cast_1 (type
, expr
, complain
));
789 if (r
!= error_mark_node
)
790 maybe_warn_about_useless_cast (type
, expr
, complain
);
794 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
797 qualifier_flags (tree type
)
800 int quals
= cp_type_quals (type
);
802 if (quals
& TYPE_QUAL_CONST
)
804 if (quals
& TYPE_QUAL_VOLATILE
)
806 if (quals
& TYPE_QUAL_RESTRICT
)
811 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
812 contains a pointer to member of an incomplete class. */
815 target_incomplete_p (tree type
)
818 if (TYPE_PTRDATAMEM_P (type
))
820 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
822 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
824 else if (TREE_CODE (type
) == POINTER_TYPE
)
825 type
= TREE_TYPE (type
);
827 return !COMPLETE_OR_VOID_TYPE_P (type
);
830 /* Returns true if TYPE involves an incomplete class type; in that
831 case, typeinfo variables for TYPE should be emitted with internal
835 involves_incomplete_p (tree type
)
837 switch (TREE_CODE (type
))
840 return target_incomplete_p (TREE_TYPE (type
));
845 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
846 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
849 if (TYPE_PTRMEMFUNC_P (type
))
853 if (!COMPLETE_TYPE_P (type
))
857 /* All other types do not involve incomplete class types. */
862 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
863 is the vtable pointer and NTBS name. The NTBS name is emitted as a
864 comdat const char array, so it becomes a unique key for the type. Generate
865 and emit that VAR_DECL here. (We can't always emit the type_info itself
866 as comdat, because of pointers to incomplete.) */
869 tinfo_base_init (tinfo_s
*ti
, tree target
)
874 VEC(constructor_elt
,gc
) *v
;
877 tree name_name
, name_string
;
879 /* Generate the NTBS array variable. */
880 tree name_type
= build_cplus_array_type
881 (cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
884 /* Determine the name of the variable -- and remember with which
885 type it is associated. */
886 name_name
= mangle_typeinfo_string_for_type (target
);
887 TREE_TYPE (name_name
) = target
;
889 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
890 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
891 DECL_ARTIFICIAL (name_decl
) = 1;
892 DECL_IGNORED_P (name_decl
) = 1;
893 TREE_READONLY (name_decl
) = 1;
894 TREE_STATIC (name_decl
) = 1;
895 DECL_EXTERNAL (name_decl
) = 0;
896 DECL_TINFO_P (name_decl
) = 1;
897 set_linkage_according_to_type (target
, name_decl
);
898 import_export_decl (name_decl
);
899 name_string
= tinfo_name (target
, !TREE_PUBLIC (name_decl
));
900 DECL_INITIAL (name_decl
) = name_string
;
901 mark_used (name_decl
);
902 pushdecl_top_level_and_finish (name_decl
, name_string
);
905 vtable_ptr
= ti
->vtable
;
909 push_abi_namespace ();
910 real_type
= xref_tag (class_type
, ti
->name
,
911 /*tag_scope=*/ts_current
, false);
912 pop_abi_namespace ();
914 if (!COMPLETE_TYPE_P (real_type
))
916 /* We never saw a definition of this type, so we need to
917 tell the compiler that this is an exported class, as
918 indeed all of the __*_type_info classes are. */
919 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
920 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
923 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
924 vtable_ptr
= cp_build_addr_expr (vtable_ptr
, tf_warning_or_error
);
926 /* We need to point into the middle of the vtable. */
927 vtable_ptr
= fold_build_pointer_plus
929 size_binop (MULT_EXPR
,
930 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
931 TYPE_SIZE_UNIT (vtable_entry_type
)));
933 ti
->vtable
= vtable_ptr
;
936 v
= VEC_alloc (constructor_elt
, gc
, 2);
937 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, vtable_ptr
);
938 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
939 decay_conversion (name_decl
, tf_warning_or_error
));
941 init
= build_constructor (init_list_type_node
, v
);
942 TREE_CONSTANT (init
) = 1;
943 TREE_STATIC (init
) = 1;
948 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
949 information about the particular type_info derivation, which adds no
950 additional fields to the type_info base. */
953 generic_initializer (tinfo_s
*ti
, tree target
)
955 tree init
= tinfo_base_init (ti
, target
);
957 init
= build_constructor_single (init_list_type_node
, NULL_TREE
, init
);
958 TREE_CONSTANT (init
) = 1;
959 TREE_STATIC (init
) = 1;
963 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
964 TI provides information about the particular type_info derivation,
965 which adds target type and qualifier flags members to the type_info base. */
968 ptr_initializer (tinfo_s
*ti
, tree target
)
970 tree init
= tinfo_base_init (ti
, target
);
971 tree to
= TREE_TYPE (target
);
972 int flags
= qualifier_flags (to
);
973 bool incomplete
= target_incomplete_p (to
);
974 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, 3);
978 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
979 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
980 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
981 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
983 init
= build_constructor (init_list_type_node
, v
);
984 TREE_CONSTANT (init
) = 1;
985 TREE_STATIC (init
) = 1;
989 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
990 TI provides information about the particular type_info derivation,
991 which adds class, target type and qualifier flags members to the type_info
995 ptm_initializer (tinfo_s
*ti
, tree target
)
997 tree init
= tinfo_base_init (ti
, target
);
998 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
999 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
1000 int flags
= qualifier_flags (to
);
1001 bool incomplete
= target_incomplete_p (to
);
1002 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, 4);
1006 if (!COMPLETE_TYPE_P (klass
))
1008 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1009 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
1010 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
1011 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
1012 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, get_tinfo_ptr (klass
));
1014 init
= build_constructor (init_list_type_node
, v
);
1015 TREE_CONSTANT (init
) = 1;
1016 TREE_STATIC (init
) = 1;
1020 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1021 TI provides information about the particular __class_type_info derivation,
1022 which adds hint flags and N extra initializers to the type_info base. */
1025 class_initializer (tinfo_s
*ti
, tree target
, unsigned n
, ...)
1027 tree init
= tinfo_base_init (ti
, target
);
1028 va_list extra_inits
;
1030 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, n
+1);
1032 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1033 va_start (extra_inits
, n
);
1034 for (i
= 0; i
< n
; i
++)
1035 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, va_arg (extra_inits
, tree
));
1036 va_end (extra_inits
);
1038 init
= build_constructor (init_list_type_node
, v
);
1039 TREE_CONSTANT (init
) = 1;
1040 TREE_STATIC (init
) = 1;
1044 /* Returns true if the typeinfo for type should be placed in
1045 the runtime library. */
1048 typeinfo_in_lib_p (tree type
)
1050 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1051 library for simple types T. */
1052 if (TREE_CODE (type
) == POINTER_TYPE
1053 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
1054 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
1055 type
= TREE_TYPE (type
);
1057 switch (TREE_CODE (type
))
1074 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1075 the index of the descriptor in the tinfo_desc vector. */
1078 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1080 tinfo_s
*ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1082 gcc_assert (at_eof
);
1085 case TK_POINTER_MEMBER_TYPE
:
1086 return ptm_initializer (ti
, type
);
1088 case TK_POINTER_TYPE
:
1089 return ptr_initializer (ti
, type
);
1091 case TK_BUILTIN_TYPE
:
1092 case TK_ENUMERAL_TYPE
:
1093 case TK_FUNCTION_TYPE
:
1095 return generic_initializer (ti
, type
);
1098 return class_initializer (ti
, type
, 0);
1100 case TK_SI_CLASS_TYPE
:
1102 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1103 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1105 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1106 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1107 return class_initializer (ti
, type
, 1, tinfo
);
1112 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1113 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1114 tree binfo
= TYPE_BINFO (type
);
1115 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1116 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1117 tree offset_type
= integer_types
[itk_long
];
1118 tree base_inits
= NULL_TREE
;
1120 VEC(constructor_elt
,gc
) *init_vec
= NULL
;
1123 gcc_assert (tk_index
>= TK_FIXED
);
1125 VEC_safe_grow (constructor_elt
, gc
, init_vec
, nbases
);
1126 /* Generate the base information initializer. */
1127 for (ix
= nbases
; ix
--;)
1129 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1134 VEC(constructor_elt
,gc
) *v
;
1136 if (VEC_index (tree
, base_accesses
, ix
) == access_public_node
)
1138 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1139 if (BINFO_VIRTUAL_P (base_binfo
))
1141 /* We store the vtable offset at which the virtual
1142 base offset can be found. */
1143 offset
= BINFO_VPTR_FIELD (base_binfo
);
1147 offset
= BINFO_OFFSET (base_binfo
);
1149 /* Combine offset and flags into one field. */
1150 offset
= fold_convert (offset_type
, offset
);
1151 offset
= fold_build2_loc (input_location
,
1152 LSHIFT_EXPR
, offset_type
, offset
,
1153 build_int_cst (offset_type
, 8));
1154 offset
= fold_build2_loc (input_location
,
1155 BIT_IOR_EXPR
, offset_type
, offset
,
1156 build_int_cst (offset_type
, flags
));
1157 v
= VEC_alloc (constructor_elt
, gc
, 2);
1158 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, tinfo
);
1159 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, offset
);
1160 base_init
= build_constructor (init_list_type_node
, v
);
1161 e
= VEC_index (constructor_elt
, init_vec
, ix
);
1162 e
->index
= NULL_TREE
;
1163 e
->value
= base_init
;
1165 base_inits
= build_constructor (init_list_type_node
, init_vec
);
1167 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1168 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1169 return class_initializer (ti
, type
, 3,
1170 build_int_cst (NULL_TREE
, hint
),
1171 build_int_cst (NULL_TREE
, nbases
),
1177 /* Generate the RECORD_TYPE containing the data layout of a type_info
1178 derivative as used by the runtime. This layout must be consistent with
1179 that defined in the runtime support. Also generate the VAR_DECL for the
1180 type's vtable. We explicitly manage the vtable member, and name it for
1181 real type as used in the runtime. The RECORD type has a different name,
1182 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1183 is the generated type and TINFO_VTABLE_NAME is the name of the
1184 vtable. We have to delay generating the VAR_DECL of the vtable
1185 until the end of the translation, when we'll have seen the library
1186 definition, if there was one.
1188 REAL_NAME is the runtime's name of the type. Trailing arguments are
1189 additional FIELD_DECL's for the structure. The final argument must be
1193 create_pseudo_type_info (int tk
, const char *real_name
, ...)
1202 va_start (ap
, real_name
);
1204 /* Generate the pseudo type name. */
1205 pseudo_name
= (char *) alloca (strlen (real_name
) + 30);
1206 strcpy (pseudo_name
, real_name
);
1207 strcat (pseudo_name
, "_pseudo");
1209 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", tk
- TK_FIXED
);
1211 /* First field is the pseudo type_info base class. */
1212 fields
= build_decl (input_location
,
1213 FIELD_DECL
, NULL_TREE
,
1214 VEC_index (tinfo_s
, tinfo_descs
,
1215 TK_TYPE_INFO_TYPE
)->type
);
1217 /* Now add the derived fields. */
1218 while ((field_decl
= va_arg (ap
, tree
)))
1220 DECL_CHAIN (field_decl
) = fields
;
1221 fields
= field_decl
;
1224 /* Create the pseudo type. */
1225 pseudo_type
= make_class_type (RECORD_TYPE
);
1226 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1227 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1229 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk
);
1230 ti
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1231 ti
->name
= get_identifier (real_name
);
1232 ti
->vtable
= NULL_TREE
;
1234 /* Pretend this is public so determine_visibility doesn't give vtables
1235 internal linkage. */
1236 TREE_PUBLIC (TYPE_MAIN_DECL (ti
->type
)) = 1;
1241 /* Return the index of a pseudo type info type node used to describe
1242 TYPE. TYPE must be a complete type (or cv void), except at the end
1243 of the translation unit. */
1246 get_pseudo_ti_index (tree type
)
1250 switch (TREE_CODE (type
))
1253 ix
= TK_POINTER_MEMBER_TYPE
;
1257 ix
= TK_POINTER_TYPE
;
1261 ix
= TK_ENUMERAL_TYPE
;
1265 ix
= TK_FUNCTION_TYPE
;
1274 if (TYPE_PTRMEMFUNC_P (type
))
1276 ix
= TK_POINTER_MEMBER_TYPE
;
1279 else if (!COMPLETE_TYPE_P (type
))
1282 cxx_incomplete_type_error (NULL_TREE
, type
);
1286 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1293 tree binfo
= TYPE_BINFO (type
);
1294 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1295 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1296 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1299 && VEC_index (tree
, base_accesses
, 0) == access_public_node
1300 && !BINFO_VIRTUAL_P (base_binfo
)
1301 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1303 /* single non-virtual public. */
1304 ix
= TK_SI_CLASS_TYPE
;
1310 tree array_domain
, base_array
;
1312 ix
= TK_FIXED
+ num_bases
;
1313 if (VEC_length (tinfo_s
, tinfo_descs
) <= ix
)
1315 /* too short, extend. */
1316 unsigned len
= VEC_length (tinfo_s
, tinfo_descs
);
1318 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, ix
+ 1);
1319 while (VEC_iterate (tinfo_s
, tinfo_descs
, len
++, ti
))
1320 ti
->type
= ti
->vtable
= ti
->name
= NULL_TREE
;
1322 else if (VEC_index (tinfo_s
, tinfo_descs
, ix
)->type
)
1323 /* already created. */
1326 /* Create the array of __base_class_type_info entries.
1327 G++ 3.2 allocated an array that had one too many
1328 entries, and then filled that extra entries with
1330 if (abi_version_at_least (2))
1331 array_domain
= build_index_type (size_int (num_bases
- 1));
1333 array_domain
= build_index_type (size_int (num_bases
));
1335 build_array_type (VEC_index (tinfo_s
, tinfo_descs
,
1336 TK_BASE_TYPE
)->type
,
1339 push_abi_namespace ();
1340 create_pseudo_type_info
1341 (ix
, "__vmi_class_type_info",
1342 build_decl (input_location
,
1343 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1344 build_decl (input_location
,
1345 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1346 build_decl (input_location
,
1347 FIELD_DECL
, NULL_TREE
, base_array
),
1349 pop_abi_namespace ();
1354 ix
= TK_BUILTIN_TYPE
;
1360 /* Make sure the required builtin types exist for generating the type_info
1361 variable definitions. */
1364 create_tinfo_types (void)
1368 gcc_assert (!tinfo_descs
);
1370 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, TK_FIXED
);
1372 push_abi_namespace ();
1374 /* Create the internal type_info structure. This is used as a base for
1375 the other structures. */
1379 field
= build_decl (BUILTINS_LOCATION
,
1380 FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1383 field
= build_decl (BUILTINS_LOCATION
,
1384 FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1385 DECL_CHAIN (field
) = fields
;
1388 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_TYPE_INFO_TYPE
);
1389 ti
->type
= make_class_type (RECORD_TYPE
);
1390 ti
->vtable
= NULL_TREE
;
1391 ti
->name
= NULL_TREE
;
1392 finish_builtin_struct (ti
->type
, "__type_info_pseudo",
1396 /* Fundamental type_info */
1397 create_pseudo_type_info (TK_BUILTIN_TYPE
, "__fundamental_type_info", NULL
);
1399 /* Array, function and enum type_info. No additional fields. */
1400 create_pseudo_type_info (TK_ARRAY_TYPE
, "__array_type_info", NULL
);
1401 create_pseudo_type_info (TK_FUNCTION_TYPE
, "__function_type_info", NULL
);
1402 create_pseudo_type_info (TK_ENUMERAL_TYPE
, "__enum_type_info", NULL
);
1404 /* Class type_info. No additional fields. */
1405 create_pseudo_type_info (TK_CLASS_TYPE
, "__class_type_info", NULL
);
1407 /* Single public non-virtual base class. Add pointer to base class.
1408 This is really a descendant of __class_type_info. */
1409 create_pseudo_type_info (TK_SI_CLASS_TYPE
, "__si_class_type_info",
1410 build_decl (BUILTINS_LOCATION
,
1411 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1414 /* Base class internal helper. Pointer to base type, offset to base,
1419 field
= build_decl (BUILTINS_LOCATION
,
1420 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
);
1423 field
= build_decl (BUILTINS_LOCATION
,
1424 FIELD_DECL
, NULL_TREE
, integer_types
[itk_long
]);
1425 DECL_CHAIN (field
) = fields
;
1428 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_BASE_TYPE
);
1430 ti
->type
= make_class_type (RECORD_TYPE
);
1431 ti
->vtable
= NULL_TREE
;
1432 ti
->name
= NULL_TREE
;
1433 finish_builtin_struct (ti
->type
, "__base_class_type_info_pseudo",
1437 /* Pointer type_info. Adds two fields, qualification mask
1438 and pointer to the pointed to type. This is really a descendant of
1439 __pbase_type_info. */
1440 create_pseudo_type_info (TK_POINTER_TYPE
, "__pointer_type_info",
1441 build_decl (BUILTINS_LOCATION
,
1442 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1443 build_decl (BUILTINS_LOCATION
,
1444 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1447 /* Pointer to member data type_info. Add qualifications flags,
1448 pointer to the member's type info and pointer to the class.
1449 This is really a descendant of __pbase_type_info. */
1450 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE
,
1451 "__pointer_to_member_type_info",
1452 build_decl (BUILTINS_LOCATION
,
1453 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1454 build_decl (BUILTINS_LOCATION
,
1455 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1456 build_decl (BUILTINS_LOCATION
,
1457 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1460 pop_abi_namespace ();
1463 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1464 support. Generating them here guarantees consistency with the other
1465 structures. We use the following heuristic to determine when the runtime
1466 is being generated. If std::__fundamental_type_info is defined, and its
1467 destructor is defined, then the runtime is being built. */
1470 emit_support_tinfos (void)
1472 /* Dummy static variable so we can put nullptr in the array; it will be
1473 set before we actually start to walk the array. */
1474 static tree
*const fundamentals
[] =
1478 &wchar_type_node
, &char16_type_node
, &char32_type_node
,
1479 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1480 &short_integer_type_node
, &short_unsigned_type_node
,
1481 &integer_type_node
, &unsigned_type_node
,
1482 &long_integer_type_node
, &long_unsigned_type_node
,
1483 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1484 &int128_integer_type_node
, &int128_unsigned_type_node
,
1485 &float_type_node
, &double_type_node
, &long_double_type_node
,
1486 &dfloat32_type_node
, &dfloat64_type_node
, &dfloat128_type_node
,
1491 tree bltn_type
, dtor
;
1493 push_abi_namespace ();
1494 bltn_type
= xref_tag (class_type
,
1495 get_identifier ("__fundamental_type_info"),
1496 /*tag_scope=*/ts_current
, false);
1497 pop_abi_namespace ();
1498 if (!COMPLETE_TYPE_P (bltn_type
))
1500 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1501 if (!dtor
|| DECL_EXTERNAL (dtor
))
1504 for (ix
= 0; fundamentals
[ix
]; ix
++)
1506 tree bltn
= *fundamentals
[ix
];
1510 if (bltn
== NULL_TREE
)
1513 types
[1] = build_pointer_type (bltn
);
1514 types
[2] = build_pointer_type (cp_build_qualified_type (bltn
,
1517 for (i
= 0; i
< 3; ++i
)
1521 tinfo
= get_tinfo_decl (types
[i
]);
1522 TREE_USED (tinfo
) = 1;
1523 mark_needed (tinfo
);
1524 /* The C++ ABI requires that these objects be COMDAT. But,
1525 On systems without weak symbols, initialized COMDAT
1526 objects are emitted with internal linkage. (See
1527 comdat_linkage for details.) Since we want these objects
1528 to have external linkage so that copies do not have to be
1529 emitted in code outside the runtime library, we make them
1532 It might also not be necessary to follow this detail of the
1534 if (!flag_weak
|| ! targetm
.cxx
.library_rtti_comdat ())
1536 gcc_assert (TREE_PUBLIC (tinfo
) && !DECL_COMDAT (tinfo
));
1537 DECL_INTERFACE_KNOWN (tinfo
) = 1;
1543 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1544 tinfo decl. Determine whether it needs emitting, and if so
1545 generate the initializer. */
1548 emit_tinfo_decl (tree decl
)
1550 tree type
= TREE_TYPE (DECL_NAME (decl
));
1551 int in_library
= typeinfo_in_lib_p (type
);
1553 gcc_assert (DECL_TINFO_P (decl
));
1558 DECL_EXTERNAL (decl
) = 0;
1561 /* If we're not in the runtime, then DECL (which is already
1562 DECL_EXTERNAL) will not be defined here. */
1563 DECL_INTERFACE_KNOWN (decl
) = 1;
1567 else if (involves_incomplete_p (type
))
1569 if (!decl_needed_p (decl
))
1571 /* If TYPE involves an incomplete class type, then the typeinfo
1572 object will be emitted with internal linkage. There is no
1573 way to know whether or not types are incomplete until the end
1574 of the compilation, so this determination must be deferred
1575 until this point. */
1576 TREE_PUBLIC (decl
) = 0;
1577 DECL_EXTERNAL (decl
) = 0;
1578 DECL_INTERFACE_KNOWN (decl
) = 1;
1581 import_export_decl (decl
);
1582 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1586 DECL_EXTERNAL (decl
) = 0;
1587 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1588 DECL_INITIAL (decl
) = init
;
1590 cp_finish_decl (decl
, init
, false, NULL_TREE
, 0);
1597 #include "gt-cp-rtti.h"