1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Mostly written by Jason Merrill (jason@cygnus.com).
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "coretypes.h"
35 /* C++ returns type information to the user in struct type_info
36 objects. We also use type information to implement dynamic_cast and
37 exception handlers. Type information for a particular type is
38 indicated with an ABI defined structure derived from type_info.
39 This would all be very straight forward, but for the fact that the
40 runtime library provides the definitions of the type_info structure
41 and the ABI defined derived classes. We cannot build declarations
42 of them directly in the compiler, but we need to layout objects of
43 their type. Somewhere we have to lie.
45 We define layout compatible POD-structs with compiler-defined names
46 and generate the appropriate initializations for them (complete
47 with explicit mention of their vtable). When we have to provide a
48 type_info to the user we reinterpret_cast the internal compiler
49 type to type_info. A well formed program can only explicitly refer
50 to the type_infos of complete types (& cv void). However, we chain
51 pointer type_infos to the pointed-to-type, and that can be
52 incomplete. We only need the addresses of such incomplete
53 type_info objects for static initialization.
55 The type information VAR_DECL of a type is held on the
56 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
57 will be the internal type. It will usually have the correct
58 internal type reflecting the kind of type it represents (pointer,
59 array, function, class, inherited class, etc). When the type it
60 represents is incomplete, it will have the internal type
61 corresponding to type_info. That will only happen at the end of
62 translation, when we are emitting the type info objects. */
64 /* Accessors for the type_info objects. We need to remember several things
65 about each of the type_info types. The global tree nodes such as
66 bltn_desc_type_node are TREE_LISTs, and these macros are used to access
67 the required information. */
68 /* The RECORD_TYPE of a type_info derived class. */
69 #define TINFO_PSEUDO_TYPE(NODE) TREE_TYPE (NODE)
70 /* The VAR_DECL of the vtable for the type_info derived class.
71 This is only filled in at the end of the translation. */
72 #define TINFO_VTABLE_DECL(NODE) TREE_VALUE (NODE)
73 /* The IDENTIFIER_NODE naming the real class. */
74 #define TINFO_REAL_NAME(NODE) TREE_PURPOSE (NODE)
76 /* A vector of all tinfo decls that haven't yet been emitted. */
77 VEC (tree) *unemitted_tinfo_decls;
79 static tree build_headof (tree);
80 static tree ifnonnull (tree, tree);
81 static tree tinfo_name (tree);
82 static tree build_dynamic_cast_1 (tree, tree);
83 static tree throw_bad_cast (void);
84 static tree throw_bad_typeid (void);
85 static tree get_tinfo_decl_dynamic (tree);
86 static tree get_tinfo_ptr (tree);
87 static bool typeid_ok_p (void);
88 static int qualifier_flags (tree);
89 static bool target_incomplete_p (tree);
90 static tree tinfo_base_init (tree, tree);
91 static tree generic_initializer (tree, tree);
92 static tree class_initializer (tree, tree, tree);
93 static tree create_pseudo_type_info (const char *, int, ...);
94 static tree get_pseudo_ti_init (tree, tree);
95 static tree get_pseudo_ti_desc (tree);
96 static void create_tinfo_types (void);
97 static bool typeinfo_in_lib_p (tree);
99 static int doing_runtime = 0;
102 /* Declare language defined type_info type and a pointer to const
103 type_info. This is incomplete here, and will be completed when
104 the user #includes <typeinfo>. There are language defined
105 restrictions on what can be done until that is included. Create
106 the internal versions of the ABI types. */
109 init_rtti_processing (void)
111 tree const_type_info_type;
113 push_namespace (std_identifier);
115 = xref_tag (class_type, get_identifier ("type_info"),
118 const_type_info_type = build_qualified_type (type_info_type_node,
120 type_info_ptr_type = build_pointer_type (const_type_info_type);
121 type_info_ref_type = build_reference_type (const_type_info_type);
123 unemitted_tinfo_decls = VEC_alloc (tree, 124);
125 create_tinfo_types ();
128 /* Given the expression EXP of type `class *', return the head of the
129 object pointed to by EXP with type cv void*, if the class has any
130 virtual functions (TYPE_POLYMORPHIC_P), else just return the
134 build_headof (tree exp)
136 tree type = TREE_TYPE (exp);
140 gcc_assert (TREE_CODE (type) == POINTER_TYPE);
141 type = TREE_TYPE (type);
143 if (!TYPE_POLYMORPHIC_P (type))
146 /* We use this a couple of times below, protect it. */
147 exp = save_expr (exp);
149 /* The offset-to-top field is at index -2 from the vptr. */
150 index = build_int_cst (NULL_TREE,
151 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
153 offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index);
155 type = build_qualified_type (ptr_type_node,
156 cp_type_quals (TREE_TYPE (exp)));
157 return build2 (PLUS_EXPR, type, exp,
158 convert_to_integer (ptrdiff_type_node, offset));
161 /* Get a bad_cast node for the program to throw...
163 See libstdc++/exception.cc for __throw_bad_cast */
166 throw_bad_cast (void)
168 tree fn = get_identifier ("__cxa_bad_cast");
169 if (!get_global_value_if_present (fn, &fn))
170 fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,
173 return build_cxx_call (fn, NULL_TREE);
176 /* Return an expression for "__cxa_bad_typeid()". The expression
177 returned is an lvalue of type "const std::type_info". */
180 throw_bad_typeid (void)
182 tree fn = get_identifier ("__cxa_bad_typeid");
183 if (!get_global_value_if_present (fn, &fn))
185 tree t = build_qualified_type (type_info_type_node, TYPE_QUAL_CONST);
186 t = build_function_type (build_reference_type (t), void_list_node);
187 fn = push_throw_library_fn (fn, t);
190 return convert_from_reference (build_cxx_call (fn, NULL_TREE));
193 /* Return an lvalue expression whose type is "const std::type_info"
194 and whose value indicates the type of the expression EXP. If EXP
195 is a reference to a polymorphic class, return the dynamic type;
196 otherwise return the static type of the expression. */
199 get_tinfo_decl_dynamic (tree exp)
204 if (exp == error_mark_node)
205 return error_mark_node;
207 /* peel back references, so they match. */
208 type = non_reference (TREE_TYPE (exp));
210 /* Peel off cv qualifiers. */
211 type = TYPE_MAIN_VARIANT (type);
213 if (!VOID_TYPE_P (type))
214 type = complete_type_or_else (type, exp);
217 return error_mark_node;
219 /* If exp is a reference to polymorphic type, get the real type_info. */
220 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
222 /* build reference to type_info from vtable. */
225 /* The RTTI information is at index -1. */
226 index = build_int_cst (NULL_TREE,
227 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
228 t = build_vtbl_ref (exp, index);
229 t = convert (type_info_ptr_type, t);
232 /* Otherwise return the type_info for the static type of the expr. */
233 t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
235 return build_indirect_ref (t, NULL);
243 error ("cannot use typeid with -fno-rtti");
247 if (!COMPLETE_TYPE_P (type_info_type_node))
249 error ("must #include <typeinfo> before using typeid");
256 /* Return an expression for "typeid(EXP)". The expression returned is
257 an lvalue of type "const std::type_info". */
260 build_typeid (tree exp)
262 tree cond = NULL_TREE;
265 if (exp == error_mark_node || !typeid_ok_p ())
266 return error_mark_node;
268 if (processing_template_decl)
269 return build_min (TYPEID_EXPR, type_info_ref_type, exp);
271 if (TREE_CODE (exp) == INDIRECT_REF
272 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
273 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
274 && ! resolves_to_fixed_type_p (exp, &nonnull)
277 exp = stabilize_reference (exp);
278 cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
281 exp = get_tinfo_decl_dynamic (exp);
283 if (exp == error_mark_node)
284 return error_mark_node;
288 tree bad = throw_bad_typeid ();
290 exp = build3 (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
296 /* Generate the NTBS name of a type. */
298 tinfo_name (tree type)
303 name = mangle_type_string (type);
304 name_string = fix_string_type (build_string (strlen (name) + 1, name));
308 /* Return a VAR_DECL for the internal ABI defined type_info object for
309 TYPE. You must arrange that the decl is mark_used, if actually use
310 it --- decls in vtables are only used if the vtable is output. */
313 get_tinfo_decl (tree type)
318 if (COMPLETE_TYPE_P (type)
319 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
321 error ("cannot create type information for type %qT because "
322 "its size is variable",
324 return error_mark_node;
327 if (TREE_CODE (type) == METHOD_TYPE)
328 type = build_function_type (TREE_TYPE (type),
329 TREE_CHAIN (TYPE_ARG_TYPES (type)));
331 /* For a class type, the variable is cached in the type node
333 if (CLASS_TYPE_P (type))
335 d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
340 name = mangle_typeinfo_for_type (type);
342 d = IDENTIFIER_GLOBAL_VALUE (name);
345 tree var_desc = get_pseudo_ti_desc (type);
347 d = build_lang_decl (VAR_DECL, name, TINFO_PSEUDO_TYPE (var_desc));
348 SET_DECL_ASSEMBLER_NAME (d, name);
349 /* Remember the type it is for. */
350 TREE_TYPE (name) = type;
351 DECL_TINFO_P (d) = 1;
352 DECL_ARTIFICIAL (d) = 1;
353 TREE_READONLY (d) = 1;
355 /* Mark the variable as undefined -- but remember that we can
356 define it later if we need to do so. */
357 DECL_EXTERNAL (d) = 1;
358 DECL_NOT_REALLY_EXTERN (d) = 1;
359 if (CLASS_TYPE_P (type))
360 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
361 set_linkage_according_to_type (type, d);
362 pushdecl_top_level_and_finish (d, NULL_TREE);
364 /* Add decl to the global array of tinfo decls. */
365 VEC_safe_push (tree, unemitted_tinfo_decls, d);
371 /* Return a pointer to a type_info object describing TYPE, suitably
372 cast to the language defined type. */
375 get_tinfo_ptr (tree type)
377 tree decl = get_tinfo_decl (type);
380 return build_nop (type_info_ptr_type,
381 build_address (decl));
384 /* Return the type_info object for TYPE. */
387 get_typeid (tree type)
389 if (type == error_mark_node || !typeid_ok_p ())
390 return error_mark_node;
392 if (processing_template_decl)
393 return build_min (TYPEID_EXPR, type_info_ref_type, type);
395 /* If the type of the type-id is a reference type, the result of the
396 typeid expression refers to a type_info object representing the
398 type = non_reference (type);
400 /* The top-level cv-qualifiers of the lvalue expression or the type-id
401 that is the operand of typeid are always ignored. */
402 type = TYPE_MAIN_VARIANT (type);
404 if (!VOID_TYPE_P (type))
405 type = complete_type_or_else (type, NULL_TREE);
408 return error_mark_node;
410 return build_indirect_ref (get_tinfo_ptr (type), NULL);
413 /* Check whether TEST is null before returning RESULT. If TEST is used in
414 RESULT, it must have previously had a save_expr applied to it. */
417 ifnonnull (tree test, tree result)
419 return build3 (COND_EXPR, TREE_TYPE (result),
420 build2 (EQ_EXPR, boolean_type_node, test, integer_zero_node),
421 cp_convert (TREE_TYPE (result), integer_zero_node),
425 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
429 build_dynamic_cast_1 (tree type, tree expr)
431 enum tree_code tc = TREE_CODE (type);
432 tree exprtype = TREE_TYPE (expr);
434 tree old_expr = expr;
435 const char *errstr = NULL;
437 /* T shall be a pointer or reference to a complete class type, or
438 `pointer to cv void''. */
442 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
445 if (! IS_AGGR_TYPE (TREE_TYPE (type)))
447 errstr = "target is not pointer or reference to class";
450 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
452 errstr = "target is not pointer or reference to complete type";
458 errstr = "target is not pointer or reference";
462 if (tc == POINTER_TYPE)
463 expr = convert_from_reference (expr);
464 else if (TREE_CODE (exprtype) != REFERENCE_TYPE)
466 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
467 exprtype = build_reference_type (exprtype);
468 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
469 LOOKUP_NORMAL, NULL_TREE);
472 exprtype = TREE_TYPE (expr);
474 if (tc == POINTER_TYPE)
476 /* If T is a pointer type, v shall be an rvalue of a pointer to
477 complete class type, and the result is an rvalue of type T. */
479 if (TREE_CODE (exprtype) != POINTER_TYPE)
481 errstr = "source is not a pointer";
484 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
486 errstr = "source is not a pointer to class";
489 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
491 errstr = "source is a pointer to incomplete type";
497 /* T is a reference type, v shall be an lvalue of a complete class
498 type, and the result is an lvalue of the type referred to by T. */
500 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
502 errstr = "source is not of class type";
505 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
507 errstr = "source is of incomplete class type";
513 /* The dynamic_cast operator shall not cast away constness. */
514 if (!at_least_as_qualified_p (TREE_TYPE (type),
515 TREE_TYPE (exprtype)))
517 errstr = "conversion casts away constness";
521 /* If *type is an unambiguous accessible base class of *exprtype,
522 convert statically. */
526 binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
531 expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),
533 if (TREE_CODE (exprtype) == POINTER_TYPE)
534 expr = non_lvalue (expr);
539 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
540 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
543 /* if TYPE is `void *', return pointer to complete object. */
544 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
546 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
547 if (TREE_CODE (expr) == ADDR_EXPR
548 && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
549 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
550 return build1 (NOP_EXPR, type, expr);
552 /* Since expr is used twice below, save it. */
553 expr = save_expr (expr);
555 expr1 = build_headof (expr);
556 if (TREE_TYPE (expr1) != type)
557 expr1 = build1 (NOP_EXPR, type, expr1);
558 return ifnonnull (expr, expr1);
563 tree result, td2, td3, elems;
564 tree static_type, target_type, boff;
566 /* If we got here, we can't convert statically. Therefore,
567 dynamic_cast<D&>(b) (b an object) cannot succeed. */
568 if (tc == REFERENCE_TYPE)
570 if (TREE_CODE (old_expr) == VAR_DECL
571 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
573 tree expr = throw_bad_cast ();
574 warning ("dynamic_cast of %q#D to %q#T can never succeed",
576 /* Bash it to the expected type. */
577 TREE_TYPE (expr) = type;
581 /* Ditto for dynamic_cast<D*>(&b). */
582 else if (TREE_CODE (expr) == ADDR_EXPR)
584 tree op = TREE_OPERAND (expr, 0);
585 if (TREE_CODE (op) == VAR_DECL
586 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
588 warning ("dynamic_cast of %q#D to %q#T can never succeed",
590 retval = build_int_cst (type, 0);
595 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
596 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
597 td2 = get_tinfo_decl (target_type);
599 td2 = build_unary_op (ADDR_EXPR, td2, 0);
600 td3 = get_tinfo_decl (static_type);
602 td3 = build_unary_op (ADDR_EXPR, td3, 0);
604 /* Determine how T and V are related. */
605 boff = dcast_base_hint (static_type, target_type);
607 /* Since expr is used twice below, save it. */
608 expr = save_expr (expr);
611 if (tc == REFERENCE_TYPE)
612 expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
615 (NULL_TREE, expr1, tree_cons
616 (NULL_TREE, td3, tree_cons
617 (NULL_TREE, td2, tree_cons
618 (NULL_TREE, boff, NULL_TREE))));
620 dcast_fn = dynamic_cast_node;
628 push_nested_namespace (ns);
629 tinfo_ptr = xref_tag (class_type,
630 get_identifier ("__class_type_info"),
633 tinfo_ptr = build_pointer_type
634 (build_qualified_type
635 (tinfo_ptr, TYPE_QUAL_CONST));
636 name = "__dynamic_cast";
638 (NULL_TREE, const_ptr_type_node, tree_cons
639 (NULL_TREE, tinfo_ptr, tree_cons
640 (NULL_TREE, tinfo_ptr, tree_cons
641 (NULL_TREE, ptrdiff_type_node, void_list_node))));
642 tmp = build_function_type (ptr_type_node, tmp);
643 dcast_fn = build_library_fn_ptr (name, tmp);
644 DECL_IS_PURE (dcast_fn) = 1;
645 pop_nested_namespace (ns);
646 dynamic_cast_node = dcast_fn;
648 result = build_cxx_call (dcast_fn, elems);
650 if (tc == REFERENCE_TYPE)
652 tree bad = throw_bad_cast ();
654 result = save_expr (result);
655 return build3 (COND_EXPR, type, result, result, bad);
658 /* Now back to the type we want from a void*. */
659 result = cp_convert (type, result);
660 return ifnonnull (expr, result);
664 errstr = "source type is not polymorphic";
667 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
668 expr, exprtype, type, errstr);
669 return error_mark_node;
673 build_dynamic_cast (tree type, tree expr)
675 if (type == error_mark_node || expr == error_mark_node)
676 return error_mark_node;
678 if (processing_template_decl)
680 expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
681 TREE_SIDE_EFFECTS (expr) = 1;
686 return convert_from_reference (build_dynamic_cast_1 (type, expr));
689 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
692 qualifier_flags (tree type)
695 int quals = cp_type_quals (type);
697 if (quals & TYPE_QUAL_CONST)
699 if (quals & TYPE_QUAL_VOLATILE)
701 if (quals & TYPE_QUAL_RESTRICT)
706 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
707 contains a pointer to member of an incomplete class. */
710 target_incomplete_p (tree type)
713 if (TYPE_PTRMEM_P (type))
715 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
717 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
719 else if (TREE_CODE (type) == POINTER_TYPE)
720 type = TREE_TYPE (type);
722 return !COMPLETE_OR_VOID_TYPE_P (type);
725 /* Returns true if TYPE involves an incomplete class type; in that
726 case, typeinfo variables for TYPE should be emitted with internal
730 involves_incomplete_p (tree type)
732 switch (TREE_CODE (type))
735 return target_incomplete_p (TREE_TYPE (type));
740 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type))
741 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)));
744 if (TYPE_PTRMEMFUNC_P (type))
748 if (!COMPLETE_TYPE_P (type))
752 /* All other types do not involve incomplete class types. */
757 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
758 is the vtable pointer and NTBS name. The NTBS name is emitted as a
759 comdat const char array, so it becomes a unique key for the type. Generate
760 and emit that VAR_DECL here. (We can't always emit the type_info itself
761 as comdat, because of pointers to incomplete.) */
764 tinfo_base_init (tree desc, tree target)
766 tree init = NULL_TREE;
773 /* Generate the NTBS array variable. */
774 tree name_type = build_cplus_array_type
775 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
777 tree name_string = tinfo_name (target);
779 /* Determine the name of the variable -- and remember with which
780 type it is associated. */
781 name_name = mangle_typeinfo_string_for_type (target);
782 TREE_TYPE (name_name) = target;
784 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
785 SET_DECL_ASSEMBLER_NAME (name_decl, name_name);
786 DECL_ARTIFICIAL (name_decl) = 1;
787 TREE_READONLY (name_decl) = 1;
788 TREE_STATIC (name_decl) = 1;
789 DECL_EXTERNAL (name_decl) = 0;
790 DECL_TINFO_P (name_decl) = 1;
791 if (involves_incomplete_p (target))
793 TREE_PUBLIC (name_decl) = 0;
794 DECL_INTERFACE_KNOWN (name_decl) = 1;
797 set_linkage_according_to_type (target, name_decl);
798 import_export_decl (name_decl);
799 DECL_INITIAL (name_decl) = name_string;
800 mark_used (name_decl);
801 pushdecl_top_level_and_finish (name_decl, name_string);
804 vtable_ptr = TINFO_VTABLE_DECL (desc);
809 push_nested_namespace (abi_node);
810 real_type = xref_tag (class_type, TINFO_REAL_NAME (desc),
812 pop_nested_namespace (abi_node);
814 if (!COMPLETE_TYPE_P (real_type))
816 /* We never saw a definition of this type, so we need to
817 tell the compiler that this is an exported class, as
818 indeed all of the __*_type_info classes are. */
819 SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
820 CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
823 vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
824 vtable_ptr = build_unary_op (ADDR_EXPR, vtable_ptr, 0);
826 /* We need to point into the middle of the vtable. */
828 (PLUS_EXPR, TREE_TYPE (vtable_ptr), vtable_ptr,
829 size_binop (MULT_EXPR,
830 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
831 TYPE_SIZE_UNIT (vtable_entry_type)));
833 TINFO_VTABLE_DECL (desc) = vtable_ptr;
836 init = tree_cons (NULL_TREE, vtable_ptr, init);
838 init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
840 init = build_constructor (NULL_TREE, nreverse (init));
841 TREE_CONSTANT (init) = 1;
842 TREE_INVARIANT (init) = 1;
843 TREE_STATIC (init) = 1;
844 init = tree_cons (NULL_TREE, init, NULL_TREE);
849 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
850 information about the particular type_info derivation, which adds no
851 additional fields to the type_info base. */
854 generic_initializer (tree desc, tree target)
856 tree init = tinfo_base_init (desc, target);
858 init = build_constructor (NULL_TREE, init);
859 TREE_CONSTANT (init) = 1;
860 TREE_INVARIANT (init) = 1;
861 TREE_STATIC (init) = 1;
865 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
866 DESC provides information about the particular type_info derivation,
867 which adds target type and qualifier flags members to the type_info base. */
870 ptr_initializer (tree desc, tree target)
872 tree init = tinfo_base_init (desc, target);
873 tree to = TREE_TYPE (target);
874 int flags = qualifier_flags (to);
875 bool incomplete = target_incomplete_p (to);
879 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
880 init = tree_cons (NULL_TREE,
881 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
884 init = build_constructor (NULL_TREE, nreverse (init));
885 TREE_CONSTANT (init) = 1;
886 TREE_INVARIANT (init) = 1;
887 TREE_STATIC (init) = 1;
891 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
892 DESC provides information about the particular type_info derivation,
893 which adds class, target type and qualifier flags members to the type_info
897 ptm_initializer (tree desc, tree target)
899 tree init = tinfo_base_init (desc, target);
900 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
901 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
902 int flags = qualifier_flags (to);
903 bool incomplete = target_incomplete_p (to);
907 if (!COMPLETE_TYPE_P (klass))
909 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
910 init = tree_cons (NULL_TREE,
911 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
913 init = tree_cons (NULL_TREE,
914 get_tinfo_ptr (klass),
917 init = build_constructor (NULL_TREE, nreverse (init));
918 TREE_CONSTANT (init) = 1;
919 TREE_INVARIANT (init) = 1;
920 TREE_STATIC (init) = 1;
924 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
925 DESC provides information about the particular __class_type_info derivation,
926 which adds hint flags and TRAIL initializers to the type_info base. */
929 class_initializer (tree desc, tree target, tree trail)
931 tree init = tinfo_base_init (desc, target);
933 TREE_CHAIN (init) = trail;
934 init = build_constructor (NULL_TREE, init);
935 TREE_CONSTANT (init) = 1;
936 TREE_INVARIANT (init) = 1;
937 TREE_STATIC (init) = 1;
941 /* Returns true if the typeinfo for type should be placed in
942 the runtime library. */
945 typeinfo_in_lib_p (tree type)
947 /* The typeinfo objects for `T*' and `const T*' are in the runtime
948 library for simple types T. */
949 if (TREE_CODE (type) == POINTER_TYPE
950 && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
951 || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
952 type = TREE_TYPE (type);
954 switch (TREE_CODE (type))
968 /* Generate the initializer for the type info describing TYPE. */
971 get_pseudo_ti_init (tree type, tree var_desc)
974 switch (TREE_CODE (type))
977 return ptm_initializer (var_desc, type);
979 return ptr_initializer (var_desc, type);
981 return generic_initializer (var_desc, type);
984 return generic_initializer (var_desc, type);
987 return generic_initializer (var_desc, type);
991 if (TYPE_PTRMEMFUNC_P (type))
992 return ptm_initializer (var_desc, type);
993 else if (var_desc == class_desc_type_node)
994 return class_initializer (var_desc, type, NULL_TREE);
995 else if (var_desc == si_class_desc_type_node)
997 tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), 0);
998 tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
999 tree base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1001 return class_initializer (var_desc, type, base_inits);
1005 int hint = ((CLASSTYPE_REPEATED_BASE_P (type) << 0)
1006 | (CLASSTYPE_DIAMOND_SHAPED_P (type) << 1));
1007 tree binfo = TYPE_BINFO (type);
1008 int nbases = BINFO_N_BASE_BINFOS (binfo);
1009 VEC (tree) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1010 tree base_inits = NULL_TREE;
1013 /* Generate the base information initializer. */
1014 for (ix = nbases; ix--;)
1016 tree base_binfo = BINFO_BASE_BINFO (binfo, ix);
1017 tree base_init = NULL_TREE;
1022 if (VEC_index (tree, base_accesses, ix) == access_public_node)
1024 tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1025 if (BINFO_VIRTUAL_P (base_binfo))
1027 /* We store the vtable offset at which the virtual
1028 base offset can be found. */
1029 offset = BINFO_VPTR_FIELD (base_binfo);
1030 offset = convert (sizetype, offset);
1034 offset = BINFO_OFFSET (base_binfo);
1036 /* Combine offset and flags into one field. */
1037 offset = cp_build_binary_op (LSHIFT_EXPR, offset,
1038 build_int_cst (NULL_TREE, 8));
1039 offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
1040 build_int_cst (NULL_TREE, flags));
1041 base_init = tree_cons (NULL_TREE, offset, base_init);
1042 base_init = tree_cons (NULL_TREE, tinfo, base_init);
1043 base_init = build_constructor (NULL_TREE, base_init);
1044 base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1046 base_inits = build_constructor (NULL_TREE, base_inits);
1047 base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1048 /* Prepend the number of bases. */
1049 base_inits = tree_cons (NULL_TREE,
1050 build_int_cst (NULL_TREE, nbases),
1052 /* Prepend the hint flags. */
1053 base_inits = tree_cons (NULL_TREE,
1054 build_int_cst (NULL_TREE, hint),
1057 return class_initializer (var_desc, type, base_inits);
1062 return generic_initializer (var_desc, type);
1066 /* Generate the RECORD_TYPE containing the data layout of a type_info
1067 derivative as used by the runtime. This layout must be consistent with
1068 that defined in the runtime support. Also generate the VAR_DECL for the
1069 type's vtable. We explicitly manage the vtable member, and name it for
1070 real type as used in the runtime. The RECORD type has a different name,
1071 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1072 is the generated type and TINFO_VTABLE_NAME is the name of the
1073 vtable. We have to delay generating the VAR_DECL of the vtable
1074 until the end of the translation, when we'll have seen the library
1075 definition, if there was one.
1077 REAL_NAME is the runtime's name of the type. Trailing arguments are
1078 additional FIELD_DECL's for the structure. The final argument must be
1082 create_pseudo_type_info (const char *real_name, int ident, ...)
1091 va_start (ap, ident);
1093 /* Generate the pseudo type name. */
1094 pseudo_name = alloca (strlen (real_name) + 30);
1095 strcpy (pseudo_name, real_name);
1096 strcat (pseudo_name, "_pseudo");
1098 sprintf (pseudo_name + strlen (pseudo_name), "%d", ident);
1100 /* First field is the pseudo type_info base class. */
1101 fields = build_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node);
1103 /* Now add the derived fields. */
1104 while ((field_decl = va_arg (ap, tree)))
1106 TREE_CHAIN (field_decl) = fields;
1107 fields = field_decl;
1110 /* Create the pseudo type. */
1111 pseudo_type = make_aggr_type (RECORD_TYPE);
1112 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
1113 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
1115 result = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE);
1116 TINFO_REAL_NAME (result) = get_identifier (real_name);
1117 TINFO_PSEUDO_TYPE (result) =
1118 cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
1124 /* Return a pseudo type info type node used to describe TYPE. TYPE
1125 must be a complete type (or cv void), except at the end of the
1126 translation unit. */
1129 get_pseudo_ti_desc (tree type)
1131 switch (TREE_CODE (type))
1134 return ptm_desc_type_node;
1136 return ptr_desc_type_node;
1138 return enum_desc_type_node;
1140 return func_desc_type_node;
1142 return ary_desc_type_node;
1145 if (TYPE_PTRMEMFUNC_P (type))
1146 return ptm_desc_type_node;
1147 else if (!COMPLETE_TYPE_P (type))
1150 cxx_incomplete_type_error (NULL_TREE, type);
1151 return class_desc_type_node;
1153 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
1154 return class_desc_type_node;
1157 tree binfo = TYPE_BINFO (type);
1158 VEC (tree) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1159 tree base_binfo = BINFO_BASE_BINFO (binfo, 0);
1160 int num_bases = BINFO_N_BASE_BINFOS (binfo);
1163 && VEC_index (tree, base_accesses, 0) == access_public_node
1164 && !BINFO_VIRTUAL_P (base_binfo)
1165 && integer_zerop (BINFO_OFFSET (base_binfo)))
1166 /* single non-virtual public. */
1167 return si_class_desc_type_node;
1171 tree array_domain, base_array;
1173 if (TREE_VEC_LENGTH (vmi_class_desc_type_node) <= num_bases)
1176 tree extend = make_tree_vec (num_bases + 5);
1178 for (ix = TREE_VEC_LENGTH (vmi_class_desc_type_node); ix--;)
1179 TREE_VEC_ELT (extend, ix)
1180 = TREE_VEC_ELT (vmi_class_desc_type_node, ix);
1181 vmi_class_desc_type_node = extend;
1183 var_desc = TREE_VEC_ELT (vmi_class_desc_type_node, num_bases);
1187 /* Create the array of __base_class_type_info entries.
1188 G++ 3.2 allocated an array that had one too many
1189 entries, and then filled that extra entries with
1191 if (abi_version_at_least (2))
1192 array_domain = build_index_type (size_int (num_bases - 1));
1194 array_domain = build_index_type (size_int (num_bases));
1196 build_array_type (base_desc_type_node, array_domain);
1198 push_nested_namespace (abi_node);
1199 var_desc = create_pseudo_type_info
1200 ("__vmi_class_type_info", num_bases,
1201 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1202 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1203 build_decl (FIELD_DECL, NULL_TREE, base_array),
1205 pop_nested_namespace (abi_node);
1207 TREE_VEC_ELT (vmi_class_desc_type_node, num_bases) = var_desc;
1212 return bltn_desc_type_node;
1216 /* Make sure the required builtin types exist for generating the type_info
1217 variable definitions. */
1220 create_tinfo_types (void)
1222 gcc_assert (!ti_desc_type_node);
1224 push_nested_namespace (abi_node);
1226 /* Create the internal type_info structure. This is used as a base for
1227 the other structures. */
1231 ti_desc_type_node = make_aggr_type (RECORD_TYPE);
1232 field = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1235 field = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1236 TREE_CHAIN (field) = fields;
1239 finish_builtin_struct (ti_desc_type_node, "__type_info_pseudo",
1241 TYPE_HAS_CONSTRUCTOR (ti_desc_type_node) = 1;
1244 /* Fundamental type_info */
1245 bltn_desc_type_node = create_pseudo_type_info
1246 ("__fundamental_type_info", 0,
1249 /* Array, function and enum type_info. No additional fields. */
1250 ary_desc_type_node = create_pseudo_type_info
1251 ("__array_type_info", 0,
1253 func_desc_type_node = create_pseudo_type_info
1254 ("__function_type_info", 0,
1256 enum_desc_type_node = create_pseudo_type_info
1257 ("__enum_type_info", 0,
1260 /* Class type_info. Add a flags field. */
1261 class_desc_type_node = create_pseudo_type_info
1262 ("__class_type_info", 0,
1265 /* Single public non-virtual base class. Add pointer to base class.
1266 This is really a descendant of __class_type_info. */
1267 si_class_desc_type_node = create_pseudo_type_info
1268 ("__si_class_type_info", 0,
1269 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1272 /* Base class internal helper. Pointer to base type, offset to base,
1277 field = build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type);
1280 field = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1281 TREE_CHAIN (field) = fields;
1284 base_desc_type_node = make_aggr_type (RECORD_TYPE);
1285 finish_builtin_struct (base_desc_type_node, "__base_class_type_info_pseudo",
1287 TYPE_HAS_CONSTRUCTOR (base_desc_type_node) = 1;
1290 /* General hierarchy is created as necessary in this vector. */
1291 vmi_class_desc_type_node = make_tree_vec (10);
1293 /* Pointer type_info. Adds two fields, qualification mask
1294 and pointer to the pointed to type. This is really a descendant of
1295 __pbase_type_info. */
1296 ptr_desc_type_node = create_pseudo_type_info
1297 ("__pointer_type_info", 0,
1298 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1299 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1302 /* Pointer to member data type_info. Add qualifications flags,
1303 pointer to the member's type info and pointer to the class.
1304 This is really a descendant of __pbase_type_info. */
1305 ptm_desc_type_node = create_pseudo_type_info
1306 ("__pointer_to_member_type_info", 0,
1307 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1308 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1309 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1312 pop_nested_namespace (abi_node);
1315 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1316 support. Generating them here guarantees consistency with the other
1317 structures. We use the following heuristic to determine when the runtime
1318 is being generated. If std::__fundamental_type_info is defined, and its
1319 destructor is defined, then the runtime is being built. */
1322 emit_support_tinfos (void)
1324 static tree *const fundamentals[] =
1329 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1330 &short_integer_type_node, &short_unsigned_type_node,
1331 &integer_type_node, &unsigned_type_node,
1332 &long_integer_type_node, &long_unsigned_type_node,
1333 &long_long_integer_type_node, &long_long_unsigned_type_node,
1334 &float_type_node, &double_type_node, &long_double_type_node,
1338 tree bltn_type, dtor;
1340 push_nested_namespace (abi_node);
1341 bltn_type = xref_tag (class_type,
1342 get_identifier ("__fundamental_type_info"),
1344 pop_nested_namespace (abi_node);
1345 if (!COMPLETE_TYPE_P (bltn_type))
1347 dtor = CLASSTYPE_DESTRUCTORS (bltn_type);
1348 if (DECL_EXTERNAL (dtor))
1351 for (ix = 0; fundamentals[ix]; ix++)
1353 tree bltn = *fundamentals[ix];
1354 tree bltn_ptr = build_pointer_type (bltn);
1355 tree bltn_const_ptr = build_pointer_type
1356 (build_qualified_type (bltn, TYPE_QUAL_CONST));
1359 tinfo = get_tinfo_decl (bltn);
1360 TREE_USED (tinfo) = 1;
1361 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1363 tinfo = get_tinfo_decl (bltn_ptr);
1364 TREE_USED (tinfo) = 1;
1365 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1367 tinfo = get_tinfo_decl (bltn_const_ptr);
1368 TREE_USED (tinfo) = 1;
1369 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1373 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1374 tinfo decl. Determine whether it needs emitting, and if so
1375 generate the initializer. */
1378 emit_tinfo_decl (tree decl)
1380 tree type = TREE_TYPE (DECL_NAME (decl));
1381 int in_library = typeinfo_in_lib_p (type);
1382 tree var_desc, var_init;
1384 gcc_assert (DECL_TINFO_P (decl));
1389 DECL_EXTERNAL (decl) = 0;
1392 /* If we're not in the runtime, then DECL (which is already
1393 DECL_EXTERNAL) will not be defined here. */
1394 DECL_INTERFACE_KNOWN (decl) = 1;
1398 else if (involves_incomplete_p (type))
1400 if (!decl_needed_p (decl))
1402 /* If TYPE involves an incomplete class type, then the typeinfo
1403 object will be emitted with internal linkage. There is no
1404 way to know whether or not types are incomplete until the end
1405 of the compilation, so this determination must be deferred
1406 until this point. */
1407 TREE_PUBLIC (decl) = 0;
1408 DECL_EXTERNAL (decl) = 0;
1409 DECL_INTERFACE_KNOWN (decl) = 1;
1412 import_export_decl (decl);
1413 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
1415 DECL_EXTERNAL (decl) = 0;
1416 var_desc = get_pseudo_ti_desc (type);
1417 var_init = get_pseudo_ti_init (type, var_desc);
1418 DECL_INITIAL (decl) = var_init;
1420 cp_finish_decl (decl, var_init, NULL_TREE, 0);