1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
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/>. */
25 #include "coretypes.h"
37 /* C++ returns type information to the user in struct type_info
38 objects. We also use type information to implement dynamic_cast and
39 exception handlers. Type information for a particular type is
40 indicated with an ABI defined structure derived from type_info.
41 This would all be very straight forward, but for the fact that the
42 runtime library provides the definitions of the type_info structure
43 and the ABI defined derived classes. We cannot build declarations
44 of them directly in the compiler, but we need to layout objects of
45 their type. Somewhere we have to lie.
47 We define layout compatible POD-structs with compiler-defined names
48 and generate the appropriate initializations for them (complete
49 with explicit mention of their vtable). When we have to provide a
50 type_info to the user we reinterpret_cast the internal compiler
51 type to type_info. A well formed program can only explicitly refer
52 to the type_infos of complete types (& cv void). However, we chain
53 pointer type_infos to the pointed-to-type, and that can be
54 incomplete. We only need the addresses of such incomplete
55 type_info objects for static initialization.
57 The type information VAR_DECL of a type is held on the
58 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
59 will be the internal type. It will usually have the correct
60 internal type reflecting the kind of type it represents (pointer,
61 array, function, class, inherited class, etc). When the type it
62 represents is incomplete, it will have the internal type
63 corresponding to type_info. That will only happen at the end of
64 translation, when we are emitting the type info objects. */
66 /* Auxiliary data we hold for each type_info derived object we need. */
67 typedef struct tinfo_s GTY (())
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);
107 static tree build_dynamic_cast_1 (tree, tree);
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, tree);
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");
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 = 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 (build_indirect_ref (exp, NULL), index);
193 type = build_qualified_type (ptr_type_node,
194 cp_type_quals (TREE_TYPE (exp)));
195 return build2 (POINTER_PLUS_EXPR, type, exp,
196 convert_to_integer (sizetype, offset));
199 /* Get a bad_cast node for the program to throw...
201 See libstdc++/exception.cc for __throw_bad_cast */
204 throw_bad_cast (void)
206 tree fn = get_identifier ("__cxa_bad_cast");
207 if (!get_global_value_if_present (fn, &fn))
208 fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,
211 return build_cxx_call (fn, 0, NULL);
214 /* Return an expression for "__cxa_bad_typeid()". The expression
215 returned is an lvalue of type "const std::type_info". */
218 throw_bad_typeid (void)
220 tree fn = get_identifier ("__cxa_bad_typeid");
221 if (!get_global_value_if_present (fn, &fn))
225 t = build_reference_type (const_type_info_type_node);
226 t = build_function_type (t, void_list_node);
227 fn = push_throw_library_fn (fn, t);
230 return build_cxx_call (fn, 0, NULL);
233 /* Return an lvalue expression whose type is "const std::type_info"
234 and whose value indicates the type of the expression EXP. If EXP
235 is a reference to a polymorphic class, return the dynamic type;
236 otherwise return the static type of the expression. */
239 get_tinfo_decl_dynamic (tree exp)
244 if (error_operand_p (exp))
245 return error_mark_node;
247 /* peel back references, so they match. */
248 type = non_reference (TREE_TYPE (exp));
250 /* Peel off cv qualifiers. */
251 type = TYPE_MAIN_VARIANT (type);
253 if (CLASS_TYPE_P (type))
254 type = complete_type_or_else (type, exp);
257 return error_mark_node;
259 /* If exp is a reference to polymorphic type, get the real type_info. */
260 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
262 /* build reference to type_info from vtable. */
265 /* The RTTI information is at index -1. */
266 index = build_int_cst (NULL_TREE,
267 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
268 t = build_vtbl_ref (exp, index);
269 t = convert (type_info_ptr_type, t);
272 /* Otherwise return the type_info for the static type of the expr. */
273 t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
275 return build_indirect_ref (t, NULL);
281 tree pseudo_type_info, type_info_type;
285 error ("cannot use typeid with -fno-rtti");
289 if (!COMPLETE_TYPE_P (const_type_info_type_node))
291 error ("must #include <typeinfo> before using typeid");
296 = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE)->type;
297 type_info_type = TYPE_MAIN_VARIANT (const_type_info_type_node);
299 /* Make sure abi::__type_info_pseudo has the same alias set
300 as std::type_info. */
301 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info))
302 TYPE_ALIAS_SET (pseudo_type_info) = get_alias_set (type_info_type);
304 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info)
305 == get_alias_set (type_info_type));
310 /* Return an expression for "typeid(EXP)". The expression returned is
311 an lvalue of type "const std::type_info". */
314 build_typeid (tree exp)
316 tree cond = NULL_TREE;
319 if (exp == error_mark_node || !typeid_ok_p ())
320 return error_mark_node;
322 if (processing_template_decl)
323 return build_min (TYPEID_EXPR, const_type_info_type_node, exp);
325 if (TREE_CODE (exp) == INDIRECT_REF
326 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
327 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
328 && ! resolves_to_fixed_type_p (exp, &nonnull)
331 exp = stabilize_reference (exp);
332 cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
335 exp = get_tinfo_decl_dynamic (exp);
337 if (exp == error_mark_node)
338 return error_mark_node;
342 tree bad = throw_bad_typeid ();
344 exp = build3 (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
350 /* Generate the NTBS name of a type. */
352 tinfo_name (tree type)
357 name = mangle_type_string (type);
358 name_string = fix_string_type (build_string (strlen (name) + 1, name));
362 /* Return a VAR_DECL for the internal ABI defined type_info object for
363 TYPE. You must arrange that the decl is mark_used, if actually use
364 it --- decls in vtables are only used if the vtable is output. */
367 get_tinfo_decl (tree type)
372 if (variably_modified_type_p (type, /*fn=*/NULL_TREE))
374 error ("cannot create type information for type %qT because "
375 "it involves types of variable size",
377 return error_mark_node;
380 if (TREE_CODE (type) == METHOD_TYPE)
381 type = build_function_type (TREE_TYPE (type),
382 TREE_CHAIN (TYPE_ARG_TYPES (type)));
384 /* For a class type, the variable is cached in the type node
386 if (CLASS_TYPE_P (type))
388 d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
393 name = mangle_typeinfo_for_type (type);
395 d = IDENTIFIER_GLOBAL_VALUE (name);
398 int ix = get_pseudo_ti_index (type);
399 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, ix);
401 d = build_lang_decl (VAR_DECL, name, ti->type);
402 SET_DECL_ASSEMBLER_NAME (d, name);
403 /* Remember the type it is for. */
404 TREE_TYPE (name) = type;
405 DECL_TINFO_P (d) = 1;
406 DECL_ARTIFICIAL (d) = 1;
407 DECL_IGNORED_P (d) = 1;
408 TREE_READONLY (d) = 1;
410 /* Mark the variable as undefined -- but remember that we can
411 define it later if we need to do so. */
412 DECL_EXTERNAL (d) = 1;
413 DECL_NOT_REALLY_EXTERN (d) = 1;
414 set_linkage_according_to_type (type, d);
416 d = pushdecl_top_level_and_finish (d, NULL_TREE);
417 if (CLASS_TYPE_P (type))
418 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
420 /* Add decl to the global array of tinfo decls. */
421 VEC_safe_push (tree, gc, unemitted_tinfo_decls, d);
427 /* Return a pointer to a type_info object describing TYPE, suitably
428 cast to the language defined type. */
431 get_tinfo_ptr (tree type)
433 tree decl = get_tinfo_decl (type);
436 return build_nop (type_info_ptr_type,
437 build_address (decl));
440 /* Return the type_info object for TYPE. */
443 get_typeid (tree type)
445 if (type == error_mark_node || !typeid_ok_p ())
446 return error_mark_node;
448 if (processing_template_decl)
449 return build_min (TYPEID_EXPR, const_type_info_type_node, type);
451 /* If the type of the type-id is a reference type, the result of the
452 typeid expression refers to a type_info object representing the
454 type = non_reference (type);
456 /* The top-level cv-qualifiers of the lvalue expression or the type-id
457 that is the operand of typeid are always ignored. */
458 type = TYPE_MAIN_VARIANT (type);
460 if (CLASS_TYPE_P (type))
461 type = complete_type_or_else (type, NULL_TREE);
464 return error_mark_node;
466 return build_indirect_ref (get_tinfo_ptr (type), NULL);
469 /* Check whether TEST is null before returning RESULT. If TEST is used in
470 RESULT, it must have previously had a save_expr applied to it. */
473 ifnonnull (tree test, tree result)
475 return build3 (COND_EXPR, TREE_TYPE (result),
476 build2 (EQ_EXPR, boolean_type_node, test,
477 cp_convert (TREE_TYPE (test), integer_zero_node)),
478 cp_convert (TREE_TYPE (result), integer_zero_node),
482 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
486 build_dynamic_cast_1 (tree type, tree expr)
488 enum tree_code tc = TREE_CODE (type);
489 tree exprtype = TREE_TYPE (expr);
491 tree old_expr = expr;
492 const char *errstr = NULL;
494 /* Save casted types in the function's used types hash table. */
495 used_types_insert (type);
497 /* T shall be a pointer or reference to a complete class type, or
498 `pointer to cv void''. */
502 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
506 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
508 errstr = "target is not pointer or reference to class";
511 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
513 errstr = "target is not pointer or reference to complete type";
519 errstr = "target is not pointer or reference";
523 if (tc == POINTER_TYPE)
525 /* If T is a pointer type, v shall be an rvalue of a pointer to
526 complete class type, and the result is an rvalue of type T. */
528 if (TREE_CODE (exprtype) != POINTER_TYPE)
530 errstr = "source is not a pointer";
533 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
535 errstr = "source is not a pointer to class";
538 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
540 errstr = "source is a pointer to incomplete type";
546 exprtype = build_reference_type (exprtype);
548 /* T is a reference type, v shall be an lvalue of a complete class
549 type, and the result is an lvalue of the type referred to by T. */
551 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
553 errstr = "source is not of class type";
556 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
558 errstr = "source is of incomplete class type";
562 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
563 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
564 LOOKUP_NORMAL, NULL_TREE);
567 /* The dynamic_cast operator shall not cast away constness. */
568 if (!at_least_as_qualified_p (TREE_TYPE (type),
569 TREE_TYPE (exprtype)))
571 errstr = "conversion casts away constness";
575 /* If *type is an unambiguous accessible base class of *exprtype,
576 convert statically. */
580 binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
585 expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),
587 if (TREE_CODE (exprtype) == POINTER_TYPE)
588 expr = rvalue (expr);
593 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
594 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
597 /* if TYPE is `void *', return pointer to complete object. */
598 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
600 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
601 if (TREE_CODE (expr) == ADDR_EXPR
602 && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
603 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
604 return build1 (NOP_EXPR, type, expr);
606 /* Since expr is used twice below, save it. */
607 expr = save_expr (expr);
609 expr1 = build_headof (expr);
610 if (TREE_TYPE (expr1) != type)
611 expr1 = build1 (NOP_EXPR, type, expr1);
612 return ifnonnull (expr, expr1);
617 tree result, td2, td3;
619 tree static_type, target_type, boff;
621 /* If we got here, we can't convert statically. Therefore,
622 dynamic_cast<D&>(b) (b an object) cannot succeed. */
623 if (tc == REFERENCE_TYPE)
625 if (TREE_CODE (old_expr) == VAR_DECL
626 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
628 tree expr = throw_bad_cast ();
629 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
631 /* Bash it to the expected type. */
632 TREE_TYPE (expr) = type;
636 /* Ditto for dynamic_cast<D*>(&b). */
637 else if (TREE_CODE (expr) == ADDR_EXPR)
639 tree op = TREE_OPERAND (expr, 0);
640 if (TREE_CODE (op) == VAR_DECL
641 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
643 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
645 retval = build_int_cst (type, 0);
650 /* Use of dynamic_cast when -fno-rtti is prohibited. */
653 error ("%<dynamic_cast%> not permitted with -fno-rtti");
654 return error_mark_node;
657 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
658 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
659 td2 = get_tinfo_decl (target_type);
661 td2 = build_unary_op (ADDR_EXPR, td2, 0);
662 td3 = get_tinfo_decl (static_type);
664 td3 = build_unary_op (ADDR_EXPR, td3, 0);
666 /* Determine how T and V are related. */
667 boff = dcast_base_hint (static_type, target_type);
669 /* Since expr is used twice below, save it. */
670 expr = save_expr (expr);
673 if (tc == REFERENCE_TYPE)
674 expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
681 dcast_fn = dynamic_cast_node;
688 push_abi_namespace ();
689 tinfo_ptr = xref_tag (class_type,
690 get_identifier ("__class_type_info"),
691 /*tag_scope=*/ts_current, false);
693 tinfo_ptr = build_pointer_type
694 (build_qualified_type
695 (tinfo_ptr, TYPE_QUAL_CONST));
696 name = "__dynamic_cast";
698 (NULL_TREE, const_ptr_type_node, tree_cons
699 (NULL_TREE, tinfo_ptr, tree_cons
700 (NULL_TREE, tinfo_ptr, tree_cons
701 (NULL_TREE, ptrdiff_type_node, void_list_node))));
702 tmp = build_function_type (ptr_type_node, tmp);
703 dcast_fn = build_library_fn_ptr (name, tmp);
704 DECL_IS_PURE (dcast_fn) = 1;
705 pop_abi_namespace ();
706 dynamic_cast_node = dcast_fn;
708 result = build_cxx_call (dcast_fn, 4, elems);
710 if (tc == REFERENCE_TYPE)
712 tree bad = throw_bad_cast ();
715 result = save_expr (result);
716 neq = c_common_truthvalue_conversion (result);
717 return build3 (COND_EXPR, type, neq, result, bad);
720 /* Now back to the type we want from a void*. */
721 result = cp_convert (type, result);
722 return ifnonnull (expr, result);
726 errstr = "source type is not polymorphic";
729 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
730 expr, exprtype, type, errstr);
731 return error_mark_node;
735 build_dynamic_cast (tree type, tree expr)
737 if (type == error_mark_node || expr == error_mark_node)
738 return error_mark_node;
740 if (processing_template_decl)
742 expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
743 TREE_SIDE_EFFECTS (expr) = 1;
744 return convert_from_reference (expr);
747 return convert_from_reference (build_dynamic_cast_1 (type, expr));
750 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
753 qualifier_flags (tree type)
756 int quals = cp_type_quals (type);
758 if (quals & TYPE_QUAL_CONST)
760 if (quals & TYPE_QUAL_VOLATILE)
762 if (quals & TYPE_QUAL_RESTRICT)
767 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
768 contains a pointer to member of an incomplete class. */
771 target_incomplete_p (tree type)
774 if (TYPE_PTRMEM_P (type))
776 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
778 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
780 else if (TREE_CODE (type) == POINTER_TYPE)
781 type = TREE_TYPE (type);
783 return !COMPLETE_OR_VOID_TYPE_P (type);
786 /* Returns true if TYPE involves an incomplete class type; in that
787 case, typeinfo variables for TYPE should be emitted with internal
791 involves_incomplete_p (tree type)
793 switch (TREE_CODE (type))
796 return target_incomplete_p (TREE_TYPE (type));
801 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type))
802 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)));
805 if (TYPE_PTRMEMFUNC_P (type))
809 if (!COMPLETE_TYPE_P (type))
813 /* All other types do not involve incomplete class types. */
818 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
819 is the vtable pointer and NTBS name. The NTBS name is emitted as a
820 comdat const char array, so it becomes a unique key for the type. Generate
821 and emit that VAR_DECL here. (We can't always emit the type_info itself
822 as comdat, because of pointers to incomplete.) */
825 tinfo_base_init (tinfo_s *ti, tree target)
827 tree init = NULL_TREE;
834 /* Generate the NTBS array variable. */
835 tree name_type = build_cplus_array_type
836 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
838 tree name_string = tinfo_name (target);
840 /* Determine the name of the variable -- and remember with which
841 type it is associated. */
842 name_name = mangle_typeinfo_string_for_type (target);
843 TREE_TYPE (name_name) = target;
845 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
846 SET_DECL_ASSEMBLER_NAME (name_decl, name_name);
847 DECL_ARTIFICIAL (name_decl) = 1;
848 DECL_IGNORED_P (name_decl) = 1;
849 TREE_READONLY (name_decl) = 1;
850 TREE_STATIC (name_decl) = 1;
851 DECL_EXTERNAL (name_decl) = 0;
852 DECL_TINFO_P (name_decl) = 1;
853 set_linkage_according_to_type (target, name_decl);
854 import_export_decl (name_decl);
855 DECL_INITIAL (name_decl) = name_string;
856 mark_used (name_decl);
857 pushdecl_top_level_and_finish (name_decl, name_string);
860 vtable_ptr = ti->vtable;
864 push_abi_namespace ();
865 real_type = xref_tag (class_type, ti->name,
866 /*tag_scope=*/ts_current, false);
867 pop_abi_namespace ();
869 if (!COMPLETE_TYPE_P (real_type))
871 /* We never saw a definition of this type, so we need to
872 tell the compiler that this is an exported class, as
873 indeed all of the __*_type_info classes are. */
874 SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
875 CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
878 vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
879 vtable_ptr = build_unary_op (ADDR_EXPR, vtable_ptr, 0);
881 /* We need to point into the middle of the vtable. */
883 (POINTER_PLUS_EXPR, TREE_TYPE (vtable_ptr), vtable_ptr,
884 size_binop (MULT_EXPR,
885 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
886 TYPE_SIZE_UNIT (vtable_entry_type)));
888 ti->vtable = vtable_ptr;
891 init = tree_cons (NULL_TREE, vtable_ptr, init);
893 init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
895 init = build_constructor_from_list (NULL_TREE, nreverse (init));
896 TREE_CONSTANT (init) = 1;
897 TREE_INVARIANT (init) = 1;
898 TREE_STATIC (init) = 1;
899 init = tree_cons (NULL_TREE, init, NULL_TREE);
904 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
905 information about the particular type_info derivation, which adds no
906 additional fields to the type_info base. */
909 generic_initializer (tinfo_s *ti, tree target)
911 tree init = tinfo_base_init (ti, target);
913 init = build_constructor_from_list (NULL_TREE, init);
914 TREE_CONSTANT (init) = 1;
915 TREE_INVARIANT (init) = 1;
916 TREE_STATIC (init) = 1;
920 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
921 TI provides information about the particular type_info derivation,
922 which adds target type and qualifier flags members to the type_info base. */
925 ptr_initializer (tinfo_s *ti, tree target)
927 tree init = tinfo_base_init (ti, target);
928 tree to = TREE_TYPE (target);
929 int flags = qualifier_flags (to);
930 bool incomplete = target_incomplete_p (to);
934 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
935 init = tree_cons (NULL_TREE,
936 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
939 init = build_constructor_from_list (NULL_TREE, nreverse (init));
940 TREE_CONSTANT (init) = 1;
941 TREE_INVARIANT (init) = 1;
942 TREE_STATIC (init) = 1;
946 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
947 TI provides information about the particular type_info derivation,
948 which adds class, target type and qualifier flags members to the type_info
952 ptm_initializer (tinfo_s *ti, tree target)
954 tree init = tinfo_base_init (ti, target);
955 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
956 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
957 int flags = qualifier_flags (to);
958 bool incomplete = target_incomplete_p (to);
962 if (!COMPLETE_TYPE_P (klass))
964 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
965 init = tree_cons (NULL_TREE,
966 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
968 init = tree_cons (NULL_TREE,
969 get_tinfo_ptr (klass),
972 init = build_constructor_from_list (NULL_TREE, nreverse (init));
973 TREE_CONSTANT (init) = 1;
974 TREE_INVARIANT (init) = 1;
975 TREE_STATIC (init) = 1;
979 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
980 TI provides information about the particular __class_type_info derivation,
981 which adds hint flags and TRAIL initializers to the type_info base. */
984 class_initializer (tinfo_s *ti, tree target, tree trail)
986 tree init = tinfo_base_init (ti, target);
988 TREE_CHAIN (init) = trail;
989 init = build_constructor_from_list (NULL_TREE, init);
990 TREE_CONSTANT (init) = 1;
991 TREE_INVARIANT (init) = 1;
992 TREE_STATIC (init) = 1;
996 /* Returns true if the typeinfo for type should be placed in
997 the runtime library. */
1000 typeinfo_in_lib_p (tree type)
1002 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1003 library for simple types T. */
1004 if (TREE_CODE (type) == POINTER_TYPE
1005 && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
1006 || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
1007 type = TREE_TYPE (type);
1009 switch (TREE_CODE (type))
1022 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1023 the index of the descriptor in the tinfo_desc vector. */
1026 get_pseudo_ti_init (tree type, unsigned tk_index)
1028 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1030 gcc_assert (at_eof);
1033 case TK_POINTER_MEMBER_TYPE:
1034 return ptm_initializer (ti, type);
1036 case TK_POINTER_TYPE:
1037 return ptr_initializer (ti, type);
1039 case TK_BUILTIN_TYPE:
1040 case TK_ENUMERAL_TYPE:
1041 case TK_FUNCTION_TYPE:
1043 return generic_initializer (ti, type);
1046 return class_initializer (ti, type, NULL_TREE);
1048 case TK_SI_CLASS_TYPE:
1050 tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), 0);
1051 tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1052 tree base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1054 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1055 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1056 return class_initializer (ti, type, base_inits);
1061 int hint = ((CLASSTYPE_REPEATED_BASE_P (type) << 0)
1062 | (CLASSTYPE_DIAMOND_SHAPED_P (type) << 1));
1063 tree binfo = TYPE_BINFO (type);
1064 int nbases = BINFO_N_BASE_BINFOS (binfo);
1065 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1066 tree offset_type = integer_types[itk_long];
1067 tree base_inits = NULL_TREE;
1070 gcc_assert (tk_index >= TK_FIXED);
1072 /* Generate the base information initializer. */
1073 for (ix = nbases; ix--;)
1075 tree base_binfo = BINFO_BASE_BINFO (binfo, ix);
1076 tree base_init = NULL_TREE;
1081 if (VEC_index (tree, base_accesses, ix) == access_public_node)
1083 tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1084 if (BINFO_VIRTUAL_P (base_binfo))
1086 /* We store the vtable offset at which the virtual
1087 base offset can be found. */
1088 offset = BINFO_VPTR_FIELD (base_binfo);
1092 offset = BINFO_OFFSET (base_binfo);
1094 /* Combine offset and flags into one field. */
1095 offset = fold_convert (offset_type, offset);
1096 offset = fold_build2 (LSHIFT_EXPR, offset_type, offset,
1097 build_int_cst (offset_type, 8));
1098 offset = fold_build2 (BIT_IOR_EXPR, offset_type, offset,
1099 build_int_cst (offset_type, flags));
1100 base_init = tree_cons (NULL_TREE, offset, base_init);
1101 base_init = tree_cons (NULL_TREE, tinfo, base_init);
1102 base_init = build_constructor_from_list (NULL_TREE, base_init);
1103 base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1105 base_inits = build_constructor_from_list (NULL_TREE, base_inits);
1106 base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1107 /* Prepend the number of bases. */
1108 base_inits = tree_cons (NULL_TREE,
1109 build_int_cst (NULL_TREE, nbases),
1111 /* Prepend the hint flags. */
1112 base_inits = tree_cons (NULL_TREE,
1113 build_int_cst (NULL_TREE, hint),
1116 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1117 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1118 return class_initializer (ti, type, base_inits);
1123 /* Generate the RECORD_TYPE containing the data layout of a type_info
1124 derivative as used by the runtime. This layout must be consistent with
1125 that defined in the runtime support. Also generate the VAR_DECL for the
1126 type's vtable. We explicitly manage the vtable member, and name it for
1127 real type as used in the runtime. The RECORD type has a different name,
1128 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1129 is the generated type and TINFO_VTABLE_NAME is the name of the
1130 vtable. We have to delay generating the VAR_DECL of the vtable
1131 until the end of the translation, when we'll have seen the library
1132 definition, if there was one.
1134 REAL_NAME is the runtime's name of the type. Trailing arguments are
1135 additional FIELD_DECL's for the structure. The final argument must be
1139 create_pseudo_type_info (int tk, const char *real_name, ...)
1148 va_start (ap, real_name);
1150 /* Generate the pseudo type name. */
1151 pseudo_name = (char *) alloca (strlen (real_name) + 30);
1152 strcpy (pseudo_name, real_name);
1153 strcat (pseudo_name, "_pseudo");
1155 sprintf (pseudo_name + strlen (pseudo_name), "%d", tk - TK_FIXED);
1157 /* First field is the pseudo type_info base class. */
1158 fields = build_decl (FIELD_DECL, NULL_TREE,
1159 VEC_index (tinfo_s, tinfo_descs,
1160 TK_TYPE_INFO_TYPE)->type);
1162 /* Now add the derived fields. */
1163 while ((field_decl = va_arg (ap, tree)))
1165 TREE_CHAIN (field_decl) = fields;
1166 fields = field_decl;
1169 /* Create the pseudo type. */
1170 pseudo_type = make_class_type (RECORD_TYPE);
1171 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
1172 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
1174 ti = VEC_index (tinfo_s, tinfo_descs, tk);
1175 ti->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
1176 ti->name = get_identifier (real_name);
1177 ti->vtable = NULL_TREE;
1179 /* Pretend this is public so determine_visibility doesn't give vtables
1180 internal linkage. */
1181 TREE_PUBLIC (TYPE_MAIN_DECL (ti->type)) = 1;
1186 /* Return the index of a pseudo type info type node used to describe
1187 TYPE. TYPE must be a complete type (or cv void), except at the end
1188 of the translation unit. */
1191 get_pseudo_ti_index (tree type)
1195 switch (TREE_CODE (type))
1198 ix = TK_POINTER_MEMBER_TYPE;
1202 ix = TK_POINTER_TYPE;
1206 ix = TK_ENUMERAL_TYPE;
1210 ix = TK_FUNCTION_TYPE;
1219 if (TYPE_PTRMEMFUNC_P (type))
1221 ix = TK_POINTER_MEMBER_TYPE;
1224 else if (!COMPLETE_TYPE_P (type))
1227 cxx_incomplete_type_error (NULL_TREE, type);
1231 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
1238 tree binfo = TYPE_BINFO (type);
1239 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1240 tree base_binfo = BINFO_BASE_BINFO (binfo, 0);
1241 int num_bases = BINFO_N_BASE_BINFOS (binfo);
1244 && VEC_index (tree, base_accesses, 0) == access_public_node
1245 && !BINFO_VIRTUAL_P (base_binfo)
1246 && integer_zerop (BINFO_OFFSET (base_binfo)))
1248 /* single non-virtual public. */
1249 ix = TK_SI_CLASS_TYPE;
1255 tree array_domain, base_array;
1257 ix = TK_FIXED + num_bases;
1258 if (VEC_length (tinfo_s, tinfo_descs) <= ix)
1260 /* too short, extend. */
1261 unsigned len = VEC_length (tinfo_s, tinfo_descs);
1263 VEC_safe_grow (tinfo_s, gc, tinfo_descs, ix + 1);
1264 while (VEC_iterate (tinfo_s, tinfo_descs, len++, ti))
1265 ti->type = ti->vtable = ti->name = NULL_TREE;
1267 else if (VEC_index (tinfo_s, tinfo_descs, ix)->type)
1268 /* already created. */
1271 /* Create the array of __base_class_type_info entries.
1272 G++ 3.2 allocated an array that had one too many
1273 entries, and then filled that extra entries with
1275 if (abi_version_at_least (2))
1276 array_domain = build_index_type (size_int (num_bases - 1));
1278 array_domain = build_index_type (size_int (num_bases));
1280 build_array_type (VEC_index (tinfo_s, tinfo_descs,
1281 TK_BASE_TYPE)->type,
1284 push_abi_namespace ();
1285 create_pseudo_type_info
1286 (ix, "__vmi_class_type_info",
1287 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1288 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1289 build_decl (FIELD_DECL, NULL_TREE, base_array),
1291 pop_abi_namespace ();
1296 ix = TK_BUILTIN_TYPE;
1302 /* Make sure the required builtin types exist for generating the type_info
1303 variable definitions. */
1306 create_tinfo_types (void)
1310 gcc_assert (!tinfo_descs);
1312 VEC_safe_grow (tinfo_s, gc, tinfo_descs, TK_FIXED);
1314 push_abi_namespace ();
1316 /* Create the internal type_info structure. This is used as a base for
1317 the other structures. */
1321 field = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1324 field = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1325 TREE_CHAIN (field) = fields;
1328 ti = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE);
1329 ti->type = make_class_type (RECORD_TYPE);
1330 ti->vtable = NULL_TREE;
1331 ti->name = NULL_TREE;
1332 finish_builtin_struct (ti->type, "__type_info_pseudo",
1336 /* Fundamental type_info */
1337 create_pseudo_type_info (TK_BUILTIN_TYPE, "__fundamental_type_info", NULL);
1339 /* Array, function and enum type_info. No additional fields. */
1340 create_pseudo_type_info (TK_ARRAY_TYPE, "__array_type_info", NULL);
1341 create_pseudo_type_info (TK_FUNCTION_TYPE, "__function_type_info", NULL);
1342 create_pseudo_type_info (TK_ENUMERAL_TYPE, "__enum_type_info", NULL);
1344 /* Class type_info. No additional fields. */
1345 create_pseudo_type_info (TK_CLASS_TYPE, "__class_type_info", NULL);
1347 /* Single public non-virtual base class. Add pointer to base class.
1348 This is really a descendant of __class_type_info. */
1349 create_pseudo_type_info (TK_SI_CLASS_TYPE, "__si_class_type_info",
1350 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1353 /* Base class internal helper. Pointer to base type, offset to base,
1358 field = build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type);
1361 field = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1362 TREE_CHAIN (field) = fields;
1365 ti = VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE);
1367 ti->type = make_class_type (RECORD_TYPE);
1368 ti->vtable = NULL_TREE;
1369 ti->name = NULL_TREE;
1370 finish_builtin_struct (ti->type, "__base_class_type_info_pseudo",
1374 /* Pointer type_info. Adds two fields, qualification mask
1375 and pointer to the pointed to type. This is really a descendant of
1376 __pbase_type_info. */
1377 create_pseudo_type_info (TK_POINTER_TYPE, "__pointer_type_info",
1378 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1379 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1382 /* Pointer to member data type_info. Add qualifications flags,
1383 pointer to the member's type info and pointer to the class.
1384 This is really a descendant of __pbase_type_info. */
1385 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE,
1386 "__pointer_to_member_type_info",
1387 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1388 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1389 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1392 pop_abi_namespace ();
1395 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1396 support. Generating them here guarantees consistency with the other
1397 structures. We use the following heuristic to determine when the runtime
1398 is being generated. If std::__fundamental_type_info is defined, and its
1399 destructor is defined, then the runtime is being built. */
1402 emit_support_tinfos (void)
1404 static tree *const fundamentals[] =
1409 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1410 &short_integer_type_node, &short_unsigned_type_node,
1411 &integer_type_node, &unsigned_type_node,
1412 &long_integer_type_node, &long_unsigned_type_node,
1413 &long_long_integer_type_node, &long_long_unsigned_type_node,
1414 &float_type_node, &double_type_node, &long_double_type_node,
1418 tree bltn_type, dtor;
1420 push_abi_namespace ();
1421 bltn_type = xref_tag (class_type,
1422 get_identifier ("__fundamental_type_info"),
1423 /*tag_scope=*/ts_current, false);
1424 pop_abi_namespace ();
1425 if (!COMPLETE_TYPE_P (bltn_type))
1427 dtor = CLASSTYPE_DESTRUCTORS (bltn_type);
1428 if (!dtor || DECL_EXTERNAL (dtor))
1431 for (ix = 0; fundamentals[ix]; ix++)
1433 tree bltn = *fundamentals[ix];
1438 types[1] = build_pointer_type (bltn);
1439 types[2] = build_pointer_type (build_qualified_type (bltn,
1442 for (i = 0; i < 3; ++i)
1446 tinfo = get_tinfo_decl (types[i]);
1447 TREE_USED (tinfo) = 1;
1448 mark_needed (tinfo);
1449 /* The C++ ABI requires that these objects be COMDAT. But,
1450 On systems without weak symbols, initialized COMDAT
1451 objects are emitted with internal linkage. (See
1452 comdat_linkage for details.) Since we want these objects
1453 to have external linkage so that copies do not have to be
1454 emitted in code outside the runtime library, we make them
1457 It might also not be necessary to follow this detail of the
1459 if (!flag_weak || ! targetm.cxx.library_rtti_comdat ())
1461 gcc_assert (TREE_PUBLIC (tinfo) && !DECL_COMDAT (tinfo));
1462 DECL_INTERFACE_KNOWN (tinfo) = 1;
1468 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1469 tinfo decl. Determine whether it needs emitting, and if so
1470 generate the initializer. */
1473 emit_tinfo_decl (tree decl)
1475 tree type = TREE_TYPE (DECL_NAME (decl));
1476 int in_library = typeinfo_in_lib_p (type);
1478 gcc_assert (DECL_TINFO_P (decl));
1483 DECL_EXTERNAL (decl) = 0;
1486 /* If we're not in the runtime, then DECL (which is already
1487 DECL_EXTERNAL) will not be defined here. */
1488 DECL_INTERFACE_KNOWN (decl) = 1;
1492 else if (involves_incomplete_p (type))
1494 if (!decl_needed_p (decl))
1496 /* If TYPE involves an incomplete class type, then the typeinfo
1497 object will be emitted with internal linkage. There is no
1498 way to know whether or not types are incomplete until the end
1499 of the compilation, so this determination must be deferred
1500 until this point. */
1501 TREE_PUBLIC (decl) = 0;
1502 DECL_EXTERNAL (decl) = 0;
1503 DECL_INTERFACE_KNOWN (decl) = 1;
1506 import_export_decl (decl);
1507 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
1511 DECL_EXTERNAL (decl) = 0;
1512 init = get_pseudo_ti_init (type, get_pseudo_ti_index (type));
1513 DECL_INITIAL (decl) = init;
1515 finish_decl (decl, init, NULL_TREE);
1522 #include "gt-cp-rtti.h"