1 /* RunTime Type Identification
2 Copyright (C) 1995-2015 Free Software Foundation, Inc.
3 Mostly written by Jason Merrill (jason@cygnus.com).
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
29 #include "double-int.h"
37 #include "stringpool.h"
38 #include "stor-layout.h"
43 #include "c-family/c-pragma.h"
45 /* C++ returns type information to the user in struct type_info
46 objects. We also use type information to implement dynamic_cast and
47 exception handlers. Type information for a particular type is
48 indicated with an ABI defined structure derived from type_info.
49 This would all be very straight forward, but for the fact that the
50 runtime library provides the definitions of the type_info structure
51 and the ABI defined derived classes. We cannot build declarations
52 of them directly in the compiler, but we need to layout objects of
53 their type. Somewhere we have to lie.
55 We define layout compatible POD-structs with compiler-defined names
56 and generate the appropriate initializations for them (complete
57 with explicit mention of their vtable). When we have to provide a
58 type_info to the user we reinterpret_cast the internal compiler
59 type to type_info. A well formed program can only explicitly refer
60 to the type_infos of complete types (& cv void). However, we chain
61 pointer type_infos to the pointed-to-type, and that can be
62 incomplete. We only need the addresses of such incomplete
63 type_info objects for static initialization.
65 The type information VAR_DECL of a type is held on the
66 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
67 will be the internal type. It will usually have the correct
68 internal type reflecting the kind of type it represents (pointer,
69 array, function, class, inherited class, etc). When the type it
70 represents is incomplete, it will have the internal type
71 corresponding to type_info. That will only happen at the end of
72 translation, when we are emitting the type info objects. */
74 /* Auxiliary data we hold for each type_info derived object we need. */
75 typedef struct GTY (()) tinfo_s {
76 tree type; /* The RECORD_TYPE for this type_info object */
78 tree vtable; /* The VAR_DECL of the vtable. Only filled at end of
81 tree name; /* IDENTIFIER_NODE for the ABI specified name of
82 the type_info derived type. */
86 typedef enum tinfo_kind
88 TK_TYPE_INFO_TYPE, /* abi::__type_info_pseudo */
89 TK_BASE_TYPE, /* abi::__base_class_type_info */
90 TK_BUILTIN_TYPE, /* abi::__fundamental_type_info */
91 TK_ARRAY_TYPE, /* abi::__array_type_info */
92 TK_FUNCTION_TYPE, /* abi::__function_type_info */
93 TK_ENUMERAL_TYPE, /* abi::__enum_type_info */
94 TK_POINTER_TYPE, /* abi::__pointer_type_info */
95 TK_POINTER_MEMBER_TYPE, /* abi::__pointer_to_member_type_info */
96 TK_CLASS_TYPE, /* abi::__class_type_info */
97 TK_SI_CLASS_TYPE, /* abi::__si_class_type_info */
98 TK_FIXED /* end of fixed descriptors. */
99 /* ... abi::__vmi_type_info<I> */
102 /* Helper macro to get maximum scalar-width of pointer or of the 'long'-type.
103 This of interest for llp64 targets. */
105 integer_types[(POINTER_SIZE <= TYPE_PRECISION (integer_types[itk_long]) \
106 ? itk_long : itk_long_long)]
108 /* A vector of all tinfo decls that haven't yet been emitted. */
109 vec<tree, va_gc> *unemitted_tinfo_decls;
111 /* A vector of all type_info derived types we need. The first few are
112 fixed and created early. The remainder are for multiple inheritance
113 and are generated as needed. */
114 static GTY (()) vec<tinfo_s, va_gc> *tinfo_descs;
116 static tree ifnonnull (tree, tree, tsubst_flags_t);
117 static tree tinfo_name (tree, bool);
118 static tree build_dynamic_cast_1 (tree, tree, tsubst_flags_t);
119 static tree throw_bad_cast (void);
120 static tree throw_bad_typeid (void);
121 static tree get_tinfo_ptr (tree);
122 static bool typeid_ok_p (void);
123 static int qualifier_flags (tree);
124 static bool target_incomplete_p (tree);
125 static tree tinfo_base_init (tinfo_s *, tree);
126 static tree generic_initializer (tinfo_s *, tree);
127 static tree ptr_initializer (tinfo_s *, tree);
128 static tree ptm_initializer (tinfo_s *, tree);
129 static tree class_initializer (tinfo_s *, tree, unsigned, ...);
130 static void create_pseudo_type_info (int, const char *, ...);
131 static tree get_pseudo_ti_init (tree, unsigned);
132 static unsigned get_pseudo_ti_index (tree);
133 static void create_tinfo_types (void);
134 static bool typeinfo_in_lib_p (tree);
136 static int doing_runtime = 0;
139 push_abi_namespace (void)
141 push_nested_namespace (abi_node);
142 push_visibility ("default", 2);
146 pop_abi_namespace (void)
149 pop_nested_namespace (abi_node);
152 /* Declare language defined type_info type and a pointer to const
153 type_info. This is incomplete here, and will be completed when
154 the user #includes <typeinfo>. There are language defined
155 restrictions on what can be done until that is included. Create
156 the internal versions of the ABI types. */
159 init_rtti_processing (void)
163 push_namespace (std_identifier);
164 type_info_type = xref_tag (class_type, get_identifier ("type_info"),
165 /*tag_scope=*/ts_current, false);
167 const_type_info_type_node
168 = cp_build_qualified_type (type_info_type, TYPE_QUAL_CONST);
169 type_info_ptr_type = build_pointer_type (const_type_info_type_node);
171 vec_alloc (unemitted_tinfo_decls, 124);
173 create_tinfo_types ();
176 /* Given the expression EXP of type `class *', return the head of the
177 object pointed to by EXP with type cv void*, if the class has any
178 virtual functions (TYPE_POLYMORPHIC_P), else just return the
182 build_headof (tree exp)
184 tree type = TREE_TYPE (exp);
188 gcc_assert (TYPE_PTR_P (type));
189 type = TREE_TYPE (type);
191 if (!TYPE_POLYMORPHIC_P (type))
194 /* We use this a couple of times below, protect it. */
195 exp = save_expr (exp);
197 /* The offset-to-top field is at index -2 from the vptr. */
198 index = build_int_cst (NULL_TREE,
199 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
201 offset = build_vtbl_ref (cp_build_indirect_ref (exp, RO_NULL,
202 tf_warning_or_error),
205 type = cp_build_qualified_type (ptr_type_node,
206 cp_type_quals (TREE_TYPE (exp)));
207 return fold_build_pointer_plus (exp, offset);
210 /* Get a bad_cast node for the program to throw...
212 See libstdc++/exception.cc for __throw_bad_cast */
215 throw_bad_cast (void)
217 tree fn = get_identifier ("__cxa_bad_cast");
218 if (!get_global_value_if_present (fn, &fn))
219 fn = push_throw_library_fn (fn, build_function_type_list (ptr_type_node,
222 return build_cxx_call (fn, 0, NULL, tf_warning_or_error);
225 /* Return an expression for "__cxa_bad_typeid()". The expression
226 returned is an lvalue of type "const std::type_info". */
229 throw_bad_typeid (void)
231 tree fn = get_identifier ("__cxa_bad_typeid");
232 if (!get_global_value_if_present (fn, &fn))
236 t = build_reference_type (const_type_info_type_node);
237 t = build_function_type_list (t, NULL_TREE);
238 fn = push_throw_library_fn (fn, t);
241 return build_cxx_call (fn, 0, NULL, tf_warning_or_error);
244 /* Return an lvalue expression whose type is "const std::type_info"
245 and whose value indicates the type of the expression EXP. If EXP
246 is a reference to a polymorphic class, return the dynamic type;
247 otherwise return the static type of the expression. */
250 get_tinfo_decl_dynamic (tree exp, tsubst_flags_t complain)
255 if (error_operand_p (exp))
256 return error_mark_node;
258 exp = resolve_nondeduced_context (exp);
260 /* peel back references, so they match. */
261 type = non_reference (TREE_TYPE (exp));
263 /* Peel off cv qualifiers. */
264 type = TYPE_MAIN_VARIANT (type);
266 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
267 if (CLASS_TYPE_P (type) || type == unknown_type_node
268 || type == init_list_type_node)
269 type = complete_type_or_maybe_complain (type, exp, complain);
272 return error_mark_node;
274 /* If exp is a reference to polymorphic type, get the real type_info. */
275 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
277 /* build reference to type_info from vtable. */
280 /* The RTTI information is at index -1. */
281 index = build_int_cst (NULL_TREE,
282 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
283 t = build_vtbl_ref (exp, index);
284 t = convert (type_info_ptr_type, t);
287 /* Otherwise return the type_info for the static type of the expr. */
288 t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
290 return cp_build_indirect_ref (t, RO_NULL, complain);
296 tree pseudo_type_info, type_info_type;
300 error ("cannot use typeid with -fno-rtti");
304 if (!COMPLETE_TYPE_P (const_type_info_type_node))
306 error ("must #include <typeinfo> before using typeid");
310 pseudo_type_info = (*tinfo_descs)[TK_TYPE_INFO_TYPE].type;
311 type_info_type = TYPE_MAIN_VARIANT (const_type_info_type_node);
313 /* Make sure abi::__type_info_pseudo has the same alias set
314 as std::type_info. */
315 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info))
316 TYPE_ALIAS_SET (pseudo_type_info) = get_alias_set (type_info_type);
318 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info)
319 == get_alias_set (type_info_type));
324 /* Return an expression for "typeid(EXP)". The expression returned is
325 an lvalue of type "const std::type_info". */
328 build_typeid (tree exp, tsubst_flags_t complain)
330 tree cond = NULL_TREE, initial_expr = exp;
333 if (exp == error_mark_node || !typeid_ok_p ())
334 return error_mark_node;
336 if (processing_template_decl)
337 return build_min (TYPEID_EXPR, const_type_info_type_node, exp);
339 /* FIXME when integrating with c_fully_fold, mark
340 resolves_to_fixed_type_p case as a non-constant expression. */
341 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
342 && ! resolves_to_fixed_type_p (exp, &nonnull)
345 /* So we need to look into the vtable of the type of exp.
346 Make sure it isn't a null lvalue. */
347 exp = cp_build_addr_expr (exp, complain);
348 exp = stabilize_reference (exp);
349 cond = cp_convert (boolean_type_node, exp, complain);
350 exp = cp_build_indirect_ref (exp, RO_NULL, complain);
353 exp = get_tinfo_decl_dynamic (exp, complain);
355 if (exp == error_mark_node)
356 return error_mark_node;
360 tree bad = throw_bad_typeid ();
362 exp = build3 (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
365 mark_type_use (initial_expr);
370 /* Generate the NTBS name of a type. If MARK_PRIVATE, put a '*' in front so that
371 comparisons will be done by pointer rather than string comparison. */
373 tinfo_name (tree type, bool mark_private)
379 name = mangle_type_string (type);
380 length = strlen (name);
384 /* Inject '*' at beginning of name to force pointer comparison. */
385 char* buf = (char*) XALLOCAVEC (char, length + 2);
387 memcpy (buf + 1, name, length + 1);
388 name_string = build_string (length + 2, buf);
391 name_string = build_string (length + 1, name);
393 return fix_string_type (name_string);
396 /* Return a VAR_DECL for the internal ABI defined type_info object for
397 TYPE. You must arrange that the decl is mark_used, if actually use
398 it --- decls in vtables are only used if the vtable is output. */
401 get_tinfo_decl (tree type)
406 if (variably_modified_type_p (type, /*fn=*/NULL_TREE))
408 error ("cannot create type information for type %qT because "
409 "it involves types of variable size",
411 return error_mark_node;
414 if (TREE_CODE (type) == METHOD_TYPE)
415 type = build_function_type (TREE_TYPE (type),
416 TREE_CHAIN (TYPE_ARG_TYPES (type)));
418 type = complete_type (type);
420 /* For a class type, the variable is cached in the type node
422 if (CLASS_TYPE_P (type))
424 d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
429 name = mangle_typeinfo_for_type (type);
431 d = IDENTIFIER_GLOBAL_VALUE (name);
434 int ix = get_pseudo_ti_index (type);
435 tinfo_s *ti = &(*tinfo_descs)[ix];
437 d = build_lang_decl (VAR_DECL, name, ti->type);
438 SET_DECL_ASSEMBLER_NAME (d, name);
439 /* Remember the type it is for. */
440 TREE_TYPE (name) = type;
441 DECL_TINFO_P (d) = 1;
442 DECL_ARTIFICIAL (d) = 1;
443 DECL_IGNORED_P (d) = 1;
444 TREE_READONLY (d) = 1;
446 /* Mark the variable as undefined -- but remember that we can
447 define it later if we need to do so. */
448 DECL_EXTERNAL (d) = 1;
449 DECL_NOT_REALLY_EXTERN (d) = 1;
450 set_linkage_according_to_type (type, d);
452 d = pushdecl_top_level_and_finish (d, NULL_TREE);
453 if (CLASS_TYPE_P (type))
454 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
456 /* Add decl to the global array of tinfo decls. */
457 vec_safe_push (unemitted_tinfo_decls, d);
463 /* Return a pointer to a type_info object describing TYPE, suitably
464 cast to the language defined type. */
467 get_tinfo_ptr (tree type)
469 tree decl = get_tinfo_decl (type);
472 return build_nop (type_info_ptr_type,
473 build_address (decl));
476 /* Return the type_info object for TYPE. */
479 get_typeid (tree type, tsubst_flags_t complain)
481 if (type == error_mark_node || !typeid_ok_p ())
482 return error_mark_node;
484 if (processing_template_decl)
485 return build_min (TYPEID_EXPR, const_type_info_type_node, type);
487 /* If the type of the type-id is a reference type, the result of the
488 typeid expression refers to a type_info object representing the
490 type = non_reference (type);
492 /* This is not one of the uses of a qualified function type in 8.3.5. */
493 if (TREE_CODE (type) == FUNCTION_TYPE
494 && (type_memfn_quals (type) != TYPE_UNQUALIFIED
495 || type_memfn_rqual (type) != REF_QUAL_NONE))
497 if (complain & tf_error)
498 error ("typeid of qualified function type %qT", type);
499 return error_mark_node;
502 /* The top-level cv-qualifiers of the lvalue expression or the type-id
503 that is the operand of typeid are always ignored. */
504 type = TYPE_MAIN_VARIANT (type);
506 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
507 if (CLASS_TYPE_P (type) || type == unknown_type_node
508 || type == init_list_type_node)
509 type = complete_type_or_maybe_complain (type, NULL_TREE, complain);
512 return error_mark_node;
514 return cp_build_indirect_ref (get_tinfo_ptr (type), RO_NULL, complain);
517 /* Check whether TEST is null before returning RESULT. If TEST is used in
518 RESULT, it must have previously had a save_expr applied to it. */
521 ifnonnull (tree test, tree result, tsubst_flags_t complain)
523 return build3 (COND_EXPR, TREE_TYPE (result),
524 build2 (EQ_EXPR, boolean_type_node, test,
525 cp_convert (TREE_TYPE (test), nullptr_node,
527 cp_convert (TREE_TYPE (result), nullptr_node, complain),
531 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
535 build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
537 enum tree_code tc = TREE_CODE (type);
540 tree old_expr = expr;
541 const char *errstr = NULL;
543 /* Save casted types in the function's used types hash table. */
544 used_types_insert (type);
546 /* T shall be a pointer or reference to a complete class type, or
547 `pointer to cv void''. */
551 if (VOID_TYPE_P (TREE_TYPE (type)))
555 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
557 errstr = _("target is not pointer or reference to class");
560 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
562 errstr = _("target is not pointer or reference to complete type");
568 errstr = _("target is not pointer or reference");
572 if (tc == POINTER_TYPE)
574 expr = decay_conversion (expr, complain);
575 exprtype = TREE_TYPE (expr);
577 /* If T is a pointer type, v shall be an rvalue of a pointer to
578 complete class type, and the result is an rvalue of type T. */
580 expr = mark_rvalue_use (expr);
582 if (!TYPE_PTR_P (exprtype))
584 errstr = _("source is not a pointer");
587 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
589 errstr = _("source is not a pointer to class");
592 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
594 errstr = _("source is a pointer to incomplete type");
600 expr = mark_lvalue_use (expr);
602 exprtype = build_reference_type (TREE_TYPE (expr));
604 /* T is a reference type, v shall be an lvalue of a complete class
605 type, and the result is an lvalue of the type referred to by T. */
607 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
609 errstr = _("source is not of class type");
612 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
614 errstr = _("source is of incomplete class type");
619 /* The dynamic_cast operator shall not cast away constness. */
620 if (!at_least_as_qualified_p (TREE_TYPE (type),
621 TREE_TYPE (exprtype)))
623 errstr = _("conversion casts away constness");
627 /* If *type is an unambiguous accessible base class of *exprtype,
628 convert statically. */
630 tree binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
631 ba_check, NULL, complain);
633 return build_static_cast (type, expr, complain);
636 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
637 if (tc == REFERENCE_TYPE)
638 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
639 LOOKUP_NORMAL, NULL_TREE, complain);
641 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
642 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
645 /* if TYPE is `void *', return pointer to complete object. */
646 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
648 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
649 if (TREE_CODE (expr) == ADDR_EXPR
650 && VAR_P (TREE_OPERAND (expr, 0))
651 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
652 return build1 (NOP_EXPR, type, expr);
654 /* Since expr is used twice below, save it. */
655 expr = save_expr (expr);
657 expr1 = build_headof (expr);
658 if (TREE_TYPE (expr1) != type)
659 expr1 = build1 (NOP_EXPR, type, expr1);
660 return ifnonnull (expr, expr1, complain);
665 tree result, td2, td3;
667 tree static_type, target_type, boff;
669 /* If we got here, we can't convert statically. Therefore,
670 dynamic_cast<D&>(b) (b an object) cannot succeed. */
671 if (tc == REFERENCE_TYPE)
674 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
676 tree expr = throw_bad_cast ();
677 if (complain & tf_warning)
678 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
680 /* Bash it to the expected type. */
681 TREE_TYPE (expr) = type;
685 /* Ditto for dynamic_cast<D*>(&b). */
686 else if (TREE_CODE (expr) == ADDR_EXPR)
688 tree op = TREE_OPERAND (expr, 0);
690 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
692 if (complain & tf_warning)
693 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
695 retval = build_int_cst (type, 0);
700 /* Use of dynamic_cast when -fno-rtti is prohibited. */
703 if (complain & tf_error)
704 error ("%<dynamic_cast%> not permitted with -fno-rtti");
705 return error_mark_node;
708 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
709 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
710 td2 = get_tinfo_decl (target_type);
712 td2 = cp_build_addr_expr (td2, complain);
713 td3 = get_tinfo_decl (static_type);
715 td3 = cp_build_addr_expr (td3, complain);
717 /* Determine how T and V are related. */
718 boff = dcast_base_hint (static_type, target_type);
720 /* Since expr is used twice below, save it. */
721 expr = save_expr (expr);
724 if (tc == REFERENCE_TYPE)
725 expr1 = cp_build_addr_expr (expr1, complain);
732 dcast_fn = dynamic_cast_node;
739 push_abi_namespace ();
740 tinfo_ptr = xref_tag (class_type,
741 get_identifier ("__class_type_info"),
742 /*tag_scope=*/ts_current, false);
744 tinfo_ptr = build_pointer_type
745 (cp_build_qualified_type
746 (tinfo_ptr, TYPE_QUAL_CONST));
747 name = "__dynamic_cast";
748 tmp = build_function_type_list (ptr_type_node,
750 tinfo_ptr, tinfo_ptr,
751 ptrdiff_type_node, NULL_TREE);
752 dcast_fn = build_library_fn_ptr (name, tmp,
753 ECF_LEAF | ECF_PURE | ECF_NOTHROW);
754 pop_abi_namespace ();
755 dynamic_cast_node = dcast_fn;
757 result = build_cxx_call (dcast_fn, 4, elems, complain);
759 if (tc == REFERENCE_TYPE)
761 tree bad = throw_bad_cast ();
764 result = save_expr (result);
765 neq = cp_truthvalue_conversion (result);
766 return cp_convert (type,
767 build3 (COND_EXPR, TREE_TYPE (result),
768 neq, result, bad), complain);
771 /* Now back to the type we want from a void*. */
772 result = cp_convert (type, result, complain);
773 return ifnonnull (expr, result, complain);
777 errstr = _("source type is not polymorphic");
780 if (complain & tf_error)
781 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
782 old_expr, TREE_TYPE (old_expr), type, errstr);
783 return error_mark_node;
787 build_dynamic_cast (tree type, tree expr, tsubst_flags_t complain)
791 if (type == error_mark_node || expr == error_mark_node)
792 return error_mark_node;
794 if (processing_template_decl)
796 expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
797 TREE_SIDE_EFFECTS (expr) = 1;
798 return convert_from_reference (expr);
801 r = convert_from_reference (build_dynamic_cast_1 (type, expr, complain));
802 if (r != error_mark_node)
803 maybe_warn_about_useless_cast (type, expr, complain);
807 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
810 qualifier_flags (tree type)
813 int quals = cp_type_quals (type);
815 if (quals & TYPE_QUAL_CONST)
817 if (quals & TYPE_QUAL_VOLATILE)
819 if (quals & TYPE_QUAL_RESTRICT)
824 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
825 contains a pointer to member of an incomplete class. */
828 target_incomplete_p (tree type)
831 if (TYPE_PTRDATAMEM_P (type))
833 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
835 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
837 else if (TYPE_PTR_P (type))
838 type = TREE_TYPE (type);
840 return !COMPLETE_OR_VOID_TYPE_P (type);
843 /* Returns true if TYPE involves an incomplete class type; in that
844 case, typeinfo variables for TYPE should be emitted with internal
848 involves_incomplete_p (tree type)
850 switch (TREE_CODE (type))
853 return target_incomplete_p (TREE_TYPE (type));
858 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type))
859 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)));
862 if (TYPE_PTRMEMFUNC_P (type))
866 if (!COMPLETE_TYPE_P (type))
870 /* All other types do not involve incomplete class types. */
875 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
876 is the vtable pointer and NTBS name. The NTBS name is emitted as a
877 comdat const char array, so it becomes a unique key for the type. Generate
878 and emit that VAR_DECL here. (We can't always emit the type_info itself
879 as comdat, because of pointers to incomplete.) */
882 tinfo_base_init (tinfo_s *ti, tree target)
887 vec<constructor_elt, va_gc> *v;
890 tree name_name, name_string;
892 /* Generate the NTBS array variable. */
893 tree name_type = build_cplus_array_type
894 (cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST),
897 /* Determine the name of the variable -- and remember with which
898 type it is associated. */
899 name_name = mangle_typeinfo_string_for_type (target);
900 TREE_TYPE (name_name) = target;
902 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
903 SET_DECL_ASSEMBLER_NAME (name_decl, name_name);
904 DECL_ARTIFICIAL (name_decl) = 1;
905 DECL_IGNORED_P (name_decl) = 1;
906 TREE_READONLY (name_decl) = 1;
907 TREE_STATIC (name_decl) = 1;
908 DECL_EXTERNAL (name_decl) = 0;
909 DECL_TINFO_P (name_decl) = 1;
910 set_linkage_according_to_type (target, name_decl);
911 import_export_decl (name_decl);
912 name_string = tinfo_name (target, !TREE_PUBLIC (name_decl));
913 DECL_INITIAL (name_decl) = name_string;
914 mark_used (name_decl);
915 pushdecl_top_level_and_finish (name_decl, name_string);
918 vtable_ptr = ti->vtable;
922 push_abi_namespace ();
923 real_type = xref_tag (class_type, ti->name,
924 /*tag_scope=*/ts_current, false);
925 pop_abi_namespace ();
927 if (!COMPLETE_TYPE_P (real_type))
929 /* We never saw a definition of this type, so we need to
930 tell the compiler that this is an exported class, as
931 indeed all of the __*_type_info classes are. */
932 SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
933 CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
936 vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
937 vtable_ptr = cp_build_addr_expr (vtable_ptr, tf_warning_or_error);
939 /* We need to point into the middle of the vtable. */
940 vtable_ptr = fold_build_pointer_plus
942 size_binop (MULT_EXPR,
943 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
944 TYPE_SIZE_UNIT (vtable_entry_type)));
946 ti->vtable = vtable_ptr;
950 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, vtable_ptr);
951 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
952 decay_conversion (name_decl, tf_warning_or_error));
954 init = build_constructor (init_list_type_node, v);
955 TREE_CONSTANT (init) = 1;
956 TREE_STATIC (init) = 1;
961 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
962 information about the particular type_info derivation, which adds no
963 additional fields to the type_info base. */
966 generic_initializer (tinfo_s *ti, tree target)
968 tree init = tinfo_base_init (ti, target);
970 init = build_constructor_single (init_list_type_node, NULL_TREE, init);
971 TREE_CONSTANT (init) = 1;
972 TREE_STATIC (init) = 1;
976 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
977 TI provides information about the particular type_info derivation,
978 which adds target type and qualifier flags members to the type_info base. */
981 ptr_initializer (tinfo_s *ti, tree target)
983 tree init = tinfo_base_init (ti, target);
984 tree to = TREE_TYPE (target);
985 int flags = qualifier_flags (to);
986 bool incomplete = target_incomplete_p (to);
987 vec<constructor_elt, va_gc> *v;
992 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
993 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, flags));
994 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
995 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)));
997 init = build_constructor (init_list_type_node, v);
998 TREE_CONSTANT (init) = 1;
999 TREE_STATIC (init) = 1;
1003 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
1004 TI provides information about the particular type_info derivation,
1005 which adds class, target type and qualifier flags members to the type_info
1009 ptm_initializer (tinfo_s *ti, tree target)
1011 tree init = tinfo_base_init (ti, target);
1012 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
1013 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
1014 int flags = qualifier_flags (to);
1015 bool incomplete = target_incomplete_p (to);
1016 vec<constructor_elt, va_gc> *v;
1021 if (!COMPLETE_TYPE_P (klass))
1023 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
1024 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, flags));
1025 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
1026 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)));
1027 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, get_tinfo_ptr (klass));
1029 init = build_constructor (init_list_type_node, v);
1030 TREE_CONSTANT (init) = 1;
1031 TREE_STATIC (init) = 1;
1035 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1036 TI provides information about the particular __class_type_info derivation,
1037 which adds hint flags and N extra initializers to the type_info base. */
1040 class_initializer (tinfo_s *ti, tree target, unsigned n, ...)
1042 tree init = tinfo_base_init (ti, target);
1043 va_list extra_inits;
1045 vec<constructor_elt, va_gc> *v;
1048 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
1049 va_start (extra_inits, n);
1050 for (i = 0; i < n; i++)
1051 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, va_arg (extra_inits, tree));
1052 va_end (extra_inits);
1054 init = build_constructor (init_list_type_node, v);
1055 TREE_CONSTANT (init) = 1;
1056 TREE_STATIC (init) = 1;
1060 /* Returns true if the typeinfo for type should be placed in
1061 the runtime library. */
1064 typeinfo_in_lib_p (tree type)
1066 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1067 library for simple types T. */
1068 if (TYPE_PTR_P (type)
1069 && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
1070 || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
1071 type = TREE_TYPE (type);
1073 switch (TREE_CODE (type))
1090 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1091 the index of the descriptor in the tinfo_desc vector. */
1094 get_pseudo_ti_init (tree type, unsigned tk_index)
1096 tinfo_s *ti = &(*tinfo_descs)[tk_index];
1098 gcc_assert (at_eof);
1101 case TK_POINTER_MEMBER_TYPE:
1102 return ptm_initializer (ti, type);
1104 case TK_POINTER_TYPE:
1105 return ptr_initializer (ti, type);
1107 case TK_BUILTIN_TYPE:
1108 case TK_ENUMERAL_TYPE:
1109 case TK_FUNCTION_TYPE:
1111 return generic_initializer (ti, type);
1114 return class_initializer (ti, type, 0);
1116 case TK_SI_CLASS_TYPE:
1118 tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), 0);
1119 tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1121 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1122 ti = &(*tinfo_descs)[tk_index];
1123 return class_initializer (ti, type, 1, tinfo);
1128 int hint = ((CLASSTYPE_REPEATED_BASE_P (type) << 0)
1129 | (CLASSTYPE_DIAMOND_SHAPED_P (type) << 1));
1130 tree binfo = TYPE_BINFO (type);
1131 int nbases = BINFO_N_BASE_BINFOS (binfo);
1132 vec<tree, va_gc> *base_accesses = BINFO_BASE_ACCESSES (binfo);
1133 tree offset_type = LONGPTR_T;
1134 tree base_inits = NULL_TREE;
1136 vec<constructor_elt, va_gc> *init_vec = NULL;
1139 gcc_assert (tk_index >= TK_FIXED);
1141 vec_safe_grow (init_vec, nbases);
1142 /* Generate the base information initializer. */
1143 for (ix = nbases; ix--;)
1145 tree base_binfo = BINFO_BASE_BINFO (binfo, ix);
1150 vec<constructor_elt, va_gc> *v;
1152 if ((*base_accesses)[ix] == access_public_node)
1154 tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1155 if (BINFO_VIRTUAL_P (base_binfo))
1157 /* We store the vtable offset at which the virtual
1158 base offset can be found. */
1159 offset = BINFO_VPTR_FIELD (base_binfo);
1163 offset = BINFO_OFFSET (base_binfo);
1165 /* Combine offset and flags into one field. */
1166 offset = fold_convert (offset_type, offset);
1167 offset = fold_build2_loc (input_location,
1168 LSHIFT_EXPR, offset_type, offset,
1169 build_int_cst (offset_type, 8));
1170 offset = fold_build2_loc (input_location,
1171 BIT_IOR_EXPR, offset_type, offset,
1172 build_int_cst (offset_type, flags));
1174 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, tinfo);
1175 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, offset);
1176 base_init = build_constructor (init_list_type_node, v);
1177 e = &(*init_vec)[ix];
1178 e->index = NULL_TREE;
1179 e->value = base_init;
1181 base_inits = build_constructor (init_list_type_node, init_vec);
1183 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1184 ti = &(*tinfo_descs)[tk_index];
1185 return class_initializer (ti, type, 3,
1186 build_int_cst (NULL_TREE, hint),
1187 build_int_cst (NULL_TREE, nbases),
1193 /* Generate the RECORD_TYPE containing the data layout of a type_info
1194 derivative as used by the runtime. This layout must be consistent with
1195 that defined in the runtime support. Also generate the VAR_DECL for the
1196 type's vtable. We explicitly manage the vtable member, and name it for
1197 real type as used in the runtime. The RECORD type has a different name,
1198 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1199 is the generated type and TINFO_VTABLE_NAME is the name of the
1200 vtable. We have to delay generating the VAR_DECL of the vtable
1201 until the end of the translation, when we'll have seen the library
1202 definition, if there was one.
1204 REAL_NAME is the runtime's name of the type. Trailing arguments are
1205 additional FIELD_DECL's for the structure. The final argument must be
1209 create_pseudo_type_info (int tk, const char *real_name, ...)
1218 va_start (ap, real_name);
1220 /* Generate the pseudo type name. */
1221 pseudo_name = (char *) alloca (strlen (real_name) + 30);
1222 strcpy (pseudo_name, real_name);
1223 strcat (pseudo_name, "_pseudo");
1225 sprintf (pseudo_name + strlen (pseudo_name), "%d", tk - TK_FIXED);
1227 /* First field is the pseudo type_info base class. */
1228 fields = build_decl (input_location,
1229 FIELD_DECL, NULL_TREE,
1230 (*tinfo_descs)[TK_TYPE_INFO_TYPE].type);
1232 /* Now add the derived fields. */
1233 while ((field_decl = va_arg (ap, tree)))
1235 DECL_CHAIN (field_decl) = fields;
1236 fields = field_decl;
1239 /* Create the pseudo type. */
1240 pseudo_type = make_class_type (RECORD_TYPE);
1241 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
1242 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
1244 ti = &(*tinfo_descs)[tk];
1245 ti->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
1246 ti->name = get_identifier (real_name);
1247 ti->vtable = NULL_TREE;
1249 /* Pretend this is public so determine_visibility doesn't give vtables
1250 internal linkage. */
1251 TREE_PUBLIC (TYPE_MAIN_DECL (ti->type)) = 1;
1256 /* Return the index of a pseudo type info type node used to describe
1257 TYPE. TYPE must be a complete type (or cv void), except at the end
1258 of the translation unit. */
1261 get_pseudo_ti_index (tree type)
1265 switch (TREE_CODE (type))
1268 ix = TK_POINTER_MEMBER_TYPE;
1272 ix = TK_POINTER_TYPE;
1276 ix = TK_ENUMERAL_TYPE;
1280 ix = TK_FUNCTION_TYPE;
1289 if (TYPE_PTRMEMFUNC_P (type))
1291 ix = TK_POINTER_MEMBER_TYPE;
1294 else if (!COMPLETE_TYPE_P (type))
1297 cxx_incomplete_type_error (NULL_TREE, type);
1301 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
1308 tree binfo = TYPE_BINFO (type);
1309 vec<tree, va_gc> *base_accesses = BINFO_BASE_ACCESSES (binfo);
1310 tree base_binfo = BINFO_BASE_BINFO (binfo, 0);
1311 int num_bases = BINFO_N_BASE_BINFOS (binfo);
1314 && (*base_accesses)[0] == access_public_node
1315 && !BINFO_VIRTUAL_P (base_binfo)
1316 && integer_zerop (BINFO_OFFSET (base_binfo)))
1318 /* single non-virtual public. */
1319 ix = TK_SI_CLASS_TYPE;
1325 tree array_domain, base_array;
1327 ix = TK_FIXED + num_bases;
1328 if (vec_safe_length (tinfo_descs) <= ix)
1330 /* too short, extend. */
1331 unsigned len = vec_safe_length (tinfo_descs);
1333 vec_safe_grow (tinfo_descs, ix + 1);
1334 while (tinfo_descs->iterate (len++, &ti))
1335 ti->type = ti->vtable = ti->name = NULL_TREE;
1337 else if ((*tinfo_descs)[ix].type)
1338 /* already created. */
1341 /* Create the array of __base_class_type_info entries. */
1342 array_domain = build_index_type (size_int (num_bases - 1));
1343 base_array = build_array_type ((*tinfo_descs)[TK_BASE_TYPE].type,
1346 push_abi_namespace ();
1347 create_pseudo_type_info
1348 (ix, "__vmi_class_type_info",
1349 build_decl (input_location,
1350 FIELD_DECL, NULL_TREE, integer_type_node),
1351 build_decl (input_location,
1352 FIELD_DECL, NULL_TREE, integer_type_node),
1353 build_decl (input_location,
1354 FIELD_DECL, NULL_TREE, base_array),
1356 pop_abi_namespace ();
1361 ix = TK_BUILTIN_TYPE;
1367 /* Make sure the required builtin types exist for generating the type_info
1368 variable definitions. */
1371 create_tinfo_types (void)
1375 gcc_assert (!tinfo_descs);
1377 vec_safe_grow (tinfo_descs, TK_FIXED);
1379 push_abi_namespace ();
1381 /* Create the internal type_info structure. This is used as a base for
1382 the other structures. */
1386 field = build_decl (BUILTINS_LOCATION,
1387 FIELD_DECL, NULL_TREE, const_ptr_type_node);
1390 field = build_decl (BUILTINS_LOCATION,
1391 FIELD_DECL, NULL_TREE, const_string_type_node);
1392 DECL_CHAIN (field) = fields;
1395 ti = &(*tinfo_descs)[TK_TYPE_INFO_TYPE];
1396 ti->type = make_class_type (RECORD_TYPE);
1397 ti->vtable = NULL_TREE;
1398 ti->name = NULL_TREE;
1399 finish_builtin_struct (ti->type, "__type_info_pseudo",
1403 /* Fundamental type_info */
1404 create_pseudo_type_info (TK_BUILTIN_TYPE, "__fundamental_type_info", NULL);
1406 /* Array, function and enum type_info. No additional fields. */
1407 create_pseudo_type_info (TK_ARRAY_TYPE, "__array_type_info", NULL);
1408 create_pseudo_type_info (TK_FUNCTION_TYPE, "__function_type_info", NULL);
1409 create_pseudo_type_info (TK_ENUMERAL_TYPE, "__enum_type_info", NULL);
1411 /* Class type_info. No additional fields. */
1412 create_pseudo_type_info (TK_CLASS_TYPE, "__class_type_info", NULL);
1414 /* Single public non-virtual base class. Add pointer to base class.
1415 This is really a descendant of __class_type_info. */
1416 create_pseudo_type_info (TK_SI_CLASS_TYPE, "__si_class_type_info",
1417 build_decl (BUILTINS_LOCATION,
1418 FIELD_DECL, NULL_TREE, type_info_ptr_type),
1421 /* Base class internal helper. Pointer to base type, offset to base,
1426 field = build_decl (BUILTINS_LOCATION,
1427 FIELD_DECL, NULL_TREE, type_info_ptr_type);
1430 field = build_decl (BUILTINS_LOCATION,
1431 FIELD_DECL, NULL_TREE, LONGPTR_T);
1432 DECL_CHAIN (field) = fields;
1435 ti = &(*tinfo_descs)[TK_BASE_TYPE];
1437 ti->type = make_class_type (RECORD_TYPE);
1438 ti->vtable = NULL_TREE;
1439 ti->name = NULL_TREE;
1440 finish_builtin_struct (ti->type, "__base_class_type_info_pseudo",
1444 /* Pointer type_info. Adds two fields, qualification mask
1445 and pointer to the pointed to type. This is really a descendant of
1446 __pbase_type_info. */
1447 create_pseudo_type_info (TK_POINTER_TYPE, "__pointer_type_info",
1448 build_decl (BUILTINS_LOCATION,
1449 FIELD_DECL, NULL_TREE, integer_type_node),
1450 build_decl (BUILTINS_LOCATION,
1451 FIELD_DECL, NULL_TREE, type_info_ptr_type),
1454 /* Pointer to member data type_info. Add qualifications flags,
1455 pointer to the member's type info and pointer to the class.
1456 This is really a descendant of __pbase_type_info. */
1457 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE,
1458 "__pointer_to_member_type_info",
1459 build_decl (BUILTINS_LOCATION,
1460 FIELD_DECL, NULL_TREE, integer_type_node),
1461 build_decl (BUILTINS_LOCATION,
1462 FIELD_DECL, NULL_TREE, type_info_ptr_type),
1463 build_decl (BUILTINS_LOCATION,
1464 FIELD_DECL, NULL_TREE, type_info_ptr_type),
1467 pop_abi_namespace ();
1470 /* Helper for emit_support_tinfos. Emits the type_info descriptor of
1474 emit_support_tinfo_1 (tree bltn)
1478 if (bltn == NULL_TREE)
1481 types[1] = build_pointer_type (bltn);
1482 types[2] = build_pointer_type (cp_build_qualified_type (bltn,
1485 for (int i = 0; i < 3; ++i)
1487 tree tinfo = get_tinfo_decl (types[i]);
1488 TREE_USED (tinfo) = 1;
1489 mark_needed (tinfo);
1490 /* The C++ ABI requires that these objects be COMDAT. But,
1491 On systems without weak symbols, initialized COMDAT
1492 objects are emitted with internal linkage. (See
1493 comdat_linkage for details.) Since we want these objects
1494 to have external linkage so that copies do not have to be
1495 emitted in code outside the runtime library, we make them
1498 It might also not be necessary to follow this detail of the
1500 if (!flag_weak || ! targetm.cxx.library_rtti_comdat ())
1502 gcc_assert (TREE_PUBLIC (tinfo) && !DECL_COMDAT (tinfo));
1503 DECL_INTERFACE_KNOWN (tinfo) = 1;
1508 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1509 support. Generating them here guarantees consistency with the other
1510 structures. We use the following heuristic to determine when the runtime
1511 is being generated. If std::__fundamental_type_info is defined, and its
1512 destructor is defined, then the runtime is being built. */
1515 emit_support_tinfos (void)
1517 /* Dummy static variable so we can put nullptr in the array; it will be
1518 set before we actually start to walk the array. */
1519 static tree *const fundamentals[] =
1523 &wchar_type_node, &char16_type_node, &char32_type_node,
1524 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1525 &short_integer_type_node, &short_unsigned_type_node,
1526 &integer_type_node, &unsigned_type_node,
1527 &long_integer_type_node, &long_unsigned_type_node,
1528 &long_long_integer_type_node, &long_long_unsigned_type_node,
1529 &float_type_node, &double_type_node, &long_double_type_node,
1530 &dfloat32_type_node, &dfloat64_type_node, &dfloat128_type_node,
1535 tree bltn_type, dtor;
1537 push_abi_namespace ();
1538 bltn_type = xref_tag (class_type,
1539 get_identifier ("__fundamental_type_info"),
1540 /*tag_scope=*/ts_current, false);
1541 pop_abi_namespace ();
1542 if (!COMPLETE_TYPE_P (bltn_type))
1544 dtor = CLASSTYPE_DESTRUCTORS (bltn_type);
1545 if (!dtor || DECL_EXTERNAL (dtor))
1548 for (ix = 0; fundamentals[ix]; ix++)
1549 emit_support_tinfo_1 (*fundamentals[ix]);
1550 for (ix = 0; ix < NUM_INT_N_ENTS; ix ++)
1551 if (int_n_enabled_p[ix])
1553 emit_support_tinfo_1 (int_n_trees[ix].signed_type);
1554 emit_support_tinfo_1 (int_n_trees[ix].unsigned_type);
1556 for (tree t = registered_builtin_types; t; t = TREE_CHAIN (t))
1557 emit_support_tinfo_1 (TREE_VALUE (t));
1560 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1561 tinfo decl. Determine whether it needs emitting, and if so
1562 generate the initializer. */
1565 emit_tinfo_decl (tree decl)
1567 tree type = TREE_TYPE (DECL_NAME (decl));
1568 int in_library = typeinfo_in_lib_p (type);
1570 gcc_assert (DECL_TINFO_P (decl));
1575 DECL_EXTERNAL (decl) = 0;
1578 /* If we're not in the runtime, then DECL (which is already
1579 DECL_EXTERNAL) will not be defined here. */
1580 DECL_INTERFACE_KNOWN (decl) = 1;
1584 else if (involves_incomplete_p (type))
1586 if (!decl_needed_p (decl))
1588 /* If TYPE involves an incomplete class type, then the typeinfo
1589 object will be emitted with internal linkage. There is no
1590 way to know whether or not types are incomplete until the end
1591 of the compilation, so this determination must be deferred
1592 until this point. */
1593 TREE_PUBLIC (decl) = 0;
1594 DECL_EXTERNAL (decl) = 0;
1595 DECL_INTERFACE_KNOWN (decl) = 1;
1598 import_export_decl (decl);
1599 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
1603 DECL_EXTERNAL (decl) = 0;
1604 init = get_pseudo_ti_init (type, get_pseudo_ti_index (type));
1605 DECL_INITIAL (decl) = init;
1607 cp_finish_decl (decl, init, false, NULL_TREE, 0);
1608 /* Avoid targets optionally bumping up the alignment to improve
1609 vector instruction accesses, tinfo are never accessed this way. */
1610 #ifdef DATA_ABI_ALIGNMENT
1611 DECL_ALIGN (decl) = DATA_ABI_ALIGNMENT (decl, TYPE_ALIGN (TREE_TYPE (decl)));
1612 DECL_USER_ALIGN (decl) = true;
1620 #include "gt-cp-rtti.h"