1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
4 Free Software Foundation, Inc.
5 Mostly written by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
37 /* C++ returns type information to the user in struct type_info
38 objects. We also use type information to implement dynamic_cast and
39 exception handlers. Type information for a particular type is
40 indicated with an ABI defined structure derived from type_info.
41 This would all be very straight forward, but for the fact that the
42 runtime library provides the definitions of the type_info structure
43 and the ABI defined derived classes. We cannot build declarations
44 of them directly in the compiler, but we need to layout objects of
45 their type. Somewhere we have to lie.
47 We define layout compatible POD-structs with compiler-defined names
48 and generate the appropriate initializations for them (complete
49 with explicit mention of their vtable). When we have to provide a
50 type_info to the user we reinterpret_cast the internal compiler
51 type to type_info. A well formed program can only explicitly refer
52 to the type_infos of complete types (& cv void). However, we chain
53 pointer type_infos to the pointed-to-type, and that can be
54 incomplete. We only need the addresses of such incomplete
55 type_info objects for static initialization.
57 The type information VAR_DECL of a type is held on the
58 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
59 will be the internal type. It will usually have the correct
60 internal type reflecting the kind of type it represents (pointer,
61 array, function, class, inherited class, etc). When the type it
62 represents is incomplete, it will have the internal type
63 corresponding to type_info. That will only happen at the end of
64 translation, when we are emitting the type info objects. */
66 /* Auxiliary data we hold for each type_info derived object we need. */
67 typedef struct tinfo_s GTY (())
69 tree type; /* The RECORD_TYPE for this type_info object */
71 tree vtable; /* The VAR_DECL of the vtable. Only filled at end of
74 tree name; /* IDENTIFIER_NODE for the ABI specified name of
75 the type_info derived type. */
79 DEF_VEC_ALLOC_O(tinfo_s,gc);
81 typedef enum tinfo_kind
83 TK_TYPE_INFO_TYPE, /* abi::__type_info_pseudo */
84 TK_BASE_TYPE, /* abi::__base_class_type_info */
85 TK_BUILTIN_TYPE, /* abi::__fundamental_type_info */
86 TK_ARRAY_TYPE, /* abi::__array_type_info */
87 TK_FUNCTION_TYPE, /* abi::__function_type_info */
88 TK_ENUMERAL_TYPE, /* abi::__enum_type_info */
89 TK_POINTER_TYPE, /* abi::__pointer_type_info */
90 TK_POINTER_MEMBER_TYPE, /* abi::__pointer_to_member_type_info */
91 TK_CLASS_TYPE, /* abi::__class_type_info */
92 TK_SI_CLASS_TYPE, /* abi::__si_class_type_info */
93 TK_FIXED /* end of fixed descriptors. */
94 /* ... abi::__vmi_type_info<I> */
97 /* A vector of all tinfo decls that haven't yet been emitted. */
98 VEC(tree,gc) *unemitted_tinfo_decls;
100 /* A vector of all type_info derived types we need. The first few are
101 fixed and created early. The remainder are for multiple inheritance
102 and are generated as needed. */
103 static GTY (()) VEC(tinfo_s,gc) *tinfo_descs;
105 static tree ifnonnull (tree, tree);
106 static tree tinfo_name (tree);
107 static tree build_dynamic_cast_1 (tree, tree, tsubst_flags_t);
108 static tree throw_bad_cast (void);
109 static tree throw_bad_typeid (void);
110 static tree get_tinfo_decl_dynamic (tree);
111 static tree get_tinfo_ptr (tree);
112 static bool typeid_ok_p (void);
113 static int qualifier_flags (tree);
114 static bool target_incomplete_p (tree);
115 static tree tinfo_base_init (tinfo_s *, tree);
116 static tree generic_initializer (tinfo_s *, tree);
117 static tree ptr_initializer (tinfo_s *, tree);
118 static tree ptm_initializer (tinfo_s *, tree);
119 static tree class_initializer (tinfo_s *, tree, tree);
120 static void create_pseudo_type_info (int, const char *, ...);
121 static tree get_pseudo_ti_init (tree, unsigned);
122 static unsigned get_pseudo_ti_index (tree);
123 static void create_tinfo_types (void);
124 static bool typeinfo_in_lib_p (tree);
126 static int doing_runtime = 0;
129 push_abi_namespace (void)
131 push_nested_namespace (abi_node);
132 push_visibility ("default");
136 pop_abi_namespace (void)
139 pop_nested_namespace (abi_node);
142 /* Declare language defined type_info type and a pointer to const
143 type_info. This is incomplete here, and will be completed when
144 the user #includes <typeinfo>. There are language defined
145 restrictions on what can be done until that is included. Create
146 the internal versions of the ABI types. */
149 init_rtti_processing (void)
153 push_namespace (std_identifier);
154 type_info_type = xref_tag (class_type, get_identifier ("type_info"),
155 /*tag_scope=*/ts_current, false);
157 const_type_info_type_node
158 = build_qualified_type (type_info_type, TYPE_QUAL_CONST);
159 type_info_ptr_type = build_pointer_type (const_type_info_type_node);
161 unemitted_tinfo_decls = VEC_alloc (tree, gc, 124);
163 create_tinfo_types ();
166 /* Given the expression EXP of type `class *', return the head of the
167 object pointed to by EXP with type cv void*, if the class has any
168 virtual functions (TYPE_POLYMORPHIC_P), else just return the
172 build_headof (tree exp)
174 tree type = TREE_TYPE (exp);
178 gcc_assert (TREE_CODE (type) == POINTER_TYPE);
179 type = TREE_TYPE (type);
181 if (!TYPE_POLYMORPHIC_P (type))
184 /* We use this a couple of times below, protect it. */
185 exp = save_expr (exp);
187 /* The offset-to-top field is at index -2 from the vptr. */
188 index = build_int_cst (NULL_TREE,
189 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
191 offset = build_vtbl_ref (cp_build_indirect_ref (exp, NULL,
192 tf_warning_or_error),
195 type = build_qualified_type (ptr_type_node,
196 cp_type_quals (TREE_TYPE (exp)));
197 return build2 (POINTER_PLUS_EXPR, type, exp,
198 convert_to_integer (sizetype, offset));
201 /* Get a bad_cast node for the program to throw...
203 See libstdc++/exception.cc for __throw_bad_cast */
206 throw_bad_cast (void)
208 tree fn = get_identifier ("__cxa_bad_cast");
209 if (!get_global_value_if_present (fn, &fn))
210 fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,
213 return build_cxx_call (fn, 0, NULL);
216 /* Return an expression for "__cxa_bad_typeid()". The expression
217 returned is an lvalue of type "const std::type_info". */
220 throw_bad_typeid (void)
222 tree fn = get_identifier ("__cxa_bad_typeid");
223 if (!get_global_value_if_present (fn, &fn))
227 t = build_reference_type (const_type_info_type_node);
228 t = build_function_type (t, void_list_node);
229 fn = push_throw_library_fn (fn, t);
232 return build_cxx_call (fn, 0, NULL);
235 /* Return an lvalue expression whose type is "const std::type_info"
236 and whose value indicates the type of the expression EXP. If EXP
237 is a reference to a polymorphic class, return the dynamic type;
238 otherwise return the static type of the expression. */
241 get_tinfo_decl_dynamic (tree exp)
246 if (error_operand_p (exp))
247 return error_mark_node;
249 /* peel back references, so they match. */
250 type = non_reference (TREE_TYPE (exp));
252 /* Peel off cv qualifiers. */
253 type = TYPE_MAIN_VARIANT (type);
255 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
256 if (CLASS_TYPE_P (type) || TREE_CODE (type) == UNKNOWN_TYPE)
257 type = complete_type_or_else (type, exp);
260 return error_mark_node;
262 /* If exp is a reference to polymorphic type, get the real type_info. */
263 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
265 /* build reference to type_info from vtable. */
268 /* The RTTI information is at index -1. */
269 index = build_int_cst (NULL_TREE,
270 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
271 t = build_vtbl_ref (exp, index);
272 t = convert (type_info_ptr_type, t);
275 /* Otherwise return the type_info for the static type of the expr. */
276 t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
278 return cp_build_indirect_ref (t, NULL, tf_warning_or_error);
284 tree pseudo_type_info, type_info_type;
288 error ("cannot use typeid with -fno-rtti");
292 if (!COMPLETE_TYPE_P (const_type_info_type_node))
294 error ("must #include <typeinfo> before using typeid");
299 = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE)->type;
300 type_info_type = TYPE_MAIN_VARIANT (const_type_info_type_node);
302 /* Make sure abi::__type_info_pseudo has the same alias set
303 as std::type_info. */
304 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info))
305 TYPE_ALIAS_SET (pseudo_type_info) = get_alias_set (type_info_type);
307 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info)
308 == get_alias_set (type_info_type));
313 /* Return an expression for "typeid(EXP)". The expression returned is
314 an lvalue of type "const std::type_info". */
317 build_typeid (tree exp)
319 tree cond = NULL_TREE;
322 if (exp == error_mark_node || !typeid_ok_p ())
323 return error_mark_node;
325 if (processing_template_decl)
326 return build_min (TYPEID_EXPR, const_type_info_type_node, exp);
328 if (TREE_CODE (exp) == INDIRECT_REF
329 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
330 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
331 && ! resolves_to_fixed_type_p (exp, &nonnull)
334 exp = stabilize_reference (exp);
335 cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
338 exp = get_tinfo_decl_dynamic (exp);
340 if (exp == error_mark_node)
341 return error_mark_node;
345 tree bad = throw_bad_typeid ();
347 exp = build3 (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
353 /* Generate the NTBS name of a type. */
355 tinfo_name (tree type)
360 name = mangle_type_string (type);
361 name_string = fix_string_type (build_string (strlen (name) + 1, name));
365 /* Return a VAR_DECL for the internal ABI defined type_info object for
366 TYPE. You must arrange that the decl is mark_used, if actually use
367 it --- decls in vtables are only used if the vtable is output. */
370 get_tinfo_decl (tree type)
375 if (variably_modified_type_p (type, /*fn=*/NULL_TREE))
377 error ("cannot create type information for type %qT because "
378 "it involves types of variable size",
380 return error_mark_node;
383 if (TREE_CODE (type) == METHOD_TYPE)
384 type = build_function_type (TREE_TYPE (type),
385 TREE_CHAIN (TYPE_ARG_TYPES (type)));
387 /* For a class type, the variable is cached in the type node
389 if (CLASS_TYPE_P (type))
391 d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
396 name = mangle_typeinfo_for_type (type);
398 d = IDENTIFIER_GLOBAL_VALUE (name);
401 int ix = get_pseudo_ti_index (type);
402 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, ix);
404 d = build_lang_decl (VAR_DECL, name, ti->type);
405 SET_DECL_ASSEMBLER_NAME (d, name);
406 /* Remember the type it is for. */
407 TREE_TYPE (name) = type;
408 DECL_TINFO_P (d) = 1;
409 DECL_ARTIFICIAL (d) = 1;
410 DECL_IGNORED_P (d) = 1;
411 TREE_READONLY (d) = 1;
413 /* Mark the variable as undefined -- but remember that we can
414 define it later if we need to do so. */
415 DECL_EXTERNAL (d) = 1;
416 DECL_NOT_REALLY_EXTERN (d) = 1;
417 set_linkage_according_to_type (type, d);
419 d = pushdecl_top_level_and_finish (d, NULL_TREE);
420 if (CLASS_TYPE_P (type))
421 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
423 /* Add decl to the global array of tinfo decls. */
424 VEC_safe_push (tree, gc, unemitted_tinfo_decls, d);
430 /* Return a pointer to a type_info object describing TYPE, suitably
431 cast to the language defined type. */
434 get_tinfo_ptr (tree type)
436 tree decl = get_tinfo_decl (type);
439 return build_nop (type_info_ptr_type,
440 build_address (decl));
443 /* Return the type_info object for TYPE. */
446 get_typeid (tree type)
448 if (type == error_mark_node || !typeid_ok_p ())
449 return error_mark_node;
451 if (processing_template_decl)
452 return build_min (TYPEID_EXPR, const_type_info_type_node, type);
454 /* If the type of the type-id is a reference type, the result of the
455 typeid expression refers to a type_info object representing the
457 type = non_reference (type);
459 /* The top-level cv-qualifiers of the lvalue expression or the type-id
460 that is the operand of typeid are always ignored. */
461 type = TYPE_MAIN_VARIANT (type);
463 /* For UNKNOWN_TYPEs call complete_type_or_else to get diagnostics. */
464 if (CLASS_TYPE_P (type) || TREE_CODE (type) == UNKNOWN_TYPE)
465 type = complete_type_or_else (type, NULL_TREE);
468 return error_mark_node;
470 return cp_build_indirect_ref (get_tinfo_ptr (type), NULL,
471 tf_warning_or_error);
474 /* Check whether TEST is null before returning RESULT. If TEST is used in
475 RESULT, it must have previously had a save_expr applied to it. */
478 ifnonnull (tree test, tree result)
480 return build3 (COND_EXPR, TREE_TYPE (result),
481 build2 (EQ_EXPR, boolean_type_node, test,
482 cp_convert (TREE_TYPE (test), integer_zero_node)),
483 cp_convert (TREE_TYPE (result), integer_zero_node),
487 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
491 build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain)
493 enum tree_code tc = TREE_CODE (type);
494 tree exprtype = TREE_TYPE (expr);
496 tree old_expr = expr;
497 const char *errstr = NULL;
499 /* Save casted types in the function's used types hash table. */
500 used_types_insert (type);
502 /* T shall be a pointer or reference to a complete class type, or
503 `pointer to cv void''. */
507 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
511 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (type)))
513 errstr = "target is not pointer or reference to class";
516 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
518 errstr = "target is not pointer or reference to complete type";
524 errstr = "target is not pointer or reference";
528 if (tc == POINTER_TYPE)
530 /* If T is a pointer type, v shall be an rvalue of a pointer to
531 complete class type, and the result is an rvalue of type T. */
533 if (TREE_CODE (exprtype) != POINTER_TYPE)
535 errstr = "source is not a pointer";
538 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
540 errstr = "source is not a pointer to class";
543 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
545 errstr = "source is a pointer to incomplete type";
551 exprtype = build_reference_type (exprtype);
553 /* T is a reference type, v shall be an lvalue of a complete class
554 type, and the result is an lvalue of the type referred to by T. */
556 if (! MAYBE_CLASS_TYPE_P (TREE_TYPE (exprtype)))
558 errstr = "source is not of class type";
561 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
563 errstr = "source is of incomplete class type";
567 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
568 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
569 LOOKUP_NORMAL, NULL_TREE);
572 /* The dynamic_cast operator shall not cast away constness. */
573 if (!at_least_as_qualified_p (TREE_TYPE (type),
574 TREE_TYPE (exprtype)))
576 errstr = "conversion casts away constness";
580 /* If *type is an unambiguous accessible base class of *exprtype,
581 convert statically. */
585 binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
590 expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),
592 if (TREE_CODE (exprtype) == POINTER_TYPE)
593 expr = rvalue (expr);
598 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
599 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
602 /* if TYPE is `void *', return pointer to complete object. */
603 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
605 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
606 if (TREE_CODE (expr) == ADDR_EXPR
607 && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
608 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
609 return build1 (NOP_EXPR, type, expr);
611 /* Since expr is used twice below, save it. */
612 expr = save_expr (expr);
614 expr1 = build_headof (expr);
615 if (TREE_TYPE (expr1) != type)
616 expr1 = build1 (NOP_EXPR, type, expr1);
617 return ifnonnull (expr, expr1);
622 tree result, td2, td3;
624 tree static_type, target_type, boff;
626 /* If we got here, we can't convert statically. Therefore,
627 dynamic_cast<D&>(b) (b an object) cannot succeed. */
628 if (tc == REFERENCE_TYPE)
630 if (TREE_CODE (old_expr) == VAR_DECL
631 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
633 tree expr = throw_bad_cast ();
634 if (complain & tf_warning)
635 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
637 /* Bash it to the expected type. */
638 TREE_TYPE (expr) = type;
642 /* Ditto for dynamic_cast<D*>(&b). */
643 else if (TREE_CODE (expr) == ADDR_EXPR)
645 tree op = TREE_OPERAND (expr, 0);
646 if (TREE_CODE (op) == VAR_DECL
647 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
649 if (complain & tf_warning)
650 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
652 retval = build_int_cst (type, 0);
657 /* Use of dynamic_cast when -fno-rtti is prohibited. */
660 if (complain & tf_error)
661 error ("%<dynamic_cast%> not permitted with -fno-rtti");
662 return error_mark_node;
665 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
666 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
667 td2 = get_tinfo_decl (target_type);
669 td2 = cp_build_unary_op (ADDR_EXPR, td2, 0, complain);
670 td3 = get_tinfo_decl (static_type);
672 td3 = cp_build_unary_op (ADDR_EXPR, td3, 0, complain);
674 /* Determine how T and V are related. */
675 boff = dcast_base_hint (static_type, target_type);
677 /* Since expr is used twice below, save it. */
678 expr = save_expr (expr);
681 if (tc == REFERENCE_TYPE)
682 expr1 = cp_build_unary_op (ADDR_EXPR, expr1, 0, complain);
689 dcast_fn = dynamic_cast_node;
696 push_abi_namespace ();
697 tinfo_ptr = xref_tag (class_type,
698 get_identifier ("__class_type_info"),
699 /*tag_scope=*/ts_current, false);
701 tinfo_ptr = build_pointer_type
702 (build_qualified_type
703 (tinfo_ptr, TYPE_QUAL_CONST));
704 name = "__dynamic_cast";
706 (NULL_TREE, const_ptr_type_node, tree_cons
707 (NULL_TREE, tinfo_ptr, tree_cons
708 (NULL_TREE, tinfo_ptr, tree_cons
709 (NULL_TREE, ptrdiff_type_node, void_list_node))));
710 tmp = build_function_type (ptr_type_node, tmp);
711 dcast_fn = build_library_fn_ptr (name, tmp);
712 DECL_PURE_P (dcast_fn) = 1;
713 pop_abi_namespace ();
714 dynamic_cast_node = dcast_fn;
716 result = build_cxx_call (dcast_fn, 4, elems);
718 if (tc == REFERENCE_TYPE)
720 tree bad = throw_bad_cast ();
723 result = save_expr (result);
724 neq = c_common_truthvalue_conversion (input_location, result);
725 return cp_convert (type,
726 build3 (COND_EXPR, TREE_TYPE (result),
730 /* Now back to the type we want from a void*. */
731 result = cp_convert (type, result);
732 return ifnonnull (expr, result);
736 errstr = "source type is not polymorphic";
739 if (complain & tf_error)
740 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
741 expr, exprtype, type, errstr);
742 return error_mark_node;
746 build_dynamic_cast (tree type, tree expr, tsubst_flags_t complain)
748 if (type == error_mark_node || expr == error_mark_node)
749 return error_mark_node;
751 if (processing_template_decl)
753 expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
754 TREE_SIDE_EFFECTS (expr) = 1;
755 return convert_from_reference (expr);
758 return convert_from_reference (build_dynamic_cast_1 (type, expr, complain));
761 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
764 qualifier_flags (tree type)
767 int quals = cp_type_quals (type);
769 if (quals & TYPE_QUAL_CONST)
771 if (quals & TYPE_QUAL_VOLATILE)
773 if (quals & TYPE_QUAL_RESTRICT)
778 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
779 contains a pointer to member of an incomplete class. */
782 target_incomplete_p (tree type)
785 if (TYPE_PTRMEM_P (type))
787 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
789 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
791 else if (TREE_CODE (type) == POINTER_TYPE)
792 type = TREE_TYPE (type);
794 return !COMPLETE_OR_VOID_TYPE_P (type);
797 /* Returns true if TYPE involves an incomplete class type; in that
798 case, typeinfo variables for TYPE should be emitted with internal
802 involves_incomplete_p (tree type)
804 switch (TREE_CODE (type))
807 return target_incomplete_p (TREE_TYPE (type));
812 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type))
813 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)));
816 if (TYPE_PTRMEMFUNC_P (type))
820 if (!COMPLETE_TYPE_P (type))
824 /* All other types do not involve incomplete class types. */
829 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
830 is the vtable pointer and NTBS name. The NTBS name is emitted as a
831 comdat const char array, so it becomes a unique key for the type. Generate
832 and emit that VAR_DECL here. (We can't always emit the type_info itself
833 as comdat, because of pointers to incomplete.) */
836 tinfo_base_init (tinfo_s *ti, tree target)
838 tree init = NULL_TREE;
845 /* Generate the NTBS array variable. */
846 tree name_type = build_cplus_array_type
847 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
849 tree name_string = tinfo_name (target);
851 /* Determine the name of the variable -- and remember with which
852 type it is associated. */
853 name_name = mangle_typeinfo_string_for_type (target);
854 TREE_TYPE (name_name) = target;
856 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
857 SET_DECL_ASSEMBLER_NAME (name_decl, name_name);
858 DECL_ARTIFICIAL (name_decl) = 1;
859 DECL_IGNORED_P (name_decl) = 1;
860 TREE_READONLY (name_decl) = 1;
861 TREE_STATIC (name_decl) = 1;
862 DECL_EXTERNAL (name_decl) = 0;
863 DECL_TINFO_P (name_decl) = 1;
864 set_linkage_according_to_type (target, name_decl);
865 import_export_decl (name_decl);
866 DECL_INITIAL (name_decl) = name_string;
867 mark_used (name_decl);
868 pushdecl_top_level_and_finish (name_decl, name_string);
871 vtable_ptr = ti->vtable;
875 push_abi_namespace ();
876 real_type = xref_tag (class_type, ti->name,
877 /*tag_scope=*/ts_current, false);
878 pop_abi_namespace ();
880 if (!COMPLETE_TYPE_P (real_type))
882 /* We never saw a definition of this type, so we need to
883 tell the compiler that this is an exported class, as
884 indeed all of the __*_type_info classes are. */
885 SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
886 CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
889 vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
890 vtable_ptr = cp_build_unary_op (ADDR_EXPR, vtable_ptr, 0,
891 tf_warning_or_error);
893 /* We need to point into the middle of the vtable. */
895 (POINTER_PLUS_EXPR, TREE_TYPE (vtable_ptr), vtable_ptr,
896 size_binop (MULT_EXPR,
897 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
898 TYPE_SIZE_UNIT (vtable_entry_type)));
900 ti->vtable = vtable_ptr;
903 init = tree_cons (NULL_TREE, vtable_ptr, init);
905 init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
907 init = build_constructor_from_list (init_list_type_node, nreverse (init));
908 TREE_CONSTANT (init) = 1;
909 TREE_STATIC (init) = 1;
910 init = tree_cons (NULL_TREE, init, NULL_TREE);
915 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
916 information about the particular type_info derivation, which adds no
917 additional fields to the type_info base. */
920 generic_initializer (tinfo_s *ti, tree target)
922 tree init = tinfo_base_init (ti, target);
924 init = build_constructor_from_list (init_list_type_node, init);
925 TREE_CONSTANT (init) = 1;
926 TREE_STATIC (init) = 1;
930 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
931 TI provides information about the particular type_info derivation,
932 which adds target type and qualifier flags members to the type_info base. */
935 ptr_initializer (tinfo_s *ti, tree target)
937 tree init = tinfo_base_init (ti, target);
938 tree to = TREE_TYPE (target);
939 int flags = qualifier_flags (to);
940 bool incomplete = target_incomplete_p (to);
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)),
949 init = build_constructor_from_list (init_list_type_node, nreverse (init));
950 TREE_CONSTANT (init) = 1;
951 TREE_STATIC (init) = 1;
955 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
956 TI provides information about the particular type_info derivation,
957 which adds class, target type and qualifier flags members to the type_info
961 ptm_initializer (tinfo_s *ti, tree target)
963 tree init = tinfo_base_init (ti, target);
964 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
965 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
966 int flags = qualifier_flags (to);
967 bool incomplete = target_incomplete_p (to);
971 if (!COMPLETE_TYPE_P (klass))
973 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
974 init = tree_cons (NULL_TREE,
975 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
977 init = tree_cons (NULL_TREE,
978 get_tinfo_ptr (klass),
981 init = build_constructor_from_list (init_list_type_node, nreverse (init));
982 TREE_CONSTANT (init) = 1;
983 TREE_STATIC (init) = 1;
987 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
988 TI provides information about the particular __class_type_info derivation,
989 which adds hint flags and TRAIL initializers to the type_info base. */
992 class_initializer (tinfo_s *ti, tree target, tree trail)
994 tree init = tinfo_base_init (ti, target);
996 TREE_CHAIN (init) = trail;
997 init = build_constructor_from_list (init_list_type_node, init);
998 TREE_CONSTANT (init) = 1;
999 TREE_STATIC (init) = 1;
1003 /* Returns true if the typeinfo for type should be placed in
1004 the runtime library. */
1007 typeinfo_in_lib_p (tree type)
1009 /* The typeinfo objects for `T*' and `const T*' are in the runtime
1010 library for simple types T. */
1011 if (TREE_CODE (type) == POINTER_TYPE
1012 && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
1013 || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
1014 type = TREE_TYPE (type);
1016 switch (TREE_CODE (type))
1029 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1030 the index of the descriptor in the tinfo_desc vector. */
1033 get_pseudo_ti_init (tree type, unsigned tk_index)
1035 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1037 gcc_assert (at_eof);
1040 case TK_POINTER_MEMBER_TYPE:
1041 return ptm_initializer (ti, type);
1043 case TK_POINTER_TYPE:
1044 return ptr_initializer (ti, type);
1046 case TK_BUILTIN_TYPE:
1047 case TK_ENUMERAL_TYPE:
1048 case TK_FUNCTION_TYPE:
1050 return generic_initializer (ti, type);
1053 return class_initializer (ti, type, NULL_TREE);
1055 case TK_SI_CLASS_TYPE:
1057 tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), 0);
1058 tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1059 tree base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1061 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1062 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1063 return class_initializer (ti, type, base_inits);
1068 int hint = ((CLASSTYPE_REPEATED_BASE_P (type) << 0)
1069 | (CLASSTYPE_DIAMOND_SHAPED_P (type) << 1));
1070 tree binfo = TYPE_BINFO (type);
1071 int nbases = BINFO_N_BASE_BINFOS (binfo);
1072 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1073 tree offset_type = integer_types[itk_long];
1074 tree base_inits = NULL_TREE;
1077 gcc_assert (tk_index >= TK_FIXED);
1079 /* Generate the base information initializer. */
1080 for (ix = nbases; ix--;)
1082 tree base_binfo = BINFO_BASE_BINFO (binfo, ix);
1083 tree base_init = NULL_TREE;
1088 if (VEC_index (tree, base_accesses, ix) == access_public_node)
1090 tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1091 if (BINFO_VIRTUAL_P (base_binfo))
1093 /* We store the vtable offset at which the virtual
1094 base offset can be found. */
1095 offset = BINFO_VPTR_FIELD (base_binfo);
1099 offset = BINFO_OFFSET (base_binfo);
1101 /* Combine offset and flags into one field. */
1102 offset = fold_convert (offset_type, offset);
1103 offset = fold_build2 (LSHIFT_EXPR, offset_type, offset,
1104 build_int_cst (offset_type, 8));
1105 offset = fold_build2 (BIT_IOR_EXPR, offset_type, offset,
1106 build_int_cst (offset_type, flags));
1107 base_init = tree_cons (NULL_TREE, offset, base_init);
1108 base_init = tree_cons (NULL_TREE, tinfo, base_init);
1109 base_init = build_constructor_from_list (init_list_type_node, base_init);
1110 base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1112 base_inits = build_constructor_from_list (init_list_type_node, base_inits);
1113 base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1114 /* Prepend the number of bases. */
1115 base_inits = tree_cons (NULL_TREE,
1116 build_int_cst (NULL_TREE, nbases),
1118 /* Prepend the hint flags. */
1119 base_inits = tree_cons (NULL_TREE,
1120 build_int_cst (NULL_TREE, hint),
1123 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1124 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1125 return class_initializer (ti, type, base_inits);
1130 /* Generate the RECORD_TYPE containing the data layout of a type_info
1131 derivative as used by the runtime. This layout must be consistent with
1132 that defined in the runtime support. Also generate the VAR_DECL for the
1133 type's vtable. We explicitly manage the vtable member, and name it for
1134 real type as used in the runtime. The RECORD type has a different name,
1135 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1136 is the generated type and TINFO_VTABLE_NAME is the name of the
1137 vtable. We have to delay generating the VAR_DECL of the vtable
1138 until the end of the translation, when we'll have seen the library
1139 definition, if there was one.
1141 REAL_NAME is the runtime's name of the type. Trailing arguments are
1142 additional FIELD_DECL's for the structure. The final argument must be
1146 create_pseudo_type_info (int tk, const char *real_name, ...)
1155 va_start (ap, real_name);
1157 /* Generate the pseudo type name. */
1158 pseudo_name = (char *) alloca (strlen (real_name) + 30);
1159 strcpy (pseudo_name, real_name);
1160 strcat (pseudo_name, "_pseudo");
1162 sprintf (pseudo_name + strlen (pseudo_name), "%d", tk - TK_FIXED);
1164 /* First field is the pseudo type_info base class. */
1165 fields = build_decl (FIELD_DECL, NULL_TREE,
1166 VEC_index (tinfo_s, tinfo_descs,
1167 TK_TYPE_INFO_TYPE)->type);
1169 /* Now add the derived fields. */
1170 while ((field_decl = va_arg (ap, tree)))
1172 TREE_CHAIN (field_decl) = fields;
1173 fields = field_decl;
1176 /* Create the pseudo type. */
1177 pseudo_type = make_class_type (RECORD_TYPE);
1178 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
1179 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
1181 ti = VEC_index (tinfo_s, tinfo_descs, tk);
1182 ti->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
1183 ti->name = get_identifier (real_name);
1184 ti->vtable = NULL_TREE;
1186 /* Pretend this is public so determine_visibility doesn't give vtables
1187 internal linkage. */
1188 TREE_PUBLIC (TYPE_MAIN_DECL (ti->type)) = 1;
1193 /* Return the index of a pseudo type info type node used to describe
1194 TYPE. TYPE must be a complete type (or cv void), except at the end
1195 of the translation unit. */
1198 get_pseudo_ti_index (tree type)
1202 switch (TREE_CODE (type))
1205 ix = TK_POINTER_MEMBER_TYPE;
1209 ix = TK_POINTER_TYPE;
1213 ix = TK_ENUMERAL_TYPE;
1217 ix = TK_FUNCTION_TYPE;
1226 if (TYPE_PTRMEMFUNC_P (type))
1228 ix = TK_POINTER_MEMBER_TYPE;
1231 else if (!COMPLETE_TYPE_P (type))
1234 cxx_incomplete_type_error (NULL_TREE, type);
1238 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
1245 tree binfo = TYPE_BINFO (type);
1246 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1247 tree base_binfo = BINFO_BASE_BINFO (binfo, 0);
1248 int num_bases = BINFO_N_BASE_BINFOS (binfo);
1251 && VEC_index (tree, base_accesses, 0) == access_public_node
1252 && !BINFO_VIRTUAL_P (base_binfo)
1253 && integer_zerop (BINFO_OFFSET (base_binfo)))
1255 /* single non-virtual public. */
1256 ix = TK_SI_CLASS_TYPE;
1262 tree array_domain, base_array;
1264 ix = TK_FIXED + num_bases;
1265 if (VEC_length (tinfo_s, tinfo_descs) <= ix)
1267 /* too short, extend. */
1268 unsigned len = VEC_length (tinfo_s, tinfo_descs);
1270 VEC_safe_grow (tinfo_s, gc, tinfo_descs, ix + 1);
1271 while (VEC_iterate (tinfo_s, tinfo_descs, len++, ti))
1272 ti->type = ti->vtable = ti->name = NULL_TREE;
1274 else if (VEC_index (tinfo_s, tinfo_descs, ix)->type)
1275 /* already created. */
1278 /* Create the array of __base_class_type_info entries.
1279 G++ 3.2 allocated an array that had one too many
1280 entries, and then filled that extra entries with
1282 if (abi_version_at_least (2))
1283 array_domain = build_index_type (size_int (num_bases - 1));
1285 array_domain = build_index_type (size_int (num_bases));
1287 build_array_type (VEC_index (tinfo_s, tinfo_descs,
1288 TK_BASE_TYPE)->type,
1291 push_abi_namespace ();
1292 create_pseudo_type_info
1293 (ix, "__vmi_class_type_info",
1294 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1295 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1296 build_decl (FIELD_DECL, NULL_TREE, base_array),
1298 pop_abi_namespace ();
1303 ix = TK_BUILTIN_TYPE;
1309 /* Make sure the required builtin types exist for generating the type_info
1310 variable definitions. */
1313 create_tinfo_types (void)
1317 gcc_assert (!tinfo_descs);
1319 VEC_safe_grow (tinfo_s, gc, tinfo_descs, TK_FIXED);
1321 push_abi_namespace ();
1323 /* Create the internal type_info structure. This is used as a base for
1324 the other structures. */
1328 field = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1331 field = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1332 TREE_CHAIN (field) = fields;
1335 ti = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE);
1336 ti->type = make_class_type (RECORD_TYPE);
1337 ti->vtable = NULL_TREE;
1338 ti->name = NULL_TREE;
1339 finish_builtin_struct (ti->type, "__type_info_pseudo",
1343 /* Fundamental type_info */
1344 create_pseudo_type_info (TK_BUILTIN_TYPE, "__fundamental_type_info", NULL);
1346 /* Array, function and enum type_info. No additional fields. */
1347 create_pseudo_type_info (TK_ARRAY_TYPE, "__array_type_info", NULL);
1348 create_pseudo_type_info (TK_FUNCTION_TYPE, "__function_type_info", NULL);
1349 create_pseudo_type_info (TK_ENUMERAL_TYPE, "__enum_type_info", NULL);
1351 /* Class type_info. No additional fields. */
1352 create_pseudo_type_info (TK_CLASS_TYPE, "__class_type_info", NULL);
1354 /* Single public non-virtual base class. Add pointer to base class.
1355 This is really a descendant of __class_type_info. */
1356 create_pseudo_type_info (TK_SI_CLASS_TYPE, "__si_class_type_info",
1357 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1360 /* Base class internal helper. Pointer to base type, offset to base,
1365 field = build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type);
1368 field = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1369 TREE_CHAIN (field) = fields;
1372 ti = VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE);
1374 ti->type = make_class_type (RECORD_TYPE);
1375 ti->vtable = NULL_TREE;
1376 ti->name = NULL_TREE;
1377 finish_builtin_struct (ti->type, "__base_class_type_info_pseudo",
1381 /* Pointer type_info. Adds two fields, qualification mask
1382 and pointer to the pointed to type. This is really a descendant of
1383 __pbase_type_info. */
1384 create_pseudo_type_info (TK_POINTER_TYPE, "__pointer_type_info",
1385 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1386 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1389 /* Pointer to member data type_info. Add qualifications flags,
1390 pointer to the member's type info and pointer to the class.
1391 This is really a descendant of __pbase_type_info. */
1392 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE,
1393 "__pointer_to_member_type_info",
1394 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1395 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1396 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1399 pop_abi_namespace ();
1402 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1403 support. Generating them here guarantees consistency with the other
1404 structures. We use the following heuristic to determine when the runtime
1405 is being generated. If std::__fundamental_type_info is defined, and its
1406 destructor is defined, then the runtime is being built. */
1409 emit_support_tinfos (void)
1411 static tree *const fundamentals[] =
1415 &wchar_type_node, &char16_type_node, &char32_type_node,
1416 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1417 &short_integer_type_node, &short_unsigned_type_node,
1418 &integer_type_node, &unsigned_type_node,
1419 &long_integer_type_node, &long_unsigned_type_node,
1420 &long_long_integer_type_node, &long_long_unsigned_type_node,
1421 &float_type_node, &double_type_node, &long_double_type_node,
1425 tree bltn_type, dtor;
1427 push_abi_namespace ();
1428 bltn_type = xref_tag (class_type,
1429 get_identifier ("__fundamental_type_info"),
1430 /*tag_scope=*/ts_current, false);
1431 pop_abi_namespace ();
1432 if (!COMPLETE_TYPE_P (bltn_type))
1434 dtor = CLASSTYPE_DESTRUCTORS (bltn_type);
1435 if (!dtor || DECL_EXTERNAL (dtor))
1438 for (ix = 0; fundamentals[ix]; ix++)
1440 tree bltn = *fundamentals[ix];
1445 types[1] = build_pointer_type (bltn);
1446 types[2] = build_pointer_type (build_qualified_type (bltn,
1449 for (i = 0; i < 3; ++i)
1453 tinfo = get_tinfo_decl (types[i]);
1454 TREE_USED (tinfo) = 1;
1455 mark_needed (tinfo);
1456 /* The C++ ABI requires that these objects be COMDAT. But,
1457 On systems without weak symbols, initialized COMDAT
1458 objects are emitted with internal linkage. (See
1459 comdat_linkage for details.) Since we want these objects
1460 to have external linkage so that copies do not have to be
1461 emitted in code outside the runtime library, we make them
1464 It might also not be necessary to follow this detail of the
1466 if (!flag_weak || ! targetm.cxx.library_rtti_comdat ())
1468 gcc_assert (TREE_PUBLIC (tinfo) && !DECL_COMDAT (tinfo));
1469 DECL_INTERFACE_KNOWN (tinfo) = 1;
1475 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1476 tinfo decl. Determine whether it needs emitting, and if so
1477 generate the initializer. */
1480 emit_tinfo_decl (tree decl)
1482 tree type = TREE_TYPE (DECL_NAME (decl));
1483 int in_library = typeinfo_in_lib_p (type);
1485 gcc_assert (DECL_TINFO_P (decl));
1490 DECL_EXTERNAL (decl) = 0;
1493 /* If we're not in the runtime, then DECL (which is already
1494 DECL_EXTERNAL) will not be defined here. */
1495 DECL_INTERFACE_KNOWN (decl) = 1;
1499 else if (involves_incomplete_p (type))
1501 if (!decl_needed_p (decl))
1503 /* If TYPE involves an incomplete class type, then the typeinfo
1504 object will be emitted with internal linkage. There is no
1505 way to know whether or not types are incomplete until the end
1506 of the compilation, so this determination must be deferred
1507 until this point. */
1508 TREE_PUBLIC (decl) = 0;
1509 DECL_EXTERNAL (decl) = 0;
1510 DECL_INTERFACE_KNOWN (decl) = 1;
1513 import_export_decl (decl);
1514 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
1518 DECL_EXTERNAL (decl) = 0;
1519 init = get_pseudo_ti_init (type, get_pseudo_ti_index (type));
1520 DECL_INITIAL (decl) = init;
1522 finish_decl (decl, init, NULL_TREE);
1529 #include "gt-cp-rtti.h"