1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2009
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"
36 #include "c-family/c-pragma.h"
38 /* C++ returns type information to the user in struct type_info
39 objects. We also use type information to implement dynamic_cast and
40 exception handlers. Type information for a particular type is
41 indicated with an ABI defined structure derived from type_info.
42 This would all be very straight forward, but for the fact that the
43 runtime library provides the definitions of the type_info structure
44 and the ABI defined derived classes. We cannot build declarations
45 of them directly in the compiler, but we need to layout objects of
46 their type. Somewhere we have to lie.
48 We define layout compatible POD-structs with compiler-defined names
49 and generate the appropriate initializations for them (complete
50 with explicit mention of their vtable). When we have to provide a
51 type_info to the user we reinterpret_cast the internal compiler
52 type to type_info. A well formed program can only explicitly refer
53 to the type_infos of complete types (& cv void). However, we chain
54 pointer type_infos to the pointed-to-type, and that can be
55 incomplete. We only need the addresses of such incomplete
56 type_info objects for static initialization.
58 The type information VAR_DECL of a type is held on the
59 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
60 will be the internal type. It will usually have the correct
61 internal type reflecting the kind of type it represents (pointer,
62 array, function, class, inherited class, etc). When the type it
63 represents is incomplete, it will have the internal type
64 corresponding to type_info. That will only happen at the end of
65 translation, when we are emitting the type info objects. */
67 /* Auxiliary data we hold for each type_info derived object we need. */
68 typedef struct GTY (()) tinfo_s
{
69 tree type
; /* The RECORD_TYPE for this type_info object */
71 tree vtable
; /* The VAR_DECL of the vtable. Only filled at end of
74 tree name
; /* IDENTIFIER_NODE for the ABI specified name of
75 the type_info derived type. */
79 DEF_VEC_ALLOC_O(tinfo_s
,gc
);
81 typedef enum tinfo_kind
83 TK_TYPE_INFO_TYPE
, /* abi::__type_info_pseudo */
84 TK_BASE_TYPE
, /* abi::__base_class_type_info */
85 TK_BUILTIN_TYPE
, /* abi::__fundamental_type_info */
86 TK_ARRAY_TYPE
, /* abi::__array_type_info */
87 TK_FUNCTION_TYPE
, /* abi::__function_type_info */
88 TK_ENUMERAL_TYPE
, /* abi::__enum_type_info */
89 TK_POINTER_TYPE
, /* abi::__pointer_type_info */
90 TK_POINTER_MEMBER_TYPE
, /* abi::__pointer_to_member_type_info */
91 TK_CLASS_TYPE
, /* abi::__class_type_info */
92 TK_SI_CLASS_TYPE
, /* abi::__si_class_type_info */
93 TK_FIXED
/* end of fixed descriptors. */
94 /* ... abi::__vmi_type_info<I> */
97 /* A vector of all tinfo decls that haven't yet been emitted. */
98 VEC(tree
,gc
) *unemitted_tinfo_decls
;
100 /* A vector of all type_info derived types we need. The first few are
101 fixed and created early. The remainder are for multiple inheritance
102 and are generated as needed. */
103 static GTY (()) VEC(tinfo_s
,gc
) *tinfo_descs
;
105 static tree
ifnonnull (tree
, tree
);
106 static tree
tinfo_name (tree
, bool);
107 static tree
build_dynamic_cast_1 (tree
, tree
, tsubst_flags_t
);
108 static tree
throw_bad_cast (void);
109 static tree
throw_bad_typeid (void);
110 static tree
get_tinfo_decl_dynamic (tree
);
111 static tree
get_tinfo_ptr (tree
);
112 static bool typeid_ok_p (void);
113 static int qualifier_flags (tree
);
114 static bool target_incomplete_p (tree
);
115 static tree
tinfo_base_init (tinfo_s
*, tree
);
116 static tree
generic_initializer (tinfo_s
*, tree
);
117 static tree
ptr_initializer (tinfo_s
*, tree
);
118 static tree
ptm_initializer (tinfo_s
*, tree
);
119 static tree
class_initializer (tinfo_s
*, tree
, unsigned, ...);
120 static void create_pseudo_type_info (int, const char *, ...);
121 static tree
get_pseudo_ti_init (tree
, unsigned);
122 static unsigned get_pseudo_ti_index (tree
);
123 static void create_tinfo_types (void);
124 static bool typeinfo_in_lib_p (tree
);
126 static int doing_runtime
= 0;
129 push_abi_namespace (void)
131 push_nested_namespace (abi_node
);
132 push_visibility ("default", 2);
136 pop_abi_namespace (void)
139 pop_nested_namespace (abi_node
);
142 /* Declare language defined type_info type and a pointer to const
143 type_info. This is incomplete here, and will be completed when
144 the user #includes <typeinfo>. There are language defined
145 restrictions on what can be done until that is included. Create
146 the internal versions of the ABI types. */
149 init_rtti_processing (void)
153 push_namespace (std_identifier
);
154 type_info_type
= xref_tag (class_type
, get_identifier ("type_info"),
155 /*tag_scope=*/ts_current
, false);
157 const_type_info_type_node
158 = cp_build_qualified_type (type_info_type
, TYPE_QUAL_CONST
);
159 type_info_ptr_type
= build_pointer_type (const_type_info_type_node
);
161 unemitted_tinfo_decls
= VEC_alloc (tree
, gc
, 124);
163 create_tinfo_types ();
166 /* Given the expression EXP of type `class *', return the head of the
167 object pointed to by EXP with type cv void*, if the class has any
168 virtual functions (TYPE_POLYMORPHIC_P), else just return the
172 build_headof (tree exp
)
174 tree type
= TREE_TYPE (exp
);
178 gcc_assert (TREE_CODE (type
) == POINTER_TYPE
);
179 type
= TREE_TYPE (type
);
181 if (!TYPE_POLYMORPHIC_P (type
))
184 /* We use this a couple of times below, protect it. */
185 exp
= save_expr (exp
);
187 /* The offset-to-top field is at index -2 from the vptr. */
188 index
= build_int_cst (NULL_TREE
,
189 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
191 offset
= build_vtbl_ref (cp_build_indirect_ref (exp
, RO_NULL
,
192 tf_warning_or_error
),
195 type
= cp_build_qualified_type (ptr_type_node
,
196 cp_type_quals (TREE_TYPE (exp
)));
197 return build2 (POINTER_PLUS_EXPR
, type
, exp
,
198 convert_to_integer (sizetype
, offset
));
201 /* Get a bad_cast node for the program to throw...
203 See libstdc++/exception.cc for __throw_bad_cast */
206 throw_bad_cast (void)
208 tree fn
= get_identifier ("__cxa_bad_cast");
209 if (!get_global_value_if_present (fn
, &fn
))
210 fn
= push_throw_library_fn (fn
, build_function_type (ptr_type_node
,
213 return build_cxx_call (fn
, 0, NULL
);
216 /* Return an expression for "__cxa_bad_typeid()". The expression
217 returned is an lvalue of type "const std::type_info". */
220 throw_bad_typeid (void)
222 tree fn
= get_identifier ("__cxa_bad_typeid");
223 if (!get_global_value_if_present (fn
, &fn
))
227 t
= build_reference_type (const_type_info_type_node
);
228 t
= build_function_type (t
, void_list_node
);
229 fn
= push_throw_library_fn (fn
, t
);
232 return build_cxx_call (fn
, 0, NULL
);
235 /* Return an lvalue expression whose type is "const std::type_info"
236 and whose value indicates the type of the expression EXP. If EXP
237 is a reference to a polymorphic class, return the dynamic type;
238 otherwise return the static type of the expression. */
241 get_tinfo_decl_dynamic (tree exp
)
246 if (error_operand_p (exp
))
247 return error_mark_node
;
249 exp
= resolve_nondeduced_context (exp
);
251 /* peel back references, so they match. */
252 type
= non_reference (TREE_TYPE (exp
));
254 /* Peel off cv qualifiers. */
255 type
= TYPE_MAIN_VARIANT (type
);
257 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
258 if (CLASS_TYPE_P (type
) || type
== unknown_type_node
259 || type
== init_list_type_node
)
260 type
= complete_type_or_else (type
, exp
);
263 return error_mark_node
;
265 /* If exp is a reference to polymorphic type, get the real type_info. */
266 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
268 /* build reference to type_info from vtable. */
271 /* The RTTI information is at index -1. */
272 index
= build_int_cst (NULL_TREE
,
273 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
274 t
= build_vtbl_ref (exp
, index
);
275 t
= convert (type_info_ptr_type
, t
);
278 /* Otherwise return the type_info for the static type of the expr. */
279 t
= get_tinfo_ptr (TYPE_MAIN_VARIANT (type
));
281 return cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
287 tree pseudo_type_info
, type_info_type
;
291 error ("cannot use typeid with -fno-rtti");
295 if (!COMPLETE_TYPE_P (const_type_info_type_node
))
297 error ("must #include <typeinfo> before using typeid");
302 = VEC_index (tinfo_s
, tinfo_descs
, TK_TYPE_INFO_TYPE
)->type
;
303 type_info_type
= TYPE_MAIN_VARIANT (const_type_info_type_node
);
305 /* Make sure abi::__type_info_pseudo has the same alias set
306 as std::type_info. */
307 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info
))
308 TYPE_ALIAS_SET (pseudo_type_info
) = get_alias_set (type_info_type
);
310 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info
)
311 == get_alias_set (type_info_type
));
316 /* Return an expression for "typeid(EXP)". The expression returned is
317 an lvalue of type "const std::type_info". */
320 build_typeid (tree exp
)
322 tree cond
= NULL_TREE
, initial_expr
= exp
;
325 if (exp
== error_mark_node
|| !typeid_ok_p ())
326 return error_mark_node
;
328 if (processing_template_decl
)
329 return build_min (TYPEID_EXPR
, const_type_info_type_node
, exp
);
331 if (TREE_CODE (exp
) == INDIRECT_REF
332 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
333 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
334 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
337 /* So we need to look into the vtable of the type of exp.
338 This is an lvalue use of expr then. */
339 exp
= mark_lvalue_use (exp
);
340 exp
= stabilize_reference (exp
);
341 cond
= cp_convert (boolean_type_node
, TREE_OPERAND (exp
, 0));
344 exp
= get_tinfo_decl_dynamic (exp
);
346 if (exp
== error_mark_node
)
347 return error_mark_node
;
351 tree bad
= throw_bad_typeid ();
353 exp
= build3 (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
356 mark_type_use (initial_expr
);
361 /* Generate the NTBS name of a type. If MARK_PRIVATE, put a '*' in front so that
362 comparisons will be done by pointer rather than string comparison. */
364 tinfo_name (tree type
, bool mark_private
)
370 name
= mangle_type_string (type
);
371 length
= strlen (name
);
375 /* Inject '*' at beginning of name to force pointer comparison. */
376 char* buf
= (char*) XALLOCAVEC (char, length
+ 2);
378 memcpy (buf
+ 1, name
, length
+ 1);
379 name_string
= build_string (length
+ 2, buf
);
382 name_string
= build_string (length
+ 1, name
);
384 return fix_string_type (name_string
);
387 /* Return a VAR_DECL for the internal ABI defined type_info object for
388 TYPE. You must arrange that the decl is mark_used, if actually use
389 it --- decls in vtables are only used if the vtable is output. */
392 get_tinfo_decl (tree type
)
397 if (variably_modified_type_p (type
, /*fn=*/NULL_TREE
))
399 error ("cannot create type information for type %qT because "
400 "it involves types of variable size",
402 return error_mark_node
;
405 if (TREE_CODE (type
) == METHOD_TYPE
)
406 type
= build_function_type (TREE_TYPE (type
),
407 TREE_CHAIN (TYPE_ARG_TYPES (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
), integer_zero_node
)),
506 cp_convert (TREE_TYPE (result
), integer_zero_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
);
517 tree exprtype
= TREE_TYPE (expr
);
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 /* If T is a pointer type, v shall be an rvalue of a pointer to
554 complete class type, and the result is an rvalue of type T. */
556 expr
= mark_rvalue_use (expr
);
558 if (TREE_CODE (exprtype
) != POINTER_TYPE
)
560 errstr
= _("source is not a pointer");
563 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
565 errstr
= _("source is not a pointer to class");
568 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
570 errstr
= _("source is a pointer to incomplete type");
576 expr
= mark_lvalue_use (expr
);
578 exprtype
= build_reference_type (exprtype
);
580 /* T is a reference type, v shall be an lvalue of a complete class
581 type, and the result is an lvalue of the type referred to by T. */
583 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype
)))
585 errstr
= _("source is not of class type");
588 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
590 errstr
= _("source is of incomplete class type");
594 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
595 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
596 LOOKUP_NORMAL
, NULL_TREE
);
599 /* The dynamic_cast operator shall not cast away constness. */
600 if (!at_least_as_qualified_p (TREE_TYPE (type
),
601 TREE_TYPE (exprtype
)))
603 errstr
= _("conversion casts away constness");
607 /* If *type is an unambiguous accessible base class of *exprtype,
608 convert statically. */
612 binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
617 expr
= build_base_path (PLUS_EXPR
, convert_from_reference (expr
),
619 if (TREE_CODE (exprtype
) == POINTER_TYPE
)
620 expr
= rvalue (expr
);
625 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
626 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
629 /* if TYPE is `void *', return pointer to complete object. */
630 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
632 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
633 if (TREE_CODE (expr
) == ADDR_EXPR
634 && TREE_CODE (TREE_OPERAND (expr
, 0)) == VAR_DECL
635 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
636 return build1 (NOP_EXPR
, type
, expr
);
638 /* Since expr is used twice below, save it. */
639 expr
= save_expr (expr
);
641 expr1
= build_headof (expr
);
642 if (TREE_TYPE (expr1
) != type
)
643 expr1
= build1 (NOP_EXPR
, type
, expr1
);
644 return ifnonnull (expr
, expr1
);
649 tree result
, td2
, td3
;
651 tree static_type
, target_type
, boff
;
653 /* If we got here, we can't convert statically. Therefore,
654 dynamic_cast<D&>(b) (b an object) cannot succeed. */
655 if (tc
== REFERENCE_TYPE
)
657 if (TREE_CODE (old_expr
) == VAR_DECL
658 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
660 tree expr
= throw_bad_cast ();
661 if (complain
& tf_warning
)
662 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
664 /* Bash it to the expected type. */
665 TREE_TYPE (expr
) = type
;
669 /* Ditto for dynamic_cast<D*>(&b). */
670 else if (TREE_CODE (expr
) == ADDR_EXPR
)
672 tree op
= TREE_OPERAND (expr
, 0);
673 if (TREE_CODE (op
) == VAR_DECL
674 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
676 if (complain
& tf_warning
)
677 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
679 retval
= build_int_cst (type
, 0);
684 /* Use of dynamic_cast when -fno-rtti is prohibited. */
687 if (complain
& tf_error
)
688 error ("%<dynamic_cast%> not permitted with -fno-rtti");
689 return error_mark_node
;
692 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
693 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
694 td2
= get_tinfo_decl (target_type
);
696 td2
= cp_build_unary_op (ADDR_EXPR
, td2
, 0, complain
);
697 td3
= get_tinfo_decl (static_type
);
699 td3
= cp_build_unary_op (ADDR_EXPR
, td3
, 0, complain
);
701 /* Determine how T and V are related. */
702 boff
= dcast_base_hint (static_type
, target_type
);
704 /* Since expr is used twice below, save it. */
705 expr
= save_expr (expr
);
708 if (tc
== REFERENCE_TYPE
)
709 expr1
= cp_build_unary_op (ADDR_EXPR
, expr1
, 0, complain
);
716 dcast_fn
= dynamic_cast_node
;
723 push_abi_namespace ();
724 tinfo_ptr
= xref_tag (class_type
,
725 get_identifier ("__class_type_info"),
726 /*tag_scope=*/ts_current
, false);
728 tinfo_ptr
= build_pointer_type
729 (cp_build_qualified_type
730 (tinfo_ptr
, TYPE_QUAL_CONST
));
731 name
= "__dynamic_cast";
733 (NULL_TREE
, const_ptr_type_node
, tree_cons
734 (NULL_TREE
, tinfo_ptr
, tree_cons
735 (NULL_TREE
, tinfo_ptr
, tree_cons
736 (NULL_TREE
, ptrdiff_type_node
, void_list_node
))));
737 tmp
= build_function_type (ptr_type_node
, tmp
);
738 dcast_fn
= build_library_fn_ptr (name
, tmp
);
739 DECL_PURE_P (dcast_fn
) = 1;
740 pop_abi_namespace ();
741 dynamic_cast_node
= dcast_fn
;
743 result
= build_cxx_call (dcast_fn
, 4, elems
);
745 if (tc
== REFERENCE_TYPE
)
747 tree bad
= throw_bad_cast ();
750 result
= save_expr (result
);
751 neq
= c_common_truthvalue_conversion (input_location
, result
);
752 return cp_convert (type
,
753 build3 (COND_EXPR
, TREE_TYPE (result
),
757 /* Now back to the type we want from a void*. */
758 result
= cp_convert (type
, result
);
759 return ifnonnull (expr
, result
);
763 errstr
= _("source type is not polymorphic");
766 if (complain
& tf_error
)
767 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
768 expr
, exprtype
, type
, errstr
);
769 return error_mark_node
;
773 build_dynamic_cast (tree type
, tree expr
, tsubst_flags_t complain
)
775 if (type
== error_mark_node
|| expr
== error_mark_node
)
776 return error_mark_node
;
778 if (processing_template_decl
)
780 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
781 TREE_SIDE_EFFECTS (expr
) = 1;
782 return convert_from_reference (expr
);
785 return convert_from_reference (build_dynamic_cast_1 (type
, expr
, complain
));
788 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
791 qualifier_flags (tree type
)
794 int quals
= cp_type_quals (type
);
796 if (quals
& TYPE_QUAL_CONST
)
798 if (quals
& TYPE_QUAL_VOLATILE
)
800 if (quals
& TYPE_QUAL_RESTRICT
)
805 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
806 contains a pointer to member of an incomplete class. */
809 target_incomplete_p (tree type
)
812 if (TYPE_PTRMEM_P (type
))
814 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
816 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
818 else if (TREE_CODE (type
) == POINTER_TYPE
)
819 type
= TREE_TYPE (type
);
821 return !COMPLETE_OR_VOID_TYPE_P (type
);
824 /* Returns true if TYPE involves an incomplete class type; in that
825 case, typeinfo variables for TYPE should be emitted with internal
829 involves_incomplete_p (tree type
)
831 switch (TREE_CODE (type
))
834 return target_incomplete_p (TREE_TYPE (type
));
839 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
840 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
843 if (TYPE_PTRMEMFUNC_P (type
))
847 if (!COMPLETE_TYPE_P (type
))
851 /* All other types do not involve incomplete class types. */
856 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
857 is the vtable pointer and NTBS name. The NTBS name is emitted as a
858 comdat const char array, so it becomes a unique key for the type. Generate
859 and emit that VAR_DECL here. (We can't always emit the type_info itself
860 as comdat, because of pointers to incomplete.) */
863 tinfo_base_init (tinfo_s
*ti
, tree target
)
868 VEC(constructor_elt
,gc
) *v
;
871 tree name_name
, name_string
;
873 /* Generate the NTBS array variable. */
874 tree name_type
= build_cplus_array_type
875 (cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
878 /* Determine the name of the variable -- and remember with which
879 type it is associated. */
880 name_name
= mangle_typeinfo_string_for_type (target
);
881 TREE_TYPE (name_name
) = target
;
883 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
884 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
885 DECL_ARTIFICIAL (name_decl
) = 1;
886 DECL_IGNORED_P (name_decl
) = 1;
887 TREE_READONLY (name_decl
) = 1;
888 TREE_STATIC (name_decl
) = 1;
889 DECL_EXTERNAL (name_decl
) = 0;
890 DECL_TINFO_P (name_decl
) = 1;
891 set_linkage_according_to_type (target
, name_decl
);
892 import_export_decl (name_decl
);
893 name_string
= tinfo_name (target
, !TREE_PUBLIC (name_decl
));
894 DECL_INITIAL (name_decl
) = name_string
;
895 mark_used (name_decl
);
896 pushdecl_top_level_and_finish (name_decl
, name_string
);
899 vtable_ptr
= ti
->vtable
;
903 push_abi_namespace ();
904 real_type
= xref_tag (class_type
, ti
->name
,
905 /*tag_scope=*/ts_current
, false);
906 pop_abi_namespace ();
908 if (!COMPLETE_TYPE_P (real_type
))
910 /* We never saw a definition of this type, so we need to
911 tell the compiler that this is an exported class, as
912 indeed all of the __*_type_info classes are. */
913 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
914 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
917 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
918 vtable_ptr
= cp_build_unary_op (ADDR_EXPR
, vtable_ptr
, 0,
919 tf_warning_or_error
);
921 /* We need to point into the middle of the vtable. */
923 (POINTER_PLUS_EXPR
, TREE_TYPE (vtable_ptr
), vtable_ptr
,
924 size_binop (MULT_EXPR
,
925 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
926 TYPE_SIZE_UNIT (vtable_entry_type
)));
928 ti
->vtable
= vtable_ptr
;
931 v
= VEC_alloc (constructor_elt
, gc
, 2);
932 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, vtable_ptr
);
933 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, decay_conversion (name_decl
));
935 init
= build_constructor (init_list_type_node
, v
);
936 TREE_CONSTANT (init
) = 1;
937 TREE_STATIC (init
) = 1;
942 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
943 information about the particular type_info derivation, which adds no
944 additional fields to the type_info base. */
947 generic_initializer (tinfo_s
*ti
, tree target
)
949 tree init
= tinfo_base_init (ti
, target
);
951 init
= build_constructor_single (init_list_type_node
, NULL_TREE
, init
);
952 TREE_CONSTANT (init
) = 1;
953 TREE_STATIC (init
) = 1;
957 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
958 TI provides information about the particular type_info derivation,
959 which adds target type and qualifier flags members to the type_info base. */
962 ptr_initializer (tinfo_s
*ti
, tree target
)
964 tree init
= tinfo_base_init (ti
, target
);
965 tree to
= TREE_TYPE (target
);
966 int flags
= qualifier_flags (to
);
967 bool incomplete
= target_incomplete_p (to
);
968 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, 3);
972 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
973 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
974 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
975 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
977 init
= build_constructor (init_list_type_node
, v
);
978 TREE_CONSTANT (init
) = 1;
979 TREE_STATIC (init
) = 1;
983 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
984 TI provides information about the particular type_info derivation,
985 which adds class, target type and qualifier flags members to the type_info
989 ptm_initializer (tinfo_s
*ti
, tree target
)
991 tree init
= tinfo_base_init (ti
, target
);
992 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
993 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
994 int flags
= qualifier_flags (to
);
995 bool incomplete
= target_incomplete_p (to
);
996 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, 4);
1000 if (!COMPLETE_TYPE_P (klass
))
1002 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1003 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, build_int_cst (NULL_TREE
, flags
));
1004 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
,
1005 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)));
1006 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, get_tinfo_ptr (klass
));
1008 init
= build_constructor (init_list_type_node
, v
);
1009 TREE_CONSTANT (init
) = 1;
1010 TREE_STATIC (init
) = 1;
1014 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1015 TI provides information about the particular __class_type_info derivation,
1016 which adds hint flags and N extra initializers to the type_info base. */
1019 class_initializer (tinfo_s
*ti
, tree target
, unsigned n
, ...)
1021 tree init
= tinfo_base_init (ti
, target
);
1022 va_list extra_inits
;
1024 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, n
+1);
1026 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
1027 va_start (extra_inits
, n
);
1028 for (i
= 0; i
< n
; i
++)
1029 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, va_arg (extra_inits
, tree
));
1030 va_end (extra_inits
);
1032 init
= build_constructor (init_list_type_node
, v
);
1033 TREE_CONSTANT (init
) = 1;
1034 TREE_STATIC (init
) = 1;
1038 /* Returns true if the typeinfo for type should be placed in
1039 the runtime library. */
1042 typeinfo_in_lib_p (tree type
)
1044 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1045 library for simple types T. */
1046 if (TREE_CODE (type
) == POINTER_TYPE
1047 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
1048 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
1049 type
= TREE_TYPE (type
);
1051 switch (TREE_CODE (type
))
1060 if (NULLPTR_TYPE_P (type
))
1062 /* else fall through. */
1069 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1070 the index of the descriptor in the tinfo_desc vector. */
1073 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1075 tinfo_s
*ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1077 gcc_assert (at_eof
);
1080 case TK_POINTER_MEMBER_TYPE
:
1081 return ptm_initializer (ti
, type
);
1083 case TK_POINTER_TYPE
:
1084 return ptr_initializer (ti
, type
);
1086 case TK_BUILTIN_TYPE
:
1087 case TK_ENUMERAL_TYPE
:
1088 case TK_FUNCTION_TYPE
:
1090 return generic_initializer (ti
, type
);
1093 return class_initializer (ti
, type
, 0);
1095 case TK_SI_CLASS_TYPE
:
1097 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1098 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1100 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1101 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1102 return class_initializer (ti
, type
, 1, tinfo
);
1107 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1108 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1109 tree binfo
= TYPE_BINFO (type
);
1110 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1111 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1112 tree offset_type
= integer_types
[itk_long
];
1113 tree base_inits
= NULL_TREE
;
1115 VEC(constructor_elt
,gc
) *init_vec
= NULL
;
1118 gcc_assert (tk_index
>= TK_FIXED
);
1120 VEC_safe_grow (constructor_elt
, gc
, init_vec
, nbases
);
1121 /* Generate the base information initializer. */
1122 for (ix
= nbases
; ix
--;)
1124 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1129 VEC(constructor_elt
,gc
) *v
;
1131 if (VEC_index (tree
, base_accesses
, ix
) == access_public_node
)
1133 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1134 if (BINFO_VIRTUAL_P (base_binfo
))
1136 /* We store the vtable offset at which the virtual
1137 base offset can be found. */
1138 offset
= BINFO_VPTR_FIELD (base_binfo
);
1142 offset
= BINFO_OFFSET (base_binfo
);
1144 /* Combine offset and flags into one field. */
1145 offset
= fold_convert (offset_type
, offset
);
1146 offset
= fold_build2_loc (input_location
,
1147 LSHIFT_EXPR
, offset_type
, offset
,
1148 build_int_cst (offset_type
, 8));
1149 offset
= fold_build2_loc (input_location
,
1150 BIT_IOR_EXPR
, offset_type
, offset
,
1151 build_int_cst (offset_type
, flags
));
1152 v
= VEC_alloc (constructor_elt
, gc
, 2);
1153 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, tinfo
);
1154 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, offset
);
1155 base_init
= build_constructor (init_list_type_node
, v
);
1156 e
= VEC_index (constructor_elt
, init_vec
, ix
);
1157 e
->index
= NULL_TREE
;
1158 e
->value
= base_init
;
1160 base_inits
= build_constructor (init_list_type_node
, init_vec
);
1162 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1163 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1164 return class_initializer (ti
, type
, 3,
1165 build_int_cst (NULL_TREE
, hint
),
1166 build_int_cst (NULL_TREE
, nbases
),
1172 /* Generate the RECORD_TYPE containing the data layout of a type_info
1173 derivative as used by the runtime. This layout must be consistent with
1174 that defined in the runtime support. Also generate the VAR_DECL for the
1175 type's vtable. We explicitly manage the vtable member, and name it for
1176 real type as used in the runtime. The RECORD type has a different name,
1177 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1178 is the generated type and TINFO_VTABLE_NAME is the name of the
1179 vtable. We have to delay generating the VAR_DECL of the vtable
1180 until the end of the translation, when we'll have seen the library
1181 definition, if there was one.
1183 REAL_NAME is the runtime's name of the type. Trailing arguments are
1184 additional FIELD_DECL's for the structure. The final argument must be
1188 create_pseudo_type_info (int tk
, const char *real_name
, ...)
1197 va_start (ap
, real_name
);
1199 /* Generate the pseudo type name. */
1200 pseudo_name
= (char *) alloca (strlen (real_name
) + 30);
1201 strcpy (pseudo_name
, real_name
);
1202 strcat (pseudo_name
, "_pseudo");
1204 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", tk
- TK_FIXED
);
1206 /* First field is the pseudo type_info base class. */
1207 fields
= build_decl (input_location
,
1208 FIELD_DECL
, NULL_TREE
,
1209 VEC_index (tinfo_s
, tinfo_descs
,
1210 TK_TYPE_INFO_TYPE
)->type
);
1212 /* Now add the derived fields. */
1213 while ((field_decl
= va_arg (ap
, tree
)))
1215 TREE_CHAIN (field_decl
) = fields
;
1216 fields
= field_decl
;
1219 /* Create the pseudo type. */
1220 pseudo_type
= make_class_type (RECORD_TYPE
);
1221 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1222 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1224 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk
);
1225 ti
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1226 ti
->name
= get_identifier (real_name
);
1227 ti
->vtable
= NULL_TREE
;
1229 /* Pretend this is public so determine_visibility doesn't give vtables
1230 internal linkage. */
1231 TREE_PUBLIC (TYPE_MAIN_DECL (ti
->type
)) = 1;
1236 /* Return the index of a pseudo type info type node used to describe
1237 TYPE. TYPE must be a complete type (or cv void), except at the end
1238 of the translation unit. */
1241 get_pseudo_ti_index (tree type
)
1245 switch (TREE_CODE (type
))
1248 ix
= TK_POINTER_MEMBER_TYPE
;
1252 ix
= TK_POINTER_TYPE
;
1256 ix
= TK_ENUMERAL_TYPE
;
1260 ix
= TK_FUNCTION_TYPE
;
1269 if (TYPE_PTRMEMFUNC_P (type
))
1271 ix
= TK_POINTER_MEMBER_TYPE
;
1274 else if (!COMPLETE_TYPE_P (type
))
1277 cxx_incomplete_type_error (NULL_TREE
, type
);
1281 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1288 tree binfo
= TYPE_BINFO (type
);
1289 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1290 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1291 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1294 && VEC_index (tree
, base_accesses
, 0) == access_public_node
1295 && !BINFO_VIRTUAL_P (base_binfo
)
1296 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1298 /* single non-virtual public. */
1299 ix
= TK_SI_CLASS_TYPE
;
1305 tree array_domain
, base_array
;
1307 ix
= TK_FIXED
+ num_bases
;
1308 if (VEC_length (tinfo_s
, tinfo_descs
) <= ix
)
1310 /* too short, extend. */
1311 unsigned len
= VEC_length (tinfo_s
, tinfo_descs
);
1313 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, ix
+ 1);
1314 while (VEC_iterate (tinfo_s
, tinfo_descs
, len
++, ti
))
1315 ti
->type
= ti
->vtable
= ti
->name
= NULL_TREE
;
1317 else if (VEC_index (tinfo_s
, tinfo_descs
, ix
)->type
)
1318 /* already created. */
1321 /* Create the array of __base_class_type_info entries.
1322 G++ 3.2 allocated an array that had one too many
1323 entries, and then filled that extra entries with
1325 if (abi_version_at_least (2))
1326 array_domain
= build_index_type (size_int (num_bases
- 1));
1328 array_domain
= build_index_type (size_int (num_bases
));
1330 build_array_type (VEC_index (tinfo_s
, tinfo_descs
,
1331 TK_BASE_TYPE
)->type
,
1334 push_abi_namespace ();
1335 create_pseudo_type_info
1336 (ix
, "__vmi_class_type_info",
1337 build_decl (input_location
,
1338 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1339 build_decl (input_location
,
1340 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1341 build_decl (input_location
,
1342 FIELD_DECL
, NULL_TREE
, base_array
),
1344 pop_abi_namespace ();
1349 ix
= TK_BUILTIN_TYPE
;
1355 /* Make sure the required builtin types exist for generating the type_info
1356 variable definitions. */
1359 create_tinfo_types (void)
1363 gcc_assert (!tinfo_descs
);
1365 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, TK_FIXED
);
1367 push_abi_namespace ();
1369 /* Create the internal type_info structure. This is used as a base for
1370 the other structures. */
1374 field
= build_decl (BUILTINS_LOCATION
,
1375 FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1378 field
= build_decl (BUILTINS_LOCATION
,
1379 FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1380 TREE_CHAIN (field
) = fields
;
1383 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_TYPE_INFO_TYPE
);
1384 ti
->type
= make_class_type (RECORD_TYPE
);
1385 ti
->vtable
= NULL_TREE
;
1386 ti
->name
= NULL_TREE
;
1387 finish_builtin_struct (ti
->type
, "__type_info_pseudo",
1391 /* Fundamental type_info */
1392 create_pseudo_type_info (TK_BUILTIN_TYPE
, "__fundamental_type_info", NULL
);
1394 /* Array, function and enum type_info. No additional fields. */
1395 create_pseudo_type_info (TK_ARRAY_TYPE
, "__array_type_info", NULL
);
1396 create_pseudo_type_info (TK_FUNCTION_TYPE
, "__function_type_info", NULL
);
1397 create_pseudo_type_info (TK_ENUMERAL_TYPE
, "__enum_type_info", NULL
);
1399 /* Class type_info. No additional fields. */
1400 create_pseudo_type_info (TK_CLASS_TYPE
, "__class_type_info", NULL
);
1402 /* Single public non-virtual base class. Add pointer to base class.
1403 This is really a descendant of __class_type_info. */
1404 create_pseudo_type_info (TK_SI_CLASS_TYPE
, "__si_class_type_info",
1405 build_decl (BUILTINS_LOCATION
,
1406 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1409 /* Base class internal helper. Pointer to base type, offset to base,
1414 field
= build_decl (BUILTINS_LOCATION
,
1415 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
);
1418 field
= build_decl (BUILTINS_LOCATION
,
1419 FIELD_DECL
, NULL_TREE
, integer_types
[itk_long
]);
1420 TREE_CHAIN (field
) = fields
;
1423 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_BASE_TYPE
);
1425 ti
->type
= make_class_type (RECORD_TYPE
);
1426 ti
->vtable
= NULL_TREE
;
1427 ti
->name
= NULL_TREE
;
1428 finish_builtin_struct (ti
->type
, "__base_class_type_info_pseudo",
1432 /* Pointer type_info. Adds two fields, qualification mask
1433 and pointer to the pointed to type. This is really a descendant of
1434 __pbase_type_info. */
1435 create_pseudo_type_info (TK_POINTER_TYPE
, "__pointer_type_info",
1436 build_decl (BUILTINS_LOCATION
,
1437 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1438 build_decl (BUILTINS_LOCATION
,
1439 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1442 /* Pointer to member data type_info. Add qualifications flags,
1443 pointer to the member's type info and pointer to the class.
1444 This is really a descendant of __pbase_type_info. */
1445 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE
,
1446 "__pointer_to_member_type_info",
1447 build_decl (BUILTINS_LOCATION
,
1448 FIELD_DECL
, NULL_TREE
, integer_type_node
),
1449 build_decl (BUILTINS_LOCATION
,
1450 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1451 build_decl (BUILTINS_LOCATION
,
1452 FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1455 pop_abi_namespace ();
1458 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1459 support. Generating them here guarantees consistency with the other
1460 structures. We use the following heuristic to determine when the runtime
1461 is being generated. If std::__fundamental_type_info is defined, and its
1462 destructor is defined, then the runtime is being built. */
1465 emit_support_tinfos (void)
1467 /* Dummy static variable so we can put nullptr in the array; it will be
1468 set before we actually start to walk the array. */
1469 static tree
*const fundamentals
[] =
1473 &wchar_type_node
, &char16_type_node
, &char32_type_node
,
1474 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1475 &short_integer_type_node
, &short_unsigned_type_node
,
1476 &integer_type_node
, &unsigned_type_node
,
1477 &long_integer_type_node
, &long_unsigned_type_node
,
1478 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1479 &int128_integer_type_node
, &int128_unsigned_type_node
,
1480 &float_type_node
, &double_type_node
, &long_double_type_node
,
1481 &dfloat32_type_node
, &dfloat64_type_node
, &dfloat128_type_node
,
1486 tree bltn_type
, dtor
;
1488 push_abi_namespace ();
1489 bltn_type
= xref_tag (class_type
,
1490 get_identifier ("__fundamental_type_info"),
1491 /*tag_scope=*/ts_current
, false);
1492 pop_abi_namespace ();
1493 if (!COMPLETE_TYPE_P (bltn_type
))
1495 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1496 if (!dtor
|| DECL_EXTERNAL (dtor
))
1499 for (ix
= 0; fundamentals
[ix
]; ix
++)
1501 tree bltn
= *fundamentals
[ix
];
1505 if (bltn
== NULL_TREE
)
1508 types
[1] = build_pointer_type (bltn
);
1509 types
[2] = build_pointer_type (cp_build_qualified_type (bltn
,
1512 for (i
= 0; i
< 3; ++i
)
1516 tinfo
= get_tinfo_decl (types
[i
]);
1517 TREE_USED (tinfo
) = 1;
1518 mark_needed (tinfo
);
1519 /* The C++ ABI requires that these objects be COMDAT. But,
1520 On systems without weak symbols, initialized COMDAT
1521 objects are emitted with internal linkage. (See
1522 comdat_linkage for details.) Since we want these objects
1523 to have external linkage so that copies do not have to be
1524 emitted in code outside the runtime library, we make them
1527 It might also not be necessary to follow this detail of the
1529 if (!flag_weak
|| ! targetm
.cxx
.library_rtti_comdat ())
1531 gcc_assert (TREE_PUBLIC (tinfo
) && !DECL_COMDAT (tinfo
));
1532 DECL_INTERFACE_KNOWN (tinfo
) = 1;
1538 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1539 tinfo decl. Determine whether it needs emitting, and if so
1540 generate the initializer. */
1543 emit_tinfo_decl (tree decl
)
1545 tree type
= TREE_TYPE (DECL_NAME (decl
));
1546 int in_library
= typeinfo_in_lib_p (type
);
1548 gcc_assert (DECL_TINFO_P (decl
));
1553 DECL_EXTERNAL (decl
) = 0;
1556 /* If we're not in the runtime, then DECL (which is already
1557 DECL_EXTERNAL) will not be defined here. */
1558 DECL_INTERFACE_KNOWN (decl
) = 1;
1562 else if (involves_incomplete_p (type
))
1564 if (!decl_needed_p (decl
))
1566 /* If TYPE involves an incomplete class type, then the typeinfo
1567 object will be emitted with internal linkage. There is no
1568 way to know whether or not types are incomplete until the end
1569 of the compilation, so this determination must be deferred
1570 until this point. */
1571 TREE_PUBLIC (decl
) = 0;
1572 DECL_EXTERNAL (decl
) = 0;
1573 DECL_INTERFACE_KNOWN (decl
) = 1;
1576 import_export_decl (decl
);
1577 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1581 DECL_EXTERNAL (decl
) = 0;
1582 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1583 DECL_INITIAL (decl
) = init
;
1585 cp_finish_decl (decl
, init
, false, NULL_TREE
, 0);
1592 #include "gt-cp-rtti.h"