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"
36 /* C++ returns type information to the user in struct type_info
37 objects. We also use type information to implement dynamic_cast and
38 exception handlers. Type information for a particular type is
39 indicated with an ABI defined structure derived from type_info.
40 This would all be very straight forward, but for the fact that the
41 runtime library provides the definitions of the type_info structure
42 and the ABI defined derived classes. We cannot build declarations
43 of them directly in the compiler, but we need to layout objects of
44 their type. Somewhere we have to lie.
46 We define layout compatible POD-structs with compiler-defined names
47 and generate the appropriate initializations for them (complete
48 with explicit mention of their vtable). When we have to provide a
49 type_info to the user we reinterpret_cast the internal compiler
50 type to type_info. A well formed program can only explicitly refer
51 to the type_infos of complete types (& cv void). However, we chain
52 pointer type_infos to the pointed-to-type, and that can be
53 incomplete. We only need the addresses of such incomplete
54 type_info objects for static initialization.
56 The type information VAR_DECL of a type is held on the
57 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
58 will be the internal type. It will usually have the correct
59 internal type reflecting the kind of type it represents (pointer,
60 array, function, class, inherited class, etc). When the type it
61 represents is incomplete, it will have the internal type
62 corresponding to type_info. That will only happen at the end of
63 translation, when we are emitting the type info objects. */
65 /* Auxiliary data we hold for each type_info derived object we need. */
66 typedef struct tinfo_s
GTY (())
68 tree type
; /* The RECORD_TYPE for this type_info object */
70 tree vtable
; /* The VAR_DECL of the vtable. Only filled at end of
73 tree name
; /* IDENTIFIER_NODE for the ABI specified name of
74 the type_info derived type. */
78 DEF_VEC_ALLOC_O(tinfo_s
,gc
);
80 typedef enum tinfo_kind
82 TK_TYPE_INFO_TYPE
, /* abi::__type_info_pseudo */
83 TK_BASE_TYPE
, /* abi::__base_class_type_info */
84 TK_BUILTIN_TYPE
, /* abi::__fundamental_type_info */
85 TK_ARRAY_TYPE
, /* abi::__array_type_info */
86 TK_FUNCTION_TYPE
, /* abi::__function_type_info */
87 TK_ENUMERAL_TYPE
, /* abi::__enum_type_info */
88 TK_POINTER_TYPE
, /* abi::__pointer_type_info */
89 TK_POINTER_MEMBER_TYPE
, /* abi::__pointer_to_member_type_info */
90 TK_CLASS_TYPE
, /* abi::__class_type_info */
91 TK_SI_CLASS_TYPE
, /* abi::__si_class_type_info */
92 TK_FIXED
/* end of fixed descriptors. */
93 /* ... abi::__vmi_type_info<I> */
96 /* A vector of all tinfo decls that haven't yet been emitted. */
97 VEC(tree
,gc
) *unemitted_tinfo_decls
;
99 /* A vector of all type_info derived types we need. The first few are
100 fixed and created early. The remainder are for multiple inheritance
101 and are generated as needed. */
102 static GTY (()) VEC(tinfo_s
,gc
) *tinfo_descs
;
104 static tree
ifnonnull (tree
, tree
);
105 static tree
tinfo_name (tree
);
106 static tree
build_dynamic_cast_1 (tree
, tree
);
107 static tree
throw_bad_cast (void);
108 static tree
throw_bad_typeid (void);
109 static tree
get_tinfo_decl_dynamic (tree
);
110 static tree
get_tinfo_ptr (tree
);
111 static bool typeid_ok_p (void);
112 static int qualifier_flags (tree
);
113 static bool target_incomplete_p (tree
);
114 static tree
tinfo_base_init (tinfo_s
*, tree
);
115 static tree
generic_initializer (tinfo_s
*, tree
);
116 static tree
ptr_initializer (tinfo_s
*, tree
);
117 static tree
ptm_initializer (tinfo_s
*, tree
);
118 static tree
class_initializer (tinfo_s
*, tree
, tree
);
119 static void create_pseudo_type_info (int, const char *, ...);
120 static tree
get_pseudo_ti_init (tree
, unsigned);
121 static unsigned get_pseudo_ti_index (tree
);
122 static void create_tinfo_types (void);
123 static bool typeinfo_in_lib_p (tree
);
125 static int doing_runtime
= 0;
128 /* Declare language defined type_info type and a pointer to const
129 type_info. This is incomplete here, and will be completed when
130 the user #includes <typeinfo>. There are language defined
131 restrictions on what can be done until that is included. Create
132 the internal versions of the ABI types. */
135 init_rtti_processing (void)
139 push_namespace (std_identifier
);
140 type_info_type
= xref_tag (class_type
, get_identifier ("type_info"),
141 /*tag_scope=*/ts_current
, false);
143 const_type_info_type_node
144 = build_qualified_type (type_info_type
, TYPE_QUAL_CONST
);
145 type_info_ptr_type
= build_pointer_type (const_type_info_type_node
);
147 unemitted_tinfo_decls
= VEC_alloc (tree
, gc
, 124);
149 create_tinfo_types ();
152 /* Given the expression EXP of type `class *', return the head of the
153 object pointed to by EXP with type cv void*, if the class has any
154 virtual functions (TYPE_POLYMORPHIC_P), else just return the
158 build_headof (tree exp
)
160 tree type
= TREE_TYPE (exp
);
164 gcc_assert (TREE_CODE (type
) == POINTER_TYPE
);
165 type
= TREE_TYPE (type
);
167 if (!TYPE_POLYMORPHIC_P (type
))
170 /* We use this a couple of times below, protect it. */
171 exp
= save_expr (exp
);
173 /* The offset-to-top field is at index -2 from the vptr. */
174 index
= build_int_cst (NULL_TREE
,
175 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
177 offset
= build_vtbl_ref (build_indirect_ref (exp
, NULL
), index
);
179 type
= build_qualified_type (ptr_type_node
,
180 cp_type_quals (TREE_TYPE (exp
)));
181 return build2 (POINTER_PLUS_EXPR
, type
, exp
,
182 convert_to_integer (sizetype
, offset
));
185 /* Get a bad_cast node for the program to throw...
187 See libstdc++/exception.cc for __throw_bad_cast */
190 throw_bad_cast (void)
192 tree fn
= get_identifier ("__cxa_bad_cast");
193 if (!get_global_value_if_present (fn
, &fn
))
194 fn
= push_throw_library_fn (fn
, build_function_type (ptr_type_node
,
197 return build_cxx_call (fn
, 0, NULL
);
200 /* Return an expression for "__cxa_bad_typeid()". The expression
201 returned is an lvalue of type "const std::type_info". */
204 throw_bad_typeid (void)
206 tree fn
= get_identifier ("__cxa_bad_typeid");
207 if (!get_global_value_if_present (fn
, &fn
))
211 t
= build_reference_type (const_type_info_type_node
);
212 t
= build_function_type (t
, void_list_node
);
213 fn
= push_throw_library_fn (fn
, t
);
216 return build_cxx_call (fn
, 0, NULL
);
219 /* Return an lvalue expression whose type is "const std::type_info"
220 and whose value indicates the type of the expression EXP. If EXP
221 is a reference to a polymorphic class, return the dynamic type;
222 otherwise return the static type of the expression. */
225 get_tinfo_decl_dynamic (tree exp
)
230 if (error_operand_p (exp
))
231 return error_mark_node
;
233 /* peel back references, so they match. */
234 type
= non_reference (TREE_TYPE (exp
));
236 /* Peel off cv qualifiers. */
237 type
= TYPE_MAIN_VARIANT (type
);
239 if (CLASS_TYPE_P (type
))
240 type
= complete_type_or_else (type
, exp
);
243 return error_mark_node
;
245 /* If exp is a reference to polymorphic type, get the real type_info. */
246 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
248 /* build reference to type_info from vtable. */
251 /* The RTTI information is at index -1. */
252 index
= build_int_cst (NULL_TREE
,
253 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
);
254 t
= build_vtbl_ref (exp
, index
);
255 t
= convert (type_info_ptr_type
, t
);
258 /* Otherwise return the type_info for the static type of the expr. */
259 t
= get_tinfo_ptr (TYPE_MAIN_VARIANT (type
));
261 return build_indirect_ref (t
, NULL
);
267 tree pseudo_type_info
, type_info_type
;
271 error ("cannot use typeid with -fno-rtti");
275 if (!COMPLETE_TYPE_P (const_type_info_type_node
))
277 error ("must #include <typeinfo> before using typeid");
282 = VEC_index (tinfo_s
, tinfo_descs
, TK_TYPE_INFO_TYPE
)->type
;
283 type_info_type
= TYPE_MAIN_VARIANT (const_type_info_type_node
);
285 /* Make sure abi::__type_info_pseudo has the same alias set
286 as std::type_info. */
287 if (! TYPE_ALIAS_SET_KNOWN_P (pseudo_type_info
))
288 TYPE_ALIAS_SET (pseudo_type_info
) = get_alias_set (type_info_type
);
290 gcc_assert (TYPE_ALIAS_SET (pseudo_type_info
)
291 == get_alias_set (type_info_type
));
296 /* Return an expression for "typeid(EXP)". The expression returned is
297 an lvalue of type "const std::type_info". */
300 build_typeid (tree exp
)
302 tree cond
= NULL_TREE
;
305 if (exp
== error_mark_node
|| !typeid_ok_p ())
306 return error_mark_node
;
308 if (processing_template_decl
)
309 return build_min (TYPEID_EXPR
, const_type_info_type_node
, exp
);
311 if (TREE_CODE (exp
) == INDIRECT_REF
312 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
313 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
314 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
317 exp
= stabilize_reference (exp
);
318 cond
= cp_convert (boolean_type_node
, TREE_OPERAND (exp
, 0));
321 exp
= get_tinfo_decl_dynamic (exp
);
323 if (exp
== error_mark_node
)
324 return error_mark_node
;
328 tree bad
= throw_bad_typeid ();
330 exp
= build3 (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
336 /* Generate the NTBS name of a type. */
338 tinfo_name (tree type
)
343 name
= mangle_type_string (type
);
344 name_string
= fix_string_type (build_string (strlen (name
) + 1, name
));
348 /* Return a VAR_DECL for the internal ABI defined type_info object for
349 TYPE. You must arrange that the decl is mark_used, if actually use
350 it --- decls in vtables are only used if the vtable is output. */
353 get_tinfo_decl (tree type
)
358 if (variably_modified_type_p (type
, /*fn=*/NULL_TREE
))
360 error ("cannot create type information for type %qT because "
361 "it involves types of variable size",
363 return error_mark_node
;
366 if (TREE_CODE (type
) == METHOD_TYPE
)
367 type
= build_function_type (TREE_TYPE (type
),
368 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
370 /* For a class type, the variable is cached in the type node
372 if (CLASS_TYPE_P (type
))
374 d
= CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
));
379 name
= mangle_typeinfo_for_type (type
);
381 d
= IDENTIFIER_GLOBAL_VALUE (name
);
384 int ix
= get_pseudo_ti_index (type
);
385 tinfo_s
*ti
= VEC_index (tinfo_s
, tinfo_descs
, ix
);
387 d
= build_lang_decl (VAR_DECL
, name
, ti
->type
);
388 SET_DECL_ASSEMBLER_NAME (d
, name
);
389 /* Remember the type it is for. */
390 TREE_TYPE (name
) = type
;
391 DECL_TINFO_P (d
) = 1;
392 DECL_ARTIFICIAL (d
) = 1;
393 DECL_IGNORED_P (d
) = 1;
394 TREE_READONLY (d
) = 1;
396 /* Mark the variable as undefined -- but remember that we can
397 define it later if we need to do so. */
398 DECL_EXTERNAL (d
) = 1;
399 DECL_NOT_REALLY_EXTERN (d
) = 1;
400 set_linkage_according_to_type (type
, d
);
402 d
= pushdecl_top_level_and_finish (d
, NULL_TREE
);
403 if (CLASS_TYPE_P (type
))
404 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type
)) = d
;
406 /* Add decl to the global array of tinfo decls. */
407 VEC_safe_push (tree
, gc
, unemitted_tinfo_decls
, d
);
413 /* Return a pointer to a type_info object describing TYPE, suitably
414 cast to the language defined type. */
417 get_tinfo_ptr (tree type
)
419 tree decl
= get_tinfo_decl (type
);
422 return build_nop (type_info_ptr_type
,
423 build_address (decl
));
426 /* Return the type_info object for TYPE. */
429 get_typeid (tree type
)
431 if (type
== error_mark_node
|| !typeid_ok_p ())
432 return error_mark_node
;
434 if (processing_template_decl
)
435 return build_min (TYPEID_EXPR
, const_type_info_type_node
, type
);
437 /* If the type of the type-id is a reference type, the result of the
438 typeid expression refers to a type_info object representing the
440 type
= non_reference (type
);
442 /* The top-level cv-qualifiers of the lvalue expression or the type-id
443 that is the operand of typeid are always ignored. */
444 type
= TYPE_MAIN_VARIANT (type
);
446 if (CLASS_TYPE_P (type
))
447 type
= complete_type_or_else (type
, NULL_TREE
);
450 return error_mark_node
;
452 return build_indirect_ref (get_tinfo_ptr (type
), NULL
);
455 /* Check whether TEST is null before returning RESULT. If TEST is used in
456 RESULT, it must have previously had a save_expr applied to it. */
459 ifnonnull (tree test
, tree result
)
461 return build3 (COND_EXPR
, TREE_TYPE (result
),
462 build2 (EQ_EXPR
, boolean_type_node
, test
,
463 cp_convert (TREE_TYPE (test
), integer_zero_node
)),
464 cp_convert (TREE_TYPE (result
), integer_zero_node
),
468 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
472 build_dynamic_cast_1 (tree type
, tree expr
)
474 enum tree_code tc
= TREE_CODE (type
);
475 tree exprtype
= TREE_TYPE (expr
);
477 tree old_expr
= expr
;
478 const char *errstr
= NULL
;
480 /* Save casted types in the function's used types hash table. */
481 used_types_insert (type
);
483 /* T shall be a pointer or reference to a complete class type, or
484 `pointer to cv void''. */
488 if (TREE_CODE (TREE_TYPE (type
)) == VOID_TYPE
)
492 if (! IS_AGGR_TYPE (TREE_TYPE (type
)))
494 errstr
= "target is not pointer or reference to class";
497 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
499 errstr
= "target is not pointer or reference to complete type";
505 errstr
= "target is not pointer or reference";
509 if (tc
== POINTER_TYPE
)
511 /* If T is a pointer type, v shall be an rvalue of a pointer to
512 complete class type, and the result is an rvalue of type T. */
514 if (TREE_CODE (exprtype
) != POINTER_TYPE
)
516 errstr
= "source is not a pointer";
519 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype
)))
521 errstr
= "source is not a pointer to class";
524 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
526 errstr
= "source is a pointer to incomplete type";
532 exprtype
= build_reference_type (exprtype
);
534 /* T is a reference type, v shall be an lvalue of a complete class
535 type, and the result is an lvalue of the type referred to by T. */
537 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype
)))
539 errstr
= "source is not of class type";
542 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype
))))
544 errstr
= "source is of incomplete class type";
548 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
549 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
550 LOOKUP_NORMAL
, NULL_TREE
);
553 /* The dynamic_cast operator shall not cast away constness. */
554 if (!at_least_as_qualified_p (TREE_TYPE (type
),
555 TREE_TYPE (exprtype
)))
557 errstr
= "conversion casts away constness";
561 /* If *type is an unambiguous accessible base class of *exprtype,
562 convert statically. */
566 binfo
= lookup_base (TREE_TYPE (exprtype
), TREE_TYPE (type
),
571 expr
= build_base_path (PLUS_EXPR
, convert_from_reference (expr
),
573 if (TREE_CODE (exprtype
) == POINTER_TYPE
)
574 expr
= rvalue (expr
);
579 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
580 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
583 /* if TYPE is `void *', return pointer to complete object. */
584 if (tc
== POINTER_TYPE
&& VOID_TYPE_P (TREE_TYPE (type
)))
586 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
587 if (TREE_CODE (expr
) == ADDR_EXPR
588 && TREE_CODE (TREE_OPERAND (expr
, 0)) == VAR_DECL
589 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
590 return build1 (NOP_EXPR
, type
, expr
);
592 /* Since expr is used twice below, save it. */
593 expr
= save_expr (expr
);
595 expr1
= build_headof (expr
);
596 if (TREE_TYPE (expr1
) != type
)
597 expr1
= build1 (NOP_EXPR
, type
, expr1
);
598 return ifnonnull (expr
, expr1
);
603 tree result
, td2
, td3
;
605 tree static_type
, target_type
, boff
;
607 /* If we got here, we can't convert statically. Therefore,
608 dynamic_cast<D&>(b) (b an object) cannot succeed. */
609 if (tc
== REFERENCE_TYPE
)
611 if (TREE_CODE (old_expr
) == VAR_DECL
612 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
614 tree expr
= throw_bad_cast ();
615 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
617 /* Bash it to the expected type. */
618 TREE_TYPE (expr
) = type
;
622 /* Ditto for dynamic_cast<D*>(&b). */
623 else if (TREE_CODE (expr
) == ADDR_EXPR
)
625 tree op
= TREE_OPERAND (expr
, 0);
626 if (TREE_CODE (op
) == VAR_DECL
627 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
629 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
631 retval
= build_int_cst (type
, 0);
636 /* Use of dynamic_cast when -fno-rtti is prohibited. */
639 error ("%<dynamic_cast%> not permitted with -fno-rtti");
640 return error_mark_node
;
643 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
644 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
645 td2
= get_tinfo_decl (target_type
);
647 td2
= build_unary_op (ADDR_EXPR
, td2
, 0);
648 td3
= get_tinfo_decl (static_type
);
650 td3
= build_unary_op (ADDR_EXPR
, td3
, 0);
652 /* Determine how T and V are related. */
653 boff
= dcast_base_hint (static_type
, target_type
);
655 /* Since expr is used twice below, save it. */
656 expr
= save_expr (expr
);
659 if (tc
== REFERENCE_TYPE
)
660 expr1
= build_unary_op (ADDR_EXPR
, expr1
, 0);
667 dcast_fn
= dynamic_cast_node
;
675 push_nested_namespace (ns
);
676 tinfo_ptr
= xref_tag (class_type
,
677 get_identifier ("__class_type_info"),
678 /*tag_scope=*/ts_current
, false);
680 tinfo_ptr
= build_pointer_type
681 (build_qualified_type
682 (tinfo_ptr
, TYPE_QUAL_CONST
));
683 name
= "__dynamic_cast";
685 (NULL_TREE
, const_ptr_type_node
, tree_cons
686 (NULL_TREE
, tinfo_ptr
, tree_cons
687 (NULL_TREE
, tinfo_ptr
, tree_cons
688 (NULL_TREE
, ptrdiff_type_node
, void_list_node
))));
689 tmp
= build_function_type (ptr_type_node
, tmp
);
690 dcast_fn
= build_library_fn_ptr (name
, tmp
);
691 DECL_IS_PURE (dcast_fn
) = 1;
692 pop_nested_namespace (ns
);
693 dynamic_cast_node
= dcast_fn
;
695 result
= build_cxx_call (dcast_fn
, 4, elems
);
697 if (tc
== REFERENCE_TYPE
)
699 tree bad
= throw_bad_cast ();
702 result
= save_expr (result
);
703 neq
= c_common_truthvalue_conversion (result
);
704 return build3 (COND_EXPR
, type
, neq
, result
, bad
);
707 /* Now back to the type we want from a void*. */
708 result
= cp_convert (type
, result
);
709 return ifnonnull (expr
, result
);
713 errstr
= "source type is not polymorphic";
716 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
717 expr
, exprtype
, type
, errstr
);
718 return error_mark_node
;
722 build_dynamic_cast (tree type
, tree expr
)
724 if (type
== error_mark_node
|| expr
== error_mark_node
)
725 return error_mark_node
;
727 if (processing_template_decl
)
729 expr
= build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
730 TREE_SIDE_EFFECTS (expr
) = 1;
731 return convert_from_reference (expr
);
734 return convert_from_reference (build_dynamic_cast_1 (type
, expr
));
737 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
740 qualifier_flags (tree type
)
743 int quals
= cp_type_quals (type
);
745 if (quals
& TYPE_QUAL_CONST
)
747 if (quals
& TYPE_QUAL_VOLATILE
)
749 if (quals
& TYPE_QUAL_RESTRICT
)
754 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
755 contains a pointer to member of an incomplete class. */
758 target_incomplete_p (tree type
)
761 if (TYPE_PTRMEM_P (type
))
763 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)))
765 type
= TYPE_PTRMEM_POINTED_TO_TYPE (type
);
767 else if (TREE_CODE (type
) == POINTER_TYPE
)
768 type
= TREE_TYPE (type
);
770 return !COMPLETE_OR_VOID_TYPE_P (type
);
773 /* Returns true if TYPE involves an incomplete class type; in that
774 case, typeinfo variables for TYPE should be emitted with internal
778 involves_incomplete_p (tree type
)
780 switch (TREE_CODE (type
))
783 return target_incomplete_p (TREE_TYPE (type
));
788 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type
))
789 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type
)));
792 if (TYPE_PTRMEMFUNC_P (type
))
796 if (!COMPLETE_TYPE_P (type
))
800 /* All other types do not involve incomplete class types. */
805 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
806 is the vtable pointer and NTBS name. The NTBS name is emitted as a
807 comdat const char array, so it becomes a unique key for the type. Generate
808 and emit that VAR_DECL here. (We can't always emit the type_info itself
809 as comdat, because of pointers to incomplete.) */
812 tinfo_base_init (tinfo_s
*ti
, tree target
)
814 tree init
= NULL_TREE
;
821 /* Generate the NTBS array variable. */
822 tree name_type
= build_cplus_array_type
823 (build_qualified_type (char_type_node
, TYPE_QUAL_CONST
),
825 tree name_string
= tinfo_name (target
);
827 /* Determine the name of the variable -- and remember with which
828 type it is associated. */
829 name_name
= mangle_typeinfo_string_for_type (target
);
830 TREE_TYPE (name_name
) = target
;
832 name_decl
= build_lang_decl (VAR_DECL
, name_name
, name_type
);
833 SET_DECL_ASSEMBLER_NAME (name_decl
, name_name
);
834 DECL_ARTIFICIAL (name_decl
) = 1;
835 DECL_IGNORED_P (name_decl
) = 1;
836 TREE_READONLY (name_decl
) = 1;
837 TREE_STATIC (name_decl
) = 1;
838 DECL_EXTERNAL (name_decl
) = 0;
839 DECL_TINFO_P (name_decl
) = 1;
840 set_linkage_according_to_type (target
, name_decl
);
841 import_export_decl (name_decl
);
842 DECL_INITIAL (name_decl
) = name_string
;
843 mark_used (name_decl
);
844 pushdecl_top_level_and_finish (name_decl
, name_string
);
847 vtable_ptr
= ti
->vtable
;
851 push_nested_namespace (abi_node
);
852 real_type
= xref_tag (class_type
, ti
->name
,
853 /*tag_scope=*/ts_current
, false);
854 pop_nested_namespace (abi_node
);
856 if (!COMPLETE_TYPE_P (real_type
))
858 /* We never saw a definition of this type, so we need to
859 tell the compiler that this is an exported class, as
860 indeed all of the __*_type_info classes are. */
861 SET_CLASSTYPE_INTERFACE_KNOWN (real_type
);
862 CLASSTYPE_INTERFACE_ONLY (real_type
) = 1;
865 vtable_ptr
= get_vtable_decl (real_type
, /*complete=*/1);
866 vtable_ptr
= build_unary_op (ADDR_EXPR
, vtable_ptr
, 0);
868 /* We need to point into the middle of the vtable. */
870 (POINTER_PLUS_EXPR
, TREE_TYPE (vtable_ptr
), vtable_ptr
,
871 size_binop (MULT_EXPR
,
872 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE
),
873 TYPE_SIZE_UNIT (vtable_entry_type
)));
875 ti
->vtable
= vtable_ptr
;
878 init
= tree_cons (NULL_TREE
, vtable_ptr
, init
);
880 init
= tree_cons (NULL_TREE
, decay_conversion (name_decl
), init
);
882 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
883 TREE_CONSTANT (init
) = 1;
884 TREE_INVARIANT (init
) = 1;
885 TREE_STATIC (init
) = 1;
886 init
= tree_cons (NULL_TREE
, init
, NULL_TREE
);
891 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
892 information about the particular type_info derivation, which adds no
893 additional fields to the type_info base. */
896 generic_initializer (tinfo_s
*ti
, tree target
)
898 tree init
= tinfo_base_init (ti
, target
);
900 init
= build_constructor_from_list (NULL_TREE
, init
);
901 TREE_CONSTANT (init
) = 1;
902 TREE_INVARIANT (init
) = 1;
903 TREE_STATIC (init
) = 1;
907 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
908 TI provides information about the particular type_info derivation,
909 which adds target type and qualifier flags members to the type_info base. */
912 ptr_initializer (tinfo_s
*ti
, tree target
)
914 tree init
= tinfo_base_init (ti
, target
);
915 tree to
= TREE_TYPE (target
);
916 int flags
= qualifier_flags (to
);
917 bool incomplete
= target_incomplete_p (to
);
921 init
= tree_cons (NULL_TREE
, build_int_cst (NULL_TREE
, flags
), init
);
922 init
= tree_cons (NULL_TREE
,
923 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)),
926 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
927 TREE_CONSTANT (init
) = 1;
928 TREE_INVARIANT (init
) = 1;
929 TREE_STATIC (init
) = 1;
933 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
934 TI provides information about the particular type_info derivation,
935 which adds class, target type and qualifier flags members to the type_info
939 ptm_initializer (tinfo_s
*ti
, tree target
)
941 tree init
= tinfo_base_init (ti
, target
);
942 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
943 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
944 int flags
= qualifier_flags (to
);
945 bool incomplete
= target_incomplete_p (to
);
949 if (!COMPLETE_TYPE_P (klass
))
951 init
= tree_cons (NULL_TREE
, build_int_cst (NULL_TREE
, flags
), init
);
952 init
= tree_cons (NULL_TREE
,
953 get_tinfo_ptr (TYPE_MAIN_VARIANT (to
)),
955 init
= tree_cons (NULL_TREE
,
956 get_tinfo_ptr (klass
),
959 init
= build_constructor_from_list (NULL_TREE
, nreverse (init
));
960 TREE_CONSTANT (init
) = 1;
961 TREE_INVARIANT (init
) = 1;
962 TREE_STATIC (init
) = 1;
966 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
967 TI provides information about the particular __class_type_info derivation,
968 which adds hint flags and TRAIL initializers to the type_info base. */
971 class_initializer (tinfo_s
*ti
, tree target
, tree trail
)
973 tree init
= tinfo_base_init (ti
, target
);
975 TREE_CHAIN (init
) = trail
;
976 init
= build_constructor_from_list (NULL_TREE
, init
);
977 TREE_CONSTANT (init
) = 1;
978 TREE_INVARIANT (init
) = 1;
979 TREE_STATIC (init
) = 1;
983 /* Returns true if the typeinfo for type should be placed in
984 the runtime library. */
987 typeinfo_in_lib_p (tree type
)
989 /* The typeinfo objects for `T*' and `const T*' are in the runtime
990 library for simple types T. */
991 if (TREE_CODE (type
) == POINTER_TYPE
992 && (cp_type_quals (TREE_TYPE (type
)) == TYPE_QUAL_CONST
993 || cp_type_quals (TREE_TYPE (type
)) == TYPE_UNQUALIFIED
))
994 type
= TREE_TYPE (type
);
996 switch (TREE_CODE (type
))
1009 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
1010 the index of the descriptor in the tinfo_desc vector. */
1013 get_pseudo_ti_init (tree type
, unsigned tk_index
)
1015 tinfo_s
*ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1017 gcc_assert (at_eof
);
1020 case TK_POINTER_MEMBER_TYPE
:
1021 return ptm_initializer (ti
, type
);
1023 case TK_POINTER_TYPE
:
1024 return ptr_initializer (ti
, type
);
1026 case TK_BUILTIN_TYPE
:
1027 case TK_ENUMERAL_TYPE
:
1028 case TK_FUNCTION_TYPE
:
1030 return generic_initializer (ti
, type
);
1033 return class_initializer (ti
, type
, NULL_TREE
);
1035 case TK_SI_CLASS_TYPE
:
1037 tree base_binfo
= BINFO_BASE_BINFO (TYPE_BINFO (type
), 0);
1038 tree tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1039 tree base_inits
= tree_cons (NULL_TREE
, tinfo
, NULL_TREE
);
1041 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1042 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1043 return class_initializer (ti
, type
, base_inits
);
1048 int hint
= ((CLASSTYPE_REPEATED_BASE_P (type
) << 0)
1049 | (CLASSTYPE_DIAMOND_SHAPED_P (type
) << 1));
1050 tree binfo
= TYPE_BINFO (type
);
1051 int nbases
= BINFO_N_BASE_BINFOS (binfo
);
1052 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1053 tree offset_type
= integer_types
[itk_long
];
1054 tree base_inits
= NULL_TREE
;
1057 gcc_assert (tk_index
>= TK_FIXED
);
1059 /* Generate the base information initializer. */
1060 for (ix
= nbases
; ix
--;)
1062 tree base_binfo
= BINFO_BASE_BINFO (binfo
, ix
);
1063 tree base_init
= NULL_TREE
;
1068 if (VEC_index (tree
, base_accesses
, ix
) == access_public_node
)
1070 tinfo
= get_tinfo_ptr (BINFO_TYPE (base_binfo
));
1071 if (BINFO_VIRTUAL_P (base_binfo
))
1073 /* We store the vtable offset at which the virtual
1074 base offset can be found. */
1075 offset
= BINFO_VPTR_FIELD (base_binfo
);
1079 offset
= BINFO_OFFSET (base_binfo
);
1081 /* Combine offset and flags into one field. */
1082 offset
= fold_convert (offset_type
, offset
);
1083 offset
= fold_build2 (LSHIFT_EXPR
, offset_type
, offset
,
1084 build_int_cst (offset_type
, 8));
1085 offset
= fold_build2 (BIT_IOR_EXPR
, offset_type
, offset
,
1086 build_int_cst (offset_type
, flags
));
1087 base_init
= tree_cons (NULL_TREE
, offset
, base_init
);
1088 base_init
= tree_cons (NULL_TREE
, tinfo
, base_init
);
1089 base_init
= build_constructor_from_list (NULL_TREE
, base_init
);
1090 base_inits
= tree_cons (NULL_TREE
, base_init
, base_inits
);
1092 base_inits
= build_constructor_from_list (NULL_TREE
, base_inits
);
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_cst (NULL_TREE
, nbases
),
1098 /* Prepend the hint flags. */
1099 base_inits
= tree_cons (NULL_TREE
,
1100 build_int_cst (NULL_TREE
, hint
),
1103 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1104 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk_index
);
1105 return class_initializer (ti
, type
, base_inits
);
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 (int tk
, const char *real_name
, ...)
1135 va_start (ap
, real_name
);
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", tk
- TK_FIXED
);
1144 /* First field is the pseudo type_info base class. */
1145 fields
= build_decl (FIELD_DECL
, NULL_TREE
,
1146 VEC_index (tinfo_s
, tinfo_descs
,
1147 TK_TYPE_INFO_TYPE
)->type
);
1149 /* Now add the derived fields. */
1150 while ((field_decl
= va_arg (ap
, tree
)))
1152 TREE_CHAIN (field_decl
) = fields
;
1153 fields
= field_decl
;
1156 /* Create the pseudo type. */
1157 pseudo_type
= make_aggr_type (RECORD_TYPE
);
1158 finish_builtin_struct (pseudo_type
, pseudo_name
, fields
, NULL_TREE
);
1159 CLASSTYPE_AS_BASE (pseudo_type
) = pseudo_type
;
1161 ti
= VEC_index (tinfo_s
, tinfo_descs
, tk
);
1162 ti
->type
= cp_build_qualified_type (pseudo_type
, TYPE_QUAL_CONST
);
1163 ti
->name
= get_identifier (real_name
);
1164 ti
->vtable
= NULL_TREE
;
1166 /* Pretend this is public so determine_visibility doesn't give vtables
1167 internal linkage. */
1168 TREE_PUBLIC (TYPE_MAIN_DECL (ti
->type
)) = 1;
1173 /* Return the index of a pseudo type info type node used to describe
1174 TYPE. TYPE must be a complete type (or cv void), except at the end
1175 of the translation unit. */
1178 get_pseudo_ti_index (tree type
)
1182 switch (TREE_CODE (type
))
1185 ix
= TK_POINTER_MEMBER_TYPE
;
1189 ix
= TK_POINTER_TYPE
;
1193 ix
= TK_ENUMERAL_TYPE
;
1197 ix
= TK_FUNCTION_TYPE
;
1206 if (TYPE_PTRMEMFUNC_P (type
))
1208 ix
= TK_POINTER_MEMBER_TYPE
;
1211 else if (!COMPLETE_TYPE_P (type
))
1214 cxx_incomplete_type_error (NULL_TREE
, type
);
1218 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)))
1225 tree binfo
= TYPE_BINFO (type
);
1226 VEC(tree
,gc
) *base_accesses
= BINFO_BASE_ACCESSES (binfo
);
1227 tree base_binfo
= BINFO_BASE_BINFO (binfo
, 0);
1228 int num_bases
= BINFO_N_BASE_BINFOS (binfo
);
1231 && VEC_index (tree
, base_accesses
, 0) == access_public_node
1232 && !BINFO_VIRTUAL_P (base_binfo
)
1233 && integer_zerop (BINFO_OFFSET (base_binfo
)))
1235 /* single non-virtual public. */
1236 ix
= TK_SI_CLASS_TYPE
;
1242 tree array_domain
, base_array
;
1244 ix
= TK_FIXED
+ num_bases
;
1245 if (VEC_length (tinfo_s
, tinfo_descs
) <= ix
)
1247 /* too short, extend. */
1248 unsigned len
= VEC_length (tinfo_s
, tinfo_descs
);
1250 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, ix
+ 1);
1251 while (VEC_iterate (tinfo_s
, tinfo_descs
, len
++, ti
))
1252 ti
->type
= ti
->vtable
= ti
->name
= NULL_TREE
;
1254 else if (VEC_index (tinfo_s
, tinfo_descs
, ix
)->type
)
1255 /* already created. */
1258 /* Create the array of __base_class_type_info entries.
1259 G++ 3.2 allocated an array that had one too many
1260 entries, and then filled that extra entries with
1262 if (abi_version_at_least (2))
1263 array_domain
= build_index_type (size_int (num_bases
- 1));
1265 array_domain
= build_index_type (size_int (num_bases
));
1267 build_array_type (VEC_index (tinfo_s
, tinfo_descs
,
1268 TK_BASE_TYPE
)->type
,
1271 push_nested_namespace (abi_node
);
1272 create_pseudo_type_info
1273 (ix
, "__vmi_class_type_info",
1274 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1275 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1276 build_decl (FIELD_DECL
, NULL_TREE
, base_array
),
1278 pop_nested_namespace (abi_node
);
1283 ix
= TK_BUILTIN_TYPE
;
1289 /* Make sure the required builtin types exist for generating the type_info
1290 variable definitions. */
1293 create_tinfo_types (void)
1297 gcc_assert (!tinfo_descs
);
1299 VEC_safe_grow (tinfo_s
, gc
, tinfo_descs
, TK_FIXED
);
1301 push_nested_namespace (abi_node
);
1303 /* Create the internal type_info structure. This is used as a base for
1304 the other structures. */
1308 field
= build_decl (FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1311 field
= build_decl (FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1312 TREE_CHAIN (field
) = fields
;
1315 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_TYPE_INFO_TYPE
);
1316 ti
->type
= make_aggr_type (RECORD_TYPE
);
1317 ti
->vtable
= NULL_TREE
;
1318 ti
->name
= NULL_TREE
;
1319 finish_builtin_struct (ti
->type
, "__type_info_pseudo",
1323 /* Fundamental type_info */
1324 create_pseudo_type_info (TK_BUILTIN_TYPE
, "__fundamental_type_info", NULL
);
1326 /* Array, function and enum type_info. No additional fields. */
1327 create_pseudo_type_info (TK_ARRAY_TYPE
, "__array_type_info", NULL
);
1328 create_pseudo_type_info (TK_FUNCTION_TYPE
, "__function_type_info", NULL
);
1329 create_pseudo_type_info (TK_ENUMERAL_TYPE
, "__enum_type_info", NULL
);
1331 /* Class type_info. No additional fields. */
1332 create_pseudo_type_info (TK_CLASS_TYPE
, "__class_type_info", NULL
);
1334 /* Single public non-virtual base class. Add pointer to base class.
1335 This is really a descendant of __class_type_info. */
1336 create_pseudo_type_info (TK_SI_CLASS_TYPE
, "__si_class_type_info",
1337 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1340 /* Base class internal helper. Pointer to base type, offset to base,
1345 field
= build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
);
1348 field
= build_decl (FIELD_DECL
, NULL_TREE
, integer_types
[itk_long
]);
1349 TREE_CHAIN (field
) = fields
;
1352 ti
= VEC_index (tinfo_s
, tinfo_descs
, TK_BASE_TYPE
);
1354 ti
->type
= make_aggr_type (RECORD_TYPE
);
1355 ti
->vtable
= NULL_TREE
;
1356 ti
->name
= NULL_TREE
;
1357 finish_builtin_struct (ti
->type
, "__base_class_type_info_pseudo",
1361 /* Pointer type_info. Adds two fields, qualification mask
1362 and pointer to the pointed to type. This is really a descendant of
1363 __pbase_type_info. */
1364 create_pseudo_type_info (TK_POINTER_TYPE
, "__pointer_type_info",
1365 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1366 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1369 /* Pointer to member data type_info. Add qualifications flags,
1370 pointer to the member's type info and pointer to the class.
1371 This is really a descendant of __pbase_type_info. */
1372 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE
,
1373 "__pointer_to_member_type_info",
1374 build_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1375 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1376 build_decl (FIELD_DECL
, NULL_TREE
, type_info_ptr_type
),
1379 pop_nested_namespace (abi_node
);
1382 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1383 support. Generating them here guarantees consistency with the other
1384 structures. We use the following heuristic to determine when the runtime
1385 is being generated. If std::__fundamental_type_info is defined, and its
1386 destructor is defined, then the runtime is being built. */
1389 emit_support_tinfos (void)
1391 static tree
*const fundamentals
[] =
1396 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1397 &short_integer_type_node
, &short_unsigned_type_node
,
1398 &integer_type_node
, &unsigned_type_node
,
1399 &long_integer_type_node
, &long_unsigned_type_node
,
1400 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1401 &float_type_node
, &double_type_node
, &long_double_type_node
,
1405 tree bltn_type
, dtor
;
1407 push_nested_namespace (abi_node
);
1408 bltn_type
= xref_tag (class_type
,
1409 get_identifier ("__fundamental_type_info"),
1410 /*tag_scope=*/ts_current
, false);
1411 pop_nested_namespace (abi_node
);
1412 if (!COMPLETE_TYPE_P (bltn_type
))
1414 dtor
= CLASSTYPE_DESTRUCTORS (bltn_type
);
1415 if (!dtor
|| DECL_EXTERNAL (dtor
))
1418 for (ix
= 0; fundamentals
[ix
]; ix
++)
1420 tree bltn
= *fundamentals
[ix
];
1425 types
[1] = build_pointer_type (bltn
);
1426 types
[2] = build_pointer_type (build_qualified_type (bltn
,
1429 for (i
= 0; i
< 3; ++i
)
1433 tinfo
= get_tinfo_decl (types
[i
]);
1434 TREE_USED (tinfo
) = 1;
1435 mark_needed (tinfo
);
1436 /* The C++ ABI requires that these objects be COMDAT. But,
1437 On systems without weak symbols, initialized COMDAT
1438 objects are emitted with internal linkage. (See
1439 comdat_linkage for details.) Since we want these objects
1440 to have external linkage so that copies do not have to be
1441 emitted in code outside the runtime library, we make them
1444 It might also not be necessary to follow this detail of the
1446 if (!flag_weak
|| ! targetm
.cxx
.library_rtti_comdat ())
1448 gcc_assert (TREE_PUBLIC (tinfo
) && !DECL_COMDAT (tinfo
));
1449 DECL_INTERFACE_KNOWN (tinfo
) = 1;
1455 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1456 tinfo decl. Determine whether it needs emitting, and if so
1457 generate the initializer. */
1460 emit_tinfo_decl (tree decl
)
1462 tree type
= TREE_TYPE (DECL_NAME (decl
));
1463 int in_library
= typeinfo_in_lib_p (type
);
1465 gcc_assert (DECL_TINFO_P (decl
));
1470 DECL_EXTERNAL (decl
) = 0;
1473 /* If we're not in the runtime, then DECL (which is already
1474 DECL_EXTERNAL) will not be defined here. */
1475 DECL_INTERFACE_KNOWN (decl
) = 1;
1479 else if (involves_incomplete_p (type
))
1481 if (!decl_needed_p (decl
))
1483 /* If TYPE involves an incomplete class type, then the typeinfo
1484 object will be emitted with internal linkage. There is no
1485 way to know whether or not types are incomplete until the end
1486 of the compilation, so this determination must be deferred
1487 until this point. */
1488 TREE_PUBLIC (decl
) = 0;
1489 DECL_EXTERNAL (decl
) = 0;
1490 DECL_INTERFACE_KNOWN (decl
) = 1;
1493 import_export_decl (decl
);
1494 if (DECL_NOT_REALLY_EXTERN (decl
) && decl_needed_p (decl
))
1498 DECL_EXTERNAL (decl
) = 0;
1499 init
= get_pseudo_ti_init (type
, get_pseudo_ti_index (type
));
1500 DECL_INITIAL (decl
) = init
;
1502 finish_decl (decl
, init
, NULL_TREE
);
1509 #include "gt-cp-rtti.h"