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 2, 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 COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
26 #include "coretypes.h"
36 /* C++ returns type information to the user in struct type_info
37 objects. We also use type information to implement dynamic_cast and
38 exception handlers. Type information for a particular type is
39 indicated with an ABI defined structure derived from type_info.
40 This would all be very straight forward, but for the fact that the
41 runtime library provides the definitions of the type_info structure
42 and the ABI defined derived classes. We cannot build declarations
43 of them directly in the compiler, but we need to layout objects of
44 their type. Somewhere we have to lie.
46 We define layout compatible POD-structs with compiler-defined names
47 and generate the appropriate initializations for them (complete
48 with explicit mention of their vtable). When we have to provide a
49 type_info to the user we reinterpret_cast the internal compiler
50 type to type_info. A well formed program can only explicitly refer
51 to the type_infos of complete types (& cv void). However, we chain
52 pointer type_infos to the pointed-to-type, and that can be
53 incomplete. We only need the addresses of such incomplete
54 type_info objects for static initialization.
56 The type information VAR_DECL of a type is held on the
57 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
58 will be the internal type. It will usually have the correct
59 internal type reflecting the kind of type it represents (pointer,
60 array, function, class, inherited class, etc). When the type it
61 represents is incomplete, it will have the internal type
62 corresponding to type_info. That will only happen at the end of
63 translation, when we are emitting the type info objects. */
65 /* Auxiliary data we hold for each type_info derived object we need. */
66 typedef struct tinfo_s GTY (())
68 tree type; /* The RECORD_TYPE for this type_info object */
70 tree vtable; /* The VAR_DECL of the vtable. Only filled at end of
73 tree name; /* IDENTIFIER_NODE for the ABI specified name of
74 the type_info derived type. */
78 DEF_VEC_ALLOC_O(tinfo_s,gc);
80 typedef enum tinfo_kind
82 TK_TYPE_INFO_TYPE, /* std::type_info */
83 TK_BASE_TYPE, /* abi::__base_class_type_info */
84 TK_BUILTIN_TYPE, /* abi::__fundamental_type_info */
85 TK_ARRAY_TYPE, /* abi::__array_type_info */
86 TK_FUNCTION_TYPE, /* abi::__function_type_info */
87 TK_ENUMERAL_TYPE, /* abi::__enum_type_info */
88 TK_POINTER_TYPE, /* abi::__pointer_type_info */
89 TK_POINTER_MEMBER_TYPE, /* abi::__pointer_to_member_type_info */
90 TK_CLASS_TYPE, /* abi::__class_type_info */
91 TK_SI_CLASS_TYPE, /* abi::__si_class_type_info */
92 TK_FIXED /* end of fixed descriptors. */
93 /* ... abi::__vmi_type_info<I> */
96 /* A vector of all tinfo decls that haven't yet been emitted. */
97 VEC(tree,gc) *unemitted_tinfo_decls;
99 /* A vector of all type_info derived types we need. The first few are
100 fixed and created early. The remainder are for multiple inheritance
101 and are generated as needed. */
102 static GTY (()) VEC(tinfo_s,gc) *tinfo_descs;
104 static tree build_headof (tree);
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 /* Declare language defined type_info type and a pointer to const
130 type_info. This is incomplete here, and will be completed when
131 the user #includes <typeinfo>. There are language defined
132 restrictions on what can be done until that is included. Create
133 the internal versions of the ABI types. */
136 init_rtti_processing (void)
140 push_namespace (std_identifier);
141 type_info_type = xref_tag (class_type, get_identifier ("type_info"),
142 /*tag_scope=*/ts_current, false);
144 const_type_info_type_node
145 = build_qualified_type (type_info_type, TYPE_QUAL_CONST);
146 type_info_ptr_type = build_pointer_type (const_type_info_type_node);
148 unemitted_tinfo_decls = VEC_alloc (tree, gc, 124);
150 create_tinfo_types ();
153 /* Given the expression EXP of type `class *', return the head of the
154 object pointed to by EXP with type cv void*, if the class has any
155 virtual functions (TYPE_POLYMORPHIC_P), else just return the
159 build_headof (tree exp)
161 tree type = TREE_TYPE (exp);
165 gcc_assert (TREE_CODE (type) == POINTER_TYPE);
166 type = TREE_TYPE (type);
168 if (!TYPE_POLYMORPHIC_P (type))
171 /* We use this a couple of times below, protect it. */
172 exp = save_expr (exp);
174 /* The offset-to-top field is at index -2 from the vptr. */
175 index = build_int_cst (NULL_TREE,
176 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
178 offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index);
180 type = build_qualified_type (ptr_type_node,
181 cp_type_quals (TREE_TYPE (exp)));
182 return build2 (PLUS_EXPR, type, exp,
183 convert_to_integer (ptrdiff_type_node, offset));
186 /* Get a bad_cast node for the program to throw...
188 See libstdc++/exception.cc for __throw_bad_cast */
191 throw_bad_cast (void)
193 tree fn = get_identifier ("__cxa_bad_cast");
194 if (!get_global_value_if_present (fn, &fn))
195 fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,
198 return build_cxx_call (fn, NULL_TREE);
201 /* Return an expression for "__cxa_bad_typeid()". The expression
202 returned is an lvalue of type "const std::type_info". */
205 throw_bad_typeid (void)
207 tree fn = get_identifier ("__cxa_bad_typeid");
208 if (!get_global_value_if_present (fn, &fn))
212 t = build_reference_type (const_type_info_type_node);
213 t = build_function_type (t, void_list_node);
214 fn = push_throw_library_fn (fn, t);
217 return build_cxx_call (fn, NULL_TREE);
220 /* Return an lvalue expression whose type is "const std::type_info"
221 and whose value indicates the type of the expression EXP. If EXP
222 is a reference to a polymorphic class, return the dynamic type;
223 otherwise return the static type of the expression. */
226 get_tinfo_decl_dynamic (tree exp)
231 if (exp == error_mark_node)
232 return error_mark_node;
234 /* peel back references, so they match. */
235 type = non_reference (TREE_TYPE (exp));
237 /* Peel off cv qualifiers. */
238 type = TYPE_MAIN_VARIANT (type);
240 if (!VOID_TYPE_P (type))
241 type = complete_type_or_else (type, exp);
244 return error_mark_node;
246 /* If exp is a reference to polymorphic type, get the real type_info. */
247 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
249 /* build reference to type_info from vtable. */
252 /* The RTTI information is at index -1. */
253 index = build_int_cst (NULL_TREE,
254 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
255 t = build_vtbl_ref (exp, index);
256 t = convert (type_info_ptr_type, t);
259 /* Otherwise return the type_info for the static type of the expr. */
260 t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
262 return build_indirect_ref (t, NULL);
270 error ("cannot use typeid with -fno-rtti");
274 if (!COMPLETE_TYPE_P (const_type_info_type_node))
276 error ("must #include <typeinfo> before using typeid");
283 /* Return an expression for "typeid(EXP)". The expression returned is
284 an lvalue of type "const std::type_info". */
287 build_typeid (tree exp)
289 tree cond = NULL_TREE;
292 if (exp == error_mark_node || !typeid_ok_p ())
293 return error_mark_node;
295 if (processing_template_decl)
296 return build_min (TYPEID_EXPR, const_type_info_type_node, exp);
298 if (TREE_CODE (exp) == INDIRECT_REF
299 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
300 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
301 && ! resolves_to_fixed_type_p (exp, &nonnull)
304 exp = stabilize_reference (exp);
305 cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
308 exp = get_tinfo_decl_dynamic (exp);
310 if (exp == error_mark_node)
311 return error_mark_node;
315 tree bad = throw_bad_typeid ();
317 exp = build3 (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
323 /* Generate the NTBS name of a type. */
325 tinfo_name (tree type)
330 name = mangle_type_string (type);
331 name_string = fix_string_type (build_string (strlen (name) + 1, name));
335 /* Return a VAR_DECL for the internal ABI defined type_info object for
336 TYPE. You must arrange that the decl is mark_used, if actually use
337 it --- decls in vtables are only used if the vtable is output. */
340 get_tinfo_decl (tree type)
345 if (COMPLETE_TYPE_P (type)
346 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
348 error ("cannot create type information for type %qT because "
349 "its size is variable",
351 return error_mark_node;
354 if (TREE_CODE (type) == METHOD_TYPE)
355 type = build_function_type (TREE_TYPE (type),
356 TREE_CHAIN (TYPE_ARG_TYPES (type)));
358 /* For a class type, the variable is cached in the type node
360 if (CLASS_TYPE_P (type))
362 d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
367 name = mangle_typeinfo_for_type (type);
369 d = IDENTIFIER_GLOBAL_VALUE (name);
372 int ix = get_pseudo_ti_index (type);
373 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, ix);
375 d = build_lang_decl (VAR_DECL, name, ti->type);
376 SET_DECL_ASSEMBLER_NAME (d, name);
377 /* Remember the type it is for. */
378 TREE_TYPE (name) = type;
379 DECL_TINFO_P (d) = 1;
380 DECL_ARTIFICIAL (d) = 1;
381 DECL_IGNORED_P (d) = 1;
382 TREE_READONLY (d) = 1;
384 /* Mark the variable as undefined -- but remember that we can
385 define it later if we need to do so. */
386 DECL_EXTERNAL (d) = 1;
387 DECL_NOT_REALLY_EXTERN (d) = 1;
388 if (CLASS_TYPE_P (type))
389 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
390 set_linkage_according_to_type (type, d);
391 pushdecl_top_level_and_finish (d, NULL_TREE);
393 /* Add decl to the global array of tinfo decls. */
394 VEC_safe_push (tree, gc, unemitted_tinfo_decls, d);
400 /* Return a pointer to a type_info object describing TYPE, suitably
401 cast to the language defined type. */
404 get_tinfo_ptr (tree type)
406 tree decl = get_tinfo_decl (type);
409 return build_nop (type_info_ptr_type,
410 build_address (decl));
413 /* Return the type_info object for TYPE. */
416 get_typeid (tree type)
418 if (type == error_mark_node || !typeid_ok_p ())
419 return error_mark_node;
421 if (processing_template_decl)
422 return build_min (TYPEID_EXPR, const_type_info_type_node, type);
424 /* If the type of the type-id is a reference type, the result of the
425 typeid expression refers to a type_info object representing the
427 type = non_reference (type);
429 /* The top-level cv-qualifiers of the lvalue expression or the type-id
430 that is the operand of typeid are always ignored. */
431 type = TYPE_MAIN_VARIANT (type);
433 if (!VOID_TYPE_P (type))
434 type = complete_type_or_else (type, NULL_TREE);
437 return error_mark_node;
439 return build_indirect_ref (get_tinfo_ptr (type), NULL);
442 /* Check whether TEST is null before returning RESULT. If TEST is used in
443 RESULT, it must have previously had a save_expr applied to it. */
446 ifnonnull (tree test, tree result)
448 return build3 (COND_EXPR, TREE_TYPE (result),
449 build2 (EQ_EXPR, boolean_type_node, test,
450 cp_convert (TREE_TYPE (test), integer_zero_node)),
451 cp_convert (TREE_TYPE (result), integer_zero_node),
455 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
459 build_dynamic_cast_1 (tree type, tree expr)
461 enum tree_code tc = TREE_CODE (type);
462 tree exprtype = TREE_TYPE (expr);
464 tree old_expr = expr;
465 const char *errstr = NULL;
467 /* Save casted types in the function's used types hash table. */
468 used_types_insert (type);
470 /* T shall be a pointer or reference to a complete class type, or
471 `pointer to cv void''. */
475 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
479 if (! IS_AGGR_TYPE (TREE_TYPE (type)))
481 errstr = "target is not pointer or reference to class";
484 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
486 errstr = "target is not pointer or reference to complete type";
492 errstr = "target is not pointer or reference";
496 if (tc == POINTER_TYPE)
498 /* If T is a pointer type, v shall be an rvalue of a pointer to
499 complete class type, and the result is an rvalue of type T. */
501 if (TREE_CODE (exprtype) != POINTER_TYPE)
503 errstr = "source is not a pointer";
506 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
508 errstr = "source is not a pointer to class";
511 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
513 errstr = "source is a pointer to incomplete type";
519 exprtype = build_reference_type (exprtype);
521 /* T is a reference type, v shall be an lvalue of a complete class
522 type, and the result is an lvalue of the type referred to by T. */
524 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
526 errstr = "source is not of class type";
529 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
531 errstr = "source is of incomplete class type";
535 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
536 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
537 LOOKUP_NORMAL, NULL_TREE);
540 /* The dynamic_cast operator shall not cast away constness. */
541 if (!at_least_as_qualified_p (TREE_TYPE (type),
542 TREE_TYPE (exprtype)))
544 errstr = "conversion casts away constness";
548 /* If *type is an unambiguous accessible base class of *exprtype,
549 convert statically. */
553 binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
558 expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),
560 if (TREE_CODE (exprtype) == POINTER_TYPE)
561 expr = rvalue (expr);
566 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
567 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
570 /* if TYPE is `void *', return pointer to complete object. */
571 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
573 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
574 if (TREE_CODE (expr) == ADDR_EXPR
575 && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
576 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
577 return build1 (NOP_EXPR, type, expr);
579 /* Since expr is used twice below, save it. */
580 expr = save_expr (expr);
582 expr1 = build_headof (expr);
583 if (TREE_TYPE (expr1) != type)
584 expr1 = build1 (NOP_EXPR, type, expr1);
585 return ifnonnull (expr, expr1);
590 tree result, td2, td3, elems;
591 tree static_type, target_type, boff;
593 /* If we got here, we can't convert statically. Therefore,
594 dynamic_cast<D&>(b) (b an object) cannot succeed. */
595 if (tc == REFERENCE_TYPE)
597 if (TREE_CODE (old_expr) == VAR_DECL
598 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
600 tree expr = throw_bad_cast ();
601 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
603 /* Bash it to the expected type. */
604 TREE_TYPE (expr) = type;
608 /* Ditto for dynamic_cast<D*>(&b). */
609 else if (TREE_CODE (expr) == ADDR_EXPR)
611 tree op = TREE_OPERAND (expr, 0);
612 if (TREE_CODE (op) == VAR_DECL
613 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
615 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
617 retval = build_int_cst (type, 0);
622 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
623 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
624 td2 = get_tinfo_decl (target_type);
626 td2 = build_unary_op (ADDR_EXPR, td2, 0);
627 td3 = get_tinfo_decl (static_type);
629 td3 = build_unary_op (ADDR_EXPR, td3, 0);
631 /* Determine how T and V are related. */
632 boff = dcast_base_hint (static_type, target_type);
634 /* Since expr is used twice below, save it. */
635 expr = save_expr (expr);
638 if (tc == REFERENCE_TYPE)
639 expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
642 (NULL_TREE, expr1, tree_cons
643 (NULL_TREE, td3, tree_cons
644 (NULL_TREE, td2, tree_cons
645 (NULL_TREE, boff, NULL_TREE))));
647 dcast_fn = dynamic_cast_node;
655 push_nested_namespace (ns);
656 tinfo_ptr = xref_tag (class_type,
657 get_identifier ("__class_type_info"),
658 /*tag_scope=*/ts_current, false);
660 tinfo_ptr = build_pointer_type
661 (build_qualified_type
662 (tinfo_ptr, TYPE_QUAL_CONST));
663 name = "__dynamic_cast";
665 (NULL_TREE, const_ptr_type_node, tree_cons
666 (NULL_TREE, tinfo_ptr, tree_cons
667 (NULL_TREE, tinfo_ptr, tree_cons
668 (NULL_TREE, ptrdiff_type_node, void_list_node))));
669 tmp = build_function_type (ptr_type_node, tmp);
670 dcast_fn = build_library_fn_ptr (name, tmp);
671 DECL_IS_PURE (dcast_fn) = 1;
672 pop_nested_namespace (ns);
673 dynamic_cast_node = dcast_fn;
675 result = build_cxx_call (dcast_fn, elems);
677 if (tc == REFERENCE_TYPE)
679 tree bad = throw_bad_cast ();
682 result = save_expr (result);
683 neq = c_common_truthvalue_conversion (result);
684 return build3 (COND_EXPR, type, neq, result, bad);
687 /* Now back to the type we want from a void*. */
688 result = cp_convert (type, result);
689 return ifnonnull (expr, result);
693 errstr = "source type is not polymorphic";
696 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
697 expr, exprtype, type, errstr);
698 return error_mark_node;
702 build_dynamic_cast (tree type, tree expr)
704 if (type == error_mark_node || expr == error_mark_node)
705 return error_mark_node;
707 /* Use of dynamic_cast when -fno-rtti is prohibited. */
710 error ("%<dynamic_cast%> not permitted with -fno-rtti");
711 return error_mark_node;
714 if (processing_template_decl)
716 expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
717 TREE_SIDE_EFFECTS (expr) = 1;
722 return convert_from_reference (build_dynamic_cast_1 (type, expr));
725 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
728 qualifier_flags (tree type)
731 int quals = cp_type_quals (type);
733 if (quals & TYPE_QUAL_CONST)
735 if (quals & TYPE_QUAL_VOLATILE)
737 if (quals & TYPE_QUAL_RESTRICT)
742 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
743 contains a pointer to member of an incomplete class. */
746 target_incomplete_p (tree type)
749 if (TYPE_PTRMEM_P (type))
751 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
753 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
755 else if (TREE_CODE (type) == POINTER_TYPE)
756 type = TREE_TYPE (type);
758 return !COMPLETE_OR_VOID_TYPE_P (type);
761 /* Returns true if TYPE involves an incomplete class type; in that
762 case, typeinfo variables for TYPE should be emitted with internal
766 involves_incomplete_p (tree type)
768 switch (TREE_CODE (type))
771 return target_incomplete_p (TREE_TYPE (type));
776 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type))
777 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)));
780 if (TYPE_PTRMEMFUNC_P (type))
784 if (!COMPLETE_TYPE_P (type))
788 /* All other types do not involve incomplete class types. */
793 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
794 is the vtable pointer and NTBS name. The NTBS name is emitted as a
795 comdat const char array, so it becomes a unique key for the type. Generate
796 and emit that VAR_DECL here. (We can't always emit the type_info itself
797 as comdat, because of pointers to incomplete.) */
800 tinfo_base_init (tinfo_s *ti, tree target)
802 tree init = NULL_TREE;
809 /* Generate the NTBS array variable. */
810 tree name_type = build_cplus_array_type
811 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
813 tree name_string = tinfo_name (target);
815 /* Determine the name of the variable -- and remember with which
816 type it is associated. */
817 name_name = mangle_typeinfo_string_for_type (target);
818 TREE_TYPE (name_name) = target;
820 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
821 SET_DECL_ASSEMBLER_NAME (name_decl, name_name);
822 DECL_ARTIFICIAL (name_decl) = 1;
823 DECL_IGNORED_P (name_decl) = 1;
824 TREE_READONLY (name_decl) = 1;
825 TREE_STATIC (name_decl) = 1;
826 DECL_EXTERNAL (name_decl) = 0;
827 DECL_TINFO_P (name_decl) = 1;
828 if (involves_incomplete_p (target))
830 TREE_PUBLIC (name_decl) = 0;
831 DECL_INTERFACE_KNOWN (name_decl) = 1;
834 set_linkage_according_to_type (target, name_decl);
835 import_export_decl (name_decl);
836 DECL_INITIAL (name_decl) = name_string;
837 mark_used (name_decl);
838 pushdecl_top_level_and_finish (name_decl, name_string);
841 vtable_ptr = ti->vtable;
845 push_nested_namespace (abi_node);
846 real_type = xref_tag (class_type, ti->name,
847 /*tag_scope=*/ts_current, false);
848 pop_nested_namespace (abi_node);
850 if (!COMPLETE_TYPE_P (real_type))
852 /* We never saw a definition of this type, so we need to
853 tell the compiler that this is an exported class, as
854 indeed all of the __*_type_info classes are. */
855 SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
856 CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
859 vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
860 vtable_ptr = build_unary_op (ADDR_EXPR, vtable_ptr, 0);
862 /* We need to point into the middle of the vtable. */
864 (PLUS_EXPR, TREE_TYPE (vtable_ptr), vtable_ptr,
865 size_binop (MULT_EXPR,
866 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
867 TYPE_SIZE_UNIT (vtable_entry_type)));
869 ti->vtable = vtable_ptr;
872 init = tree_cons (NULL_TREE, vtable_ptr, init);
874 init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
876 init = build_constructor_from_list (NULL_TREE, nreverse (init));
877 TREE_CONSTANT (init) = 1;
878 TREE_INVARIANT (init) = 1;
879 TREE_STATIC (init) = 1;
880 init = tree_cons (NULL_TREE, init, NULL_TREE);
885 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
886 information about the particular type_info derivation, which adds no
887 additional fields to the type_info base. */
890 generic_initializer (tinfo_s *ti, tree target)
892 tree init = tinfo_base_init (ti, target);
894 init = build_constructor_from_list (NULL_TREE, init);
895 TREE_CONSTANT (init) = 1;
896 TREE_INVARIANT (init) = 1;
897 TREE_STATIC (init) = 1;
901 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
902 TI provides information about the particular type_info derivation,
903 which adds target type and qualifier flags members to the type_info base. */
906 ptr_initializer (tinfo_s *ti, tree target)
908 tree init = tinfo_base_init (ti, target);
909 tree to = TREE_TYPE (target);
910 int flags = qualifier_flags (to);
911 bool incomplete = target_incomplete_p (to);
915 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
916 init = tree_cons (NULL_TREE,
917 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
920 init = build_constructor_from_list (NULL_TREE, nreverse (init));
921 TREE_CONSTANT (init) = 1;
922 TREE_INVARIANT (init) = 1;
923 TREE_STATIC (init) = 1;
927 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
928 TI provides information about the particular type_info derivation,
929 which adds class, target type and qualifier flags members to the type_info
933 ptm_initializer (tinfo_s *ti, tree target)
935 tree init = tinfo_base_init (ti, target);
936 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
937 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
938 int flags = qualifier_flags (to);
939 bool incomplete = target_incomplete_p (to);
943 if (!COMPLETE_TYPE_P (klass))
945 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
946 init = tree_cons (NULL_TREE,
947 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
949 init = tree_cons (NULL_TREE,
950 get_tinfo_ptr (klass),
953 init = build_constructor_from_list (NULL_TREE, nreverse (init));
954 TREE_CONSTANT (init) = 1;
955 TREE_INVARIANT (init) = 1;
956 TREE_STATIC (init) = 1;
960 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
961 TI provides information about the particular __class_type_info derivation,
962 which adds hint flags and TRAIL initializers to the type_info base. */
965 class_initializer (tinfo_s *ti, tree target, tree trail)
967 tree init = tinfo_base_init (ti, target);
969 TREE_CHAIN (init) = trail;
970 init = build_constructor_from_list (NULL_TREE, init);
971 TREE_CONSTANT (init) = 1;
972 TREE_INVARIANT (init) = 1;
973 TREE_STATIC (init) = 1;
977 /* Returns true if the typeinfo for type should be placed in
978 the runtime library. */
981 typeinfo_in_lib_p (tree type)
983 /* The typeinfo objects for `T*' and `const T*' are in the runtime
984 library for simple types T. */
985 if (TREE_CODE (type) == POINTER_TYPE
986 && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
987 || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
988 type = TREE_TYPE (type);
990 switch (TREE_CODE (type))
1003 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1004 the index of the descriptor in the tinfo_desc vector. */
1007 get_pseudo_ti_init (tree type, unsigned tk_index)
1009 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1011 gcc_assert (at_eof);
1014 case TK_POINTER_MEMBER_TYPE:
1015 return ptm_initializer (ti, type);
1017 case TK_POINTER_TYPE:
1018 return ptr_initializer (ti, type);
1020 case TK_BUILTIN_TYPE:
1021 case TK_ENUMERAL_TYPE:
1022 case TK_FUNCTION_TYPE:
1024 return generic_initializer (ti, type);
1027 return class_initializer (ti, type, NULL_TREE);
1029 case TK_SI_CLASS_TYPE:
1031 tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), 0);
1032 tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1033 tree base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1035 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1036 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1037 return class_initializer (ti, type, base_inits);
1042 int hint = ((CLASSTYPE_REPEATED_BASE_P (type) << 0)
1043 | (CLASSTYPE_DIAMOND_SHAPED_P (type) << 1));
1044 tree binfo = TYPE_BINFO (type);
1045 int nbases = BINFO_N_BASE_BINFOS (binfo);
1046 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1047 tree base_inits = NULL_TREE;
1050 gcc_assert (tk_index >= TK_FIXED);
1052 /* Generate the base information initializer. */
1053 for (ix = nbases; ix--;)
1055 tree base_binfo = BINFO_BASE_BINFO (binfo, ix);
1056 tree base_init = NULL_TREE;
1061 if (VEC_index (tree, base_accesses, ix) == access_public_node)
1063 tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1064 if (BINFO_VIRTUAL_P (base_binfo))
1066 /* We store the vtable offset at which the virtual
1067 base offset can be found. */
1068 offset = BINFO_VPTR_FIELD (base_binfo);
1069 offset = convert (sizetype, offset);
1073 offset = BINFO_OFFSET (base_binfo);
1075 /* Combine offset and flags into one field. */
1076 offset = cp_build_binary_op (LSHIFT_EXPR, offset,
1077 build_int_cst (NULL_TREE, 8));
1078 offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
1079 build_int_cst (NULL_TREE, flags));
1080 base_init = tree_cons (NULL_TREE, offset, base_init);
1081 base_init = tree_cons (NULL_TREE, tinfo, base_init);
1082 base_init = build_constructor_from_list (NULL_TREE, base_init);
1083 base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1085 base_inits = build_constructor_from_list (NULL_TREE, base_inits);
1086 base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1087 /* Prepend the number of bases. */
1088 base_inits = tree_cons (NULL_TREE,
1089 build_int_cst (NULL_TREE, nbases),
1091 /* Prepend the hint flags. */
1092 base_inits = tree_cons (NULL_TREE,
1093 build_int_cst (NULL_TREE, hint),
1096 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1097 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1098 return class_initializer (ti, type, base_inits);
1103 /* Generate the RECORD_TYPE containing the data layout of a type_info
1104 derivative as used by the runtime. This layout must be consistent with
1105 that defined in the runtime support. Also generate the VAR_DECL for the
1106 type's vtable. We explicitly manage the vtable member, and name it for
1107 real type as used in the runtime. The RECORD type has a different name,
1108 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1109 is the generated type and TINFO_VTABLE_NAME is the name of the
1110 vtable. We have to delay generating the VAR_DECL of the vtable
1111 until the end of the translation, when we'll have seen the library
1112 definition, if there was one.
1114 REAL_NAME is the runtime's name of the type. Trailing arguments are
1115 additional FIELD_DECL's for the structure. The final argument must be
1119 create_pseudo_type_info (int tk, const char *real_name, ...)
1128 va_start (ap, real_name);
1130 /* Generate the pseudo type name. */
1131 pseudo_name = (char *) alloca (strlen (real_name) + 30);
1132 strcpy (pseudo_name, real_name);
1133 strcat (pseudo_name, "_pseudo");
1135 sprintf (pseudo_name + strlen (pseudo_name), "%d", tk - TK_FIXED);
1137 /* First field is the pseudo type_info base class. */
1138 fields = build_decl (FIELD_DECL, NULL_TREE,
1139 VEC_index (tinfo_s, tinfo_descs,
1140 TK_TYPE_INFO_TYPE)->type);
1142 /* Now add the derived fields. */
1143 while ((field_decl = va_arg (ap, tree)))
1145 TREE_CHAIN (field_decl) = fields;
1146 fields = field_decl;
1149 /* Create the pseudo type. */
1150 pseudo_type = make_aggr_type (RECORD_TYPE);
1151 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
1152 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
1154 ti = VEC_index (tinfo_s, tinfo_descs, tk);
1155 ti->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
1156 ti->name = get_identifier (real_name);
1157 ti->vtable = NULL_TREE;
1162 /* Return the index of a pseudo type info type node used to describe
1163 TYPE. TYPE must be a complete type (or cv void), except at the end
1164 of the translation unit. */
1167 get_pseudo_ti_index (tree type)
1171 switch (TREE_CODE (type))
1174 ix = TK_POINTER_MEMBER_TYPE;
1178 ix = TK_POINTER_TYPE;
1182 ix = TK_ENUMERAL_TYPE;
1186 ix = TK_FUNCTION_TYPE;
1195 if (TYPE_PTRMEMFUNC_P (type))
1197 ix = TK_POINTER_MEMBER_TYPE;
1200 else if (!COMPLETE_TYPE_P (type))
1203 cxx_incomplete_type_error (NULL_TREE, type);
1207 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
1214 tree binfo = TYPE_BINFO (type);
1215 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1216 tree base_binfo = BINFO_BASE_BINFO (binfo, 0);
1217 int num_bases = BINFO_N_BASE_BINFOS (binfo);
1220 && VEC_index (tree, base_accesses, 0) == access_public_node
1221 && !BINFO_VIRTUAL_P (base_binfo)
1222 && integer_zerop (BINFO_OFFSET (base_binfo)))
1224 /* single non-virtual public. */
1225 ix = TK_SI_CLASS_TYPE;
1231 tree array_domain, base_array;
1233 ix = TK_FIXED + num_bases;
1234 if (VEC_length (tinfo_s, tinfo_descs) <= ix)
1236 /* too short, extend. */
1237 unsigned len = VEC_length (tinfo_s, tinfo_descs);
1239 VEC_safe_grow (tinfo_s, gc, tinfo_descs, ix + 1);
1240 while (VEC_iterate (tinfo_s, tinfo_descs, len++, ti))
1241 ti->type = ti->vtable = ti->name = NULL_TREE;
1243 else if (VEC_index (tinfo_s, tinfo_descs, ix)->type)
1244 /* already created. */
1247 /* Create the array of __base_class_type_info entries.
1248 G++ 3.2 allocated an array that had one too many
1249 entries, and then filled that extra entries with
1251 if (abi_version_at_least (2))
1252 array_domain = build_index_type (size_int (num_bases - 1));
1254 array_domain = build_index_type (size_int (num_bases));
1256 build_array_type (VEC_index (tinfo_s, tinfo_descs,
1257 TK_BASE_TYPE)->type,
1260 push_nested_namespace (abi_node);
1261 create_pseudo_type_info
1262 (ix, "__vmi_class_type_info",
1263 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1264 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1265 build_decl (FIELD_DECL, NULL_TREE, base_array),
1267 pop_nested_namespace (abi_node);
1272 ix = TK_BUILTIN_TYPE;
1278 /* Make sure the required builtin types exist for generating the type_info
1279 variable definitions. */
1282 create_tinfo_types (void)
1286 gcc_assert (!tinfo_descs);
1288 VEC_safe_grow (tinfo_s, gc, tinfo_descs, TK_FIXED);
1290 push_nested_namespace (abi_node);
1292 /* Create the internal type_info structure. This is used as a base for
1293 the other structures. */
1297 field = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1300 field = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1301 TREE_CHAIN (field) = fields;
1304 ti = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE);
1305 ti->type = make_aggr_type (RECORD_TYPE);
1306 ti->vtable = NULL_TREE;
1307 ti->name = NULL_TREE;
1308 finish_builtin_struct (ti->type, "__type_info_pseudo",
1310 TYPE_HAS_CONSTRUCTOR (ti->type) = 1;
1313 /* Fundamental type_info */
1314 create_pseudo_type_info (TK_BUILTIN_TYPE, "__fundamental_type_info", NULL);
1316 /* Array, function and enum type_info. No additional fields. */
1317 create_pseudo_type_info (TK_ARRAY_TYPE, "__array_type_info", NULL);
1318 create_pseudo_type_info (TK_FUNCTION_TYPE, "__function_type_info", NULL);
1319 create_pseudo_type_info (TK_ENUMERAL_TYPE, "__enum_type_info", NULL);
1321 /* Class type_info. No additional fields. */
1322 create_pseudo_type_info (TK_CLASS_TYPE, "__class_type_info", NULL);
1324 /* Single public non-virtual base class. Add pointer to base class.
1325 This is really a descendant of __class_type_info. */
1326 create_pseudo_type_info (TK_SI_CLASS_TYPE, "__si_class_type_info",
1327 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1330 /* Base class internal helper. Pointer to base type, offset to base,
1335 field = build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type);
1338 field = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1339 TREE_CHAIN (field) = fields;
1342 ti = VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE);
1344 ti->type = make_aggr_type (RECORD_TYPE);
1345 ti->vtable = NULL_TREE;
1346 ti->name = NULL_TREE;
1347 finish_builtin_struct (ti->type, "__base_class_type_info_pseudo",
1349 TYPE_HAS_CONSTRUCTOR (ti->type) = 1;
1352 /* Pointer type_info. Adds two fields, qualification mask
1353 and pointer to the pointed to type. This is really a descendant of
1354 __pbase_type_info. */
1355 create_pseudo_type_info (TK_POINTER_TYPE, "__pointer_type_info",
1356 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1357 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1360 /* Pointer to member data type_info. Add qualifications flags,
1361 pointer to the member's type info and pointer to the class.
1362 This is really a descendant of __pbase_type_info. */
1363 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE,
1364 "__pointer_to_member_type_info",
1365 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1366 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1367 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1370 pop_nested_namespace (abi_node);
1373 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1374 support. Generating them here guarantees consistency with the other
1375 structures. We use the following heuristic to determine when the runtime
1376 is being generated. If std::__fundamental_type_info is defined, and its
1377 destructor is defined, then the runtime is being built. */
1380 emit_support_tinfos (void)
1382 static tree *const fundamentals[] =
1387 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1388 &short_integer_type_node, &short_unsigned_type_node,
1389 &integer_type_node, &unsigned_type_node,
1390 &long_integer_type_node, &long_unsigned_type_node,
1391 &long_long_integer_type_node, &long_long_unsigned_type_node,
1392 &float_type_node, &double_type_node, &long_double_type_node,
1396 tree bltn_type, dtor;
1398 push_nested_namespace (abi_node);
1399 bltn_type = xref_tag (class_type,
1400 get_identifier ("__fundamental_type_info"),
1401 /*tag_scope=*/ts_current, false);
1402 pop_nested_namespace (abi_node);
1403 if (!COMPLETE_TYPE_P (bltn_type))
1405 dtor = CLASSTYPE_DESTRUCTORS (bltn_type);
1406 if (!dtor || DECL_EXTERNAL (dtor))
1409 for (ix = 0; fundamentals[ix]; ix++)
1411 tree bltn = *fundamentals[ix];
1416 types[1] = build_pointer_type (bltn);
1417 types[2] = build_pointer_type (build_qualified_type (bltn,
1420 for (i = 0; i < 3; ++i)
1424 tinfo = get_tinfo_decl (types[i]);
1425 TREE_USED (tinfo) = 1;
1426 mark_needed (tinfo);
1427 /* The C++ ABI requires that these objects be COMDAT. But,
1428 On systems without weak symbols, initialized COMDAT
1429 objects are emitted with internal linkage. (See
1430 comdat_linkage for details.) Since we want these objects
1431 to have external linkage so that copies do not have to be
1432 emitted in code outside the runtime library, we make them
1436 gcc_assert (TREE_PUBLIC (tinfo) && !DECL_COMDAT (tinfo));
1437 DECL_INTERFACE_KNOWN (tinfo) = 1;
1443 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1444 tinfo decl. Determine whether it needs emitting, and if so
1445 generate the initializer. */
1448 emit_tinfo_decl (tree decl)
1450 tree type = TREE_TYPE (DECL_NAME (decl));
1451 int in_library = typeinfo_in_lib_p (type);
1453 gcc_assert (DECL_TINFO_P (decl));
1458 DECL_EXTERNAL (decl) = 0;
1461 /* If we're not in the runtime, then DECL (which is already
1462 DECL_EXTERNAL) will not be defined here. */
1463 DECL_INTERFACE_KNOWN (decl) = 1;
1467 else if (involves_incomplete_p (type))
1469 if (!decl_needed_p (decl))
1471 /* If TYPE involves an incomplete class type, then the typeinfo
1472 object will be emitted with internal linkage. There is no
1473 way to know whether or not types are incomplete until the end
1474 of the compilation, so this determination must be deferred
1475 until this point. */
1476 TREE_PUBLIC (decl) = 0;
1477 DECL_EXTERNAL (decl) = 0;
1478 DECL_INTERFACE_KNOWN (decl) = 1;
1481 import_export_decl (decl);
1482 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
1486 DECL_EXTERNAL (decl) = 0;
1487 init = get_pseudo_ti_init (type, get_pseudo_ti_index (type));
1488 DECL_INITIAL (decl) = init;
1490 finish_decl (decl, init, NULL_TREE);
1497 #include "gt-cp-rtti.h"