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 (error_operand_p (exp))
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 (variably_modified_type_p (type, /*fn=*/NULL_TREE))
347 error ("cannot create type information for type %qT because "
348 "it involves types of variable size",
350 return error_mark_node;
353 if (TREE_CODE (type) == METHOD_TYPE)
354 type = build_function_type (TREE_TYPE (type),
355 TREE_CHAIN (TYPE_ARG_TYPES (type)));
357 /* For a class type, the variable is cached in the type node
359 if (CLASS_TYPE_P (type))
361 d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
366 name = mangle_typeinfo_for_type (type);
368 d = IDENTIFIER_GLOBAL_VALUE (name);
371 int ix = get_pseudo_ti_index (type);
372 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, ix);
374 d = build_lang_decl (VAR_DECL, name, ti->type);
375 SET_DECL_ASSEMBLER_NAME (d, name);
376 /* Remember the type it is for. */
377 TREE_TYPE (name) = type;
378 DECL_TINFO_P (d) = 1;
379 DECL_ARTIFICIAL (d) = 1;
380 DECL_IGNORED_P (d) = 1;
381 TREE_READONLY (d) = 1;
383 /* Mark the variable as undefined -- but remember that we can
384 define it later if we need to do so. */
385 DECL_EXTERNAL (d) = 1;
386 DECL_NOT_REALLY_EXTERN (d) = 1;
387 if (CLASS_TYPE_P (type))
388 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
389 set_linkage_according_to_type (type, d);
390 pushdecl_top_level_and_finish (d, NULL_TREE);
392 /* Add decl to the global array of tinfo decls. */
393 VEC_safe_push (tree, gc, unemitted_tinfo_decls, d);
399 /* Return a pointer to a type_info object describing TYPE, suitably
400 cast to the language defined type. */
403 get_tinfo_ptr (tree type)
405 tree decl = get_tinfo_decl (type);
408 return build_nop (type_info_ptr_type,
409 build_address (decl));
412 /* Return the type_info object for TYPE. */
415 get_typeid (tree type)
417 if (type == error_mark_node || !typeid_ok_p ())
418 return error_mark_node;
420 if (processing_template_decl)
421 return build_min (TYPEID_EXPR, const_type_info_type_node, type);
423 /* If the type of the type-id is a reference type, the result of the
424 typeid expression refers to a type_info object representing the
426 type = non_reference (type);
428 /* The top-level cv-qualifiers of the lvalue expression or the type-id
429 that is the operand of typeid are always ignored. */
430 type = TYPE_MAIN_VARIANT (type);
432 if (!VOID_TYPE_P (type))
433 type = complete_type_or_else (type, NULL_TREE);
436 return error_mark_node;
438 return build_indirect_ref (get_tinfo_ptr (type), NULL);
441 /* Check whether TEST is null before returning RESULT. If TEST is used in
442 RESULT, it must have previously had a save_expr applied to it. */
445 ifnonnull (tree test, tree result)
447 return build3 (COND_EXPR, TREE_TYPE (result),
448 build2 (EQ_EXPR, boolean_type_node, test,
449 cp_convert (TREE_TYPE (test), integer_zero_node)),
450 cp_convert (TREE_TYPE (result), integer_zero_node),
454 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
458 build_dynamic_cast_1 (tree type, tree expr)
460 enum tree_code tc = TREE_CODE (type);
461 tree exprtype = TREE_TYPE (expr);
463 tree old_expr = expr;
464 const char *errstr = NULL;
466 /* Save casted types in the function's used types hash table. */
467 used_types_insert (type);
469 /* T shall be a pointer or reference to a complete class type, or
470 `pointer to cv void''. */
474 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
478 if (! IS_AGGR_TYPE (TREE_TYPE (type)))
480 errstr = "target is not pointer or reference to class";
483 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
485 errstr = "target is not pointer or reference to complete type";
491 errstr = "target is not pointer or reference";
495 if (tc == POINTER_TYPE)
497 /* If T is a pointer type, v shall be an rvalue of a pointer to
498 complete class type, and the result is an rvalue of type T. */
500 if (TREE_CODE (exprtype) != POINTER_TYPE)
502 errstr = "source is not a pointer";
505 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
507 errstr = "source is not a pointer to class";
510 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
512 errstr = "source is a pointer to incomplete type";
518 exprtype = build_reference_type (exprtype);
520 /* T is a reference type, v shall be an lvalue of a complete class
521 type, and the result is an lvalue of the type referred to by T. */
523 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
525 errstr = "source is not of class type";
528 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
530 errstr = "source is of incomplete class type";
534 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
535 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
536 LOOKUP_NORMAL, NULL_TREE);
539 /* The dynamic_cast operator shall not cast away constness. */
540 if (!at_least_as_qualified_p (TREE_TYPE (type),
541 TREE_TYPE (exprtype)))
543 errstr = "conversion casts away constness";
547 /* If *type is an unambiguous accessible base class of *exprtype,
548 convert statically. */
552 binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
557 expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),
559 if (TREE_CODE (exprtype) == POINTER_TYPE)
560 expr = rvalue (expr);
565 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
566 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
569 /* if TYPE is `void *', return pointer to complete object. */
570 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
572 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
573 if (TREE_CODE (expr) == ADDR_EXPR
574 && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
575 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
576 return build1 (NOP_EXPR, type, expr);
578 /* Since expr is used twice below, save it. */
579 expr = save_expr (expr);
581 expr1 = build_headof (expr);
582 if (TREE_TYPE (expr1) != type)
583 expr1 = build1 (NOP_EXPR, type, expr1);
584 return ifnonnull (expr, expr1);
589 tree result, td2, td3, elems;
590 tree static_type, target_type, boff;
592 /* If we got here, we can't convert statically. Therefore,
593 dynamic_cast<D&>(b) (b an object) cannot succeed. */
594 if (tc == REFERENCE_TYPE)
596 if (TREE_CODE (old_expr) == VAR_DECL
597 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
599 tree expr = throw_bad_cast ();
600 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
602 /* Bash it to the expected type. */
603 TREE_TYPE (expr) = type;
607 /* Ditto for dynamic_cast<D*>(&b). */
608 else if (TREE_CODE (expr) == ADDR_EXPR)
610 tree op = TREE_OPERAND (expr, 0);
611 if (TREE_CODE (op) == VAR_DECL
612 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
614 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
616 retval = build_int_cst (type, 0);
621 /* Use of dynamic_cast when -fno-rtti is prohibited. */
624 error ("%<dynamic_cast%> not permitted with -fno-rtti");
625 return error_mark_node;
628 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
629 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
630 td2 = get_tinfo_decl (target_type);
632 td2 = build_unary_op (ADDR_EXPR, td2, 0);
633 td3 = get_tinfo_decl (static_type);
635 td3 = build_unary_op (ADDR_EXPR, td3, 0);
637 /* Determine how T and V are related. */
638 boff = dcast_base_hint (static_type, target_type);
640 /* Since expr is used twice below, save it. */
641 expr = save_expr (expr);
644 if (tc == REFERENCE_TYPE)
645 expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
648 (NULL_TREE, expr1, tree_cons
649 (NULL_TREE, td3, tree_cons
650 (NULL_TREE, td2, tree_cons
651 (NULL_TREE, boff, NULL_TREE))));
653 dcast_fn = dynamic_cast_node;
661 push_nested_namespace (ns);
662 tinfo_ptr = xref_tag (class_type,
663 get_identifier ("__class_type_info"),
664 /*tag_scope=*/ts_current, false);
666 tinfo_ptr = build_pointer_type
667 (build_qualified_type
668 (tinfo_ptr, TYPE_QUAL_CONST));
669 name = "__dynamic_cast";
671 (NULL_TREE, const_ptr_type_node, tree_cons
672 (NULL_TREE, tinfo_ptr, tree_cons
673 (NULL_TREE, tinfo_ptr, tree_cons
674 (NULL_TREE, ptrdiff_type_node, void_list_node))));
675 tmp = build_function_type (ptr_type_node, tmp);
676 dcast_fn = build_library_fn_ptr (name, tmp);
677 DECL_IS_PURE (dcast_fn) = 1;
678 pop_nested_namespace (ns);
679 dynamic_cast_node = dcast_fn;
681 result = build_cxx_call (dcast_fn, elems);
683 if (tc == REFERENCE_TYPE)
685 tree bad = throw_bad_cast ();
688 result = save_expr (result);
689 neq = c_common_truthvalue_conversion (result);
690 return build3 (COND_EXPR, type, neq, result, bad);
693 /* Now back to the type we want from a void*. */
694 result = cp_convert (type, result);
695 return ifnonnull (expr, result);
699 errstr = "source type is not polymorphic";
702 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
703 expr, exprtype, type, errstr);
704 return error_mark_node;
708 build_dynamic_cast (tree type, tree expr)
710 if (type == error_mark_node || expr == error_mark_node)
711 return error_mark_node;
713 if (processing_template_decl)
715 expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
716 TREE_SIDE_EFFECTS (expr) = 1;
721 return convert_from_reference (build_dynamic_cast_1 (type, expr));
724 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
727 qualifier_flags (tree type)
730 int quals = cp_type_quals (type);
732 if (quals & TYPE_QUAL_CONST)
734 if (quals & TYPE_QUAL_VOLATILE)
736 if (quals & TYPE_QUAL_RESTRICT)
741 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
742 contains a pointer to member of an incomplete class. */
745 target_incomplete_p (tree type)
748 if (TYPE_PTRMEM_P (type))
750 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
752 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
754 else if (TREE_CODE (type) == POINTER_TYPE)
755 type = TREE_TYPE (type);
757 return !COMPLETE_OR_VOID_TYPE_P (type);
760 /* Returns true if TYPE involves an incomplete class type; in that
761 case, typeinfo variables for TYPE should be emitted with internal
765 involves_incomplete_p (tree type)
767 switch (TREE_CODE (type))
770 return target_incomplete_p (TREE_TYPE (type));
775 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type))
776 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)));
779 if (TYPE_PTRMEMFUNC_P (type))
783 if (!COMPLETE_TYPE_P (type))
787 /* All other types do not involve incomplete class types. */
792 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
793 is the vtable pointer and NTBS name. The NTBS name is emitted as a
794 comdat const char array, so it becomes a unique key for the type. Generate
795 and emit that VAR_DECL here. (We can't always emit the type_info itself
796 as comdat, because of pointers to incomplete.) */
799 tinfo_base_init (tinfo_s *ti, tree target)
801 tree init = NULL_TREE;
808 /* Generate the NTBS array variable. */
809 tree name_type = build_cplus_array_type
810 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
812 tree name_string = tinfo_name (target);
814 /* Determine the name of the variable -- and remember with which
815 type it is associated. */
816 name_name = mangle_typeinfo_string_for_type (target);
817 TREE_TYPE (name_name) = target;
819 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
820 SET_DECL_ASSEMBLER_NAME (name_decl, name_name);
821 DECL_ARTIFICIAL (name_decl) = 1;
822 DECL_IGNORED_P (name_decl) = 1;
823 TREE_READONLY (name_decl) = 1;
824 TREE_STATIC (name_decl) = 1;
825 DECL_EXTERNAL (name_decl) = 0;
826 DECL_TINFO_P (name_decl) = 1;
827 if (involves_incomplete_p (target))
829 TREE_PUBLIC (name_decl) = 0;
830 DECL_INTERFACE_KNOWN (name_decl) = 1;
833 set_linkage_according_to_type (target, name_decl);
834 import_export_decl (name_decl);
835 DECL_INITIAL (name_decl) = name_string;
836 mark_used (name_decl);
837 pushdecl_top_level_and_finish (name_decl, name_string);
840 vtable_ptr = ti->vtable;
844 push_nested_namespace (abi_node);
845 real_type = xref_tag (class_type, ti->name,
846 /*tag_scope=*/ts_current, false);
847 pop_nested_namespace (abi_node);
849 if (!COMPLETE_TYPE_P (real_type))
851 /* We never saw a definition of this type, so we need to
852 tell the compiler that this is an exported class, as
853 indeed all of the __*_type_info classes are. */
854 SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
855 CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
858 vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
859 vtable_ptr = build_unary_op (ADDR_EXPR, vtable_ptr, 0);
861 /* We need to point into the middle of the vtable. */
863 (PLUS_EXPR, TREE_TYPE (vtable_ptr), vtable_ptr,
864 size_binop (MULT_EXPR,
865 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
866 TYPE_SIZE_UNIT (vtable_entry_type)));
868 ti->vtable = vtable_ptr;
871 init = tree_cons (NULL_TREE, vtable_ptr, init);
873 init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
875 init = build_constructor_from_list (NULL_TREE, nreverse (init));
876 TREE_CONSTANT (init) = 1;
877 TREE_INVARIANT (init) = 1;
878 TREE_STATIC (init) = 1;
879 init = tree_cons (NULL_TREE, init, NULL_TREE);
884 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
885 information about the particular type_info derivation, which adds no
886 additional fields to the type_info base. */
889 generic_initializer (tinfo_s *ti, tree target)
891 tree init = tinfo_base_init (ti, target);
893 init = build_constructor_from_list (NULL_TREE, init);
894 TREE_CONSTANT (init) = 1;
895 TREE_INVARIANT (init) = 1;
896 TREE_STATIC (init) = 1;
900 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
901 TI provides information about the particular type_info derivation,
902 which adds target type and qualifier flags members to the type_info base. */
905 ptr_initializer (tinfo_s *ti, tree target)
907 tree init = tinfo_base_init (ti, target);
908 tree to = TREE_TYPE (target);
909 int flags = qualifier_flags (to);
910 bool incomplete = target_incomplete_p (to);
914 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
915 init = tree_cons (NULL_TREE,
916 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
919 init = build_constructor_from_list (NULL_TREE, nreverse (init));
920 TREE_CONSTANT (init) = 1;
921 TREE_INVARIANT (init) = 1;
922 TREE_STATIC (init) = 1;
926 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
927 TI provides information about the particular type_info derivation,
928 which adds class, target type and qualifier flags members to the type_info
932 ptm_initializer (tinfo_s *ti, tree target)
934 tree init = tinfo_base_init (ti, target);
935 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
936 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
937 int flags = qualifier_flags (to);
938 bool incomplete = target_incomplete_p (to);
942 if (!COMPLETE_TYPE_P (klass))
944 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
945 init = tree_cons (NULL_TREE,
946 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
948 init = tree_cons (NULL_TREE,
949 get_tinfo_ptr (klass),
952 init = build_constructor_from_list (NULL_TREE, nreverse (init));
953 TREE_CONSTANT (init) = 1;
954 TREE_INVARIANT (init) = 1;
955 TREE_STATIC (init) = 1;
959 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
960 TI provides information about the particular __class_type_info derivation,
961 which adds hint flags and TRAIL initializers to the type_info base. */
964 class_initializer (tinfo_s *ti, tree target, tree trail)
966 tree init = tinfo_base_init (ti, target);
968 TREE_CHAIN (init) = trail;
969 init = build_constructor_from_list (NULL_TREE, init);
970 TREE_CONSTANT (init) = 1;
971 TREE_INVARIANT (init) = 1;
972 TREE_STATIC (init) = 1;
976 /* Returns true if the typeinfo for type should be placed in
977 the runtime library. */
980 typeinfo_in_lib_p (tree type)
982 /* The typeinfo objects for `T*' and `const T*' are in the runtime
983 library for simple types T. */
984 if (TREE_CODE (type) == POINTER_TYPE
985 && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
986 || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
987 type = TREE_TYPE (type);
989 switch (TREE_CODE (type))
1002 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1003 the index of the descriptor in the tinfo_desc vector. */
1006 get_pseudo_ti_init (tree type, unsigned tk_index)
1008 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1010 gcc_assert (at_eof);
1013 case TK_POINTER_MEMBER_TYPE:
1014 return ptm_initializer (ti, type);
1016 case TK_POINTER_TYPE:
1017 return ptr_initializer (ti, type);
1019 case TK_BUILTIN_TYPE:
1020 case TK_ENUMERAL_TYPE:
1021 case TK_FUNCTION_TYPE:
1023 return generic_initializer (ti, type);
1026 return class_initializer (ti, type, NULL_TREE);
1028 case TK_SI_CLASS_TYPE:
1030 tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), 0);
1031 tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1032 tree base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1034 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1035 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1036 return class_initializer (ti, type, base_inits);
1041 int hint = ((CLASSTYPE_REPEATED_BASE_P (type) << 0)
1042 | (CLASSTYPE_DIAMOND_SHAPED_P (type) << 1));
1043 tree binfo = TYPE_BINFO (type);
1044 int nbases = BINFO_N_BASE_BINFOS (binfo);
1045 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1046 tree base_inits = NULL_TREE;
1049 gcc_assert (tk_index >= TK_FIXED);
1051 /* Generate the base information initializer. */
1052 for (ix = nbases; ix--;)
1054 tree base_binfo = BINFO_BASE_BINFO (binfo, ix);
1055 tree base_init = NULL_TREE;
1060 if (VEC_index (tree, base_accesses, ix) == access_public_node)
1062 tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1063 if (BINFO_VIRTUAL_P (base_binfo))
1065 /* We store the vtable offset at which the virtual
1066 base offset can be found. */
1067 offset = BINFO_VPTR_FIELD (base_binfo);
1068 offset = convert (sizetype, offset);
1072 offset = BINFO_OFFSET (base_binfo);
1074 /* Combine offset and flags into one field. */
1075 offset = cp_build_binary_op (LSHIFT_EXPR, offset,
1076 build_int_cst (NULL_TREE, 8));
1077 offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
1078 build_int_cst (NULL_TREE, flags));
1079 base_init = tree_cons (NULL_TREE, offset, base_init);
1080 base_init = tree_cons (NULL_TREE, tinfo, base_init);
1081 base_init = build_constructor_from_list (NULL_TREE, base_init);
1082 base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1084 base_inits = build_constructor_from_list (NULL_TREE, base_inits);
1085 base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1086 /* Prepend the number of bases. */
1087 base_inits = tree_cons (NULL_TREE,
1088 build_int_cst (NULL_TREE, nbases),
1090 /* Prepend the hint flags. */
1091 base_inits = tree_cons (NULL_TREE,
1092 build_int_cst (NULL_TREE, hint),
1095 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1096 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1097 return class_initializer (ti, type, base_inits);
1102 /* Generate the RECORD_TYPE containing the data layout of a type_info
1103 derivative as used by the runtime. This layout must be consistent with
1104 that defined in the runtime support. Also generate the VAR_DECL for the
1105 type's vtable. We explicitly manage the vtable member, and name it for
1106 real type as used in the runtime. The RECORD type has a different name,
1107 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1108 is the generated type and TINFO_VTABLE_NAME is the name of the
1109 vtable. We have to delay generating the VAR_DECL of the vtable
1110 until the end of the translation, when we'll have seen the library
1111 definition, if there was one.
1113 REAL_NAME is the runtime's name of the type. Trailing arguments are
1114 additional FIELD_DECL's for the structure. The final argument must be
1118 create_pseudo_type_info (int tk, const char *real_name, ...)
1127 va_start (ap, real_name);
1129 /* Generate the pseudo type name. */
1130 pseudo_name = (char *) alloca (strlen (real_name) + 30);
1131 strcpy (pseudo_name, real_name);
1132 strcat (pseudo_name, "_pseudo");
1134 sprintf (pseudo_name + strlen (pseudo_name), "%d", tk - TK_FIXED);
1136 /* First field is the pseudo type_info base class. */
1137 fields = build_decl (FIELD_DECL, NULL_TREE,
1138 VEC_index (tinfo_s, tinfo_descs,
1139 TK_TYPE_INFO_TYPE)->type);
1141 /* Now add the derived fields. */
1142 while ((field_decl = va_arg (ap, tree)))
1144 TREE_CHAIN (field_decl) = fields;
1145 fields = field_decl;
1148 /* Create the pseudo type. */
1149 pseudo_type = make_aggr_type (RECORD_TYPE);
1150 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
1151 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
1153 ti = VEC_index (tinfo_s, tinfo_descs, tk);
1154 ti->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
1155 ti->name = get_identifier (real_name);
1156 ti->vtable = NULL_TREE;
1158 /* Pretend this is public so determine_visibility doesn't give vtables
1159 internal linkage. */
1160 TREE_PUBLIC (TYPE_MAIN_DECL (ti->type)) = 1;
1165 /* Return the index of a pseudo type info type node used to describe
1166 TYPE. TYPE must be a complete type (or cv void), except at the end
1167 of the translation unit. */
1170 get_pseudo_ti_index (tree type)
1174 switch (TREE_CODE (type))
1177 ix = TK_POINTER_MEMBER_TYPE;
1181 ix = TK_POINTER_TYPE;
1185 ix = TK_ENUMERAL_TYPE;
1189 ix = TK_FUNCTION_TYPE;
1198 if (TYPE_PTRMEMFUNC_P (type))
1200 ix = TK_POINTER_MEMBER_TYPE;
1203 else if (!COMPLETE_TYPE_P (type))
1206 cxx_incomplete_type_error (NULL_TREE, type);
1210 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
1217 tree binfo = TYPE_BINFO (type);
1218 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1219 tree base_binfo = BINFO_BASE_BINFO (binfo, 0);
1220 int num_bases = BINFO_N_BASE_BINFOS (binfo);
1223 && VEC_index (tree, base_accesses, 0) == access_public_node
1224 && !BINFO_VIRTUAL_P (base_binfo)
1225 && integer_zerop (BINFO_OFFSET (base_binfo)))
1227 /* single non-virtual public. */
1228 ix = TK_SI_CLASS_TYPE;
1234 tree array_domain, base_array;
1236 ix = TK_FIXED + num_bases;
1237 if (VEC_length (tinfo_s, tinfo_descs) <= ix)
1239 /* too short, extend. */
1240 unsigned len = VEC_length (tinfo_s, tinfo_descs);
1242 VEC_safe_grow (tinfo_s, gc, tinfo_descs, ix + 1);
1243 while (VEC_iterate (tinfo_s, tinfo_descs, len++, ti))
1244 ti->type = ti->vtable = ti->name = NULL_TREE;
1246 else if (VEC_index (tinfo_s, tinfo_descs, ix)->type)
1247 /* already created. */
1250 /* Create the array of __base_class_type_info entries.
1251 G++ 3.2 allocated an array that had one too many
1252 entries, and then filled that extra entries with
1254 if (abi_version_at_least (2))
1255 array_domain = build_index_type (size_int (num_bases - 1));
1257 array_domain = build_index_type (size_int (num_bases));
1259 build_array_type (VEC_index (tinfo_s, tinfo_descs,
1260 TK_BASE_TYPE)->type,
1263 push_nested_namespace (abi_node);
1264 create_pseudo_type_info
1265 (ix, "__vmi_class_type_info",
1266 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1267 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1268 build_decl (FIELD_DECL, NULL_TREE, base_array),
1270 pop_nested_namespace (abi_node);
1275 ix = TK_BUILTIN_TYPE;
1281 /* Make sure the required builtin types exist for generating the type_info
1282 variable definitions. */
1285 create_tinfo_types (void)
1289 gcc_assert (!tinfo_descs);
1291 VEC_safe_grow (tinfo_s, gc, tinfo_descs, TK_FIXED);
1293 push_nested_namespace (abi_node);
1295 /* Create the internal type_info structure. This is used as a base for
1296 the other structures. */
1300 field = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1303 field = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1304 TREE_CHAIN (field) = fields;
1307 ti = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE);
1308 ti->type = make_aggr_type (RECORD_TYPE);
1309 ti->vtable = NULL_TREE;
1310 ti->name = NULL_TREE;
1311 finish_builtin_struct (ti->type, "__type_info_pseudo",
1313 TYPE_HAS_CONSTRUCTOR (ti->type) = 1;
1316 /* Fundamental type_info */
1317 create_pseudo_type_info (TK_BUILTIN_TYPE, "__fundamental_type_info", NULL);
1319 /* Array, function and enum type_info. No additional fields. */
1320 create_pseudo_type_info (TK_ARRAY_TYPE, "__array_type_info", NULL);
1321 create_pseudo_type_info (TK_FUNCTION_TYPE, "__function_type_info", NULL);
1322 create_pseudo_type_info (TK_ENUMERAL_TYPE, "__enum_type_info", NULL);
1324 /* Class type_info. No additional fields. */
1325 create_pseudo_type_info (TK_CLASS_TYPE, "__class_type_info", NULL);
1327 /* Single public non-virtual base class. Add pointer to base class.
1328 This is really a descendant of __class_type_info. */
1329 create_pseudo_type_info (TK_SI_CLASS_TYPE, "__si_class_type_info",
1330 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1333 /* Base class internal helper. Pointer to base type, offset to base,
1338 field = build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type);
1341 field = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1342 TREE_CHAIN (field) = fields;
1345 ti = VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE);
1347 ti->type = make_aggr_type (RECORD_TYPE);
1348 ti->vtable = NULL_TREE;
1349 ti->name = NULL_TREE;
1350 finish_builtin_struct (ti->type, "__base_class_type_info_pseudo",
1352 TYPE_HAS_CONSTRUCTOR (ti->type) = 1;
1355 /* Pointer type_info. Adds two fields, qualification mask
1356 and pointer to the pointed to type. This is really a descendant of
1357 __pbase_type_info. */
1358 create_pseudo_type_info (TK_POINTER_TYPE, "__pointer_type_info",
1359 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1360 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1363 /* Pointer to member data type_info. Add qualifications flags,
1364 pointer to the member's type info and pointer to the class.
1365 This is really a descendant of __pbase_type_info. */
1366 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE,
1367 "__pointer_to_member_type_info",
1368 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1369 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1370 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1373 pop_nested_namespace (abi_node);
1376 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1377 support. Generating them here guarantees consistency with the other
1378 structures. We use the following heuristic to determine when the runtime
1379 is being generated. If std::__fundamental_type_info is defined, and its
1380 destructor is defined, then the runtime is being built. */
1383 emit_support_tinfos (void)
1385 static tree *const fundamentals[] =
1390 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1391 &short_integer_type_node, &short_unsigned_type_node,
1392 &integer_type_node, &unsigned_type_node,
1393 &long_integer_type_node, &long_unsigned_type_node,
1394 &long_long_integer_type_node, &long_long_unsigned_type_node,
1395 &float_type_node, &double_type_node, &long_double_type_node,
1399 tree bltn_type, dtor;
1401 push_nested_namespace (abi_node);
1402 bltn_type = xref_tag (class_type,
1403 get_identifier ("__fundamental_type_info"),
1404 /*tag_scope=*/ts_current, false);
1405 pop_nested_namespace (abi_node);
1406 if (!COMPLETE_TYPE_P (bltn_type))
1408 dtor = CLASSTYPE_DESTRUCTORS (bltn_type);
1409 if (!dtor || DECL_EXTERNAL (dtor))
1412 for (ix = 0; fundamentals[ix]; ix++)
1414 tree bltn = *fundamentals[ix];
1419 types[1] = build_pointer_type (bltn);
1420 types[2] = build_pointer_type (build_qualified_type (bltn,
1423 for (i = 0; i < 3; ++i)
1427 tinfo = get_tinfo_decl (types[i]);
1428 TREE_USED (tinfo) = 1;
1429 mark_needed (tinfo);
1430 /* The C++ ABI requires that these objects be COMDAT. But,
1431 On systems without weak symbols, initialized COMDAT
1432 objects are emitted with internal linkage. (See
1433 comdat_linkage for details.) Since we want these objects
1434 to have external linkage so that copies do not have to be
1435 emitted in code outside the runtime library, we make them
1439 gcc_assert (TREE_PUBLIC (tinfo) && !DECL_COMDAT (tinfo));
1440 DECL_INTERFACE_KNOWN (tinfo) = 1;
1446 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1447 tinfo decl. Determine whether it needs emitting, and if so
1448 generate the initializer. */
1451 emit_tinfo_decl (tree decl)
1453 tree type = TREE_TYPE (DECL_NAME (decl));
1454 int in_library = typeinfo_in_lib_p (type);
1456 gcc_assert (DECL_TINFO_P (decl));
1461 DECL_EXTERNAL (decl) = 0;
1464 /* If we're not in the runtime, then DECL (which is already
1465 DECL_EXTERNAL) will not be defined here. */
1466 DECL_INTERFACE_KNOWN (decl) = 1;
1470 else if (involves_incomplete_p (type))
1472 if (!decl_needed_p (decl))
1474 /* If TYPE involves an incomplete class type, then the typeinfo
1475 object will be emitted with internal linkage. There is no
1476 way to know whether or not types are incomplete until the end
1477 of the compilation, so this determination must be deferred
1478 until this point. */
1479 TREE_PUBLIC (decl) = 0;
1480 DECL_EXTERNAL (decl) = 0;
1481 DECL_INTERFACE_KNOWN (decl) = 1;
1484 import_export_decl (decl);
1485 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
1489 DECL_EXTERNAL (decl) = 0;
1490 init = get_pseudo_ti_init (type, get_pseudo_ti_index (type));
1491 DECL_INITIAL (decl) = init;
1493 finish_decl (decl, init, NULL_TREE);
1500 #include "gt-cp-rtti.h"