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 TREE_THIS_VOLATILE (d
) = 1;
189 pushdecl_top_level (d
);
190 make_function_rtl (d
);
197 /* Get a bad_cast node for the program to throw...
199 See libstdc++/exception.cc for __throw_bad_cast */
204 if (!throw_bad_cast_node
)
205 throw_bad_cast_node
= build_runtime_decl
206 ("__throw_bad_cast", ptr_type_node
);
208 return build_call (throw_bad_cast_node
,
209 TREE_TYPE (TREE_TYPE (throw_bad_cast_node
)),
216 if (!throw_bad_typeid_node
)
217 throw_bad_typeid_node
= build_runtime_decl
218 ("__throw_bad_typeid",
220 (build_qualified_type
221 (type_info_type_node
, TYPE_QUAL_CONST
)));
223 return build_call (throw_bad_typeid_node
,
224 TREE_TYPE (TREE_TYPE (throw_bad_typeid_node
)),
228 /* Return a pointer to type_info function associated with the expression EXP.
229 If EXP is a reference to a polymorphic class, return the dynamic type;
230 otherwise return the static type of the expression. */
233 get_tinfo_decl_dynamic (exp
)
238 if (exp
== error_mark_node
)
239 return error_mark_node
;
241 type
= TREE_TYPE (exp
);
243 /* peel back references, so they match. */
244 if (TREE_CODE (type
) == REFERENCE_TYPE
)
245 type
= TREE_TYPE (type
);
247 /* Peel off cv qualifiers. */
248 type
= TYPE_MAIN_VARIANT (type
);
250 if (type
!= void_type_node
)
251 type
= complete_type_or_else (type
, exp
);
254 return error_mark_node
;
256 /* If exp is a reference to polymorphic type, get the real type_info. */
257 if (TYPE_POLYMORPHIC_P (type
) && ! resolves_to_fixed_type_p (exp
, 0))
259 /* build reference to type_info from vtable. */
263 error ("taking dynamic typeid of object with -fno-rtti");
264 if (CLASSTYPE_COM_INTERFACE (type
))
266 cp_error ("RTTI not supported for COM interface type `%T'", type
);
267 return error_mark_node
;
270 /* If we don't have rtti stuff, get to a sub-object that does. */
271 if (! CLASSTYPE_VFIELDS (type
))
273 exp
= build_unary_op (ADDR_EXPR
, exp
, 0);
274 exp
= build_headof_sub (exp
);
275 exp
= build_indirect_ref (exp
, NULL_PTR
);
278 if (flag_vtable_thunks
)
279 t
= build_vfn_ref ((tree
*) 0, exp
, integer_one_node
);
281 t
= build_vfn_ref ((tree
*) 0, exp
, integer_zero_node
);
282 TREE_TYPE (t
) = build_pointer_type (tinfo_decl_type
);
286 /* otherwise return the type_info for the static type of the expr. */
287 exp
= get_tinfo_decl (TYPE_MAIN_VARIANT (type
));
288 return build_unary_op (ADDR_EXPR
, exp
, 0);
295 tree cond
= NULL_TREE
;
300 error ("cannot use typeid with -fno-rtti");
301 return error_mark_node
;
304 if (TYPE_SIZE (type_info_type_node
) == NULL_TREE
)
306 error ("must #include <typeinfo> before using typeid");
307 return error_mark_node
;
310 if (processing_template_decl
)
311 return build_min_nt (TYPEID_EXPR
, exp
);
313 if (TREE_CODE (exp
) == INDIRECT_REF
314 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == POINTER_TYPE
315 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp
))
316 && ! resolves_to_fixed_type_p (exp
, &nonnull
)
319 exp
= stabilize_reference (exp
);
320 cond
= cp_convert (boolean_type_node
, TREE_OPERAND (exp
, 0));
323 exp
= get_tinfo_decl_dynamic (exp
);
325 if (exp
== error_mark_node
)
326 return error_mark_node
;
328 exp
= tinfo_from_decl (exp
);
332 tree bad
= throw_bad_typeid ();
334 exp
= build (COND_EXPR
, TREE_TYPE (exp
), cond
, exp
, bad
);
337 return convert_from_reference (exp
);
344 tree tname
= build_overload_with_type (tinfo_var_id
, type
);
348 my_friendly_assert (!new_abi_rtti_p (), 20000118);
349 if (IDENTIFIER_GLOBAL_VALUE (tname
))
350 return IDENTIFIER_GLOBAL_VALUE (tname
);
352 /* Figure out how much space we need to allocate for the type_info object.
353 If our struct layout or the type_info classes are changed, this will
354 need to be modified. */
355 if (TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
356 size
= 3 * POINTER_SIZE
+ INT_TYPE_SIZE
;
357 else if (TREE_CODE (type
) == POINTER_TYPE
358 && ! (TREE_CODE (TREE_TYPE (type
)) == OFFSET_TYPE
359 || TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
))
360 size
= 3 * POINTER_SIZE
;
361 else if (IS_AGGR_TYPE (type
))
363 if (CLASSTYPE_N_BASECLASSES (type
) == 0)
364 size
= 2 * POINTER_SIZE
;
365 else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type
)
367 (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type
), 0))))
368 size
= 3 * POINTER_SIZE
;
370 size
= 3 * POINTER_SIZE
+ TYPE_PRECISION (sizetype
);
373 size
= 2 * POINTER_SIZE
;
375 /* The type for a character array of the appropriate size. */
376 arrtype
= build_cplus_array_type
377 (unsigned_char_type_node
,
378 build_index_type (size_int (size
/ BITS_PER_UNIT
- 1)));
380 return declare_global_var (tname
, arrtype
);
383 /* Generate the NTBS name of a type. */
388 const char *name
= build_overload_name (type
, 1, 1);
389 tree name_string
= combine_strings (build_string (strlen (name
) + 1, name
));
393 /* Returns a decl for a function or variable which can be used to obtain a
394 type_info object for TYPE. The old-abi uses functions, the new-abi
395 uses the type_info object directly. You can take the address of the
396 returned decl, to save the decl. To use the decl call
397 tinfo_from_decl. You must arrange that the decl is mark_used, if
398 actually use it --- decls in vtables are only used if the vtable is
402 get_tinfo_decl (type
)
408 if (TREE_CODE (type
) == OFFSET_TYPE
)
409 type
= TREE_TYPE (type
);
410 if (TREE_CODE (type
) == METHOD_TYPE
)
411 type
= build_function_type (TREE_TYPE (type
),
412 TREE_CHAIN (TYPE_ARG_TYPES (type
)));
414 name
= build_overload_with_type (tinfo_decl_id
, type
);
416 d
= IDENTIFIER_GLOBAL_VALUE (name
);
419 else if (!new_abi_rtti_p ())
421 /* The tinfo decl is a function returning a reference to the type_info
423 d
= build_lang_decl (FUNCTION_DECL
, name
, tinfo_decl_type
);
424 DECL_EXTERNAL (d
) = 1;
426 DECL_ARTIFICIAL (d
) = 1;
427 TREE_NOTHROW (d
) = 1;
428 DECL_NOT_REALLY_EXTERN (d
) = 1;
429 SET_DECL_TINFO_FN_P (d
);
430 TREE_TYPE (name
) = type
;
432 pushdecl_top_level (d
);
433 make_function_rtl (d
);
434 mark_inline_for_output (d
);
438 /* The tinfo decl is the type_info object itself. We make all
439 tinfo objects look as type_info, even though they will end up
440 being a subclass of that when emitted. This means the we'll
441 erroneously think we know the dynamic type -- be careful in the
443 d
= build_lang_decl (VAR_DECL
, name
, tinfo_decl_type
);
445 DECL_ARTIFICIAL (d
) = 1;
446 DECL_ALIGN (d
) = TYPE_ALIGN (ptr_type_node
);
447 TREE_READONLY (d
) = 1;
449 DECL_EXTERNAL (d
) = 1;
451 DECL_ASSEMBLER_NAME (d
) = DECL_NAME (d
);
452 cp_finish_decl (d
, NULL_TREE
, NULL_TREE
, 0);
454 pushdecl_top_level (d
);
455 /* Remember the type it is for. */
456 TREE_TYPE (name
) = type
;
461 /* Given an expr produced by get_tinfo_decl, return an expr which
462 produces a reference to the type_info object. */
465 tinfo_from_decl (expr
)
470 if (!new_abi_rtti_p ())
471 t
= build_call (expr
, TREE_TYPE (tinfo_decl_type
), NULL_TREE
);
472 else if (TREE_CODE (TREE_TYPE (expr
)) == POINTER_TYPE
)
473 t
= build_indirect_ref (expr
, NULL
);
486 t
= get_tinfo_decl (type
);
487 t
= tinfo_from_decl (t
);
488 return convert_from_reference (t
);
491 /* Return the type_info object for TYPE. */
497 if (type
== error_mark_node
)
498 return error_mark_node
;
500 if (TYPE_SIZE (type_info_type_node
) == NULL_TREE
)
502 error ("must #include <typeinfo> before using typeid");
503 return error_mark_node
;
506 if (processing_template_decl
)
507 return build_min_nt (TYPEID_EXPR
, type
);
509 /* If the type of the type-id is a reference type, the result of the
510 typeid expression refers to a type_info object representing the
512 if (TREE_CODE (type
) == REFERENCE_TYPE
)
513 type
= TREE_TYPE (type
);
515 /* The top-level cv-qualifiers of the lvalue expression or the type-id
516 that is the operand of typeid are always ignored. */
517 type
= TYPE_MAIN_VARIANT (type
);
519 if (type
!= void_type_node
)
520 type
= complete_type_or_else (type
, NULL_TREE
);
523 return error_mark_node
;
525 return get_typeid_1 (type
);
528 /* Check whether TEST is null before returning RESULT. If TEST is used in
529 RESULT, it must have previously had a save_expr applied to it. */
532 ifnonnull (test
, result
)
535 return build (COND_EXPR
, TREE_TYPE (result
),
536 build (EQ_EXPR
, boolean_type_node
, test
, integer_zero_node
),
537 cp_convert (TREE_TYPE (result
), integer_zero_node
),
541 /* Generate the constant expression describing where direct base BINFO
542 appears within the PARENT. How to interpret this expression depends on
543 details of the ABI, which the runtime must be aware of. */
546 get_base_offset (binfo
, parent
)
552 if (!TREE_VIA_VIRTUAL (binfo
))
553 offset
= BINFO_OFFSET (binfo
);
554 else if (!vbase_offsets_in_vtable_p ())
556 tree t
= BINFO_TYPE (binfo
);
560 FORMAT_VBASE_NAME (name
, t
);
561 field
= lookup_field (parent
, get_identifier (name
), 0, 0);
562 offset
= size_binop (FLOOR_DIV_EXPR
,
563 DECL_FIELD_BITPOS (field
),
564 bitsize_int (BITS_PER_UNIT
));
565 offset
= convert (sizetype
, offset
);
569 /* Under the new ABI, we store the vtable offset at which
570 the virtual base offset can be found. */
571 tree vbase
= BINFO_FOR_VBASE (BINFO_TYPE (binfo
), parent
);
572 offset
= convert (sizetype
, BINFO_VPTR_FIELD (vbase
));
577 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
581 build_dynamic_cast_1 (type
, expr
)
584 enum tree_code tc
= TREE_CODE (type
);
588 tree old_expr
= expr
;
590 if (TREE_CODE (expr
) == OFFSET_REF
)
591 expr
= resolve_offset_ref (expr
);
593 exprtype
= TREE_TYPE (expr
);
594 assert (exprtype
!= NULL_TREE
);
595 ec
= TREE_CODE (exprtype
);
600 if (ec
== REFERENCE_TYPE
)
602 expr
= convert_from_reference (expr
);
603 exprtype
= TREE_TYPE (expr
);
604 ec
= TREE_CODE (exprtype
);
606 if (ec
!= POINTER_TYPE
)
608 if (TREE_CODE (TREE_TYPE (exprtype
)) != RECORD_TYPE
)
610 if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype
))) == NULL_TREE
)
612 if (!at_least_as_qualified_p (TREE_TYPE (type
),
613 TREE_TYPE (exprtype
)))
615 if (TYPE_MAIN_VARIANT (TREE_TYPE (type
)) == void_type_node
)
617 /* else fall through */
619 if (TREE_CODE (TREE_TYPE (type
)) != RECORD_TYPE
)
621 if (TYPE_SIZE (complete_type (TREE_TYPE (type
))) == NULL_TREE
)
624 /* else fall through */
629 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
630 if (ec
== RECORD_TYPE
)
632 exprtype
= build_reference_type (exprtype
);
633 expr
= convert_to_reference (exprtype
, expr
, CONV_IMPLICIT
,
634 LOOKUP_NORMAL
, NULL_TREE
);
638 if (tc
== REFERENCE_TYPE
)
640 if (ec
!= REFERENCE_TYPE
)
642 if (TREE_CODE (TREE_TYPE (exprtype
)) != RECORD_TYPE
)
644 if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype
))) == NULL_TREE
)
646 if (!at_least_as_qualified_p (TREE_TYPE (type
),
647 TREE_TYPE (exprtype
)))
651 /* If *type is an unambiguous accessible base class of *exprtype,
652 convert statically. */
657 distance
= get_base_distance (TREE_TYPE (type
), TREE_TYPE (exprtype
), 1,
662 cp_error ("dynamic_cast from `%T' to ambiguous base class `%T'",
663 TREE_TYPE (exprtype
), TREE_TYPE (type
));
664 return error_mark_node
;
668 cp_error ("dynamic_cast from `%T' to private base class `%T'",
669 TREE_TYPE (exprtype
), TREE_TYPE (type
));
670 return error_mark_node
;
674 return build_vbase_path (PLUS_EXPR
, type
, expr
, path
, 0);
677 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
678 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype
)))
681 /* if TYPE is `void *', return pointer to complete object. */
682 if (tc
== POINTER_TYPE
683 && TYPE_MAIN_VARIANT (TREE_TYPE (type
)) == void_type_node
)
685 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
686 if (TREE_CODE (expr
) == ADDR_EXPR
687 && TREE_CODE (TREE_OPERAND (expr
, 0)) == VAR_DECL
688 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == RECORD_TYPE
)
689 return build1 (NOP_EXPR
, type
, expr
);
691 /* Since expr is used twice below, save it. */
692 expr
= save_expr (expr
);
694 expr1
= build_headof (expr
);
695 if (TREE_TYPE (expr1
) != type
)
696 expr1
= build1 (NOP_EXPR
, type
, expr1
);
697 return ifnonnull (expr
, expr1
);
702 tree result
, td2
, td3
, elems
;
703 tree static_type
, target_type
, boff
;
705 /* If we got here, we can't convert statically. Therefore,
706 dynamic_cast<D&>(b) (b an object) cannot succeed. */
707 if (ec
== REFERENCE_TYPE
)
709 if (TREE_CODE (old_expr
) == VAR_DECL
710 && TREE_CODE (TREE_TYPE (old_expr
)) == RECORD_TYPE
)
712 tree expr
= throw_bad_cast ();
713 cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
715 /* Bash it to the expected type. */
716 TREE_TYPE (expr
) = type
;
720 /* Ditto for dynamic_cast<D*>(&b). */
721 else if (TREE_CODE (expr
) == ADDR_EXPR
)
723 tree op
= TREE_OPERAND (expr
, 0);
724 if (TREE_CODE (op
) == VAR_DECL
725 && TREE_CODE (TREE_TYPE (op
)) == RECORD_TYPE
)
727 cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
729 retval
= build_int_2 (0, 0);
730 TREE_TYPE (retval
) = type
;
735 target_type
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
736 static_type
= TYPE_MAIN_VARIANT (TREE_TYPE (exprtype
));
737 td2
= build_unary_op (ADDR_EXPR
, get_tinfo_decl (target_type
), 0);
738 td3
= build_unary_op (ADDR_EXPR
, get_tinfo_decl (static_type
), 0);
740 /* Determine how T and V are related. */
741 boff
= get_dynamic_cast_base_type (static_type
, target_type
);
743 /* Since expr is used twice below, save it. */
744 expr
= save_expr (expr
);
747 if (tc
== REFERENCE_TYPE
)
748 expr1
= build_unary_op (ADDR_EXPR
, expr1
, 0);
750 if (!new_abi_rtti_p ())
752 tree expr2
= build_headof (expr1
);
755 if (ec
== POINTER_TYPE
)
756 td1
= build_indirect_ref (td1
, NULL_PTR
);
757 td1
= get_tinfo_decl_dynamic (td1
);
760 (NULL_TREE
, td1
, tree_cons
761 (NULL_TREE
, td2
, tree_cons
762 (NULL_TREE
, boff
, tree_cons
763 (NULL_TREE
, expr2
, tree_cons
764 (NULL_TREE
, td3
, tree_cons
765 (NULL_TREE
, expr1
, NULL_TREE
))))));
769 (NULL_TREE
, expr1
, tree_cons
770 (NULL_TREE
, td3
, tree_cons
771 (NULL_TREE
, td2
, tree_cons
772 (NULL_TREE
, boff
, NULL_TREE
))));
774 dcast_fn
= dynamic_cast_node
;
779 tree ns
= global_namespace
;
782 push_nested_namespace (ns
);
783 if (!new_abi_rtti_p ())
785 tinfo_ptr
= build_pointer_type (tinfo_decl_type
);
786 name
= "__dynamic_cast_2";
788 (NULL_TREE
, tinfo_ptr
, tree_cons
789 (NULL_TREE
, tinfo_ptr
, tree_cons
790 (NULL_TREE
, integer_type_node
, tree_cons
791 (NULL_TREE
, ptr_type_node
, tree_cons
792 (NULL_TREE
, tinfo_ptr
, tree_cons
793 (NULL_TREE
, ptr_type_node
, void_list_node
))))));
799 push_namespace (get_identifier ("std"));
800 ns
= current_namespace
;
802 tinfo_ptr
= xref_tag (class_type_node
,
803 get_identifier ("__class_type_info"),
806 tinfo_ptr
= build_pointer_type
807 (build_qualified_type
808 (tinfo_ptr
, TYPE_QUAL_CONST
));
809 name
= "__dynamic_cast";
811 (NULL_TREE
, const_ptr_type_node
, tree_cons
812 (NULL_TREE
, tinfo_ptr
, tree_cons
813 (NULL_TREE
, tinfo_ptr
, tree_cons
814 (NULL_TREE
, ptrdiff_type_node
, void_list_node
))));
816 tmp
= build_function_type (ptr_type_node
, tmp
);
817 dcast_fn
= build_lang_decl (FUNCTION_DECL
,
818 get_identifier (name
),
820 DECL_EXTERNAL (dcast_fn
) = 1;
821 TREE_PUBLIC (dcast_fn
) = 1;
822 DECL_ARTIFICIAL (dcast_fn
) = 1;
823 TREE_NOTHROW (dcast_fn
) = 1;
825 if (new_abi_rtti_p ())
826 /* We want its name mangling. */
827 set_mangled_name_for_decl (dcast_fn
);
828 make_function_rtl (dcast_fn
);
829 pop_nested_namespace (ns
);
830 dynamic_cast_node
= dcast_fn
;
832 mark_used (dcast_fn
);
834 (dcast_fn
, TREE_TYPE (TREE_TYPE (dcast_fn
)), elems
);
836 if (tc
== REFERENCE_TYPE
)
838 tree bad
= throw_bad_cast ();
840 result
= save_expr (result
);
841 return build (COND_EXPR
, type
, result
, result
, bad
);
844 /* Now back to the type we want from a void*. */
845 result
= cp_convert (type
, result
);
846 return ifnonnull (expr
, result
);
850 cp_error ("dynamic_cast from non-polymorphic type `%#T'", exprtype
);
851 return error_mark_node
;
854 cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T'",
855 expr
, exprtype
, type
);
856 return error_mark_node
;
860 build_dynamic_cast (type
, expr
)
863 if (type
== error_mark_node
|| expr
== error_mark_node
)
864 return error_mark_node
;
866 if (processing_template_decl
)
867 return build_min (DYNAMIC_CAST_EXPR
, type
, expr
);
869 return convert_from_reference (build_dynamic_cast_1 (type
, expr
));
872 /* Build and initialize various sorts of descriptors. Every descriptor
873 node has a name associated with it (the name created by mangling).
874 For this reason, we use the identifier as our access to the __*_desc
875 nodes, instead of sticking them directly in the types. Otherwise we
876 would burden all built-in types (and pointer types) with slots that
877 we don't necessarily want to use.
879 For each descriptor we build, we build a variable that contains
880 the descriptor's information. When we need this info at runtime,
881 all we need is access to these variables.
883 Note: these constructors always return the address of the descriptor
884 info, since that is simplest for their mutual interaction. */
886 /* Build an initializer for a __si_type_info node. */
889 expand_si_desc (tdecl
, type
)
894 tree name_string
= tinfo_name (type
);
896 type
= BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type
), 0));
897 finish_expr_stmt (get_typeid_1 (type
));
898 t
= decay_conversion (get_tinfo_var (type
));
900 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
901 (NULL_TREE
, decay_conversion (name_string
), tree_cons
902 (NULL_TREE
, t
, NULL_TREE
)));
904 fn
= get_identifier ("__rtti_si");
905 if (IDENTIFIER_GLOBAL_VALUE (fn
))
906 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
911 (NULL_TREE
, ptr_type_node
, tree_cons
912 (NULL_TREE
, const_string_type_node
, tree_cons
913 (NULL_TREE
, build_pointer_type (type_info_type_node
),
915 tmp
= build_function_type (void_type_node
, tmp
);
917 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
918 DECL_EXTERNAL (fn
) = 1;
919 TREE_PUBLIC (fn
) = 1;
920 DECL_ARTIFICIAL (fn
) = 1;
921 TREE_NOTHROW (fn
) = 1;
922 pushdecl_top_level (fn
);
923 make_function_rtl (fn
);
927 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
928 finish_expr_stmt (fn
);
931 /* Build an initializer for a __class_type_info node. */
934 expand_class_desc (tdecl
, type
)
941 int i
= CLASSTYPE_N_BASECLASSES (type
);
943 tree binfos
= TYPE_BINFO_BASETYPES (type
);
945 /* See code below that used these. */
946 tree vb
= CLASSTYPE_VBASECLASSES (type
);
949 tree base
, elems
, access
, offset
, isvir
;
950 tree elt
, elts
= NULL_TREE
;
952 if (base_desc_type_node
== NULL_TREE
)
956 /* A reasonably close approximation of __class_type_info::base_info */
958 base_desc_type_node
= make_aggr_type (RECORD_TYPE
);
960 /* Actually const __user_type_info * */
961 fields
[0] = build_lang_decl
962 (FIELD_DECL
, NULL_TREE
,
963 build_pointer_type (build_qualified_type
964 (type_info_type_node
,
966 fields
[1] = build_lang_decl
967 (FIELD_DECL
, NULL_TREE
,
968 flag_new_abi
? intSI_type_node
: unsigned_intSI_type_node
);
969 DECL_BIT_FIELD (fields
[1]) = 1;
970 DECL_SIZE (fields
[1]) = bitsize_int (29);
972 fields
[2] = build_lang_decl (FIELD_DECL
, NULL_TREE
, boolean_type_node
);
973 DECL_BIT_FIELD (fields
[2]) = 1;
974 DECL_SIZE (fields
[2]) = bitsize_int (1);
976 /* Actually enum access */
977 fields
[3] = build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
);
978 DECL_BIT_FIELD (fields
[3]) = 1;
979 DECL_SIZE (fields
[3]) = bitsize_int (2);
981 finish_builtin_type (base_desc_type_node
, "__base_info", fields
,
987 tree binfo
= TREE_VEC_ELT (binfos
, i
);
989 finish_expr_stmt (get_typeid_1 (BINFO_TYPE (binfo
)));
990 base
= decay_conversion (get_tinfo_var (BINFO_TYPE (binfo
)));
991 offset
= get_base_offset (binfo
, type
);
993 if (TREE_VIA_PUBLIC (binfo
))
994 access
= access_public_node
;
995 else if (TREE_VIA_PROTECTED (binfo
))
996 access
= access_protected_node
;
998 access
= access_private_node
;
999 if (TREE_VIA_VIRTUAL (binfo
))
1000 isvir
= boolean_true_node
;
1002 isvir
= boolean_false_node
;
1005 (CONSTRUCTOR
, base_desc_type_node
, NULL_TREE
, tree_cons
1006 (NULL_TREE
, base
, tree_cons
1007 (NULL_TREE
, offset
, tree_cons
1008 (NULL_TREE
, isvir
, tree_cons
1009 (NULL_TREE
, access
, NULL_TREE
)))));
1010 TREE_HAS_CONSTRUCTOR (elt
) = TREE_CONSTANT (elt
) = TREE_STATIC (elt
) = 1;
1011 elts
= tree_cons (NULL_TREE
, elt
, elts
);
1019 access
= access_public_node
;
1022 b
= TREE_VEC_ELT (binfos
, i
);
1023 if (BINFO_TYPE (vb
) == BINFO_TYPE (b
) && TREE_VIA_VIRTUAL (b
))
1025 if (TREE_VIA_PUBLIC (b
))
1026 access
= access_public_node
;
1027 else if (TREE_VIA_PROTECTED (b
))
1028 access
= access_protected_node
;
1030 access
= access_private_node
;
1034 base
= build_t_desc (BINFO_TYPE (vb
), 1);
1035 offset
= BINFO_OFFSET (vb
);
1036 isvir
= build_int_2 (1, 0);
1038 base_list
= tree_cons (NULL_TREE
, base
, base_list
);
1039 isvir_list
= tree_cons (NULL_TREE
, isvir
, isvir_list
);
1040 acc_list
= tree_cons (NULL_TREE
, access
, acc_list
);
1041 off_list
= tree_cons (NULL_TREE
, offset
, off_list
);
1044 vb
= TREE_CHAIN (vb
);
1048 name_string
= tinfo_name (type
);
1051 tree arrtype
= build_array_type (base_desc_type_node
, NULL_TREE
);
1052 elts
= build (CONSTRUCTOR
, arrtype
, NULL_TREE
, elts
);
1053 TREE_HAS_CONSTRUCTOR (elts
) = TREE_CONSTANT (elts
)
1054 = TREE_STATIC (elts
) = 1;
1055 complete_array_type (arrtype
, elts
, 1);
1059 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
1060 (NULL_TREE
, decay_conversion (name_string
), tree_cons
1061 (NULL_TREE
, decay_conversion (elts
), tree_cons
1062 (NULL_TREE
, cp_convert (sizetype
, build_int_2 (base_cnt
, 0)),
1065 fn
= get_identifier ("__rtti_class");
1066 if (IDENTIFIER_GLOBAL_VALUE (fn
))
1067 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
1071 (NULL_TREE
, ptr_type_node
, tree_cons
1072 (NULL_TREE
, const_string_type_node
, tree_cons
1073 (NULL_TREE
, build_pointer_type (base_desc_type_node
), tree_cons
1074 (NULL_TREE
, sizetype
, void_list_node
))));
1075 tmp
= build_function_type (void_type_node
, tmp
);
1077 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
1078 DECL_EXTERNAL (fn
) = 1;
1079 TREE_PUBLIC (fn
) = 1;
1080 DECL_ARTIFICIAL (fn
) = 1;
1081 TREE_NOTHROW (fn
) = 1;
1082 pushdecl_top_level (fn
);
1083 make_function_rtl (fn
);
1087 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
1088 finish_expr_stmt (fn
);
1091 /* Build an initializer for a __pointer_type_info node. */
1094 expand_ptr_desc (tdecl
, type
)
1099 tree name_string
= tinfo_name (type
);
1101 type
= TREE_TYPE (type
);
1102 finish_expr_stmt (get_typeid_1 (type
));
1103 t
= decay_conversion (get_tinfo_var (type
));
1105 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
1106 (NULL_TREE
, decay_conversion (name_string
), tree_cons
1107 (NULL_TREE
, t
, NULL_TREE
)));
1109 fn
= get_identifier ("__rtti_ptr");
1110 if (IDENTIFIER_GLOBAL_VALUE (fn
))
1111 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
1116 (NULL_TREE
, ptr_type_node
, tree_cons
1117 (NULL_TREE
, const_string_type_node
, tree_cons
1118 (NULL_TREE
, build_pointer_type (type_info_type_node
),
1120 tmp
= build_function_type (void_type_node
, tmp
);
1122 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
1123 DECL_EXTERNAL (fn
) = 1;
1124 TREE_PUBLIC (fn
) = 1;
1125 DECL_ARTIFICIAL (fn
) = 1;
1126 TREE_NOTHROW (fn
) = 1;
1127 pushdecl_top_level (fn
);
1128 make_function_rtl (fn
);
1132 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
1133 finish_expr_stmt (fn
);
1136 /* Build an initializer for a __attr_type_info node. */
1139 expand_attr_desc (tdecl
, type
)
1144 tree name_string
= tinfo_name (type
);
1145 tree attrval
= build_int_2 (TYPE_QUALS (type
), 0);
1147 finish_expr_stmt (get_typeid_1 (TYPE_MAIN_VARIANT (type
)));
1148 t
= decay_conversion (get_tinfo_var (TYPE_MAIN_VARIANT (type
)));
1150 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
1151 (NULL_TREE
, decay_conversion (name_string
), tree_cons
1152 (NULL_TREE
, attrval
, tree_cons (NULL_TREE
, t
, NULL_TREE
))));
1154 fn
= get_identifier ("__rtti_attr");
1155 if (IDENTIFIER_GLOBAL_VALUE (fn
))
1156 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
1161 (NULL_TREE
, ptr_type_node
, tree_cons
1162 (NULL_TREE
, const_string_type_node
, tree_cons
1163 (NULL_TREE
, integer_type_node
, tree_cons
1164 (NULL_TREE
, build_pointer_type (type_info_type_node
),
1166 tmp
= build_function_type (void_type_node
, tmp
);
1168 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
1169 DECL_EXTERNAL (fn
) = 1;
1170 TREE_PUBLIC (fn
) = 1;
1171 DECL_ARTIFICIAL (fn
) = 1;
1172 TREE_NOTHROW (fn
) = 1;
1173 pushdecl_top_level (fn
);
1174 make_function_rtl (fn
);
1178 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
1179 finish_expr_stmt (fn
);
1182 /* Build an initializer for a type_info node that just has a name. */
1185 expand_generic_desc (tdecl
, type
, fnname
)
1190 tree name_string
= tinfo_name (type
);
1191 tree elems
= tree_cons
1192 (NULL_TREE
, decay_conversion (tdecl
), tree_cons
1193 (NULL_TREE
, decay_conversion (name_string
), NULL_TREE
));
1195 tree fn
= get_identifier (fnname
);
1196 if (IDENTIFIER_GLOBAL_VALUE (fn
))
1197 fn
= IDENTIFIER_GLOBAL_VALUE (fn
);
1202 (NULL_TREE
, ptr_type_node
, tree_cons
1203 (NULL_TREE
, const_string_type_node
, void_list_node
));
1204 tmp
= build_function_type (void_type_node
, tmp
);
1206 fn
= build_lang_decl (FUNCTION_DECL
, fn
, tmp
);
1207 DECL_EXTERNAL (fn
) = 1;
1208 TREE_PUBLIC (fn
) = 1;
1209 DECL_ARTIFICIAL (fn
) = 1;
1210 TREE_NOTHROW (fn
) = 1;
1211 pushdecl_top_level (fn
);
1212 make_function_rtl (fn
);
1216 fn
= build_call (fn
, TREE_TYPE (TREE_TYPE (fn
)), elems
);
1217 finish_expr_stmt (fn
);
1220 /* Generate the code for a type_info initialization function.
1221 Note that we take advantage of the passage
1223 5.2.7 Type identification [expr.typeid]
1225 Whether or not the destructor is called for the type_info object at the
1226 end of the program is unspecified.
1228 and don't bother to arrange for these objects to be destroyed. It
1229 doesn't matter, anyway, since the destructors don't do anything.
1231 This must only be called from toplevel (i.e. from finish_file)! */
1234 synthesize_tinfo_fn (fndecl
)
1237 tree type
= TREE_TYPE (DECL_NAME (fndecl
));
1238 tree tmp
, addr
, tdecl
;
1243 my_friendly_assert (!new_abi_rtti_p (), 20000118);
1246 import_export_decl (fndecl
);
1247 if (DECL_REALLY_EXTERN (fndecl
))
1251 /* Declare the static typeinfo variable. */
1252 tdecl
= get_tinfo_var (type
);
1253 DECL_EXTERNAL (tdecl
) = 0;
1254 TREE_STATIC (tdecl
) = 1;
1255 DECL_COMMON (tdecl
) = 1;
1256 TREE_USED (tdecl
) = 1;
1257 DECL_ALIGN (tdecl
) = TYPE_ALIGN (ptr_type_node
);
1258 cp_finish_decl (tdecl
, NULL_TREE
, NULL_TREE
, 0);
1260 /* Begin processing the function. */
1261 start_function (NULL_TREE
, fndecl
, NULL_TREE
,
1262 SF_DEFAULT
| SF_PRE_PARSED
);
1263 DECL_DEFER_OUTPUT (fndecl
) = 1;
1264 store_parm_decls ();
1267 /* Begin the body of the function. */
1268 compound_stmt
= begin_compound_stmt (/*has_no_scope=*/0);
1270 /* For convenience, we save away the address of the static
1272 addr
= decay_conversion (tdecl
);
1274 /* If the first word of the array (the vtable) is non-zero, we've already
1275 initialized the object, so don't do it again. */
1276 if_stmt
= begin_if_stmt ();
1277 tmp
= cp_convert (build_pointer_type (ptr_type_node
), addr
);
1278 tmp
= build_indirect_ref (tmp
, 0);
1279 tmp
= build_binary_op (EQ_EXPR
, tmp
, integer_zero_node
);
1280 finish_if_stmt_cond (tmp
, if_stmt
);
1281 then_clause
= begin_compound_stmt (/*has_no_scope=*/0);
1283 if (TREE_CODE (type
) == FUNCTION_TYPE
)
1284 expand_generic_desc (tdecl
, type
, "__rtti_func");
1285 else if (TREE_CODE (type
) == ARRAY_TYPE
)
1286 expand_generic_desc (tdecl
, type
, "__rtti_array");
1287 else if (TYPE_QUALS (type
) != TYPE_UNQUALIFIED
)
1288 expand_attr_desc (tdecl
, type
);
1289 else if (TREE_CODE (type
) == POINTER_TYPE
)
1291 if (TREE_CODE (TREE_TYPE (type
)) == OFFSET_TYPE
)
1292 expand_generic_desc (tdecl
, type
, "__rtti_ptmd");
1293 else if (TREE_CODE (TREE_TYPE (type
)) == METHOD_TYPE
)
1294 expand_generic_desc (tdecl
, type
, "__rtti_ptmf");
1296 expand_ptr_desc (tdecl
, type
);
1298 else if (TYPE_PTRMEMFUNC_P (type
))
1299 expand_generic_desc (tdecl
, type
, "__rtti_ptmf");
1300 else if (IS_AGGR_TYPE (type
))
1302 if (CLASSTYPE_N_BASECLASSES (type
) == 0)
1303 expand_generic_desc (tdecl
, type
, "__rtti_user");
1304 else if (! TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (type
)
1306 (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type
), 0))))
1307 expand_si_desc (tdecl
, type
);
1309 expand_class_desc (tdecl
, type
);
1311 else if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1312 expand_generic_desc (tdecl
, type
, "__rtti_user");
1314 my_friendly_abort (252);
1316 finish_compound_stmt (/*has_no_scope=*/0, then_clause
);
1317 finish_then_clause (if_stmt
);
1320 /* OK, now return the type_info object. */
1321 tmp
= cp_convert (build_pointer_type (type_info_type_node
), addr
);
1322 tmp
= build_indirect_ref (tmp
, 0);
1323 finish_return_stmt (tmp
);
1324 /* Finish the function body. */
1325 finish_compound_stmt (/*has_no_scope=*/0, compound_stmt
);
1326 expand_body (finish_function (lineno
, 0));
1329 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
1332 qualifier_flags (type
)
1336 /* we want the qualifiers on this type, not any array core, it might have */
1337 int quals
= TYPE_QUALS (type
);
1339 if (quals
& TYPE_QUAL_CONST
)
1341 if (quals
& TYPE_QUAL_VOLATILE
)
1346 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
1347 is the vtable pointer and NTBS name. */
1350 tinfo_base_init (desc
, target
)
1354 tree name_string
= tinfo_name (target
);
1355 tree init
= NULL_TREE
;
1357 if (TINFO_VTABLE_DECL (desc
))
1359 tree vtbl_ptr
= build_unary_op (ADDR_EXPR
, TINFO_VTABLE_DECL (desc
), 0);
1361 init
= tree_cons (NULL_TREE
, vtbl_ptr
, init
);
1364 init
= tree_cons (NULL_TREE
, decay_conversion (name_string
), init
);
1366 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, nreverse(init
));
1367 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1368 init
= tree_cons (NULL_TREE
, init
, NULL_TREE
);
1373 /* Return the CONSTRUCTOR expr for a type_info of TYPE. DESC provides the
1374 information about the particular type_info derivation, which adds no
1375 additional fields to the type_info base. */
1378 generic_initializer (desc
, target
)
1382 tree init
= tinfo_base_init (desc
, target
);
1384 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, init
);
1385 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1389 /* Return the CONSTRUCTOR expr for a type_info of pointer or reference TYPE.
1390 DESC provides information about the particular type_info derivation,
1391 which adds target type and qualifier flags members to the type_info base. */
1394 ptr_ref_initializer (desc
, target
)
1398 tree init
= tinfo_base_init (desc
, target
);
1399 tree to
= TREE_TYPE (target
);
1400 int flags
= qualifier_flags (to
);
1402 init
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), init
);
1403 init
= tree_cons (NULL_TREE
,
1404 build_unary_op (ADDR_EXPR
,
1405 get_tinfo_decl (TYPE_MAIN_VARIANT (to
)), 0),
1408 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, nreverse (init
));
1409 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1413 /* Return the CONSTRUCTOR expr for a type_info of pointer or reference TYPE.
1414 DESC provides information about the particular type_info derivation,
1415 which adds target type and qualifier flags members to the type_info base. */
1418 ptmd_initializer (desc
, target
)
1422 tree init
= tinfo_base_init (desc
, target
);
1423 tree to
= TYPE_PTRMEM_POINTED_TO_TYPE (target
);
1424 tree klass
= TYPE_PTRMEM_CLASS_TYPE (target
);
1425 int flags
= qualifier_flags (to
);
1427 init
= tree_cons (NULL_TREE
,
1428 build_unary_op (ADDR_EXPR
, get_tinfo_decl (klass
), 0),
1430 init
= tree_cons (NULL_TREE
,
1431 build_unary_op (ADDR_EXPR
,
1432 get_tinfo_decl (TYPE_MAIN_VARIANT (to
)), 0),
1434 init
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), init
);
1436 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, nreverse (init
));
1437 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1441 /* Determine the hint flags describing the features of a class's heirarchy.
1442 FIXME: better set the hint_flags here! For now set them
1443 to safe 'don't know' values. The specification is under
1444 review. Don't forget to check the runtime dynamic_cast and
1445 catch machinery if these change. */
1448 class_hint_flags (type
)
1452 hint_flags
|= 0x1; /* contains multiply inherited sub object */
1453 hint_flags
|= 0x4; /* has virtual bases */
1454 hint_flags
|= 0x8; /* has private base */
1455 if (TYPE_POLYMORPHIC_P (type
))
1461 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1462 DESC provides information about the particular __class_type_info derivation,
1463 which adds hint flags and TRAIL initializers to the type_info base. */
1466 class_initializer (desc
, target
, trail
)
1471 tree init
= tinfo_base_init (desc
, target
);
1472 int flags
= class_hint_flags (target
);
1474 trail
= tree_cons (NULL_TREE
, build_int_2 (flags
, 0), trail
);
1475 TREE_CHAIN (init
) = trail
;
1476 init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, init
);
1477 TREE_HAS_CONSTRUCTOR (init
) = TREE_CONSTANT (init
) = TREE_STATIC (init
) = 1;
1481 /* Generate a pseudo_type_info VAR_DECL suitable for the supplied
1482 TARGET_TYPE and given the REAL_NAME. This is the structure expected by
1483 the runtime, and therefore has additional fields. If we need not emit a
1484 definition (because the runtime must contain it), return NULL_TREE,
1485 otherwise return the VAR_DECL. */
1488 synthesize_tinfo_var (target_type
, real_name
)
1492 tree var_init
= NULL_TREE
;
1493 tree var_type
= NULL_TREE
;
1495 my_friendly_assert (new_abi_rtti_p (), 20000118);
1497 switch (TREE_CODE (target_type
))
1500 if (TYPE_PTRMEM_P (target_type
))
1502 var_type
= ptmd_desc_type_node
;
1503 var_init
= ptmd_initializer (var_type
, target_type
);
1507 int code
= TREE_CODE (TREE_TYPE (target_type
));
1509 if ((CP_TYPE_QUALS (TREE_TYPE (target_type
)) | TYPE_QUAL_CONST
)
1511 && (code
== INTEGER_TYPE
|| code
== BOOLEAN_TYPE
1512 || code
== CHAR_TYPE
|| code
== REAL_TYPE
1513 || code
== VOID_TYPE
)
1515 /* These are in the runtime. */
1517 var_type
= ptr_desc_type_node
;
1518 var_init
= ptr_ref_initializer (var_type
, target_type
);
1521 case REFERENCE_TYPE
:
1522 var_type
= ref_desc_type_node
;
1523 var_init
= ptr_ref_initializer (var_type
, target_type
);
1526 var_type
= enum_desc_type_node
;
1527 var_init
= generic_initializer (var_type
, target_type
);
1530 var_type
= func_desc_type_node
;
1531 var_init
= generic_initializer (var_type
, target_type
);
1534 var_type
= ary_desc_type_node
;
1535 var_init
= generic_initializer (var_type
, target_type
);
1539 if (!TYPE_SIZE (target_type
))
1541 /* FIXME: incomplete type. Awaiting specification. */
1544 else if (!CLASSTYPE_N_BASECLASSES (target_type
))
1546 var_type
= class_desc_type_node
;
1547 var_init
= class_initializer (var_type
, target_type
, NULL_TREE
);
1551 /* if this has a single public non-virtual base, it's easier */
1552 tree binfo
= TYPE_BINFO (target_type
);
1553 int nbases
= BINFO_N_BASETYPES (binfo
);
1554 tree base_binfos
= BINFO_BASETYPES (binfo
);
1555 tree base_inits
= NULL_TREE
;
1556 int is_simple
= nbases
== 1;
1559 /* Generate the base information initializer. */
1560 for (ix
= nbases
; ix
--;)
1562 tree base_binfo
= TREE_VEC_ELT (base_binfos
, ix
);
1563 tree base_init
= NULL_TREE
;
1568 if (TREE_VIA_VIRTUAL (base_binfo
))
1570 if (TREE_PUBLIC (base_binfo
))
1572 tinfo
= get_tinfo_decl (BINFO_TYPE (base_binfo
));
1573 tinfo
= build_unary_op (ADDR_EXPR
, tinfo
, 0);
1574 offset
= get_base_offset (base_binfo
, target_type
);
1576 /* is it a single public inheritance? */
1577 if (is_simple
&& flags
== 2 && integer_zerop (offset
))
1579 base_inits
= tree_cons (NULL_TREE
, tinfo
, NULL_TREE
);
1584 base_init
= tree_cons
1585 (NULL_TREE
, build_int_2 (flags
, 0), base_init
);
1586 base_init
= tree_cons (NULL_TREE
, offset
, base_init
);
1587 base_init
= tree_cons (NULL_TREE
, tinfo
, base_init
);
1588 base_init
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, base_init
);
1589 base_inits
= tree_cons (NULL_TREE
, base_init
, base_inits
);
1593 var_type
= si_class_desc_type_node
;
1596 /* Prepend the number of bases. */
1597 base_inits
= build (CONSTRUCTOR
, NULL_TREE
, NULL_TREE
, base_inits
);
1598 base_inits
= tree_cons (NULL_TREE
, base_inits
, NULL_TREE
);
1599 base_inits
= tree_cons (NULL_TREE
,
1600 build_int_2 (nbases
, 0), base_inits
);
1602 var_type
= get_vmi_pseudo_type_info (nbases
);
1604 var_init
= class_initializer (var_type
, target_type
, base_inits
);
1613 /* These are guaranteed to be in the runtime. */
1615 var_type
= bltn_desc_type_node
;
1616 var_init
= generic_initializer (var_type
, target_type
);
1619 my_friendly_abort (20000117);
1622 return create_real_tinfo_var (real_name
, TINFO_PSEUDO_TYPE (var_type
), var_init
);
1625 /* Create the real typeinfo variable. */
1628 create_real_tinfo_var (name
, type
, init
)
1635 decl
= build_lang_decl (VAR_DECL
, name
,
1636 build_qualified_type (type
, TYPE_QUAL_CONST
));
1637 DECL_ARTIFICIAL (decl
) = 1;
1638 TREE_READONLY (decl
) = 1;
1639 TREE_STATIC (decl
) = 1;
1640 TREE_PUBLIC (decl
) = 1;
1641 DECL_EXTERNAL (decl
) = 0;
1643 comdat_linkage (decl
);
1644 DECL_ASSEMBLER_NAME (decl
) = name
;
1645 DECL_INITIAL (decl
) = init
;
1646 cp_finish_decl (decl
, init
, NULL_TREE
, 0);
1651 /* Generate the RECORD_TYPE containing the data layout of a type_info
1652 derivative as used by the runtime. This layout must be consistent with
1653 that defined in the runtime support. Also generate the VAR_DECL for the
1654 type's vtable. We explicitly manage the vtable member, and name it for
1655 real type as used in the runtime. The RECORD type has a different name,
1656 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1657 is the generated type and TINFO_VTABLE_DECL is the vtable decl.
1659 REAL_NAME is the runtime's name of the type. Trailing arguments are
1660 additional FIELD_DECL's for the structure. The final argument must be
1664 create_pseudo_type_info
VPARAMS((const char *real_name
, int ident
, ...))
1666 #ifndef ANSI_PROTOTYPES
1667 char const *real_name
;
1671 tree real_type
, pseudo_type
;
1679 VA_START (ap
, ident
);
1680 #ifndef ANSI_PROTOTYPES
1681 real_name
= va_arg (ap
, char const *);
1682 ident
= va_arg (app
, int);
1685 /* Generate the pseudo type name. */
1686 pseudo_name
= (char *)alloca (strlen (real_name
) + 30);
1687 strcpy (pseudo_name
, real_name
);
1688 strcat (pseudo_name
, "_pseudo");
1690 sprintf (pseudo_name
+ strlen (pseudo_name
), "%d", ident
);
1692 /* Get the vtable decl. */
1693 real_type
= xref_tag (class_type_node
, get_identifier (real_name
), 1);
1694 vtable_decl
= get_vtable_decl (real_type
, /*complete=*/1);
1696 /* First field is the pseudo type_info base class. */
1697 fields
[0] = build_lang_decl (FIELD_DECL
, NULL_TREE
, ti_desc_type_node
);
1699 /* Now add the derived fields. */
1700 for (ix
= 0; (field_decl
= va_arg (ap
, tree
));)
1701 fields
[++ix
] = field_decl
;
1703 /* Create the pseudo type. */
1704 pseudo_type
= make_aggr_type (RECORD_TYPE
);
1705 finish_builtin_type (pseudo_type
, pseudo_name
, fields
, ix
, ptr_type_node
);
1706 TYPE_HAS_CONSTRUCTOR (pseudo_type
) = 1;
1709 result
= tree_cons (NULL_TREE
, NULL_TREE
, NULL_TREE
);
1710 TINFO_VTABLE_DECL (result
) = vtable_decl
;
1711 TINFO_PSEUDO_TYPE (result
) = pseudo_type
;
1716 /* Return a descriptor for a vmi type with NUM_BASES bases. */
1719 get_vmi_pseudo_type_info (num_bases
)
1723 tree array_domain
, base_array
;
1725 if (TREE_VEC_LENGTH (vmi_class_desc_type_node
) <= num_bases
)
1728 tree extend
= make_tree_vec (num_bases
+ 5);
1730 for (ix
= TREE_VEC_LENGTH (vmi_class_desc_type_node
); ix
--;)
1731 TREE_VEC_ELT (extend
, ix
) = TREE_VEC_ELT (vmi_class_desc_type_node
, ix
);
1732 vmi_class_desc_type_node
= extend
;
1734 desc
= TREE_VEC_ELT (vmi_class_desc_type_node
, num_bases
);
1739 /* Add number of bases and trailing array of base_class_type_info. */
1740 array_domain
= build_index_type (build_int_2 (num_bases
, 0));
1741 base_array
= build_array_type (base_desc_type_node
, array_domain
);
1744 push_namespace (get_identifier ("std"));
1746 desc
= create_pseudo_type_info
1747 ("__vmi_class_type_info", num_bases
,
1748 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1749 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1750 build_lang_decl (FIELD_DECL
, NULL_TREE
, base_array
),
1756 TREE_VEC_ELT (vmi_class_desc_type_node
, num_bases
) = desc
;
1760 /* Make sure the required builtin types exist for generating the type_info
1761 varable definitions. */
1764 create_tinfo_types ()
1768 if (bltn_desc_type_node
)
1771 push_namespace (get_identifier ("std"));
1773 ptr_type_info
= build_pointer_type
1774 (build_qualified_type
1775 (type_info_type_node
, TYPE_QUAL_CONST
));
1777 /* Create the internal type_info structure. This is used as a base for
1778 the other structures. */
1782 ti_desc_type_node
= make_aggr_type (RECORD_TYPE
);
1783 fields
[0] = build_lang_decl (FIELD_DECL
, NULL_TREE
, const_ptr_type_node
);
1784 fields
[1] = build_lang_decl (FIELD_DECL
, NULL_TREE
, const_string_type_node
);
1785 finish_builtin_type (ti_desc_type_node
, "__type_info_pseudo",
1786 fields
, 1, ptr_type_node
);
1787 TYPE_HAS_CONSTRUCTOR (ti_desc_type_node
) = 1;
1790 /* Fundamental type_info */
1791 bltn_desc_type_node
= create_pseudo_type_info
1792 ("__fundamental_type_info", 0,
1795 /* Pointer and reference type_info. These two fields, qualification mask
1796 and pointer to the pointed to (referenced) type. */
1797 ptr_desc_type_node
= create_pseudo_type_info
1798 ("__pointer_type_info", 0,
1799 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1800 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1802 ref_desc_type_node
= create_pseudo_type_info
1803 ("__reference_type_info", 0,
1804 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1805 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1808 /* Array, function and enum type_info. No additional fields. */
1809 ary_desc_type_node
= create_pseudo_type_info
1810 ("__array_type_info", 0,
1812 func_desc_type_node
= create_pseudo_type_info
1813 ("__function_type_info", 0,
1815 enum_desc_type_node
= create_pseudo_type_info
1816 ("__enum_type_info", 0,
1819 /* Class type_info. Add a flags field. */
1820 class_desc_type_node
= create_pseudo_type_info
1821 ("__class_type_info", 0,
1822 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1825 /* Single public non-virtual base class. Add pointer to base class. */
1826 si_class_desc_type_node
= create_pseudo_type_info
1827 ("__si_class_type_info", 0,
1828 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1829 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1832 /* Base class internal helper. Pointer to base type, offset to base,
1837 fields
[0] = build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1838 fields
[1] = build_lang_decl (FIELD_DECL
, NULL_TREE
, ptrdiff_type_node
),
1839 fields
[2] = build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1840 base_desc_type_node
= make_aggr_type (RECORD_TYPE
);
1841 finish_builtin_type (base_desc_type_node
, "__base_class_type_info_pseudo",
1842 fields
, 2, ptr_type_node
);
1843 TYPE_HAS_CONSTRUCTOR (base_desc_type_node
) = 1;
1846 /* General heirarchy is created as necessary in this vector. */
1847 vmi_class_desc_type_node
= make_tree_vec (10);
1849 /* Pointer to member data type_info. Add pointer to the class, pointer
1850 to the member's type info and qualifications flags. */
1851 ptmd_desc_type_node
= create_pseudo_type_info
1852 ("__ptr_to_member_type_info", 0,
1853 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1854 build_lang_decl (FIELD_DECL
, NULL_TREE
, ptr_type_info
),
1855 build_lang_decl (FIELD_DECL
, NULL_TREE
, integer_type_node
),
1862 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1863 support. Generating them here guarantees consistency with the other
1864 structures. We use the following heuristic to determine when the runtime
1865 is being generated. If std::__fundamental_type_info is defined, and it's
1866 destructor is defined, then the runtime is being built. */
1869 emit_support_tinfos ()
1871 static tree
*const fundamentals
[] =
1877 &signed_wchar_type_node
, &unsigned_wchar_type_node
,
1879 &char_type_node
, &signed_char_type_node
, &unsigned_char_type_node
,
1880 &short_integer_type_node
, &short_unsigned_type_node
,
1881 &integer_type_node
, &unsigned_type_node
,
1882 &long_integer_type_node
, &long_unsigned_type_node
,
1883 &long_long_integer_type_node
, &long_long_unsigned_type_node
,
1884 &float_type_node
, &double_type_node
, &long_double_type_node
,
1886 /* GCC extension types */
1888 &complex_integer_type_node
,
1889 &complex_float_type_node
, &complex_double_type_node
,
1890 &complex_long_double_type_node
,
1896 tree bltn_type
, dtor
;
1899 push_namespace (get_identifier ("std"));
1900 bltn_type
= xref_tag (class_type_node
,
1901 get_identifier ("__fundamental_type_info"), 1);
1904 if (!TYPE_SIZE (bltn_type
))
1906 dtor
= TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (bltn_type
), 1);
1907 if (DECL_EXTERNAL (dtor
))
1910 for (ix
= 0; fundamentals
[ix
]; ix
++)
1912 tree bltn
= *fundamentals
[ix
];
1913 tree bltn_ptr
= build_pointer_type (bltn
);
1914 tree bltn_const_ptr
= build_pointer_type
1915 (build_qualified_type (bltn
, TYPE_QUAL_CONST
));
1918 tinfo
= get_tinfo_decl (bltn
);
1919 TREE_USED (tinfo
) = 1;
1920 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1922 tinfo
= get_tinfo_decl (bltn_ptr
);
1923 TREE_USED (tinfo
) = 1;
1924 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1926 tinfo
= get_tinfo_decl (bltn_const_ptr
);
1927 TREE_USED (tinfo
) = 1;
1928 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (tinfo
)) = 1;
1932 /* Return non-zero, iff T is a type_info variable which has not had a
1933 definition emitted for it. */
1936 tinfo_decl_p (t
, data
)
1938 void *data ATTRIBUTE_UNUSED
;
1940 return TREE_CODE (t
) == VAR_DECL
1941 && IDENTIFIER_GLOBAL_VALUE (DECL_NAME (t
)) == (t
)
1942 && TREE_TYPE (t
) == tinfo_decl_type
1943 && TREE_TYPE (DECL_NAME (t
));
1946 /* Emit a suitable type_info definition for the type_info decl pointed to by
1947 DECL_PTR. We emit a completely new variable, of the correct type for the
1948 actual type this is describing. The DECL_ASSEMBLER_NAME of the generated
1949 definition is set to that of the supplied decl, so that they can be tied
1950 up. Mark the supplied decl as having been dealt with. Emitting one
1951 definitions might cause other declarations to be emitted.
1953 We need to do things this way, because we're trying to do something like
1959 extern const A tinfo_var;
1961 const B tinfo_var = {...};
1963 which is not permitted. Also, we've not necessarily seen the definition of B.
1964 So we do something like the following,
1966 extern const A tinfo_var;
1969 const void *vtable_ptr;
1977 const pseudo_B proxy_tinfo_var attribute((assembler_name="tinfo_var")) =
1979 {&B::vtable, "..."},
1983 pseudo_A and pseudo_B must be layout equivalent to the real definitions in
1987 emit_tinfo_decl (decl_ptr
, data
)
1989 void *data ATTRIBUTE_UNUSED
;
1991 tree tinfo_decl
= *decl_ptr
;
1992 tree tinfo_type
, decl
;
1994 my_friendly_assert (TREE_TYPE (tinfo_decl
) == tinfo_decl_type
, 20000121);
1995 tinfo_type
= TREE_TYPE (DECL_NAME (tinfo_decl
));
1996 my_friendly_assert (tinfo_type
!= NULL_TREE
, 20000120);
1998 /* Say we've dealt with it. */
1999 TREE_TYPE (DECL_NAME (tinfo_decl
)) = NULL_TREE
;
2001 if (!DECL_NEEDED_P (tinfo_decl
))
2003 create_tinfo_types ();
2004 decl
= synthesize_tinfo_var (tinfo_type
, DECL_ASSEMBLER_NAME (tinfo_decl
));