1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009, 2010
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"
34 #include "c-family/c-pragma.h"
36 /* C++ returns type information to the user in struct type_info
37 objects. We also use type information to implement dynamic_cast and
38 exception handlers. Type information for a particular type is
39 indicated with an ABI defined structure derived from type_info.
40 This would all be very straight forward, but for the fact that the
41 runtime library provides the definitions of the type_info structure
42 and the ABI defined derived classes. We cannot build declarations
43 of them directly in the compiler, but we need to layout objects of
44 their type. Somewhere we have to lie.
46 We define layout compatible POD-structs with compiler-defined names
47 and generate the appropriate initializations for them (complete
48 with explicit mention of their vtable). When we have to provide a
49 type_info to the user we reinterpret_cast the internal compiler
50 type to type_info. A well formed program can only explicitly refer
51 to the type_infos of complete types (& cv void). However, we chain
52 pointer type_infos to the pointed-to-type, and that can be
53 incomplete. We only need the addresses of such incomplete
54 type_info objects for static initialization.
56 The type information VAR_DECL of a type is held on the
57 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
58 will be the internal type. It will usually have the correct
59 internal type reflecting the kind of type it represents (pointer,
60 array, function, class, inherited class, etc). When the type it
61 represents is incomplete, it will have the internal type
62 corresponding to type_info. That will only happen at the end of
63 translation, when we are emitting the type info objects. */
65 /* Auxiliary data we hold for each type_info derived object we need. */
66 typedef struct GTY (()) tinfo_s
{
67 tree type
; /* The RECORD_TYPE for this type_info object */
69 tree vtable
; /* The VAR_DECL of the vtable. Only filled at end of
72 tree name
; /* IDENTIFIER_NODE for the ABI specified name of
73 the type_info derived type. */
77 DEF_VEC_ALLOC_O(tinfo_s
,gc
);
79 typedef enum tinfo_kind
81 TK_TYPE_INFO_TYPE
, /* abi::__type_info_pseudo */
82 TK_BASE_TYPE
, /* abi::__base_class_type_info */
83 TK_BUILTIN_TYPE
, /* abi::__fundamental_type_info */
84 TK_ARRAY_TYPE
, /* abi::__array_type_info */
85 TK_FUNCTION_TYPE
, /* abi::__function_type_info */
86 TK_ENUMERAL_TYPE
, /* abi::__enum_type_info */
87 TK_POINTER_TYPE
, /* abi::__pointer_type_info */
88 TK_POINTER_MEMBER_TYPE
, /* abi::__pointer_to_member_type_info */
89 TK_CLASS_TYPE
, /* abi::__class_type_info */
90 TK_SI_CLASS_TYPE
, /* abi::__si_class_type_info */
91 TK_FIXED
/* end of fixed descriptors. */
92 /* ... abi::__vmi_type_info<I> */
95 /* A vector of all tinfo decls that haven't yet been emitted. */
96 VEC(tree
,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
,gc
) *tinfo_descs
;
103 static tree
ifnonnull (tree
, tree
);
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_decl_dynamic (tree
);
109 static tree
get_tinfo_ptr (tree
);
110 static bool typeid_ok_p (void);
111 static int qualifier_flags (tree
);
112 static bool target_incomplete_p (tree
);
113 static tree
tinfo_base_init (tinfo_s
*, tree
);
114 static tree
generic_initializer (tinfo_s
*, tree
);
115 static tree
ptr_initializer (tinfo_s
*, tree
);
116 static tree
ptm_initializer (tinfo_s
*, tree
);
117 static tree
class_initializer (tinfo_s
*, tree
, unsigned, ...);
118 static void create_pseudo_type_info (int, const char *, ...);
119 static tree
get_pseudo_ti_init (tree
, unsigned);
120 static unsigned get_pseudo_ti_index (tree
);
121 static void create_tinfo_types (void);
122 static bool typeinfo_in_lib_p (tree
);
124 static int doing_runtime
= 0;
127 push_abi_namespace (void)
129 push_nested_namespace (abi_node
);
130 push_visibility ("default", 2);
134 pop_abi_namespace (void)
137 pop_nested_namespace (abi_node
);
140 /* Declare language defined type_info type and a pointer to const
141 type_info. This is incomplete here, and will be completed when
142 the user #includes <typeinfo>. There are language defined
143 restrictions on what can be done until that is included. Create
144 the internal versions of the ABI types. */
147 init_rtti_processing (void)
151 push_namespace (std_identifier
);
152 type_info_type
= xref_tag (class_type
, get_identifier ("type_info"),
153 /*tag_scope=*/ts_current
, false);
155 const_type_info_type_node
156 = cp_build_qualified_type (type_info_type
, TYPE_QUAL_CONST
);
157 type_info_ptr_type
= build_pointer_type (const_type_info_type_node
);
159 unemitted_tinfo_decls
= VEC_alloc (tree
, gc
, 124);
161 create_tinfo_types ();
164 /* Given the expression EXP of type `class *', return the head of the
165 object pointed to by EXP with type cv void*, if the class has any
166 virtual functions (TYPE_POLYMORPHIC_P), else just return the
170 build_headof (tree exp
)
172 tree type
= TREE_TYPE (exp
);
176 gcc_assert (TREE_CODE (type
) == POINTER_TYPE
);
177 type
= TREE_TYPE (type
);
179 if (!TYPE_POLYMORPHIC_P (type
))
182 /* We use this a couple of times below, protect it. */
183 exp
= save_expr (exp
);
185 /* The offset-to-top field is at index -2 from the vptr. */
186 index
= build_int_cst (NULL_TREE
,
187 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
189 offset
= build_vtbl_ref (cp_build_indirect_ref (exp
, RO_NULL
,
190 tf_warning_or_error
),
193 type
= cp_build_qualified_type (ptr_type_node
,
194 cp_type_quals (TREE_TYPE (exp
)));
195 return fold_build_pointer_plus (exp
, offset
);
198 /* Get a bad_cast node for the program to throw...
200 See libstdc++/exception.cc for __throw_bad_cast */
203 throw_bad_cast (void)
205 tree fn
= get_identifier ("__cxa_bad_cast");
206 if (!get_global_value_if_present (fn
, &fn
))
207 fn
= push_throw_library_fn (fn
, build_function_type_list (ptr_type_node
,
210 return build_cxx_call (fn
, 0, NULL
);
213 /* Return an expression for "__cxa_bad_typeid()". The expression
214 returned is an lvalue of type "const std::type_info". */
217 throw_bad_typeid (void)
219 tree fn
= get_identifier ("__cxa_bad_typeid");
220 if (!get_global_value_if_present (fn
, &fn
))
224 t
= build_reference_type (const_type_info_type_node
);
225 t
= build_function_type_list (t
, NULL_TREE
);
226 fn
= push_throw_library_fn (fn
, t
);
229 return build_cxx_call (fn
, 0, NULL
);
232 /* Return an lvalue expression whose type is "const std::type_info"
233 and whose value indicates the type of the expression EXP. If EXP
234 is a reference to a polymorphic class, return the dynamic type;
235 otherwise return the static type of the expression. */
238 get_tinfo_decl_dynamic (tree exp
)
243 if (error_operand_p (exp
))
244 return error_mark_node
;
246 exp
= resolve_nondeduced_context (exp
);
248 /* peel back references, so they match. */
249 type
= non_reference (TREE_TYPE (exp
));
251 /* Peel off cv qualifiers. */
252 type
= TYPE_MAIN_VARIANT (type
);
254 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
255 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
256 || type
== init_list_type_node
)
257 type
= complete_type_or_else (type
, exp
);
260 return error_mark_node
;
262 /* If exp is a reference to polymorphic type, get the real type_info. */
263 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
265 /* build reference to type_info from vtable. */
268 /* The RTTI information is at index -1. */
269 index
= build_int_cst (NULL_TREE
,
270 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
271 t
= build_vtbl_ref (exp
, index
);
272 t
= convert (type_info_ptr_type
, t
);
275 /* Otherwise return the type_info for the static type of the expr. */
276 t
= get_tinfo_ptr (TYPE_MAIN_VARIANT (type
));
278 return cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
284 tree pseudo_type_info
, type_info_type
;
288 error ("cannot use typeid with -fno-rtti");
292 if (!COMPLETE_TYPE_P (const_type_info_type_node
))
294 error ("must #include <typeinfo> before using typeid");
299 = VEC_index (tinfo_s
, tinfo_descs
, TK_TYPE_INFO_TYPE
)->type
;
300 type_info_type
= TYPE_MAIN_VARIANT (const_type_info_type_node
);
302 /* Make sure abi::__type_info_pseudo has the same alias set
303 as std::type_info. */
304 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info
))
305 TYPE_ALIAS_SET (pseudo_type_info
) = get_alias_set (type_info_type
);
307 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info
)
308 == get_alias_set (type_info_type
));
313 /* Return an expression for "typeid(EXP)". The expression returned is
314 an lvalue of type "const std::type_info". */
317 build_typeid (tree exp
)
319 tree cond
= NULL_TREE
, initial_expr
= exp
;
322 if (exp
== error_mark_node
|| !typeid_ok_p ())
323 return error_mark_node
;
325 if (processing_template_decl
)
326 return build_min (TYPEID_EXPR
, const_type_info_type_node
, exp
);
328 /* FIXME when integrating with c_fully_fold, mark
329 resolves_to_fixed_type_p case as a non-constant expression. */
330 if (TREE_CODE (exp
) == INDIRECT_REF
331 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
332 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
333 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
336 /* So we need to look into the vtable of the type of exp.
337 This is an lvalue use of expr then. */
338 exp
= mark_lvalue_use (exp
);
339 exp
= stabilize_reference (exp
);
340 cond
= cp_convert (boolean_type_node
, TREE_OPERAND (exp
, 0));
343 exp
= get_tinfo_decl_dynamic (exp
);
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 error ("cannot create type information for type %qT because "
399 "it involves types of variable size",
401 return error_mark_node
;
404 if (TREE_CODE (type
) == METHOD_TYPE
)
405 type
= build_function_type (TREE_TYPE (type
),
406 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
408 type
= complete_type (type
);
410 /* For a class type, the variable is cached in the type node
412 if (CLASS_TYPE_P (type
))
414 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
419 name
= mangle_typeinfo_for_type (type
);
421 d
= IDENTIFIER_GLOBAL_VALUE (name
);
424 int ix
= get_pseudo_ti_index (type
);
425 tinfo_s
*ti
= VEC_index (tinfo_s
, tinfo_descs
, ix
);
427 d
= build_lang_decl (VAR_DECL
, name
, ti
->type
);
428 SET_DECL_ASSEMBLER_NAME (d
, name
);
429 /* Remember the type it is for. */
430 TREE_TYPE (name
) = type
;
431 DECL_TINFO_P (d
) = 1;
432 DECL_ARTIFICIAL (d
) = 1;
433 DECL_IGNORED_P (d
) = 1;
434 TREE_READONLY (d
) = 1;
436 /* Mark the variable as undefined -- but remember that we can
437 define it later if we need to do so. */
438 DECL_EXTERNAL (d
) = 1;
439 DECL_NOT_REALLY_EXTERN (d
) = 1;
440 set_linkage_according_to_type (type
, d
);
442 d
= pushdecl_top_level_and_finish (d
, NULL_TREE
);
443 if (CLASS_TYPE_P (type
))
444 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
446 /* Add decl to the global array of tinfo decls. */
447 VEC_safe_push (tree
, gc
, unemitted_tinfo_decls
, d
);
453 /* Return a pointer to a type_info object describing TYPE, suitably
454 cast to the language defined type. */
457 get_tinfo_ptr (tree type
)
459 tree decl
= get_tinfo_decl (type
);
462 return build_nop (type_info_ptr_type
,
463 build_address (decl
));
466 /* Return the type_info object for TYPE. */
469 get_typeid (tree type
)
471 if (type
== error_mark_node
|| !typeid_ok_p ())
472 return error_mark_node
;
474 if (processing_template_decl
)
475 return build_min (TYPEID_EXPR
, const_type_info_type_node
, type
);
477 /* If the type of the type-id is a reference type, the result of the
478 typeid expression refers to a type_info object representing the
480 type
= non_reference (type
);
482 /* The top-level cv-qualifiers of the lvalue expression or the type-id
483 that is the operand of typeid are always ignored. */
484 type
= TYPE_MAIN_VARIANT (type
);
486 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
487 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
488 || type
== init_list_type_node
)
489 type
= complete_type_or_else (type
, NULL_TREE
);
492 return error_mark_node
;
494 return cp_build_indirect_ref (get_tinfo_ptr (type
), RO_NULL
,
495 tf_warning_or_error
);
498 /* Check whether TEST is null before returning RESULT. If TEST is used in
499 RESULT, it must have previously had a save_expr applied to it. */
502 ifnonnull (tree test
, tree result
)
504 return build3 (COND_EXPR
, TREE_TYPE (result
),
505 build2 (EQ_EXPR
, boolean_type_node
, test
,
506 cp_convert (TREE_TYPE (test
), integer_zero_node
)),
507 cp_convert (TREE_TYPE (result
), integer_zero_node
),
511 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
515 build_dynamic_cast_1 (tree type
, tree expr
, tsubst_flags_t complain
)
517 enum tree_code tc
= TREE_CODE (type
);
518 tree exprtype
= TREE_TYPE (expr
);
520 tree old_expr
= expr
;
521 const char *errstr
= NULL
;
523 /* Save casted types in the function's used types hash table. */
524 used_types_insert (type
);
526 /* T shall be a pointer or reference to a complete class type, or
527 `pointer to cv void''. */
531 if (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
)
535 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type
)))
537 errstr
= _("target is not pointer or reference to class");
540 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
542 errstr
= _("target is not pointer or reference to complete type");
548 errstr
= _("target is not pointer or reference");
552 if (tc
== POINTER_TYPE
)
554 /* If T is a pointer type, v shall be an rvalue of a pointer to
555 complete class type, and the result is an rvalue of type T. */
557 expr
= mark_rvalue_use (expr
);
559 if (TREE_CODE (exprtype
) != POINTER_TYPE
)
561 errstr
= _("source is not a pointer");
564 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
566 errstr
= _("source is not a pointer to class");
569 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
571 errstr
= _("source is a pointer to incomplete type");
577 expr
= mark_lvalue_use (expr
);
579 exprtype
= build_reference_type (exprtype
);
581 /* T is a reference type, v shall be an lvalue of a complete class
582 type, and the result is an lvalue of the type referred to by T. */
584 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
586 errstr
= _("source is not of class type");
589 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
591 errstr
= _("source is of incomplete class type");
595 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
596 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
597 LOOKUP_NORMAL
, NULL_TREE
);
600 /* The dynamic_cast operator shall not cast away constness. */
601 if (!at_least_as_qualified_p (TREE_TYPE (type
),
602 TREE_TYPE (exprtype
)))
604 errstr
= _("conversion casts away constness");
608 /* If *type is an unambiguous accessible base class of *exprtype,
609 convert statically. */
613 binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
618 expr
= build_base_path (PLUS_EXPR
, convert_from_reference (expr
),
620 if (TREE_CODE (exprtype
) == POINTER_TYPE
)
621 expr
= rvalue (expr
);
626 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
627 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
630 /* if TYPE is `void *', return pointer to complete object. */
631 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
633 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
634 if (TREE_CODE (expr
) == ADDR_EXPR
635 && TREE_CODE (TREE_OPERAND (expr
, 0)) == VAR_DECL
636 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
637 return build1 (NOP_EXPR
, type
, expr
);
639 /* Since expr is used twice below, save it. */
640 expr
= save_expr (expr
);
642 expr1
= build_headof (expr
);
643 if (TREE_TYPE (expr1
) != type
)
644 expr1
= build1 (NOP_EXPR
, type
, expr1
);
645 return ifnonnull (expr
, expr1
);
650 tree result
, td2
, td3
;
652 tree static_type
, target_type
, boff
;
654 /* If we got here, we can't convert statically. Therefore,
655 dynamic_cast<D&>(b) (b an object) cannot succeed. */
656 if (tc
== REFERENCE_TYPE
)
658 if (TREE_CODE (old_expr
) == VAR_DECL
659 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
661 tree expr
= throw_bad_cast ();
662 if (complain
& tf_warning
)
663 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
665 /* Bash it to the expected type. */
666 TREE_TYPE (expr
) = type
;
670 /* Ditto for dynamic_cast<D*>(&b). */
671 else if (TREE_CODE (expr
) == ADDR_EXPR
)
673 tree op
= TREE_OPERAND (expr
, 0);
674 if (TREE_CODE (op
) == VAR_DECL
675 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
677 if (complain
& tf_warning
)
678 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
680 retval
= build_int_cst (type
, 0);
685 /* Use of dynamic_cast when -fno-rtti is prohibited. */
688 if (complain
& tf_error
)
689 error ("%<dynamic_cast%> not permitted with -fno-rtti");
690 return error_mark_node
;
693 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
694 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
695 td2
= get_tinfo_decl (target_type
);
697 td2
= cp_build_addr_expr (td2
, complain
);
698 td3
= get_tinfo_decl (static_type
);
700 td3
= cp_build_addr_expr (td3
, complain
);
702 /* Determine how T and V are related. */
703 boff
= dcast_base_hint (static_type
, target_type
);
705 /* Since expr is used twice below, save it. */
706 expr
= save_expr (expr
);
709 if (tc
== REFERENCE_TYPE
)
710 expr1
= cp_build_addr_expr (expr1
, complain
);
717 dcast_fn
= dynamic_cast_node
;
724 push_abi_namespace ();
725 tinfo_ptr
= xref_tag (class_type
,
726 get_identifier ("__class_type_info"),
727 /*tag_scope=*/ts_current
, false);
729 tinfo_ptr
= build_pointer_type
730 (cp_build_qualified_type
731 (tinfo_ptr
, TYPE_QUAL_CONST
));
732 name
= "__dynamic_cast";
733 tmp
= build_function_type_list (ptr_type_node
,
735 tinfo_ptr
, tinfo_ptr
,
736 ptrdiff_type_node
, NULL_TREE
);
737 dcast_fn
= build_library_fn_ptr (name
, tmp
);
738 DECL_PURE_P (dcast_fn
) = 1;
739 pop_abi_namespace ();
740 dynamic_cast_node
= dcast_fn
;
742 result
= build_cxx_call (dcast_fn
, 4, elems
);
744 if (tc
== REFERENCE_TYPE
)
746 tree bad
= throw_bad_cast ();
749 result
= save_expr (result
);
750 neq
= c_common_truthvalue_conversion (input_location
, result
);
751 return cp_convert (type
,
752 build3 (COND_EXPR
, TREE_TYPE (result
),
756 /* Now back to the type we want from a void*. */
757 result
= cp_convert (type
, result
);
758 return ifnonnull (expr
, result
);
762 errstr
= _("source type is not polymorphic");
765 if (complain
& tf_error
)
766 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
767 expr
, exprtype
, type
, errstr
);
768 return error_mark_node
;
772 build_dynamic_cast (tree type
, tree expr
, tsubst_flags_t complain
)
774 if (type
== error_mark_node
|| expr
== error_mark_node
)
775 return error_mark_node
;
777 if (processing_template_decl
)
779 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
780 TREE_SIDE_EFFECTS (expr
) = 1;
781 return convert_from_reference (expr
);
784 return convert_from_reference (build_dynamic_cast_1 (type
, expr
, complain
));
787 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
790 qualifier_flags (tree type
)
793 int quals
= cp_type_quals (type
);
795 if (quals
& TYPE_QUAL_CONST
)
797 if (quals
& TYPE_QUAL_VOLATILE
)
799 if (quals
& TYPE_QUAL_RESTRICT
)
804 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
805 contains a pointer to member of an incomplete class. */
808 target_incomplete_p (tree type
)
811 if (TYPE_PTRMEM_P (type
))
813 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
815 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
817 else if (TREE_CODE (type
) == POINTER_TYPE
)
818 type
= TREE_TYPE (type
);
820 return !COMPLETE_OR_VOID_TYPE_P (type
);
823 /* Returns true if TYPE involves an incomplete class type; in that
824 case, typeinfo variables for TYPE should be emitted with internal
828 involves_incomplete_p (tree type
)
830 switch (TREE_CODE (type
))
833 return target_incomplete_p (TREE_TYPE (type
));
838 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
839 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
842 if (TYPE_PTRMEMFUNC_P (type
))
846 if (!COMPLETE_TYPE_P (type
))
850 /* All other types do not involve incomplete class types. */
855 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
856 is the vtable pointer and NTBS name. The NTBS name is emitted as a
857 comdat const char array, so it becomes a unique key for the type. Generate
858 and emit that VAR_DECL here. (We can't always emit the type_info itself
859 as comdat, because of pointers to incomplete.) */
862 tinfo_base_init (tinfo_s
*ti
, tree target
)
867 VEC(constructor_elt
,gc
) *v
;
870 tree name_name
, name_string
;
872 /* Generate the NTBS array variable. */
873 tree name_type
= build_cplus_array_type
874 (cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
877 /* Determine the name of the variable -- and remember with which
878 type it is associated. */
879 name_name
= mangle_typeinfo_string_for_type (target
);
880 TREE_TYPE (name_name
) = target
;
882 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
883 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
884 DECL_ARTIFICIAL (name_decl
) = 1;
885 DECL_IGNORED_P (name_decl
) = 1;
886 TREE_READONLY (name_decl
) = 1;
887 TREE_STATIC (name_decl
) = 1;
888 DECL_EXTERNAL (name_decl
) = 0;
889 DECL_TINFO_P (name_decl
) = 1;
890 set_linkage_according_to_type (target
, name_decl
);
891 import_export_decl (name_decl
);
892 name_string
= tinfo_name (target
, !TREE_PUBLIC (name_decl
));
893 DECL_INITIAL (name_decl
) = name_string
;
894 mark_used (name_decl
);
895 pushdecl_top_level_and_finish (name_decl
, name_string
);
898 vtable_ptr
= ti
->vtable
;
902 push_abi_namespace ();
903 real_type
= xref_tag (class_type
, ti
->name
,
904 /*tag_scope=*/ts_current
, false);
905 pop_abi_namespace ();
907 if (!COMPLETE_TYPE_P (real_type
))
909 /* We never saw a definition of this type, so we need to
910 tell the compiler that this is an exported class, as
911 indeed all of the __*_type_info classes are. */
912 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
913 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
916 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
917 vtable_ptr
= cp_build_addr_expr (vtable_ptr
, tf_warning_or_error
);
919 /* We need to point into the middle of the vtable. */
920 vtable_ptr
= fold_build_pointer_plus
922 size_binop (MULT_EXPR
,
923 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
924 TYPE_SIZE_UNIT (vtable_entry_type
)));
926 ti
->vtable
= vtable_ptr
;
929 v
= VEC_alloc (constructor_elt
, gc
, 2);
930 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, vtable_ptr
);
931 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, decay_conversion (name_decl
));
933 init
= build_constructor (init_list_type_node
, v
);
934 TREE_CONSTANT (init
) = 1;
935 TREE_STATIC (init
) = 1;
940 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
941 information about the particular type_info derivation, which adds no
942 additional fields to the type_info base. */
945 generic_initializer (tinfo_s
*ti
, tree target
)
947 tree init
= tinfo_base_init (ti
, target
);
949 init
= build_constructor_single (init_list_type_node
, NULL_TREE
, init
);
950 TREE_CONSTANT (init
) = 1;
951 TREE_STATIC (init
) = 1;
955 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
956 TI provides information about the particular type_info derivation,
957 which adds target type and qualifier flags members to the type_info base. */
960 ptr_initializer (tinfo_s
*ti
, tree target
)
962 tree init
= tinfo_base_init (ti
, target
);
963 tree to
= TREE_TYPE (target
);
964 int flags
= qualifier_flags (to
);
965 bool incomplete
= target_incomplete_p (to
);
966 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, 3);
970 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
971 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
972 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
973 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
975 init
= build_constructor (init_list_type_node
, v
);
976 TREE_CONSTANT (init
) = 1;
977 TREE_STATIC (init
) = 1;
981 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
982 TI provides information about the particular type_info derivation,
983 which adds class, target type and qualifier flags members to the type_info
987 ptm_initializer (tinfo_s
*ti
, tree target
)
989 tree init
= tinfo_base_init (ti
, target
);
990 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
991 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
992 int flags
= qualifier_flags (to
);
993 bool incomplete
= target_incomplete_p (to
);
994 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, 4);
998 if (!COMPLETE_TYPE_P (klass
))
1000 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1001 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
1002 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
1003 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
1004 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, get_tinfo_ptr (klass
));
1006 init
= build_constructor (init_list_type_node
, v
);
1007 TREE_CONSTANT (init
) = 1;
1008 TREE_STATIC (init
) = 1;
1012 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1013 TI provides information about the particular __class_type_info derivation,
1014 which adds hint flags and N extra initializers to the type_info base. */
1017 class_initializer (tinfo_s
*ti
, tree target
, unsigned n
, ...)
1019 tree init
= tinfo_base_init (ti
, target
);
1020 va_list extra_inits
;
1022 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, n
+1);
1024 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1025 va_start (extra_inits
, n
);
1026 for (i
= 0; i
< n
; i
++)
1027 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, va_arg (extra_inits
, tree
));
1028 va_end (extra_inits
);
1030 init
= build_constructor (init_list_type_node
, v
);
1031 TREE_CONSTANT (init
) = 1;
1032 TREE_STATIC (init
) = 1;
1036 /* Returns true if the typeinfo for type should be placed in
1037 the runtime library. */
1040 typeinfo_in_lib_p (tree type
)
1042 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1043 library for simple types T. */
1044 if (TREE_CODE (type
) == POINTER_TYPE
1045 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
1046 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
1047 type
= TREE_TYPE (type
);
1049 switch (TREE_CODE (type
))
1066 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1067 the index of the descriptor in the tinfo_desc vector. */
1070 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1072 tinfo_s
*ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1074 gcc_assert (at_eof
);
1077 case TK_POINTER_MEMBER_TYPE
:
1078 return ptm_initializer (ti
, type
);
1080 case TK_POINTER_TYPE
:
1081 return ptr_initializer (ti
, type
);
1083 case TK_BUILTIN_TYPE
:
1084 case TK_ENUMERAL_TYPE
:
1085 case TK_FUNCTION_TYPE
:
1087 return generic_initializer (ti
, type
);
1090 return class_initializer (ti
, type
, 0);
1092 case TK_SI_CLASS_TYPE
:
1094 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1095 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1097 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1098 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1099 return class_initializer (ti
, type
, 1, tinfo
);
1104 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1105 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1106 tree binfo
= TYPE_BINFO (type
);
1107 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1108 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1109 tree offset_type
= integer_types
[itk_long
];
1110 tree base_inits
= NULL_TREE
;
1112 VEC(constructor_elt
,gc
) *init_vec
= NULL
;
1115 gcc_assert (tk_index
>= TK_FIXED
);
1117 VEC_safe_grow (constructor_elt
, gc
, init_vec
, nbases
);
1118 /* Generate the base information initializer. */
1119 for (ix
= nbases
; ix
--;)
1121 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1126 VEC(constructor_elt
,gc
) *v
;
1128 if (VEC_index (tree
, base_accesses
, ix
) == access_public_node
)
1130 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1131 if (BINFO_VIRTUAL_P (base_binfo
))
1133 /* We store the vtable offset at which the virtual
1134 base offset can be found. */
1135 offset
= BINFO_VPTR_FIELD (base_binfo
);
1139 offset
= BINFO_OFFSET (base_binfo
);
1141 /* Combine offset and flags into one field. */
1142 offset
= fold_convert (offset_type
, offset
);
1143 offset
= fold_build2_loc (input_location
,
1144 LSHIFT_EXPR
, offset_type
, offset
,
1145 build_int_cst (offset_type
, 8));
1146 offset
= fold_build2_loc (input_location
,
1147 BIT_IOR_EXPR
, offset_type
, offset
,
1148 build_int_cst (offset_type
, flags
));
1149 v
= VEC_alloc (constructor_elt
, gc
, 2);
1150 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, tinfo
);
1151 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, offset
);
1152 base_init
= build_constructor (init_list_type_node
, v
);
1153 e
= VEC_index (constructor_elt
, init_vec
, ix
);
1154 e
->index
= NULL_TREE
;
1155 e
->value
= base_init
;
1157 base_inits
= build_constructor (init_list_type_node
, init_vec
);
1159 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1160 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1161 return class_initializer (ti
, type
, 3,
1162 build_int_cst (NULL_TREE
, hint
),
1163 build_int_cst (NULL_TREE
, nbases
),
1169 /* Generate the RECORD_TYPE containing the data layout of a type_info
1170 derivative as used by the runtime. This layout must be consistent with
1171 that defined in the runtime support. Also generate the VAR_DECL for the
1172 type's vtable. We explicitly manage the vtable member, and name it for
1173 real type as used in the runtime. The RECORD type has a different name,
1174 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1175 is the generated type and TINFO_VTABLE_NAME is the name of the
1176 vtable. We have to delay generating the VAR_DECL of the vtable
1177 until the end of the translation, when we'll have seen the library
1178 definition, if there was one.
1180 REAL_NAME is the runtime's name of the type. Trailing arguments are
1181 additional FIELD_DECL's for the structure. The final argument must be
1185 create_pseudo_type_info (int tk
, const char *real_name
, ...)
1194 va_start (ap
, real_name
);
1196 /* Generate the pseudo type name. */
1197 pseudo_name
= (char *) alloca (strlen (real_name
) + 30);
1198 strcpy (pseudo_name
, real_name
);
1199 strcat (pseudo_name
, "_pseudo");
1201 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", tk
- TK_FIXED
);
1203 /* First field is the pseudo type_info base class. */
1204 fields
= build_decl (input_location
,
1205 FIELD_DECL
, NULL_TREE
,
1206 VEC_index (tinfo_s
, tinfo_descs
,
1207 TK_TYPE_INFO_TYPE
)->type
);
1209 /* Now add the derived fields. */
1210 while ((field_decl
= va_arg (ap
, tree
)))
1212 DECL_CHAIN (field_decl
) = fields
;
1213 fields
= field_decl
;
1216 /* Create the pseudo type. */
1217 pseudo_type
= make_class_type (RECORD_TYPE
);
1218 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1219 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1221 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk
);
1222 ti
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1223 ti
->name
= get_identifier (real_name
);
1224 ti
->vtable
= NULL_TREE
;
1226 /* Pretend this is public so determine_visibility doesn't give vtables
1227 internal linkage. */
1228 TREE_PUBLIC (TYPE_MAIN_DECL (ti
->type
)) = 1;
1233 /* Return the index of a pseudo type info type node used to describe
1234 TYPE. TYPE must be a complete type (or cv void), except at the end
1235 of the translation unit. */
1238 get_pseudo_ti_index (tree type
)
1242 switch (TREE_CODE (type
))
1245 ix
= TK_POINTER_MEMBER_TYPE
;
1249 ix
= TK_POINTER_TYPE
;
1253 ix
= TK_ENUMERAL_TYPE
;
1257 ix
= TK_FUNCTION_TYPE
;
1266 if (TYPE_PTRMEMFUNC_P (type
))
1268 ix
= TK_POINTER_MEMBER_TYPE
;
1271 else if (!COMPLETE_TYPE_P (type
))
1274 cxx_incomplete_type_error (NULL_TREE
, type
);
1278 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1285 tree binfo
= TYPE_BINFO (type
);
1286 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1287 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1288 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1291 && VEC_index (tree
, base_accesses
, 0) == access_public_node
1292 && !BINFO_VIRTUAL_P (base_binfo
)
1293 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1295 /* single non-virtual public. */
1296 ix
= TK_SI_CLASS_TYPE
;
1302 tree array_domain
, base_array
;
1304 ix
= TK_FIXED
+ num_bases
;
1305 if (VEC_length (tinfo_s
, tinfo_descs
) <= ix
)
1307 /* too short, extend. */
1308 unsigned len
= VEC_length (tinfo_s
, tinfo_descs
);
1310 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, ix
+ 1);
1311 while (VEC_iterate (tinfo_s
, tinfo_descs
, len
++, ti
))
1312 ti
->type
= ti
->vtable
= ti
->name
= NULL_TREE
;
1314 else if (VEC_index (tinfo_s
, tinfo_descs
, ix
)->type
)
1315 /* already created. */
1318 /* Create the array of __base_class_type_info entries.
1319 G++ 3.2 allocated an array that had one too many
1320 entries, and then filled that extra entries with
1322 if (abi_version_at_least (2))
1323 array_domain
= build_index_type (size_int (num_bases
- 1));
1325 array_domain
= build_index_type (size_int (num_bases
));
1327 build_array_type (VEC_index (tinfo_s
, tinfo_descs
,
1328 TK_BASE_TYPE
)->type
,
1331 push_abi_namespace ();
1332 create_pseudo_type_info
1333 (ix
, "__vmi_class_type_info",
1334 build_decl (input_location
,
1335 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1336 build_decl (input_location
,
1337 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1338 build_decl (input_location
,
1339 FIELD_DECL
, NULL_TREE
, base_array
),
1341 pop_abi_namespace ();
1346 ix
= TK_BUILTIN_TYPE
;
1352 /* Make sure the required builtin types exist for generating the type_info
1353 variable definitions. */
1356 create_tinfo_types (void)
1360 gcc_assert (!tinfo_descs
);
1362 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, TK_FIXED
);
1364 push_abi_namespace ();
1366 /* Create the internal type_info structure. This is used as a base for
1367 the other structures. */
1371 field
= build_decl (BUILTINS_LOCATION
,
1372 FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1375 field
= build_decl (BUILTINS_LOCATION
,
1376 FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1377 DECL_CHAIN (field
) = fields
;
1380 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_TYPE_INFO_TYPE
);
1381 ti
->type
= make_class_type (RECORD_TYPE
);
1382 ti
->vtable
= NULL_TREE
;
1383 ti
->name
= NULL_TREE
;
1384 finish_builtin_struct (ti
->type
, "__type_info_pseudo",
1388 /* Fundamental type_info */
1389 create_pseudo_type_info (TK_BUILTIN_TYPE
, "__fundamental_type_info", NULL
);
1391 /* Array, function and enum type_info. No additional fields. */
1392 create_pseudo_type_info (TK_ARRAY_TYPE
, "__array_type_info", NULL
);
1393 create_pseudo_type_info (TK_FUNCTION_TYPE
, "__function_type_info", NULL
);
1394 create_pseudo_type_info (TK_ENUMERAL_TYPE
, "__enum_type_info", NULL
);
1396 /* Class type_info. No additional fields. */
1397 create_pseudo_type_info (TK_CLASS_TYPE
, "__class_type_info", NULL
);
1399 /* Single public non-virtual base class. Add pointer to base class.
1400 This is really a descendant of __class_type_info. */
1401 create_pseudo_type_info (TK_SI_CLASS_TYPE
, "__si_class_type_info",
1402 build_decl (BUILTINS_LOCATION
,
1403 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1406 /* Base class internal helper. Pointer to base type, offset to base,
1411 field
= build_decl (BUILTINS_LOCATION
,
1412 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
);
1415 field
= build_decl (BUILTINS_LOCATION
,
1416 FIELD_DECL
, NULL_TREE
, integer_types
[itk_long
]);
1417 DECL_CHAIN (field
) = fields
;
1420 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_BASE_TYPE
);
1422 ti
->type
= make_class_type (RECORD_TYPE
);
1423 ti
->vtable
= NULL_TREE
;
1424 ti
->name
= NULL_TREE
;
1425 finish_builtin_struct (ti
->type
, "__base_class_type_info_pseudo",
1429 /* Pointer type_info. Adds two fields, qualification mask
1430 and pointer to the pointed to type. This is really a descendant of
1431 __pbase_type_info. */
1432 create_pseudo_type_info (TK_POINTER_TYPE
, "__pointer_type_info",
1433 build_decl (BUILTINS_LOCATION
,
1434 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1435 build_decl (BUILTINS_LOCATION
,
1436 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1439 /* Pointer to member data type_info. Add qualifications flags,
1440 pointer to the member's type info and pointer to the class.
1441 This is really a descendant of __pbase_type_info. */
1442 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE
,
1443 "__pointer_to_member_type_info",
1444 build_decl (BUILTINS_LOCATION
,
1445 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1446 build_decl (BUILTINS_LOCATION
,
1447 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1448 build_decl (BUILTINS_LOCATION
,
1449 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1452 pop_abi_namespace ();
1455 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1456 support. Generating them here guarantees consistency with the other
1457 structures. We use the following heuristic to determine when the runtime
1458 is being generated. If std::__fundamental_type_info is defined, and its
1459 destructor is defined, then the runtime is being built. */
1462 emit_support_tinfos (void)
1464 /* Dummy static variable so we can put nullptr in the array; it will be
1465 set before we actually start to walk the array. */
1466 static tree
*const fundamentals
[] =
1470 &wchar_type_node
, &char16_type_node
, &char32_type_node
,
1471 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1472 &short_integer_type_node
, &short_unsigned_type_node
,
1473 &integer_type_node
, &unsigned_type_node
,
1474 &long_integer_type_node
, &long_unsigned_type_node
,
1475 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1476 &int128_integer_type_node
, &int128_unsigned_type_node
,
1477 &float_type_node
, &double_type_node
, &long_double_type_node
,
1478 &dfloat32_type_node
, &dfloat64_type_node
, &dfloat128_type_node
,
1483 tree bltn_type
, dtor
;
1485 push_abi_namespace ();
1486 bltn_type
= xref_tag (class_type
,
1487 get_identifier ("__fundamental_type_info"),
1488 /*tag_scope=*/ts_current
, false);
1489 pop_abi_namespace ();
1490 if (!COMPLETE_TYPE_P (bltn_type
))
1492 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1493 if (!dtor
|| DECL_EXTERNAL (dtor
))
1496 for (ix
= 0; fundamentals
[ix
]; ix
++)
1498 tree bltn
= *fundamentals
[ix
];
1502 if (bltn
== NULL_TREE
)
1505 types
[1] = build_pointer_type (bltn
);
1506 types
[2] = build_pointer_type (cp_build_qualified_type (bltn
,
1509 for (i
= 0; i
< 3; ++i
)
1513 tinfo
= get_tinfo_decl (types
[i
]);
1514 TREE_USED (tinfo
) = 1;
1515 mark_needed (tinfo
);
1516 /* The C++ ABI requires that these objects be COMDAT. But,
1517 On systems without weak symbols, initialized COMDAT
1518 objects are emitted with internal linkage. (See
1519 comdat_linkage for details.) Since we want these objects
1520 to have external linkage so that copies do not have to be
1521 emitted in code outside the runtime library, we make them
1524 It might also not be necessary to follow this detail of the
1526 if (!flag_weak
|| ! targetm
.cxx
.library_rtti_comdat ())
1528 gcc_assert (TREE_PUBLIC (tinfo
) && !DECL_COMDAT (tinfo
));
1529 DECL_INTERFACE_KNOWN (tinfo
) = 1;
1535 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1536 tinfo decl. Determine whether it needs emitting, and if so
1537 generate the initializer. */
1540 emit_tinfo_decl (tree decl
)
1542 tree type
= TREE_TYPE (DECL_NAME (decl
));
1543 int in_library
= typeinfo_in_lib_p (type
);
1545 gcc_assert (DECL_TINFO_P (decl
));
1550 DECL_EXTERNAL (decl
) = 0;
1553 /* If we're not in the runtime, then DECL (which is already
1554 DECL_EXTERNAL) will not be defined here. */
1555 DECL_INTERFACE_KNOWN (decl
) = 1;
1559 else if (involves_incomplete_p (type
))
1561 if (!decl_needed_p (decl
))
1563 /* If TYPE involves an incomplete class type, then the typeinfo
1564 object will be emitted with internal linkage. There is no
1565 way to know whether or not types are incomplete until the end
1566 of the compilation, so this determination must be deferred
1567 until this point. */
1568 TREE_PUBLIC (decl
) = 0;
1569 DECL_EXTERNAL (decl
) = 0;
1570 DECL_INTERFACE_KNOWN (decl
) = 1;
1573 import_export_decl (decl
);
1574 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1578 DECL_EXTERNAL (decl
) = 0;
1579 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1580 DECL_INITIAL (decl
) = init
;
1582 cp_finish_decl (decl
, init
, false, NULL_TREE
, 0);
1589 #include "gt-cp-rtti.h"