1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
4 Mostly written by Jason Merrill (jason@cygnus.com).
6 This file is part of GNU CC.
8 GNU CC 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 GNU CC 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 GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
34 #define INT_TYPE_SIZE BITS_PER_WORD
37 /* Accessors for the type_info objects. We need to remember several things
38 about each of the type_info types. The global tree nodes such as
39 bltn_desc_type_node are TREE_LISTs, and these macros are used to access
40 the required information. */
41 /* The RECORD_TYPE of a type_info derived class. */
42 #define TINFO_PSEUDO_TYPE(NODE) TREE_TYPE (NODE)
43 /* The VAR_DECL of the vtable for the type_info derived class. */
44 #define TINFO_VTABLE_DECL(NODE) TREE_VALUE (NODE)
46 extern struct obstack permanent_obstack
;
48 static tree build_runtime_decl
PARAMS((const char *, tree
));
49 static tree build_headof_sub
PARAMS((tree
));
50 static tree build_headof
PARAMS((tree
));
51 static tree get_tinfo_var
PARAMS((tree
));
52 static tree ifnonnull
PARAMS((tree
, tree
));
53 static tree tinfo_name
PARAMS((tree
));
54 static tree get_base_offset
PARAMS((tree
, tree
));
55 static tree build_dynamic_cast_1
PARAMS((tree
, tree
));
56 static void expand_si_desc
PARAMS((tree
, tree
));
57 static void expand_class_desc
PARAMS((tree
, tree
));
58 static void expand_attr_desc
PARAMS((tree
, tree
));
59 static void expand_ptr_desc
PARAMS((tree
, tree
));
60 static void expand_generic_desc
PARAMS((tree
, tree
, const char *));
61 static tree throw_bad_cast
PARAMS((void));
62 static tree throw_bad_typeid
PARAMS((void));
63 static tree get_tinfo_decl_dynamic
PARAMS((tree
));
64 static tree tinfo_from_decl
PARAMS((tree
));
65 static int qualifier_flags
PARAMS((tree
));
66 static tree tinfo_base_init
PARAMS((tree
, tree
));
67 static tree generic_initializer
PARAMS((tree
, tree
));
68 static tree ptr_ref_initializer
PARAMS((tree
, tree
));
69 static tree ptmd_initializer
PARAMS((tree
, tree
));
70 static int class_hint_flags
PARAMS((tree
));
71 static tree class_initializer
PARAMS((tree
, tree
, tree
));
72 static tree synthesize_tinfo_var
PARAMS((tree
, tree
));
73 static tree create_real_tinfo_var
PARAMS((tree
, tree
, tree
));
74 static tree create_pseudo_type_info
PARAMS((const char *, int, ...));
75 static tree get_vmi_pseudo_type_info
PARAMS((int));
76 static void create_tinfo_types
PARAMS((void));
78 static int doing_runtime
= 0;
81 init_rtti_processing ()
84 push_namespace (get_identifier ("std"));
85 type_info_type_node
= xref_tag
86 (class_type_node
, get_identifier ("type_info"), 1);
89 if (!new_abi_rtti_p ())
91 tinfo_decl_id
= get_identifier ("__tf");
92 tinfo_decl_type
= build_function_type
95 (type_info_type_node
, TYPE_QUAL_CONST
)),
100 tinfo_decl_id
= get_identifier ("__ti");
101 tinfo_decl_type
= build_qualified_type
102 (type_info_type_node
, TYPE_QUAL_CONST
);
104 tinfo_var_id
= get_identifier ("__ti");
107 /* Given a pointer to an object with at least one virtual table
108 pointer somewhere, return a pointer to a possible sub-object that
109 has a virtual table pointer in it that is the vtable parent for
113 build_headof_sub (exp
)
116 tree type
= TREE_TYPE (TREE_TYPE (exp
));
117 tree basetype
= CLASSTYPE_RTTI (type
);
118 tree binfo
= get_binfo (basetype
, type
, 0);
120 exp
= convert_pointer_to_real (binfo
, exp
);
124 /* Given the expression EXP of type `class *', return the head of the
125 object pointed to by EXP with type cv void*, if the class has any
126 virtual functions (TYPE_POLYMORPHIC_P), else just return the
133 tree type
= TREE_TYPE (exp
);
137 my_friendly_assert (TREE_CODE (type
) == POINTER_TYPE
, 20000112);
138 type
= TREE_TYPE (type
);
140 if (!TYPE_POLYMORPHIC_P (type
))
142 if (CLASSTYPE_COM_INTERFACE (type
))
144 cp_error ("RTTI not supported for COM interface type `%T'", type
);
145 return error_mark_node
;
148 /* If we don't have rtti stuff, get to a sub-object that does. */
149 if (!CLASSTYPE_VFIELDS (TREE_TYPE (TREE_TYPE (exp
))))
150 exp
= build_headof_sub (exp
);
152 /* We use this a couple of times below, protect it. */
153 exp
= save_expr (exp
);
155 aref
= build_vtbl_ref (build_indirect_ref (exp
, NULL_PTR
), integer_zero_node
);
157 if (flag_vtable_thunks
)
160 offset
= build_component_ref (aref
, delta_identifier
, NULL_TREE
, 0);
162 type
= build_qualified_type (ptr_type_node
,
163 CP_TYPE_QUALS (TREE_TYPE (exp
)));
164 return build (PLUS_EXPR
, type
, exp
,
165 cp_convert (ptrdiff_type_node
, offset
));
168 /* Build a decl to a runtime entry point taking void and returning TYPE.
169 Although the entry point may never return, making its return type
170 consistent is necessary. */
173 build_runtime_decl (name
, type
)
177 tree d
= get_identifier (name
);
179 if (IDENTIFIER_GLOBAL_VALUE (d
))
180 d
= IDENTIFIER_GLOBAL_VALUE (d
);
183 type
= build_function_type (type
, void_list_node
);
184 d
= build_lang_decl (FUNCTION_DECL
, d
, type
);
185 DECL_EXTERNAL (d
) = 1;
187 DECL_ARTIFICIAL (d
) = 1;
188 pushdecl_top_level (d
);
189 make_function_rtl (d
);
196 /* Get a bad_cast node for the program to throw...
198 See libstdc++/exception.cc for __throw_bad_cast */
203 if (!throw_bad_cast_node
)
204 throw_bad_cast_node
= build_runtime_decl
205 ("__throw_bad_cast", ptr_type_node
);
207 return build_call (throw_bad_cast_node
,
208 TREE_TYPE (TREE_TYPE (throw_bad_cast_node
)),
215 if (!throw_bad_typeid_node
)
216 throw_bad_typeid_node
= build_runtime_decl
217 ("__throw_bad_typeid",
219 (build_qualified_type
220 (type_info_type_node
, TYPE_QUAL_CONST
)));
222 return build_call (throw_bad_typeid_node
,
223 TREE_TYPE (TREE_TYPE (throw_bad_typeid_node
)),
227 /* Return a pointer to type_info function associated with the expression EXP.
228 If EXP is a reference to a polymorphic class, return the dynamic type;
229 otherwise return the static type of the expression. */
232 get_tinfo_decl_dynamic (exp
)
237 if (exp
== error_mark_node
)
238 return error_mark_node
;
240 type
= TREE_TYPE (exp
);
242 /* peel back references, so they match. */
243 if (TREE_CODE (type
) == REFERENCE_TYPE
)
244 type
= TREE_TYPE (type
);
246 /* Peel off cv qualifiers. */
247 type
= TYPE_MAIN_VARIANT (type
);
249 if (type
!= void_type_node
)
250 type
= complete_type_or_else (type
, exp
);
253 return error_mark_node
;
255 /* If exp is a reference to polymorphic type, get the real type_info. */
256 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
258 /* build reference to type_info from vtable. */
262 error ("taking dynamic typeid of object with -fno-rtti");
263 if (CLASSTYPE_COM_INTERFACE (type
))
265 cp_error ("RTTI not supported for COM interface type `%T'", type
);
266 return error_mark_node
;
269 /* If we don't have rtti stuff, get to a sub-object that does. */
270 if (! CLASSTYPE_VFIELDS (type
))
272 exp
= build_unary_op (ADDR_EXPR
, exp
, 0);
273 exp
= build_headof_sub (exp
);
274 exp
= build_indirect_ref (exp
, NULL_PTR
);
277 if (flag_vtable_thunks
)
278 t
= build_vfn_ref ((tree
*) 0, exp
, integer_one_node
);
280 t
= build_vfn_ref ((tree
*) 0, exp
, integer_zero_node
);
281 TREE_TYPE (t
) = build_pointer_type (tinfo_decl_type
);
285 /* otherwise return the type_info for the static type of the expr. */
286 exp
= get_tinfo_decl (TYPE_MAIN_VARIANT (type
));
287 return build_unary_op (ADDR_EXPR
, exp
, 0);
294 tree cond
= NULL_TREE
;
299 error ("cannot use typeid with -fno-rtti");
300 return error_mark_node
;
303 if (TYPE_SIZE (type_info_type_node
) == NULL_TREE
)
305 error ("must #include <typeinfo> before using typeid");
306 return error_mark_node
;
309 if (processing_template_decl
)
310 return build_min_nt (TYPEID_EXPR
, exp
);
312 if (TREE_CODE (exp
) == INDIRECT_REF
313 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
314 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
315 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
318 exp
= stabilize_reference (exp
);
319 cond
= cp_convert (boolean_type_node
, TREE_OPERAND (exp
, 0));
322 exp
= get_tinfo_decl_dynamic (exp
);
324 if (exp
== error_mark_node
)
325 return error_mark_node
;
327 exp
= tinfo_from_decl (exp
);
331 tree bad
= throw_bad_typeid ();
333 exp
= build (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
336 return convert_from_reference (exp
);
343 tree tname
= build_overload_with_type (tinfo_var_id
, type
);
347 my_friendly_assert (!new_abi_rtti_p (), 20000118);
348 if (IDENTIFIER_GLOBAL_VALUE (tname
))
349 return IDENTIFIER_GLOBAL_VALUE (tname
);
351 /* Figure out how much space we need to allocate for the type_info object.
352 If our struct layout or the type_info classes are changed, this will
353 need to be modified. */
354 if (TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
355 size
= 3 * POINTER_SIZE
+ INT_TYPE_SIZE
;
356 else if (TREE_CODE (type
) == POINTER_TYPE
357 && ! (TREE_CODE (TREE_TYPE (type
)) == OFFSET_TYPE
358 || TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
))
359 size
= 3 * POINTER_SIZE
;
360 else if (IS_AGGR_TYPE (type
))
362 if (CLASSTYPE_N_BASECLASSES (type
) == 0)
363 size
= 2 * POINTER_SIZE
;
364 else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type
)
366 (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type
), 0))))
367 size
= 3 * POINTER_SIZE
;
369 size
= 3 * POINTER_SIZE
+ TYPE_PRECISION (sizetype
);
372 size
= 2 * POINTER_SIZE
;
374 /* The type for a character array of the appropriate size. */
375 arrtype
= build_cplus_array_type
376 (unsigned_char_type_node
,
377 build_index_type (size_int (size
/ BITS_PER_UNIT
- 1)));
379 return declare_global_var (tname
, arrtype
);
382 /* Generate the NTBS name of a type. */
387 const char *name
= build_overload_name (type
, 1, 1);
388 tree name_string
= combine_strings (build_string (strlen (name
) + 1, name
));
392 /* Returns a decl for a function or variable which can be used to obtain a
393 type_info object for TYPE. The old-abi uses functions, the new-abi
394 uses the type_info object directly. You can take the address of the
395 returned decl, to save the decl. To use the decl call
396 tinfo_from_decl. You must arrange that the decl is mark_used, if
397 actually use it --- decls in vtables are only used if the vtable is
401 get_tinfo_decl (type
)
407 if (TREE_CODE (type
) == OFFSET_TYPE
)
408 type
= TREE_TYPE (type
);
409 if (TREE_CODE (type
) == METHOD_TYPE
)
410 type
= build_function_type (TREE_TYPE (type
),
411 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
413 name
= build_overload_with_type (tinfo_decl_id
, type
);
415 d
= IDENTIFIER_GLOBAL_VALUE (name
);
418 else if (!new_abi_rtti_p ())
420 /* The tinfo decl is a function returning a reference to the type_info
422 d
= build_lang_decl (FUNCTION_DECL
, name
, tinfo_decl_type
);
423 DECL_EXTERNAL (d
) = 1;
425 DECL_ARTIFICIAL (d
) = 1;
426 DECL_NOT_REALLY_EXTERN (d
) = 1;
427 SET_DECL_TINFO_FN_P (d
);
428 TREE_TYPE (name
) = type
;
430 pushdecl_top_level (d
);
431 make_function_rtl (d
);
432 mark_inline_for_output (d
);
436 /* The tinfo decl is the type_info object itself. We make all
437 tinfo objects look as type_info, even though they will end up
438 being a subclass of that when emitted. This means the we'll
439 erroneously think we know the dynamic type -- be careful in the
441 d
= build_lang_decl (VAR_DECL
, name
, tinfo_decl_type
);
443 DECL_ARTIFICIAL (d
) = 1;
444 DECL_ALIGN (d
) = TYPE_ALIGN (ptr_type_node
);
445 TREE_READONLY (d
) = 1;
447 DECL_EXTERNAL (d
) = 1;
449 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
450 cp_finish_decl (d
, NULL_TREE
, NULL_TREE
, 0);
452 pushdecl_top_level (d
);
453 /* Remember the type it is for. */
454 TREE_TYPE (name
) = type
;
459 /* Given an expr produced by get_tinfo_decl, return an expr which
460 produces a reference to the type_info object. */
463 tinfo_from_decl (expr
)
468 if (!new_abi_rtti_p ())
469 t
= build_call (expr
, TREE_TYPE (tinfo_decl_type
), NULL_TREE
);
470 else if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
471 t
= build_indirect_ref (expr
, NULL
);
484 t
= get_tinfo_decl (type
);
485 t
= tinfo_from_decl (t
);
486 return convert_from_reference (t
);
489 /* Return the type_info object for TYPE. */
495 if (type
== error_mark_node
)
496 return error_mark_node
;
498 if (TYPE_SIZE (type_info_type_node
) == NULL_TREE
)
500 error ("must #include <typeinfo> before using typeid");
501 return error_mark_node
;
504 if (processing_template_decl
)
505 return build_min_nt (TYPEID_EXPR
, type
);
507 /* If the type of the type-id is a reference type, the result of the
508 typeid expression refers to a type_info object representing the
510 if (TREE_CODE (type
) == REFERENCE_TYPE
)
511 type
= TREE_TYPE (type
);
513 /* The top-level cv-qualifiers of the lvalue expression or the type-id
514 that is the operand of typeid are always ignored. */
515 type
= TYPE_MAIN_VARIANT (type
);
517 if (type
!= void_type_node
)
518 type
= complete_type_or_else (type
, NULL_TREE
);
521 return error_mark_node
;
523 return get_typeid_1 (type
);
526 /* Check whether TEST is null before returning RESULT. If TEST is used in
527 RESULT, it must have previously had a save_expr applied to it. */
530 ifnonnull (test
, result
)
533 return build (COND_EXPR
, TREE_TYPE (result
),
534 build (EQ_EXPR
, boolean_type_node
, test
, integer_zero_node
),
535 cp_convert (TREE_TYPE (result
), integer_zero_node
),
539 /* Generate the constant expression describing where direct base BINFO
540 appears within the PARENT. How to interpret this expression depends on
541 details of the ABI, which the runtime must be aware of. */
544 get_base_offset (binfo
, parent
)
550 if (!TREE_VIA_VIRTUAL (binfo
))
551 offset
= BINFO_OFFSET (binfo
);
552 else if (!vbase_offsets_in_vtable_p ())
554 tree t
= BINFO_TYPE (binfo
);
558 FORMAT_VBASE_NAME (name
, t
);
559 field
= lookup_field (parent
, get_identifier (name
), 0, 0);
560 offset
= size_binop (FLOOR_DIV_EXPR
,
561 DECL_FIELD_BITPOS (field
),
562 bitsize_int (BITS_PER_UNIT
));
563 offset
= convert (sizetype
, offset
);
567 /* Under the new ABI, we store the vtable offset at which
568 the virtual base offset can be found. */
569 tree vbase
= BINFO_FOR_VBASE (BINFO_TYPE (binfo
), parent
);
570 offset
= convert (sizetype
, BINFO_VPTR_FIELD (vbase
));
575 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
579 build_dynamic_cast_1 (type
, expr
)
582 enum tree_code tc
= TREE_CODE (type
);
586 tree old_expr
= expr
;
588 if (TREE_CODE (expr
) == OFFSET_REF
)
589 expr
= resolve_offset_ref (expr
);
591 exprtype
= TREE_TYPE (expr
);
592 assert (exprtype
!= NULL_TREE
);
593 ec
= TREE_CODE (exprtype
);
598 if (ec
== REFERENCE_TYPE
)
600 expr
= convert_from_reference (expr
);
601 exprtype
= TREE_TYPE (expr
);
602 ec
= TREE_CODE (exprtype
);
604 if (ec
!= POINTER_TYPE
)
606 if (TREE_CODE (TREE_TYPE (exprtype
)) != RECORD_TYPE
)
608 if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype
))) == NULL_TREE
)
610 if (!at_least_as_qualified_p (TREE_TYPE (type
),
611 TREE_TYPE (exprtype
)))
613 if (TYPE_MAIN_VARIANT (TREE_TYPE (type
)) == void_type_node
)
615 /* else fall through */
617 if (TREE_CODE (TREE_TYPE (type
)) != RECORD_TYPE
)
619 if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
622 /* else fall through */
627 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
628 if (ec
== RECORD_TYPE
)
630 exprtype
= build_reference_type (exprtype
);
631 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
632 LOOKUP_NORMAL
, NULL_TREE
);
636 if (tc
== REFERENCE_TYPE
)
638 if (ec
!= REFERENCE_TYPE
)
640 if (TREE_CODE (TREE_TYPE (exprtype
)) != RECORD_TYPE
)
642 if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype
))) == NULL_TREE
)
644 if (!at_least_as_qualified_p (TREE_TYPE (type
),
645 TREE_TYPE (exprtype
)))
649 /* If *type is an unambiguous accessible base class of *exprtype,
650 convert statically. */
655 distance
= get_base_distance (TREE_TYPE (type
), TREE_TYPE (exprtype
), 1,
660 cp_error ("dynamic_cast from `%T' to ambiguous base class `%T'",
661 TREE_TYPE (exprtype
), TREE_TYPE (type
));
662 return error_mark_node
;
666 cp_error ("dynamic_cast from `%T' to private base class `%T'",
667 TREE_TYPE (exprtype
), TREE_TYPE (type
));
668 return error_mark_node
;
672 return build_vbase_path (PLUS_EXPR
, type
, expr
, path
, 0);
675 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
676 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
679 /* if TYPE is `void *', return pointer to complete object. */
680 if (tc
== POINTER_TYPE
681 && TYPE_MAIN_VARIANT (TREE_TYPE (type
)) == void_type_node
)
683 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
684 if (TREE_CODE (expr
) == ADDR_EXPR
685 && TREE_CODE (TREE_OPERAND (expr
, 0)) == VAR_DECL
686 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
687 return build1 (NOP_EXPR
, type
, expr
);
689 /* Since expr is used twice below, save it. */
690 expr
= save_expr (expr
);
692 expr1
= build_headof (expr
);
693 if (TREE_TYPE (expr1
) != type
)
694 expr1
= build1 (NOP_EXPR
, type
, expr1
);
695 return ifnonnull (expr
, expr1
);
700 tree result
, td2
, td3
, elems
;
701 tree static_type
, target_type
, boff
;
703 /* If we got here, we can't convert statically. Therefore,
704 dynamic_cast<D&>(b) (b an object) cannot succeed. */
705 if (ec
== REFERENCE_TYPE
)
707 if (TREE_CODE (old_expr
) == VAR_DECL
708 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
710 tree expr
= throw_bad_cast ();
711 cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
713 /* Bash it to the expected type. */
714 TREE_TYPE (expr
) = type
;
718 /* Ditto for dynamic_cast<D*>(&b). */
719 else if (TREE_CODE (expr
) == ADDR_EXPR
)
721 tree op
= TREE_OPERAND (expr
, 0);
722 if (TREE_CODE (op
) == VAR_DECL
723 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
725 cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
727 retval
= build_int_2 (0, 0);
728 TREE_TYPE (retval
) = type
;
733 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
734 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
735 td2
= build_unary_op (ADDR_EXPR
, get_tinfo_decl (target_type
), 0);
736 td3
= build_unary_op (ADDR_EXPR
, get_tinfo_decl (static_type
), 0);
738 /* Determine how T and V are related. */
739 boff
= get_dynamic_cast_base_type (static_type
, target_type
);
741 /* Since expr is used twice below, save it. */
742 expr
= save_expr (expr
);
745 if (tc
== REFERENCE_TYPE
)
746 expr1
= build_unary_op (ADDR_EXPR
, expr1
, 0);
748 if (!new_abi_rtti_p ())
750 tree expr2
= build_headof (expr1
);
753 if (ec
== POINTER_TYPE
)
754 td1
= build_indirect_ref (td1
, NULL_PTR
);
755 td1
= get_tinfo_decl_dynamic (td1
);
758 (NULL_TREE
, td1
, tree_cons
759 (NULL_TREE
, td2
, tree_cons
760 (NULL_TREE
, boff
, tree_cons
761 (NULL_TREE
, expr2
, tree_cons
762 (NULL_TREE
, td3
, tree_cons
763 (NULL_TREE
, expr1
, NULL_TREE
))))));
767 (NULL_TREE
, expr1
, tree_cons
768 (NULL_TREE
, td3
, tree_cons
769 (NULL_TREE
, td2
, tree_cons
770 (NULL_TREE
, boff
, NULL_TREE
))));
772 dcast_fn
= dynamic_cast_node
;
777 tree ns
= global_namespace
;
780 push_nested_namespace (ns
);
781 if (!new_abi_rtti_p ())
783 tinfo_ptr
= build_pointer_type (tinfo_decl_type
);
784 name
= "__dynamic_cast_2";
786 (NULL_TREE
, tinfo_ptr
, tree_cons
787 (NULL_TREE
, tinfo_ptr
, tree_cons
788 (NULL_TREE
, integer_type_node
, tree_cons
789 (NULL_TREE
, ptr_type_node
, tree_cons
790 (NULL_TREE
, tinfo_ptr
, tree_cons
791 (NULL_TREE
, ptr_type_node
, void_list_node
))))));
797 push_namespace (get_identifier ("std"));
798 ns
= current_namespace
;
800 tinfo_ptr
= xref_tag (class_type_node
,
801 get_identifier ("__class_type_info"),
804 tinfo_ptr
= build_pointer_type
805 (build_qualified_type
806 (tinfo_ptr
, TYPE_QUAL_CONST
));
807 name
= "__dynamic_cast";
809 (NULL_TREE
, const_ptr_type_node
, tree_cons
810 (NULL_TREE
, tinfo_ptr
, tree_cons
811 (NULL_TREE
, tinfo_ptr
, tree_cons
812 (NULL_TREE
, ptrdiff_type_node
, void_list_node
))));
814 tmp
= build_function_type (ptr_type_node
, tmp
);
815 dcast_fn
= build_lang_decl (FUNCTION_DECL
,
816 get_identifier (name
),
818 DECL_EXTERNAL (dcast_fn
) = 1;
819 TREE_PUBLIC (dcast_fn
) = 1;
820 DECL_ARTIFICIAL (dcast_fn
) = 1;
822 if (new_abi_rtti_p ())
823 /* We want it's name mangling. */
824 set_mangled_name_for_decl (dcast_fn
);
825 make_function_rtl (dcast_fn
);
826 pop_nested_namespace (ns
);
827 dynamic_cast_node
= dcast_fn
;
829 mark_used (dcast_fn
);
831 (dcast_fn
, TREE_TYPE (TREE_TYPE (dcast_fn
)), elems
);
833 if (tc
== REFERENCE_TYPE
)
835 tree bad
= throw_bad_cast ();
837 result
= save_expr (result
);
838 return build (COND_EXPR
, type
, result
, result
, bad
);
841 /* Now back to the type we want from a void*. */
842 result
= cp_convert (type
, result
);
843 return ifnonnull (expr
, result
);
847 cp_error ("dynamic_cast from non-polymorphic type `%#T'", exprtype
);
848 return error_mark_node
;
851 cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T'",
852 expr
, exprtype
, type
);
853 return error_mark_node
;
857 build_dynamic_cast (type
, expr
)
860 if (type
== error_mark_node
|| expr
== error_mark_node
)
861 return error_mark_node
;
863 if (processing_template_decl
)
864 return build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
866 return convert_from_reference (build_dynamic_cast_1 (type
, expr
));
869 /* Build and initialize various sorts of descriptors. Every descriptor
870 node has a name associated with it (the name created by mangling).
871 For this reason, we use the identifier as our access to the __*_desc
872 nodes, instead of sticking them directly in the types. Otherwise we
873 would burden all built-in types (and pointer types) with slots that
874 we don't necessarily want to use.
876 For each descriptor we build, we build a variable that contains
877 the descriptor's information. When we need this info at runtime,
878 all we need is access to these variables.
880 Note: these constructors always return the address of the descriptor
881 info, since that is simplest for their mutual interaction. */
883 /* Build an initializer for a __si_type_info node. */
886 expand_si_desc (tdecl
, type
)
891 tree name_string
= tinfo_name (type
);
893 type
= BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type
), 0));
894 finish_expr_stmt (get_typeid_1 (type
));
895 t
= decay_conversion (get_tinfo_var (type
));
897 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
898 (NULL_TREE
, decay_conversion (name_string
), tree_cons
899 (NULL_TREE
, t
, NULL_TREE
)));
901 fn
= get_identifier ("__rtti_si");
902 if (IDENTIFIER_GLOBAL_VALUE (fn
))
903 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
908 (NULL_TREE
, ptr_type_node
, tree_cons
909 (NULL_TREE
, const_string_type_node
, tree_cons
910 (NULL_TREE
, build_pointer_type (type_info_type_node
),
912 tmp
= build_function_type (void_type_node
, tmp
);
914 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
915 DECL_EXTERNAL (fn
) = 1;
916 TREE_PUBLIC (fn
) = 1;
917 DECL_ARTIFICIAL (fn
) = 1;
918 pushdecl_top_level (fn
);
919 make_function_rtl (fn
);
923 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
924 finish_expr_stmt (fn
);
927 /* Build an initializer for a __class_type_info node. */
930 expand_class_desc (tdecl
, type
)
937 int i
= CLASSTYPE_N_BASECLASSES (type
);
939 tree binfos
= TYPE_BINFO_BASETYPES (type
);
941 /* See code below that used these. */
942 tree vb
= CLASSTYPE_VBASECLASSES (type
);
945 tree base
, elems
, access
, offset
, isvir
;
946 tree elt
, elts
= NULL_TREE
;
948 if (base_desc_type_node
== NULL_TREE
)
952 /* A reasonably close approximation of __class_type_info::base_info */
954 base_desc_type_node
= make_aggr_type (RECORD_TYPE
);
956 /* Actually const __user_type_info * */
957 fields
[0] = build_lang_decl
958 (FIELD_DECL
, NULL_TREE
,
959 build_pointer_type (build_qualified_type
960 (type_info_type_node
,
962 fields
[1] = build_lang_decl
963 (FIELD_DECL
, NULL_TREE
,
964 flag_new_abi
? intSI_type_node
: unsigned_intSI_type_node
);
965 DECL_BIT_FIELD (fields
[1]) = 1;
966 DECL_SIZE (fields
[1]) = bitsize_int (29);
968 fields
[2] = build_lang_decl (FIELD_DECL
, NULL_TREE
, boolean_type_node
);
969 DECL_BIT_FIELD (fields
[2]) = 1;
970 DECL_SIZE (fields
[2]) = bitsize_int (1);
972 /* Actually enum access */
973 fields
[3] = build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
);
974 DECL_BIT_FIELD (fields
[3]) = 1;
975 DECL_SIZE (fields
[3]) = bitsize_int (2);
977 finish_builtin_type (base_desc_type_node
, "__base_info", fields
,
983 tree binfo
= TREE_VEC_ELT (binfos
, i
);
985 finish_expr_stmt (get_typeid_1 (BINFO_TYPE (binfo
)));
986 base
= decay_conversion (get_tinfo_var (BINFO_TYPE (binfo
)));
987 offset
= get_base_offset (binfo
, type
);
989 if (TREE_VIA_PUBLIC (binfo
))
990 access
= access_public_node
;
991 else if (TREE_VIA_PROTECTED (binfo
))
992 access
= access_protected_node
;
994 access
= access_private_node
;
995 if (TREE_VIA_VIRTUAL (binfo
))
996 isvir
= boolean_true_node
;
998 isvir
= boolean_false_node
;
1001 (CONSTRUCTOR
, base_desc_type_node
, NULL_TREE
, tree_cons
1002 (NULL_TREE
, base
, tree_cons
1003 (NULL_TREE
, offset
, tree_cons
1004 (NULL_TREE
, isvir
, tree_cons
1005 (NULL_TREE
, access
, NULL_TREE
)))));
1006 TREE_HAS_CONSTRUCTOR (elt
) = TREE_CONSTANT (elt
) = TREE_STATIC (elt
) = 1;
1007 elts
= tree_cons (NULL_TREE
, elt
, elts
);
1015 access
= access_public_node
;
1018 b
= TREE_VEC_ELT (binfos
, i
);
1019 if (BINFO_TYPE (vb
) == BINFO_TYPE (b
) && TREE_VIA_VIRTUAL (b
))
1021 if (TREE_VIA_PUBLIC (b
))
1022 access
= access_public_node
;
1023 else if (TREE_VIA_PROTECTED (b
))
1024 access
= access_protected_node
;
1026 access
= access_private_node
;
1030 base
= build_t_desc (BINFO_TYPE (vb
), 1);
1031 offset
= BINFO_OFFSET (vb
);
1032 isvir
= build_int_2 (1, 0);
1034 base_list
= tree_cons (NULL_TREE
, base
, base_list
);
1035 isvir_list
= tree_cons (NULL_TREE
, isvir
, isvir_list
);
1036 acc_list
= tree_cons (NULL_TREE
, access
, acc_list
);
1037 off_list
= tree_cons (NULL_TREE
, offset
, off_list
);
1040 vb
= TREE_CHAIN (vb
);
1044 name_string
= tinfo_name (type
);
1047 tree arrtype
= build_array_type (base_desc_type_node
, NULL_TREE
);
1048 elts
= build (CONSTRUCTOR
, arrtype
, NULL_TREE
, elts
);
1049 TREE_HAS_CONSTRUCTOR (elts
) = TREE_CONSTANT (elts
)
1050 = TREE_STATIC (elts
) = 1;
1051 complete_array_type (arrtype
, elts
, 1);
1055 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
1056 (NULL_TREE
, decay_conversion (name_string
), tree_cons
1057 (NULL_TREE
, decay_conversion (elts
), tree_cons
1058 (NULL_TREE
, cp_convert (sizetype
, build_int_2 (base_cnt
, 0)),
1061 fn
= get_identifier ("__rtti_class");
1062 if (IDENTIFIER_GLOBAL_VALUE (fn
))
1063 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
1067 (NULL_TREE
, ptr_type_node
, tree_cons
1068 (NULL_TREE
, const_string_type_node
, tree_cons
1069 (NULL_TREE
, build_pointer_type (base_desc_type_node
), tree_cons
1070 (NULL_TREE
, sizetype
, void_list_node
))));
1071 tmp
= build_function_type (void_type_node
, tmp
);
1073 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
1074 DECL_EXTERNAL (fn
) = 1;
1075 TREE_PUBLIC (fn
) = 1;
1076 DECL_ARTIFICIAL (fn
) = 1;
1077 pushdecl_top_level (fn
);
1078 make_function_rtl (fn
);
1082 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
1083 finish_expr_stmt (fn
);
1086 /* Build an initializer for a __pointer_type_info node. */
1089 expand_ptr_desc (tdecl
, type
)
1094 tree name_string
= tinfo_name (type
);
1096 type
= TREE_TYPE (type
);
1097 finish_expr_stmt (get_typeid_1 (type
));
1098 t
= decay_conversion (get_tinfo_var (type
));
1100 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
1101 (NULL_TREE
, decay_conversion (name_string
), tree_cons
1102 (NULL_TREE
, t
, NULL_TREE
)));
1104 fn
= get_identifier ("__rtti_ptr");
1105 if (IDENTIFIER_GLOBAL_VALUE (fn
))
1106 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
1111 (NULL_TREE
, ptr_type_node
, tree_cons
1112 (NULL_TREE
, const_string_type_node
, tree_cons
1113 (NULL_TREE
, build_pointer_type (type_info_type_node
),
1115 tmp
= build_function_type (void_type_node
, tmp
);
1117 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
1118 DECL_EXTERNAL (fn
) = 1;
1119 TREE_PUBLIC (fn
) = 1;
1120 DECL_ARTIFICIAL (fn
) = 1;
1121 pushdecl_top_level (fn
);
1122 make_function_rtl (fn
);
1126 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
1127 finish_expr_stmt (fn
);
1130 /* Build an initializer for a __attr_type_info node. */
1133 expand_attr_desc (tdecl
, type
)
1138 tree name_string
= tinfo_name (type
);
1139 tree attrval
= build_int_2 (TYPE_QUALS (type
), 0);
1141 finish_expr_stmt (get_typeid_1 (TYPE_MAIN_VARIANT (type
)));
1142 t
= decay_conversion (get_tinfo_var (TYPE_MAIN_VARIANT (type
)));
1144 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
1145 (NULL_TREE
, decay_conversion (name_string
), tree_cons
1146 (NULL_TREE
, attrval
, tree_cons (NULL_TREE
, t
, NULL_TREE
))));
1148 fn
= get_identifier ("__rtti_attr");
1149 if (IDENTIFIER_GLOBAL_VALUE (fn
))
1150 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
1155 (NULL_TREE
, ptr_type_node
, tree_cons
1156 (NULL_TREE
, const_string_type_node
, tree_cons
1157 (NULL_TREE
, integer_type_node
, tree_cons
1158 (NULL_TREE
, build_pointer_type (type_info_type_node
),
1160 tmp
= build_function_type (void_type_node
, tmp
);
1162 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
1163 DECL_EXTERNAL (fn
) = 1;
1164 TREE_PUBLIC (fn
) = 1;
1165 DECL_ARTIFICIAL (fn
) = 1;
1166 pushdecl_top_level (fn
);
1167 make_function_rtl (fn
);
1171 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
1172 finish_expr_stmt (fn
);
1175 /* Build an initializer for a type_info node that just has a name. */
1178 expand_generic_desc (tdecl
, type
, fnname
)
1183 tree name_string
= tinfo_name (type
);
1184 tree elems
= tree_cons
1185 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
1186 (NULL_TREE
, decay_conversion (name_string
), NULL_TREE
));
1188 tree fn
= get_identifier (fnname
);
1189 if (IDENTIFIER_GLOBAL_VALUE (fn
))
1190 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
1195 (NULL_TREE
, ptr_type_node
, tree_cons
1196 (NULL_TREE
, const_string_type_node
, void_list_node
));
1197 tmp
= build_function_type (void_type_node
, tmp
);
1199 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
1200 DECL_EXTERNAL (fn
) = 1;
1201 TREE_PUBLIC (fn
) = 1;
1202 DECL_ARTIFICIAL (fn
) = 1;
1203 pushdecl_top_level (fn
);
1204 make_function_rtl (fn
);
1208 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
1209 finish_expr_stmt (fn
);
1212 /* Generate the code for a type_info initialization function.
1213 Note that we take advantage of the passage
1215 5.2.7 Type identification [expr.typeid]
1217 Whether or not the destructor is called for the type_info object at the
1218 end of the program is unspecified.
1220 and don't bother to arrange for these objects to be destroyed. It
1221 doesn't matter, anyway, since the destructors don't do anything.
1223 This must only be called from toplevel (i.e. from finish_file)! */
1226 synthesize_tinfo_fn (fndecl
)
1229 tree type
= TREE_TYPE (DECL_NAME (fndecl
));
1230 tree tmp
, addr
, tdecl
;
1235 my_friendly_assert (!new_abi_rtti_p (), 20000118);
1238 import_export_decl (fndecl
);
1239 if (DECL_REALLY_EXTERN (fndecl
))
1243 /* Declare the static typeinfo variable. */
1244 tdecl
= get_tinfo_var (type
);
1245 DECL_EXTERNAL (tdecl
) = 0;
1246 TREE_STATIC (tdecl
) = 1;
1247 DECL_COMMON (tdecl
) = 1;
1248 TREE_USED (tdecl
) = 1;
1249 DECL_ALIGN (tdecl
) = TYPE_ALIGN (ptr_type_node
);
1250 cp_finish_decl (tdecl
, NULL_TREE
, NULL_TREE
, 0);
1252 /* Begin processing the function. */
1253 start_function (NULL_TREE
, fndecl
, NULL_TREE
,
1254 SF_DEFAULT
| SF_PRE_PARSED
);
1255 DECL_DEFER_OUTPUT (fndecl
) = 1;
1256 store_parm_decls ();
1259 /* Begin the body of the function. */
1260 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
1262 /* For convenience, we save away the address of the static
1264 addr
= decay_conversion (tdecl
);
1266 /* If the first word of the array (the vtable) is non-zero, we've already
1267 initialized the object, so don't do it again. */
1268 if_stmt
= begin_if_stmt ();
1269 tmp
= cp_convert (build_pointer_type (ptr_type_node
), addr
);
1270 tmp
= build_indirect_ref (tmp
, 0);
1271 tmp
= build_binary_op (EQ_EXPR
, tmp
, integer_zero_node
);
1272 finish_if_stmt_cond (tmp
, if_stmt
);
1273 then_clause
= begin_compound_stmt (/*has_no_scope=*/0);
1275 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1276 expand_generic_desc (tdecl
, type
, "__rtti_func");
1277 else if (TREE_CODE (type
) == ARRAY_TYPE
)
1278 expand_generic_desc (tdecl
, type
, "__rtti_array");
1279 else if (TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
1280 expand_attr_desc (tdecl
, type
);
1281 else if (TREE_CODE (type
) == POINTER_TYPE
)
1283 if (TREE_CODE (TREE_TYPE (type
)) == OFFSET_TYPE
)
1284 expand_generic_desc (tdecl
, type
, "__rtti_ptmd");
1285 else if (TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
1286 expand_generic_desc (tdecl
, type
, "__rtti_ptmf");
1288 expand_ptr_desc (tdecl
, type
);
1290 else if (TYPE_PTRMEMFUNC_P (type
))
1291 expand_generic_desc (tdecl
, type
, "__rtti_ptmf");
1292 else if (IS_AGGR_TYPE (type
))
1294 if (CLASSTYPE_N_BASECLASSES (type
) == 0)
1295 expand_generic_desc (tdecl
, type
, "__rtti_user");
1296 else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type
)
1298 (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type
), 0))))
1299 expand_si_desc (tdecl
, type
);
1301 expand_class_desc (tdecl
, type
);
1303 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1304 expand_generic_desc (tdecl
, type
, "__rtti_user");
1306 my_friendly_abort (252);
1308 finish_compound_stmt (/*has_no_scope=*/0, then_clause
);
1309 finish_then_clause (if_stmt
);
1312 /* OK, now return the type_info object. */
1313 tmp
= cp_convert (build_pointer_type (type_info_type_node
), addr
);
1314 tmp
= build_indirect_ref (tmp
, 0);
1315 finish_return_stmt (tmp
);
1316 /* Finish the function body. */
1317 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
1318 expand_body (finish_function (lineno
, 0));
1321 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
1324 qualifier_flags (type
)
1328 /* we want the qualifiers on this type, not any array core, it might have */
1329 int quals
= TYPE_QUALS (type
);
1331 if (quals
& TYPE_QUAL_CONST
)
1333 if (quals
& TYPE_QUAL_VOLATILE
)
1338 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
1339 is the vtable pointer and NTBS name. */
1342 tinfo_base_init (desc
, target
)
1346 tree name_string
= tinfo_name (target
);
1347 tree init
= NULL_TREE
;
1349 if (TINFO_VTABLE_DECL (desc
))
1351 tree vtbl_ptr
= build_unary_op (ADDR_EXPR
, TINFO_VTABLE_DECL (desc
), 0);
1353 init
= tree_cons (NULL_TREE
, vtbl_ptr
, init
);
1356 init
= tree_cons (NULL_TREE
, decay_conversion (name_string
), init
);
1358 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, nreverse(init
));
1359 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1360 init
= tree_cons (NULL_TREE
, init
, NULL_TREE
);
1365 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
1366 information about the particular type_info derivation, which adds no
1367 additional fields to the type_info base. */
1370 generic_initializer (desc
, target
)
1374 tree init
= tinfo_base_init (desc
, target
);
1376 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, init
);
1377 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1381 /* Return the CONSTRUCTOR expr for a type_info of pointer or reference TYPE.
1382 DESC provides information about the particular type_info derivation,
1383 which adds target type and qualifier flags members to the type_info base. */
1386 ptr_ref_initializer (desc
, target
)
1390 tree init
= tinfo_base_init (desc
, target
);
1391 tree to
= TREE_TYPE (target
);
1392 int flags
= qualifier_flags (to
);
1394 init
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), init
);
1395 init
= tree_cons (NULL_TREE
,
1396 build_unary_op (ADDR_EXPR
,
1397 get_tinfo_decl (TYPE_MAIN_VARIANT (to
)), 0),
1400 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, nreverse (init
));
1401 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1405 /* Return the CONSTRUCTOR expr for a type_info of pointer or reference TYPE.
1406 DESC provides information about the particular type_info derivation,
1407 which adds target type and qualifier flags members to the type_info base. */
1410 ptmd_initializer (desc
, target
)
1414 tree init
= tinfo_base_init (desc
, target
);
1415 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
1416 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
1417 int flags
= qualifier_flags (to
);
1419 init
= tree_cons (NULL_TREE
,
1420 build_unary_op (ADDR_EXPR
, get_tinfo_decl (klass
), 0),
1422 init
= tree_cons (NULL_TREE
,
1423 build_unary_op (ADDR_EXPR
,
1424 get_tinfo_decl (TYPE_MAIN_VARIANT (to
)), 0),
1426 init
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), init
);
1428 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, nreverse (init
));
1429 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1433 /* Determine the hint flags describing the features of a class's heirarchy.
1434 FIXME: better set the hint_flags here! For now set them
1435 to safe 'don't know' values. The specification is under
1436 review. Don't forget to check the runtime dynamic_cast and
1437 catch machinery if these change. */
1440 class_hint_flags (type
)
1444 hint_flags
|= 0x1; /* contains multiply inherited sub object */
1445 hint_flags
|= 0x4; /* has virtual bases */
1446 hint_flags
|= 0x8; /* has private base */
1447 if (TYPE_POLYMORPHIC_P (type
))
1453 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1454 DESC provides information about the particular __class_type_info derivation,
1455 which adds hint flags and TRAIL initializers to the type_info base. */
1458 class_initializer (desc
, target
, trail
)
1463 tree init
= tinfo_base_init (desc
, target
);
1464 int flags
= class_hint_flags (target
);
1466 trail
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), trail
);
1467 TREE_CHAIN (init
) = trail
;
1468 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, init
);
1469 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1473 /* Generate a pseudo_type_info VAR_DECL suitable for the supplied
1474 TARGET_TYPE and given the REAL_NAME. This is the structure expected by
1475 the runtime, and therefore has additional fields. If we need not emit a
1476 definition (because the runtime must contain it), return NULL_TREE,
1477 otherwise return the VAR_DECL. */
1480 synthesize_tinfo_var (target_type
, real_name
)
1484 tree var_init
= NULL_TREE
;
1485 tree var_type
= NULL_TREE
;
1487 my_friendly_assert (new_abi_rtti_p (), 20000118);
1489 switch (TREE_CODE (target_type
))
1492 if (TYPE_PTRMEM_P (target_type
))
1494 var_type
= ptmd_desc_type_node
;
1495 var_init
= ptmd_initializer (var_type
, target_type
);
1499 int code
= TREE_CODE (TREE_TYPE (target_type
));
1501 if ((CP_TYPE_QUALS (TREE_TYPE (target_type
)) | TYPE_QUAL_CONST
)
1503 && (code
== INTEGER_TYPE
|| code
== BOOLEAN_TYPE
1504 || code
== CHAR_TYPE
|| code
== REAL_TYPE
1505 || code
== VOID_TYPE
)
1507 /* These are in the runtime. */
1509 var_type
= ptr_desc_type_node
;
1510 var_init
= ptr_ref_initializer (var_type
, target_type
);
1513 case REFERENCE_TYPE
:
1514 var_type
= ref_desc_type_node
;
1515 var_init
= ptr_ref_initializer (var_type
, target_type
);
1518 var_type
= enum_desc_type_node
;
1519 var_init
= generic_initializer (var_type
, target_type
);
1522 var_type
= func_desc_type_node
;
1523 var_init
= generic_initializer (var_type
, target_type
);
1526 var_type
= ary_desc_type_node
;
1527 var_init
= generic_initializer (var_type
, target_type
);
1531 if (!TYPE_SIZE (target_type
))
1533 /* FIXME: incomplete type. Awaiting specification. */
1536 else if (!CLASSTYPE_N_BASECLASSES (target_type
))
1538 var_type
= class_desc_type_node
;
1539 var_init
= class_initializer (var_type
, target_type
, NULL_TREE
);
1543 /* if this has a single public non-virtual base, it's easier */
1544 tree binfo
= TYPE_BINFO (target_type
);
1545 int nbases
= BINFO_N_BASETYPES (binfo
);
1546 tree base_binfos
= BINFO_BASETYPES (binfo
);
1547 tree base_inits
= NULL_TREE
;
1548 int is_simple
= nbases
== 1;
1551 /* Generate the base information initializer. */
1552 for (ix
= nbases
; ix
--;)
1554 tree base_binfo
= TREE_VEC_ELT (base_binfos
, ix
);
1555 tree base_init
= NULL_TREE
;
1560 if (TREE_VIA_VIRTUAL (base_binfo
))
1562 if (TREE_PUBLIC (base_binfo
))
1564 tinfo
= get_tinfo_decl (BINFO_TYPE (base_binfo
));
1565 tinfo
= build_unary_op (ADDR_EXPR
, tinfo
, 0);
1566 offset
= get_base_offset (base_binfo
, target_type
);
1568 /* is it a single public inheritance? */
1569 if (is_simple
&& flags
== 2 && integer_zerop (offset
))
1571 base_inits
= tree_cons (NULL_TREE
, tinfo
, NULL_TREE
);
1576 base_init
= tree_cons
1577 (NULL_TREE
, build_int_2 (flags
, 0), base_init
);
1578 base_init
= tree_cons (NULL_TREE
, offset
, base_init
);
1579 base_init
= tree_cons (NULL_TREE
, tinfo
, base_init
);
1580 base_init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, base_init
);
1581 base_inits
= tree_cons (NULL_TREE
, base_init
, base_inits
);
1585 var_type
= si_class_desc_type_node
;
1588 /* Prepend the number of bases. */
1589 base_inits
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, base_inits
);
1590 base_inits
= tree_cons (NULL_TREE
, base_inits
, NULL_TREE
);
1591 base_inits
= tree_cons (NULL_TREE
,
1592 build_int_2 (nbases
, 0), base_inits
);
1594 var_type
= get_vmi_pseudo_type_info (nbases
);
1596 var_init
= class_initializer (var_type
, target_type
, base_inits
);
1605 /* These are guaranteed to be in the runtime. */
1607 var_type
= bltn_desc_type_node
;
1608 var_init
= generic_initializer (var_type
, target_type
);
1611 my_friendly_abort (20000117);
1614 return create_real_tinfo_var (real_name
, TINFO_PSEUDO_TYPE (var_type
), var_init
);
1617 /* Create the real typeinfo variable. */
1620 create_real_tinfo_var (name
, type
, init
)
1627 decl
= build_lang_decl (VAR_DECL
, name
,
1628 build_qualified_type (type
, TYPE_QUAL_CONST
));
1629 DECL_ARTIFICIAL (decl
) = 1;
1630 TREE_READONLY (decl
) = 1;
1631 TREE_STATIC (decl
) = 1;
1632 TREE_PUBLIC (decl
) = 1;
1633 DECL_EXTERNAL (decl
) = 0;
1635 comdat_linkage (decl
);
1636 DECL_ASSEMBLER_NAME (decl
) = name
;
1637 DECL_INITIAL (decl
) = init
;
1638 cp_finish_decl (decl
, init
, NULL_TREE
, 0);
1643 /* Generate the RECORD_TYPE containing the data layout of a type_info
1644 derivative as used by the runtime. This layout must be consistent with
1645 that defined in the runtime support. Also generate the VAR_DECL for the
1646 type's vtable. We explicitly manage the vtable member, and name it for
1647 real type as used in the runtime. The RECORD type has a different name,
1648 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1649 is the generated type and TINFO_VTABLE_DECL is the vtable decl.
1651 REAL_NAME is the runtime's name of the type. Trailing arguments are
1652 additional FIELD_DECL's for the structure. The final argument must be
1656 create_pseudo_type_info
VPARAMS((const char *real_name
, int ident
, ...))
1658 #ifndef ANSI_PROTOTYPES
1659 char const *real_name
;
1663 tree real_type
, pseudo_type
;
1671 VA_START (ap
, ident
);
1672 #ifndef ANSI_PROTOTYPES
1673 real_name
= va_arg (ap
, char const *);
1674 ident
= va_arg (app
, int);
1677 /* Generate the pseudo type name. */
1678 pseudo_name
= (char *)alloca (strlen (real_name
) + 30);
1679 strcpy (pseudo_name
, real_name
);
1680 strcat (pseudo_name
, "_pseudo");
1682 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", ident
);
1684 /* Get the vtable decl. */
1685 real_type
= xref_tag (class_type_node
, get_identifier (real_name
), 1);
1686 vtable_decl
= get_vtable_decl (real_type
, /*complete=*/1);
1688 /* First field is the pseudo type_info base class. */
1689 fields
[0] = build_lang_decl (FIELD_DECL
, NULL_TREE
, ti_desc_type_node
);
1691 /* Now add the derived fields. */
1692 for (ix
= 0; (field_decl
= va_arg (ap
, tree
));)
1693 fields
[++ix
] = field_decl
;
1695 /* Create the pseudo type. */
1696 pseudo_type
= make_aggr_type (RECORD_TYPE
);
1697 finish_builtin_type (pseudo_type
, pseudo_name
, fields
, ix
, ptr_type_node
);
1698 TYPE_HAS_CONSTRUCTOR (pseudo_type
) = 1;
1701 result
= tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
);
1702 TINFO_VTABLE_DECL (result
) = vtable_decl
;
1703 TINFO_PSEUDO_TYPE (result
) = pseudo_type
;
1708 /* Return a descriptor for a vmi type with NUM_BASES bases. */
1711 get_vmi_pseudo_type_info (num_bases
)
1715 tree array_domain
, base_array
;
1717 if (TREE_VEC_LENGTH (vmi_class_desc_type_node
) <= num_bases
)
1720 tree extend
= make_tree_vec (num_bases
+ 5);
1722 for (ix
= TREE_VEC_LENGTH (vmi_class_desc_type_node
); ix
--;)
1723 TREE_VEC_ELT (extend
, ix
) = TREE_VEC_ELT (vmi_class_desc_type_node
, ix
);
1724 vmi_class_desc_type_node
= extend
;
1726 desc
= TREE_VEC_ELT (vmi_class_desc_type_node
, num_bases
);
1731 /* Add number of bases and trailing array of base_class_type_info. */
1732 array_domain
= build_index_type (build_int_2 (num_bases
, 0));
1733 base_array
= build_array_type (base_desc_type_node
, array_domain
);
1736 push_namespace (get_identifier ("std"));
1738 desc
= create_pseudo_type_info
1739 ("__vmi_class_type_info", num_bases
,
1740 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1741 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1742 build_lang_decl (FIELD_DECL
, NULL_TREE
, base_array
),
1748 TREE_VEC_ELT (vmi_class_desc_type_node
, num_bases
) = desc
;
1752 /* Make sure the required builtin types exist for generating the type_info
1753 varable definitions. */
1756 create_tinfo_types ()
1760 if (bltn_desc_type_node
)
1763 push_namespace (get_identifier ("std"));
1765 ptr_type_info
= build_pointer_type
1766 (build_qualified_type
1767 (type_info_type_node
, TYPE_QUAL_CONST
));
1769 /* Create the internal type_info structure. This is used as a base for
1770 the other structures. */
1774 ti_desc_type_node
= make_aggr_type (RECORD_TYPE
);
1775 fields
[0] = build_lang_decl (FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1776 fields
[1] = build_lang_decl (FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1777 finish_builtin_type (ti_desc_type_node
, "__type_info_pseudo",
1778 fields
, 1, ptr_type_node
);
1779 TYPE_HAS_CONSTRUCTOR (ti_desc_type_node
) = 1;
1782 /* Fundamental type_info */
1783 bltn_desc_type_node
= create_pseudo_type_info
1784 ("__fundamental_type_info", 0,
1787 /* Pointer and reference type_info. These two fields, qualification mask
1788 and pointer to the pointed to (referenced) type. */
1789 ptr_desc_type_node
= create_pseudo_type_info
1790 ("__pointer_type_info", 0,
1791 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1792 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1794 ref_desc_type_node
= create_pseudo_type_info
1795 ("__reference_type_info", 0,
1796 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1797 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1800 /* Array, function and enum type_info. No additional fields. */
1801 ary_desc_type_node
= create_pseudo_type_info
1802 ("__array_type_info", 0,
1804 func_desc_type_node
= create_pseudo_type_info
1805 ("__function_type_info", 0,
1807 enum_desc_type_node
= create_pseudo_type_info
1808 ("__enum_type_info", 0,
1811 /* Class type_info. Add a flags field. */
1812 class_desc_type_node
= create_pseudo_type_info
1813 ("__class_type_info", 0,
1814 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1817 /* Single public non-virtual base class. Add pointer to base class. */
1818 si_class_desc_type_node
= create_pseudo_type_info
1819 ("__si_class_type_info", 0,
1820 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1821 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1824 /* Base class internal helper. Pointer to base type, offset to base,
1829 fields
[0] = build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1830 fields
[1] = build_lang_decl (FIELD_DECL
, NULL_TREE
, ptrdiff_type_node
),
1831 fields
[2] = build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1832 base_desc_type_node
= make_aggr_type (RECORD_TYPE
);
1833 finish_builtin_type (base_desc_type_node
, "__base_class_type_info_pseudo",
1834 fields
, 2, ptr_type_node
);
1835 TYPE_HAS_CONSTRUCTOR (base_desc_type_node
) = 1;
1838 /* General heirarchy is created as necessary in this vector. */
1839 vmi_class_desc_type_node
= make_tree_vec (10);
1841 /* Pointer to member data type_info. Add pointer to the class, pointer
1842 to the member's type info and qualifications flags. */
1843 ptmd_desc_type_node
= create_pseudo_type_info
1844 ("__ptr_to_member_type_info", 0,
1845 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1846 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1847 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1854 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1855 support. Generating them here guarantees consistency with the other
1856 structures. We use the following heuristic to determine when the runtime
1857 is being generated. If std::__fundamental_type_info is defined, and it's
1858 destructor is defined, then the runtime is being built. */
1861 emit_support_tinfos ()
1863 static tree
*const fundamentals
[] =
1869 &signed_wchar_type_node
, &unsigned_wchar_type_node
,
1871 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1872 &short_integer_type_node
, &short_unsigned_type_node
,
1873 &integer_type_node
, &unsigned_type_node
,
1874 &long_integer_type_node
, &long_unsigned_type_node
,
1875 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1876 &float_type_node
, &double_type_node
, &long_double_type_node
,
1878 /* GCC extension types */
1880 &complex_integer_type_node
,
1881 &complex_float_type_node
, &complex_double_type_node
,
1882 &complex_long_double_type_node
,
1888 tree bltn_type
, dtor
;
1891 push_namespace (get_identifier ("std"));
1892 bltn_type
= xref_tag (class_type_node
,
1893 get_identifier ("__fundamental_type_info"), 1);
1896 if (!TYPE_SIZE (bltn_type
))
1898 dtor
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type
), 1);
1899 if (DECL_EXTERNAL (dtor
))
1902 for (ix
= 0; fundamentals
[ix
]; ix
++)
1904 tree bltn
= *fundamentals
[ix
];
1905 tree bltn_ptr
= build_pointer_type (bltn
);
1906 tree bltn_const_ptr
= build_pointer_type
1907 (build_qualified_type (bltn
, TYPE_QUAL_CONST
));
1910 tinfo
= get_tinfo_decl (bltn
);
1911 TREE_USED (tinfo
) = 1;
1912 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1914 tinfo
= get_tinfo_decl (bltn_ptr
);
1915 TREE_USED (tinfo
) = 1;
1916 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1918 tinfo
= get_tinfo_decl (bltn_const_ptr
);
1919 TREE_USED (tinfo
) = 1;
1920 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1924 /* Return non-zero, iff T is a type_info variable which has not had a
1925 definition emitted for it. */
1928 tinfo_decl_p (t
, data
)
1930 void *data ATTRIBUTE_UNUSED
;
1932 return TREE_CODE (t
) == VAR_DECL
1933 && IDENTIFIER_GLOBAL_VALUE (DECL_NAME (t
)) == (t
)
1934 && TREE_TYPE (t
) == tinfo_decl_type
1935 && TREE_TYPE (DECL_NAME (t
));
1938 /* Emit a suitable type_info definition for the type_info decl pointed to by
1939 DECL_PTR. We emit a completely new variable, of the correct type for the
1940 actual type this is describing. The DECL_ASSEMBLER_NAME of the generated
1941 definition is set to that of the supplied decl, so that they can be tied
1942 up. Mark the supplied decl as having been dealt with. Emitting one
1943 definitions might cause other declarations to be emitted.
1945 We need to do things this way, because we're trying to do something like
1951 extern const A tinfo_var;
1953 const B tinfo_var = {...};
1955 which is not permitted. Also, we've not necessarily seen the definition of B.
1956 So we do something like the following,
1958 extern const A tinfo_var;
1961 const void *vtable_ptr;
1969 const pseudo_B proxy_tinfo_var attribute((assembler_name="tinfo_var")) =
1971 {&B::vtable, "..."},
1975 pseudo_A and pseudo_B must be layout equivalent to the real definitions in
1979 emit_tinfo_decl (decl_ptr
, data
)
1981 void *data ATTRIBUTE_UNUSED
;
1983 tree tinfo_decl
= *decl_ptr
;
1984 tree tinfo_type
, decl
;
1986 my_friendly_assert (TREE_TYPE (tinfo_decl
) == tinfo_decl_type
, 20000121);
1987 tinfo_type
= TREE_TYPE (DECL_NAME (tinfo_decl
));
1988 my_friendly_assert (tinfo_type
!= NULL_TREE
, 20000120);
1990 /* Say we've dealt with it. */
1991 TREE_TYPE (DECL_NAME (tinfo_decl
)) = NULL_TREE
;
1993 if (!DECL_NEEDED_P (tinfo_decl
))
1995 create_tinfo_types ();
1996 decl
= synthesize_tinfo_var (tinfo_type
, DECL_ASSEMBLER_NAME (tinfo_decl
));