1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
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. */
26 #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 varray of all tinfo decls that haven't yet been emitted. */
77 varray_type 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 ptr_initializer (tree, tree, bool *);
93 static tree ptm_initializer (tree, tree, bool *);
94 static tree dfs_class_hint_mark (tree, void *);
95 static tree dfs_class_hint_unmark (tree, void *);
96 static int class_hint_flags (tree);
97 static tree class_initializer (tree, tree, tree);
98 static tree create_pseudo_type_info (const char *, int, ...);
99 static tree get_pseudo_ti_init (tree, tree, bool *);
100 static tree get_pseudo_ti_desc (tree);
101 static void create_tinfo_types (void);
102 static bool typeinfo_in_lib_p (tree);
103 static bool unemitted_tinfo_decl_p (tree);
105 static int doing_runtime = 0;
108 /* Declare language defined type_info type and a pointer to const
109 type_info. This is incomplete here, and will be completed when
110 the user #includes <typeinfo>. There are language defined
111 restrictions on what can be done until that is included. Create
112 the internal versions of the ABI types. */
115 init_rtti_processing (void)
117 tree const_type_info_type;
119 push_namespace (std_identifier);
121 = xref_tag (class_type, get_identifier ("type_info"),
122 /*attributes=*/NULL_TREE, 1);
124 const_type_info_type = build_qualified_type (type_info_type_node,
126 type_info_ptr_type = build_pointer_type (const_type_info_type);
127 type_info_ref_type = build_reference_type (const_type_info_type);
129 VARRAY_TREE_INIT (unemitted_tinfo_decls, 10, "RTTI decls");
131 create_tinfo_types ();
134 /* Given the expression EXP of type `class *', return the head of the
135 object pointed to by EXP with type cv void*, if the class has any
136 virtual functions (TYPE_POLYMORPHIC_P), else just return the
140 build_headof (tree exp)
142 tree type = TREE_TYPE (exp);
146 my_friendly_assert (TREE_CODE (type) == POINTER_TYPE, 20000112);
147 type = TREE_TYPE (type);
149 if (!TYPE_POLYMORPHIC_P (type))
152 /* We use this a couple of times below, protect it. */
153 exp = save_expr (exp);
155 /* The offset-to-top field is at index -2 from the vptr. */
156 index = build_int_2 (-2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE, -1);
158 offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index);
160 type = build_qualified_type (ptr_type_node,
161 cp_type_quals (TREE_TYPE (exp)));
162 return build (PLUS_EXPR, type, exp,
163 cp_convert (ptrdiff_type_node, offset));
166 /* Get a bad_cast node for the program to throw...
168 See libstdc++/exception.cc for __throw_bad_cast */
171 throw_bad_cast (void)
173 tree fn = get_identifier ("__cxa_bad_cast");
174 if (IDENTIFIER_GLOBAL_VALUE (fn))
175 fn = IDENTIFIER_GLOBAL_VALUE (fn);
177 fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,
180 return build_cxx_call (fn, NULL_TREE, NULL_TREE);
183 /* Return an expression for "__cxa_bad_typeid()". The expression
184 returned is an lvalue of type "const std::type_info". */
187 throw_bad_typeid (void)
189 tree fn = get_identifier ("__cxa_bad_typeid");
190 if (IDENTIFIER_GLOBAL_VALUE (fn))
191 fn = IDENTIFIER_GLOBAL_VALUE (fn);
194 tree t = build_qualified_type (type_info_type_node, TYPE_QUAL_CONST);
195 t = build_function_type (build_reference_type (t), void_list_node);
196 fn = push_throw_library_fn (fn, t);
199 return convert_from_reference (build_cxx_call (fn, NULL_TREE, NULL_TREE));
202 /* Return an lvalue expression whose type is "const std::type_info"
203 and whose value indicates the type of the expression EXP. If EXP
204 is a reference to a polymorphic class, return the dynamic type;
205 otherwise return the static type of the expression. */
208 get_tinfo_decl_dynamic (tree exp)
213 if (exp == error_mark_node)
214 return error_mark_node;
216 type = TREE_TYPE (exp);
218 /* peel back references, so they match. */
219 if (TREE_CODE (type) == REFERENCE_TYPE)
220 type = TREE_TYPE (type);
222 /* Peel off cv qualifiers. */
223 type = TYPE_MAIN_VARIANT (type);
225 if (!VOID_TYPE_P (type))
226 type = complete_type_or_else (type, exp);
229 return error_mark_node;
231 /* If exp is a reference to polymorphic type, get the real type_info. */
232 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
234 /* build reference to type_info from vtable. */
237 /* The RTTI information is at index -1. */
238 index = build_int_2 (-1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE, -1);
239 t = build_vtbl_ref (exp, index);
240 TREE_TYPE (t) = type_info_ptr_type;
243 /* Otherwise return the type_info for the static type of the expr. */
244 t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
246 return build_indirect_ref (t, NULL);
254 error ("cannot use typeid with -fno-rtti");
258 if (!COMPLETE_TYPE_P (type_info_type_node))
260 error ("must #include <typeinfo> before using typeid");
267 /* Return an expression for "typeid(EXP)". The expression returned is
268 an lvalue of type "const std::type_info". */
271 build_typeid (tree exp)
273 tree cond = NULL_TREE;
276 if (exp == error_mark_node || !typeid_ok_p ())
277 return error_mark_node;
279 if (processing_template_decl)
280 return build_min (TYPEID_EXPR, type_info_ref_type, exp);
282 if (TREE_CODE (exp) == INDIRECT_REF
283 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
284 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
285 && ! resolves_to_fixed_type_p (exp, &nonnull)
288 exp = stabilize_reference (exp);
289 cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
292 exp = get_tinfo_decl_dynamic (exp);
294 if (exp == error_mark_node)
295 return error_mark_node;
299 tree bad = throw_bad_typeid ();
301 exp = build (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
307 /* Generate the NTBS name of a type. */
309 tinfo_name (tree type)
314 name = mangle_type_string (type);
315 name_string = fix_string_type (build_string (strlen (name) + 1, name));
319 /* Return a VAR_DECL for the internal ABI defined type_info object for
320 TYPE. You must arrange that the decl is mark_used, if actually use
321 it --- decls in vtables are only used if the vtable is output. */
324 get_tinfo_decl (tree type)
329 if (COMPLETE_TYPE_P (type)
330 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
332 error ("cannot create type information for type `%T' because its size is variable",
334 return error_mark_node;
337 if (TREE_CODE (type) == OFFSET_TYPE)
338 type = TREE_TYPE (type);
339 if (TREE_CODE (type) == METHOD_TYPE)
340 type = build_function_type (TREE_TYPE (type),
341 TREE_CHAIN (TYPE_ARG_TYPES (type)));
343 /* For a class type, the variable is cached in the type node
345 if (CLASS_TYPE_P (type))
347 d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
352 name = mangle_typeinfo_for_type (type);
354 d = IDENTIFIER_GLOBAL_VALUE (name);
357 tree var_desc = get_pseudo_ti_desc (type);
359 d = build_lang_decl (VAR_DECL, name, TINFO_PSEUDO_TYPE (var_desc));
361 DECL_ARTIFICIAL (d) = 1;
362 TREE_READONLY (d) = 1;
364 DECL_EXTERNAL (d) = 1;
365 SET_DECL_ASSEMBLER_NAME (d, name);
368 pushdecl_top_level_and_finish (d, NULL_TREE);
370 if (CLASS_TYPE_P (type))
371 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
373 /* Remember the type it is for. */
374 TREE_TYPE (name) = type;
376 /* Add decl to the global array of tinfo decls. */
377 my_friendly_assert (unemitted_tinfo_decls != 0, 20030312);
378 VARRAY_PUSH_TREE (unemitted_tinfo_decls, d);
384 /* Return a pointer to a type_info object describing TYPE, suitably
385 cast to the language defined type. */
388 get_tinfo_ptr (tree type)
390 tree decl = get_tinfo_decl (type);
393 return build_nop (type_info_ptr_type,
394 build_address (decl));
397 /* Return the type_info object for TYPE. */
400 get_typeid (tree type)
402 if (type == error_mark_node || !typeid_ok_p ())
403 return error_mark_node;
405 if (processing_template_decl)
406 return build_min (TYPEID_EXPR, type_info_ref_type, type);
408 /* If the type of the type-id is a reference type, the result of the
409 typeid expression refers to a type_info object representing the
411 if (TREE_CODE (type) == REFERENCE_TYPE)
412 type = TREE_TYPE (type);
414 /* The top-level cv-qualifiers of the lvalue expression or the type-id
415 that is the operand of typeid are always ignored. */
416 type = TYPE_MAIN_VARIANT (type);
418 if (!VOID_TYPE_P (type))
419 type = complete_type_or_else (type, NULL_TREE);
422 return error_mark_node;
424 return build_indirect_ref (get_tinfo_ptr (type), NULL);
427 /* Check whether TEST is null before returning RESULT. If TEST is used in
428 RESULT, it must have previously had a save_expr applied to it. */
431 ifnonnull (tree test, tree result)
433 return build (COND_EXPR, TREE_TYPE (result),
434 build (EQ_EXPR, boolean_type_node, test, integer_zero_node),
435 cp_convert (TREE_TYPE (result), integer_zero_node),
439 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
443 build_dynamic_cast_1 (tree type, tree expr)
445 enum tree_code tc = TREE_CODE (type);
446 tree exprtype = TREE_TYPE (expr);
448 tree old_expr = expr;
449 const char *errstr = NULL;
451 /* T shall be a pointer or reference to a complete class type, or
452 `pointer to cv void''. */
456 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
459 if (! IS_AGGR_TYPE (TREE_TYPE (type)))
461 errstr = "target is not pointer or reference to class";
464 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
466 errstr = "target is not pointer or reference to complete type";
472 errstr = "target is not pointer or reference";
476 if (TREE_CODE (expr) == OFFSET_REF)
478 expr = resolve_offset_ref (expr);
479 exprtype = TREE_TYPE (expr);
482 if (tc == POINTER_TYPE)
483 expr = convert_from_reference (expr);
484 else if (TREE_CODE (exprtype) != REFERENCE_TYPE)
486 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
487 exprtype = build_reference_type (exprtype);
488 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
489 LOOKUP_NORMAL, NULL_TREE);
492 exprtype = TREE_TYPE (expr);
494 if (tc == POINTER_TYPE)
496 /* If T is a pointer type, v shall be an rvalue of a pointer to
497 complete class type, and the result is an rvalue of type T. */
499 if (TREE_CODE (exprtype) != POINTER_TYPE)
501 errstr = "source is not a pointer";
504 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
506 errstr = "source is not a pointer to class";
509 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
511 errstr = "source is a pointer to incomplete type";
517 /* T is a reference type, v shall be an lvalue of a complete class
518 type, and the result is an lvalue of the type referred to by T. */
520 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
522 errstr = "source is not of class type";
525 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
527 errstr = "source is of incomplete class type";
533 /* The dynamic_cast operator shall not cast away constness. */
534 if (!at_least_as_qualified_p (TREE_TYPE (type),
535 TREE_TYPE (exprtype)))
537 errstr = "conversion casts away constness";
541 /* If *type is an unambiguous accessible base class of *exprtype,
542 convert statically. */
546 binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
547 ba_not_special, NULL);
551 expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),
553 if (TREE_CODE (exprtype) == POINTER_TYPE)
554 expr = non_lvalue (expr);
559 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
560 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
563 /* if TYPE is `void *', return pointer to complete object. */
564 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
566 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
567 if (TREE_CODE (expr) == ADDR_EXPR
568 && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
569 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
570 return build1 (NOP_EXPR, type, expr);
572 /* Since expr is used twice below, save it. */
573 expr = save_expr (expr);
575 expr1 = build_headof (expr);
576 if (TREE_TYPE (expr1) != type)
577 expr1 = build1 (NOP_EXPR, type, expr1);
578 return ifnonnull (expr, expr1);
583 tree result, td2, td3, elems;
584 tree static_type, target_type, boff;
586 /* If we got here, we can't convert statically. Therefore,
587 dynamic_cast<D&>(b) (b an object) cannot succeed. */
588 if (tc == REFERENCE_TYPE)
590 if (TREE_CODE (old_expr) == VAR_DECL
591 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
593 tree expr = throw_bad_cast ();
594 warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
596 /* Bash it to the expected type. */
597 TREE_TYPE (expr) = type;
601 /* Ditto for dynamic_cast<D*>(&b). */
602 else if (TREE_CODE (expr) == ADDR_EXPR)
604 tree op = TREE_OPERAND (expr, 0);
605 if (TREE_CODE (op) == VAR_DECL
606 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
608 warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
610 retval = build_int_2 (0, 0);
611 TREE_TYPE (retval) = type;
616 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
617 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
618 td2 = get_tinfo_decl (target_type);
620 td2 = build_unary_op (ADDR_EXPR, td2, 0);
621 td3 = get_tinfo_decl (static_type);
623 td3 = build_unary_op (ADDR_EXPR, td3, 0);
625 /* Determine how T and V are related. */
626 boff = get_dynamic_cast_base_type (static_type, target_type);
628 /* Since expr is used twice below, save it. */
629 expr = save_expr (expr);
632 if (tc == REFERENCE_TYPE)
633 expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
636 (NULL_TREE, expr1, tree_cons
637 (NULL_TREE, td3, tree_cons
638 (NULL_TREE, td2, tree_cons
639 (NULL_TREE, boff, NULL_TREE))));
641 dcast_fn = dynamic_cast_node;
649 push_nested_namespace (ns);
650 tinfo_ptr = xref_tag (class_type,
651 get_identifier ("__class_type_info"),
652 /*attributes=*/NULL_TREE,
655 tinfo_ptr = build_pointer_type
656 (build_qualified_type
657 (tinfo_ptr, TYPE_QUAL_CONST));
658 name = "__dynamic_cast";
660 (NULL_TREE, const_ptr_type_node, tree_cons
661 (NULL_TREE, tinfo_ptr, tree_cons
662 (NULL_TREE, tinfo_ptr, tree_cons
663 (NULL_TREE, ptrdiff_type_node, void_list_node))));
664 tmp = build_function_type (ptr_type_node, tmp);
665 dcast_fn = build_library_fn_ptr (name, tmp);
666 pop_nested_namespace (ns);
667 dynamic_cast_node = dcast_fn;
669 result = build_cxx_call (dcast_fn, elems, elems);
671 if (tc == REFERENCE_TYPE)
673 tree bad = throw_bad_cast ();
675 result = save_expr (result);
676 return build (COND_EXPR, type, result, result, bad);
679 /* Now back to the type we want from a void*. */
680 result = cp_convert (type, result);
681 return ifnonnull (expr, result);
685 errstr = "source type is not polymorphic";
688 error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T' (%s)",
689 expr, exprtype, type, errstr);
690 return error_mark_node;
694 build_dynamic_cast (tree type, tree expr)
696 if (type == error_mark_node || expr == error_mark_node)
697 return error_mark_node;
699 if (processing_template_decl)
700 return build_min (DYNAMIC_CAST_EXPR, type, expr);
702 return convert_from_reference (build_dynamic_cast_1 (type, expr));
705 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
708 qualifier_flags (tree type)
711 int quals = cp_type_quals (type);
713 if (quals & TYPE_QUAL_CONST)
715 if (quals & TYPE_QUAL_VOLATILE)
717 if (quals & TYPE_QUAL_RESTRICT)
722 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
723 contains a pointer to member of an incomplete class. */
726 target_incomplete_p (tree type)
728 while (TREE_CODE (type) == POINTER_TYPE)
729 if (TYPE_PTRMEM_P (type))
731 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
733 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
736 type = TREE_TYPE (type);
737 if (!COMPLETE_OR_VOID_TYPE_P (type))
743 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
744 is the vtable pointer and NTBS name. The NTBS name is emitted as a
745 comdat const char array, so it becomes a unique key for the type. Generate
746 and emit that VAR_DECL here. (We can't always emit the type_info itself
747 as comdat, because of pointers to incomplete.) */
750 tinfo_base_init (tree desc, tree target)
752 tree init = NULL_TREE;
759 /* Generate the NTBS array variable. */
760 tree name_type = build_cplus_array_type
761 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
763 tree name_string = tinfo_name (target);
765 name_name = mangle_typeinfo_string_for_type (target);
766 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
768 DECL_ARTIFICIAL (name_decl) = 1;
769 TREE_READONLY (name_decl) = 1;
770 TREE_STATIC (name_decl) = 1;
771 DECL_EXTERNAL (name_decl) = 0;
772 TREE_PUBLIC (name_decl) = 1;
773 comdat_linkage (name_decl);
774 /* External name of the string containing the type's name has a
776 SET_DECL_ASSEMBLER_NAME (name_decl,
777 mangle_typeinfo_string_for_type (target));
778 DECL_INITIAL (name_decl) = name_string;
779 mark_used (name_decl);
780 pushdecl_top_level_and_finish (name_decl, name_string);
783 vtable_ptr = TINFO_VTABLE_DECL (desc);
788 push_nested_namespace (abi_node);
789 real_type = xref_tag (class_type, TINFO_REAL_NAME (desc),
790 /*attributes=*/NULL_TREE, 1);
791 pop_nested_namespace (abi_node);
793 if (!COMPLETE_TYPE_P (real_type))
795 /* We never saw a definition of this type, so we need to
796 tell the compiler that this is an exported class, as
797 indeed all of the __*_type_info classes are. */
798 SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
799 CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
802 vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
803 vtable_ptr = build_unary_op (ADDR_EXPR, vtable_ptr, 0);
805 /* We need to point into the middle of the vtable. */
807 (PLUS_EXPR, TREE_TYPE (vtable_ptr), vtable_ptr,
808 size_binop (MULT_EXPR,
809 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
810 TYPE_SIZE_UNIT (vtable_entry_type)));
811 TREE_CONSTANT (vtable_ptr) = 1;
813 TINFO_VTABLE_DECL (desc) = vtable_ptr;
816 init = tree_cons (NULL_TREE, vtable_ptr, init);
818 init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
820 init = build_constructor (NULL_TREE, nreverse (init));
821 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
822 init = tree_cons (NULL_TREE, init, NULL_TREE);
827 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
828 information about the particular type_info derivation, which adds no
829 additional fields to the type_info base. */
832 generic_initializer (tree desc, tree target)
834 tree init = tinfo_base_init (desc, target);
836 init = build_constructor (NULL_TREE, init);
837 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
841 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
842 DESC provides information about the particular type_info derivation,
843 which adds target type and qualifier flags members to the type_info base. */
846 ptr_initializer (tree desc, tree target, bool *non_public_ptr)
848 tree init = tinfo_base_init (desc, target);
849 tree to = TREE_TYPE (target);
850 int flags = qualifier_flags (to);
851 bool incomplete = target_incomplete_p (to);
856 *non_public_ptr = true;
858 init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
859 init = tree_cons (NULL_TREE,
860 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
863 init = build_constructor (NULL_TREE, nreverse (init));
864 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
868 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
869 DESC provides information about the particular type_info derivation,
870 which adds class, target type and qualifier flags members to the type_info
874 ptm_initializer (tree desc, tree target, bool *non_public_ptr)
876 tree init = tinfo_base_init (desc, target);
877 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
878 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
879 int flags = qualifier_flags (to);
880 bool incomplete = target_incomplete_p (to);
885 *non_public_ptr = true;
887 if (!COMPLETE_TYPE_P (klass))
890 *non_public_ptr = true;
892 init = tree_cons (NULL_TREE, build_int_2 (flags, 0), init);
893 init = tree_cons (NULL_TREE,
894 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
896 init = tree_cons (NULL_TREE,
897 get_tinfo_ptr (klass),
900 init = build_constructor (NULL_TREE, nreverse (init));
901 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
905 /* Check base BINFO to set hint flags in *DATA, which is really an int.
906 We use CLASSTYPE_MARKED to tag types we've found as non-virtual bases and
907 CLASSTYPE_MARKED2 to tag those which are virtual bases. Remember it is
908 possible for a type to be both a virtual and non-virtual base. */
911 dfs_class_hint_mark (tree binfo, void *data)
913 tree basetype = BINFO_TYPE (binfo);
914 int *hint = (int *) data;
916 if (TREE_VIA_VIRTUAL (binfo))
918 if (CLASSTYPE_MARKED (basetype))
920 if (CLASSTYPE_MARKED2 (basetype))
922 SET_CLASSTYPE_MARKED2 (basetype);
926 if (CLASSTYPE_MARKED (basetype) || CLASSTYPE_MARKED2 (basetype))
928 SET_CLASSTYPE_MARKED (basetype);
933 /* Clear the base's dfs marks, after searching for duplicate bases. */
936 dfs_class_hint_unmark (tree binfo, void *data ATTRIBUTE_UNUSED)
938 tree basetype = BINFO_TYPE (binfo);
940 CLEAR_CLASSTYPE_MARKED (basetype);
941 CLEAR_CLASSTYPE_MARKED2 (basetype);
945 /* Determine the hint flags describing the features of a class's hierarchy. */
948 class_hint_flags (tree type)
952 dfs_walk (TYPE_BINFO (type), dfs_class_hint_mark, NULL, &hint_flags);
953 dfs_walk (TYPE_BINFO (type), dfs_class_hint_unmark, NULL, NULL);
958 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
959 DESC provides information about the particular __class_type_info derivation,
960 which adds hint flags and TRAIL initializers to the type_info base. */
963 class_initializer (tree desc, tree target, tree trail)
965 tree init = tinfo_base_init (desc, target);
967 TREE_CHAIN (init) = trail;
968 init = build_constructor (NULL_TREE, init);
969 TREE_HAS_CONSTRUCTOR (init) = TREE_CONSTANT (init) = TREE_STATIC (init) = 1;
973 /* Returns true if the typeinfo for type should be placed in
974 the runtime library. */
977 typeinfo_in_lib_p (tree type)
979 /* The typeinfo objects for `T*' and `const T*' are in the runtime
980 library for simple types T. */
981 if (TREE_CODE (type) == POINTER_TYPE
982 && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
983 || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
984 type = TREE_TYPE (type);
986 switch (TREE_CODE (type))
1000 /* Generate the initializer for the type info describing
1001 TYPE. VAR_DESC is a . NON_PUBLIC_P is set nonzero, if the VAR_DECL
1002 should not be exported from this object file. This should only be
1003 called at the end of translation, when we know that no further
1004 types will be completed. */
1007 get_pseudo_ti_init (tree type, tree var_desc, bool *non_public_p)
1009 my_friendly_assert (at_eof, 20021120);
1010 switch (TREE_CODE (type))
1013 if (TYPE_PTRMEM_P (type))
1014 return ptm_initializer (var_desc, type, non_public_p);
1016 return ptr_initializer (var_desc, type, non_public_p);
1019 return generic_initializer (var_desc, type);
1022 return generic_initializer (var_desc, type);
1025 return generic_initializer (var_desc, type);
1029 if (TYPE_PTRMEMFUNC_P (type))
1030 return ptm_initializer (var_desc, type, non_public_p);
1031 else if (var_desc == class_desc_type_node)
1033 if (!COMPLETE_TYPE_P (type))
1034 /* Emit a non-public class_type_info. */
1035 *non_public_p = true;
1036 return class_initializer (var_desc, type, NULL_TREE);
1038 else if (var_desc == si_class_desc_type_node)
1040 tree base_binfos = BINFO_BASETYPES (TYPE_BINFO (type));
1041 tree base_binfo = TREE_VEC_ELT (base_binfos, 0);
1042 tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1043 tree base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1045 return class_initializer (var_desc, type, base_inits);
1049 int hint = class_hint_flags (type);
1050 tree binfo = TYPE_BINFO (type);
1051 int nbases = BINFO_N_BASETYPES (binfo);
1052 tree base_binfos = BINFO_BASETYPES (binfo);
1053 tree base_accesses = BINFO_BASEACCESSES (binfo);
1054 tree base_inits = NULL_TREE;
1057 /* Generate the base information initializer. */
1058 for (ix = nbases; ix--;)
1060 tree base_binfo = TREE_VEC_ELT (base_binfos, ix);
1061 tree base_init = NULL_TREE;
1066 if (TREE_VEC_ELT (base_accesses, ix) == access_public_node)
1068 tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1069 if (TREE_VIA_VIRTUAL (base_binfo))
1071 /* We store the vtable offset at which the virtual
1072 base offset can be found. */
1073 offset = BINFO_VPTR_FIELD (base_binfo);
1074 offset = convert (sizetype, offset);
1078 offset = BINFO_OFFSET (base_binfo);
1080 /* combine offset and flags into one field */
1081 offset = cp_build_binary_op (LSHIFT_EXPR, offset,
1082 build_int_2 (8, 0));
1083 offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
1084 build_int_2 (flags, 0));
1085 base_init = tree_cons (NULL_TREE, offset, base_init);
1086 base_init = tree_cons (NULL_TREE, tinfo, base_init);
1087 base_init = build_constructor (NULL_TREE, base_init);
1088 TREE_HAS_CONSTRUCTOR (base_init) = 1;
1089 base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1091 base_inits = build_constructor (NULL_TREE, base_inits);
1092 TREE_HAS_CONSTRUCTOR (base_inits) = 1;
1093 base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1094 /* Prepend the number of bases. */
1095 base_inits = tree_cons (NULL_TREE,
1096 build_int_2 (nbases, 0), base_inits);
1097 /* Prepend the hint flags. */
1098 base_inits = tree_cons (NULL_TREE,
1099 build_int_2 (hint, 0), base_inits);
1101 return class_initializer (var_desc, type, base_inits);
1106 return generic_initializer (var_desc, type);
1110 /* Generate the RECORD_TYPE containing the data layout of a type_info
1111 derivative as used by the runtime. This layout must be consistent with
1112 that defined in the runtime support. Also generate the VAR_DECL for the
1113 type's vtable. We explicitly manage the vtable member, and name it for
1114 real type as used in the runtime. The RECORD type has a different name,
1115 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1116 is the generated type and TINFO_VTABLE_NAME is the name of the
1117 vtable. We have to delay generating the VAR_DECL of the vtable
1118 until the end of the translation, when we'll have seen the library
1119 definition, if there was one.
1121 REAL_NAME is the runtime's name of the type. Trailing arguments are
1122 additional FIELD_DECL's for the structure. The final argument must be
1126 create_pseudo_type_info (const char *real_name, int ident, ...)
1135 va_start (ap, ident);
1137 /* Generate the pseudo type name. */
1138 pseudo_name = (char *)alloca (strlen (real_name) + 30);
1139 strcpy (pseudo_name, real_name);
1140 strcat (pseudo_name, "_pseudo");
1142 sprintf (pseudo_name + strlen (pseudo_name), "%d", ident);
1144 /* First field is the pseudo type_info base class. */
1145 fields = build_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node);
1147 /* Now add the derived fields. */
1148 while ((field_decl = va_arg (ap, tree)))
1150 TREE_CHAIN (field_decl) = fields;
1151 fields = field_decl;
1154 /* Create the pseudo type. */
1155 pseudo_type = make_aggr_type (RECORD_TYPE);
1156 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
1157 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
1159 result = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE);
1160 TINFO_REAL_NAME (result) = get_identifier (real_name);
1161 TINFO_PSEUDO_TYPE (result) =
1162 cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
1168 /* Return a pseudo type info type node used to describe TYPE. TYPE
1169 must be a complete type (or cv void), except at the end of the
1170 translation unit. */
1173 get_pseudo_ti_desc (tree type)
1175 switch (TREE_CODE (type))
1178 return TYPE_PTRMEM_P (type) ? ptm_desc_type_node : ptr_desc_type_node;
1180 return enum_desc_type_node;
1182 return func_desc_type_node;
1184 return ary_desc_type_node;
1187 if (TYPE_PTRMEMFUNC_P (type))
1188 return ptm_desc_type_node;
1189 else if (!COMPLETE_TYPE_P (type))
1192 cxx_incomplete_type_error (NULL_TREE, type);
1193 return class_desc_type_node;
1195 else if (!CLASSTYPE_N_BASECLASSES (type))
1196 return class_desc_type_node;
1199 tree binfo = TYPE_BINFO (type);
1200 tree base_binfos = BINFO_BASETYPES (binfo);
1201 tree base_accesses = BINFO_BASEACCESSES (binfo);
1202 tree base_binfo = TREE_VEC_ELT (base_binfos, 0);
1203 int num_bases = TREE_VEC_LENGTH (base_binfos);
1206 && TREE_VEC_ELT (base_accesses, 0) == access_public_node
1207 && !TREE_VIA_VIRTUAL (base_binfo)
1208 && integer_zerop (BINFO_OFFSET (base_binfo)))
1209 /* single non-virtual public. */
1210 return si_class_desc_type_node;
1214 tree array_domain, base_array;
1216 if (TREE_VEC_LENGTH (vmi_class_desc_type_node) <= num_bases)
1219 tree extend = make_tree_vec (num_bases + 5);
1221 for (ix = TREE_VEC_LENGTH (vmi_class_desc_type_node); ix--;)
1222 TREE_VEC_ELT (extend, ix)
1223 = TREE_VEC_ELT (vmi_class_desc_type_node, ix);
1224 vmi_class_desc_type_node = extend;
1226 var_desc = TREE_VEC_ELT (vmi_class_desc_type_node, num_bases);
1230 /* Create the array of __base_class_type_info entries.
1231 G++ 3.2 allocated an array that had one too many
1232 entries, and then filled that extra entries with
1234 if (abi_version_at_least (2))
1235 array_domain = build_index_type (size_int (num_bases - 1));
1237 array_domain = build_index_type (size_int (num_bases));
1239 build_array_type (base_desc_type_node, array_domain);
1241 push_nested_namespace (abi_node);
1242 var_desc = create_pseudo_type_info
1243 ("__vmi_class_type_info", num_bases,
1244 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1245 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1246 build_decl (FIELD_DECL, NULL_TREE, base_array),
1248 pop_nested_namespace (abi_node);
1250 TREE_VEC_ELT (vmi_class_desc_type_node, num_bases) = var_desc;
1255 return bltn_desc_type_node;
1259 /* Make sure the required builtin types exist for generating the type_info
1260 varable definitions. */
1263 create_tinfo_types (void)
1265 my_friendly_assert (!ti_desc_type_node, 20020609);
1267 push_nested_namespace (abi_node);
1269 /* Create the internal type_info structure. This is used as a base for
1270 the other structures. */
1274 ti_desc_type_node = make_aggr_type (RECORD_TYPE);
1275 field = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1278 field = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1279 TREE_CHAIN (field) = fields;
1282 finish_builtin_struct (ti_desc_type_node, "__type_info_pseudo",
1284 TYPE_HAS_CONSTRUCTOR (ti_desc_type_node) = 1;
1287 /* Fundamental type_info */
1288 bltn_desc_type_node = create_pseudo_type_info
1289 ("__fundamental_type_info", 0,
1292 /* Array, function and enum type_info. No additional fields. */
1293 ary_desc_type_node = create_pseudo_type_info
1294 ("__array_type_info", 0,
1296 func_desc_type_node = create_pseudo_type_info
1297 ("__function_type_info", 0,
1299 enum_desc_type_node = create_pseudo_type_info
1300 ("__enum_type_info", 0,
1303 /* Class type_info. Add a flags field. */
1304 class_desc_type_node = create_pseudo_type_info
1305 ("__class_type_info", 0,
1308 /* Single public non-virtual base class. Add pointer to base class.
1309 This is really a descendant of __class_type_info. */
1310 si_class_desc_type_node = create_pseudo_type_info
1311 ("__si_class_type_info", 0,
1312 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1315 /* Base class internal helper. Pointer to base type, offset to base,
1320 field = build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type);
1323 field = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1324 TREE_CHAIN (field) = fields;
1327 base_desc_type_node = make_aggr_type (RECORD_TYPE);
1328 finish_builtin_struct (base_desc_type_node, "__base_class_type_info_pseudo",
1330 TYPE_HAS_CONSTRUCTOR (base_desc_type_node) = 1;
1333 /* General hierarchy is created as necessary in this vector. */
1334 vmi_class_desc_type_node = make_tree_vec (10);
1336 /* Pointer type_info. Adds two fields, qualification mask
1337 and pointer to the pointed to type. This is really a descendant of
1338 __pbase_type_info. */
1339 ptr_desc_type_node = create_pseudo_type_info
1340 ("__pointer_type_info", 0,
1341 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1342 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1345 /* Pointer to member data type_info. Add qualifications flags,
1346 pointer to the member's type info and pointer to the class.
1347 This is really a descendant of __pbase_type_info. */
1348 ptm_desc_type_node = create_pseudo_type_info
1349 ("__pointer_to_member_type_info", 0,
1350 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1351 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1352 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1355 pop_nested_namespace (abi_node);
1358 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1359 support. Generating them here guarantees consistency with the other
1360 structures. We use the following heuristic to determine when the runtime
1361 is being generated. If std::__fundamental_type_info is defined, and its
1362 destructor is defined, then the runtime is being built. */
1365 emit_support_tinfos (void)
1367 static tree *const fundamentals[] =
1372 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1373 &short_integer_type_node, &short_unsigned_type_node,
1374 &integer_type_node, &unsigned_type_node,
1375 &long_integer_type_node, &long_unsigned_type_node,
1376 &long_long_integer_type_node, &long_long_unsigned_type_node,
1377 &float_type_node, &double_type_node, &long_double_type_node,
1381 tree bltn_type, dtor;
1383 push_nested_namespace (abi_node);
1384 bltn_type = xref_tag (class_type,
1385 get_identifier ("__fundamental_type_info"),
1386 /*attributes=*/NULL_TREE,
1388 pop_nested_namespace (abi_node);
1389 if (!COMPLETE_TYPE_P (bltn_type))
1391 dtor = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type), 1);
1392 if (DECL_EXTERNAL (dtor))
1395 for (ix = 0; fundamentals[ix]; ix++)
1397 tree bltn = *fundamentals[ix];
1398 tree bltn_ptr = build_pointer_type (bltn);
1399 tree bltn_const_ptr = build_pointer_type
1400 (build_qualified_type (bltn, TYPE_QUAL_CONST));
1403 tinfo = get_tinfo_decl (bltn);
1404 TREE_USED (tinfo) = 1;
1405 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1407 tinfo = get_tinfo_decl (bltn_ptr);
1408 TREE_USED (tinfo) = 1;
1409 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1411 tinfo = get_tinfo_decl (bltn_const_ptr);
1412 TREE_USED (tinfo) = 1;
1413 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo)) = 1;
1417 /* Return true, iff T is a type_info variable which has not had a
1418 definition emitted for it. */
1421 unemitted_tinfo_decl_p (tree t)
1423 if (/* It's a var decl */
1424 TREE_CODE (t) == VAR_DECL
1425 /* which has a name */
1427 /* whose name points back to itself */
1428 && IDENTIFIER_GLOBAL_VALUE (DECL_NAME (t)) == t
1429 /* whose name's type is non-null */
1430 && TREE_TYPE (DECL_NAME (t))
1431 /* and whose type is a struct */
1432 && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
1434 && TYPE_FIELDS (TREE_TYPE (t))
1435 /* which is our pseudo type info */
1436 && TREE_TYPE (TYPE_FIELDS (TREE_TYPE (t))) == ti_desc_type_node)
1441 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1442 tinfo decl. Determine whether it needs emitting, and if so
1443 generate the initializer. */
1446 emit_tinfo_decl (tree decl)
1448 tree type = TREE_TYPE (DECL_NAME (decl));
1450 int in_library = typeinfo_in_lib_p (type);
1451 tree var_desc, var_init;
1453 my_friendly_assert (unemitted_tinfo_decl_p (decl), 20030307);
1455 import_export_tinfo (decl, type, in_library);
1456 if (DECL_REALLY_EXTERN (decl) || !DECL_NEEDED_P (decl))
1459 if (!doing_runtime && in_library)
1463 var_desc = get_pseudo_ti_desc (type);
1464 var_init = get_pseudo_ti_init (type, var_desc, &non_public);
1466 DECL_EXTERNAL (decl) = 0;
1467 TREE_PUBLIC (decl) = !non_public;
1469 DECL_COMDAT (decl) = 0;
1471 DECL_INITIAL (decl) = var_init;
1473 cp_finish_decl (decl, var_init, NULL_TREE, 0);
1474 /* cp_finish_decl will have dealt with linkage. */
1476 /* Say we've dealt with it. */
1477 TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;