1 /* RunTime Type Identification
2 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006
4 Free Software Foundation, Inc.
5 Mostly written by Jason Merrill ([email protected]).
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to
21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "tree.h"
29 #include "cp-tree.h"
30 #include "flags.h"
31 #include "output.h"
32 #include "assert.h"
33 #include "toplev.h"
34 #include "convert.h"
35 #include "target.h"
36
37 /* C++ returns type information to the user in struct type_info
38 objects. We also use type information to implement dynamic_cast and
39 exception handlers. Type information for a particular type is
40 indicated with an ABI defined structure derived from type_info.
41 This would all be very straight forward, but for the fact that the
42 runtime library provides the definitions of the type_info structure
43 and the ABI defined derived classes. We cannot build declarations
44 of them directly in the compiler, but we need to layout objects of
45 their type. Somewhere we have to lie.
46
47 We define layout compatible POD-structs with compiler-defined names
48 and generate the appropriate initializations for them (complete
49 with explicit mention of their vtable). When we have to provide a
50 type_info to the user we reinterpret_cast the internal compiler
51 type to type_info. A well formed program can only explicitly refer
52 to the type_infos of complete types (& cv void). However, we chain
53 pointer type_infos to the pointed-to-type, and that can be
54 incomplete. We only need the addresses of such incomplete
55 type_info objects for static initialization.
56
57 The type information VAR_DECL of a type is held on the
58 IDENTIFIER_GLOBAL_VALUE of the type's mangled name. That VAR_DECL
59 will be the internal type. It will usually have the correct
60 internal type reflecting the kind of type it represents (pointer,
61 array, function, class, inherited class, etc). When the type it
62 represents is incomplete, it will have the internal type
63 corresponding to type_info. That will only happen at the end of
64 translation, when we are emitting the type info objects. */
65
66 /* Auxiliary data we hold for each type_info derived object we need. */
67 typedef struct tinfo_s GTY (())
68 {
69 tree type; /* The RECORD_TYPE for this type_info object */
70
71 tree vtable; /* The VAR_DECL of the vtable. Only filled at end of
72 translation. */
73
74 tree name; /* IDENTIFIER_NODE for the ABI specified name of
75 the type_info derived type. */
76 } tinfo_s;
77
78 DEF_VEC_O(tinfo_s);
79 DEF_VEC_ALLOC_O(tinfo_s,gc);
80
81 typedef enum tinfo_kind
82 {
83 TK_TYPE_INFO_TYPE, /* std::type_info */
84 TK_BASE_TYPE, /* abi::__base_class_type_info */
85 TK_BUILTIN_TYPE, /* abi::__fundamental_type_info */
86 TK_ARRAY_TYPE, /* abi::__array_type_info */
87 TK_FUNCTION_TYPE, /* abi::__function_type_info */
88 TK_ENUMERAL_TYPE, /* abi::__enum_type_info */
89 TK_POINTER_TYPE, /* abi::__pointer_type_info */
90 TK_POINTER_MEMBER_TYPE, /* abi::__pointer_to_member_type_info */
91 TK_CLASS_TYPE, /* abi::__class_type_info */
92 TK_SI_CLASS_TYPE, /* abi::__si_class_type_info */
93 TK_FIXED /* end of fixed descriptors. */
94 /* ... abi::__vmi_type_info<I> */
95 } tinfo_kind;
96
97 /* A vector of all tinfo decls that haven't yet been emitted. */
98 VEC(tree,gc) *unemitted_tinfo_decls;
99
100 /* A vector of all type_info derived types we need. The first few are
101 fixed and created early. The remainder are for multiple inheritance
102 and are generated as needed. */
103 static GTY (()) VEC(tinfo_s,gc) *tinfo_descs;
104
105 static tree build_headof (tree);
106 static tree ifnonnull (tree, tree);
107 static tree tinfo_name (tree);
108 static tree build_dynamic_cast_1 (tree, tree);
109 static tree throw_bad_cast (void);
110 static tree throw_bad_typeid (void);
111 static tree get_tinfo_decl_dynamic (tree);
112 static tree get_tinfo_ptr (tree);
113 static bool typeid_ok_p (void);
114 static int qualifier_flags (tree);
115 static bool target_incomplete_p (tree);
116 static tree tinfo_base_init (tinfo_s *, tree);
117 static tree generic_initializer (tinfo_s *, tree);
118 static tree ptr_initializer (tinfo_s *, tree);
119 static tree ptm_initializer (tinfo_s *, tree);
120 static tree class_initializer (tinfo_s *, tree, tree);
121 static void create_pseudo_type_info (int, const char *, ...);
122 static tree get_pseudo_ti_init (tree, unsigned);
123 static unsigned get_pseudo_ti_index (tree);
124 static void create_tinfo_types (void);
125 static bool typeinfo_in_lib_p (tree);
126
127 static int doing_runtime = 0;
128
129
130 /* Declare language defined type_info type and a pointer to const
131 type_info. This is incomplete here, and will be completed when
132 the user #includes <typeinfo>. There are language defined
133 restrictions on what can be done until that is included. Create
134 the internal versions of the ABI types. */
135
136 void
init_rtti_processing(void)137 init_rtti_processing (void)
138 {
139 tree type_info_type;
140
141 push_namespace (std_identifier);
142 type_info_type = xref_tag (class_type, get_identifier ("type_info"),
143 /*tag_scope=*/ts_current, false);
144 pop_namespace ();
145 const_type_info_type_node
146 = build_qualified_type (type_info_type, TYPE_QUAL_CONST);
147 type_info_ptr_type = build_pointer_type (const_type_info_type_node);
148
149 unemitted_tinfo_decls = VEC_alloc (tree, gc, 124);
150
151 create_tinfo_types ();
152 }
153
154 /* Given the expression EXP of type `class *', return the head of the
155 object pointed to by EXP with type cv void*, if the class has any
156 virtual functions (TYPE_POLYMORPHIC_P), else just return the
157 expression. */
158
159 static tree
build_headof(tree exp)160 build_headof (tree exp)
161 {
162 tree type = TREE_TYPE (exp);
163 tree offset;
164 tree index;
165
166 gcc_assert (TREE_CODE (type) == POINTER_TYPE);
167 type = TREE_TYPE (type);
168
169 if (!TYPE_POLYMORPHIC_P (type))
170 return exp;
171
172 /* We use this a couple of times below, protect it. */
173 exp = save_expr (exp);
174
175 /* The offset-to-top field is at index -2 from the vptr. */
176 index = build_int_cst (NULL_TREE,
177 -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
178
179 offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index);
180
181 type = build_qualified_type (ptr_type_node,
182 cp_type_quals (TREE_TYPE (exp)));
183 return build2 (PLUS_EXPR, type, exp,
184 convert_to_integer (ptrdiff_type_node, offset));
185 }
186
187 /* Get a bad_cast node for the program to throw...
188
189 See libstdc++/exception.cc for __throw_bad_cast */
190
191 static tree
throw_bad_cast(void)192 throw_bad_cast (void)
193 {
194 tree fn = get_identifier ("__cxa_bad_cast");
195 if (!get_global_value_if_present (fn, &fn))
196 fn = push_throw_library_fn (fn, build_function_type (ptr_type_node,
197 void_list_node));
198
199 return build_cxx_call (fn, NULL_TREE);
200 }
201
202 /* Return an expression for "__cxa_bad_typeid()". The expression
203 returned is an lvalue of type "const std::type_info". */
204
205 static tree
throw_bad_typeid(void)206 throw_bad_typeid (void)
207 {
208 tree fn = get_identifier ("__cxa_bad_typeid");
209 if (!get_global_value_if_present (fn, &fn))
210 {
211 tree t;
212
213 t = build_reference_type (const_type_info_type_node);
214 t = build_function_type (t, void_list_node);
215 fn = push_throw_library_fn (fn, t);
216 }
217
218 return build_cxx_call (fn, NULL_TREE);
219 }
220
221 /* Return an lvalue expression whose type is "const std::type_info"
222 and whose value indicates the type of the expression EXP. If EXP
223 is a reference to a polymorphic class, return the dynamic type;
224 otherwise return the static type of the expression. */
225
226 static tree
get_tinfo_decl_dynamic(tree exp)227 get_tinfo_decl_dynamic (tree exp)
228 {
229 tree type;
230 tree t;
231
232 if (error_operand_p (exp))
233 return error_mark_node;
234
235 /* peel back references, so they match. */
236 type = non_reference (TREE_TYPE (exp));
237
238 /* Peel off cv qualifiers. */
239 type = TYPE_MAIN_VARIANT (type);
240
241 if (CLASS_TYPE_P (type))
242 type = complete_type_or_else (type, exp);
243
244 if (!type)
245 return error_mark_node;
246
247 /* If exp is a reference to polymorphic type, get the real type_info. */
248 if (TYPE_POLYMORPHIC_P (type) && ! resolves_to_fixed_type_p (exp, 0))
249 {
250 /* build reference to type_info from vtable. */
251 tree index;
252
253 /* The RTTI information is at index -1. */
254 index = build_int_cst (NULL_TREE,
255 -1 * TARGET_VTABLE_DATA_ENTRY_DISTANCE);
256 t = build_vtbl_ref (exp, index);
257 t = convert (type_info_ptr_type, t);
258 }
259 else
260 /* Otherwise return the type_info for the static type of the expr. */
261 t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type));
262
263 return build_indirect_ref (t, NULL);
264 }
265
266 static bool
typeid_ok_p(void)267 typeid_ok_p (void)
268 {
269 if (! flag_rtti)
270 {
271 error ("cannot use typeid with -fno-rtti");
272 return false;
273 }
274
275 if (!COMPLETE_TYPE_P (const_type_info_type_node))
276 {
277 error ("must #include <typeinfo> before using typeid");
278 return false;
279 }
280
281 return true;
282 }
283
284 /* Return an expression for "typeid(EXP)". The expression returned is
285 an lvalue of type "const std::type_info". */
286
287 tree
build_typeid(tree exp)288 build_typeid (tree exp)
289 {
290 tree cond = NULL_TREE;
291 int nonnull = 0;
292
293 if (exp == error_mark_node || !typeid_ok_p ())
294 return error_mark_node;
295
296 if (processing_template_decl)
297 return build_min (TYPEID_EXPR, const_type_info_type_node, exp);
298
299 if (TREE_CODE (exp) == INDIRECT_REF
300 && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
301 && TYPE_POLYMORPHIC_P (TREE_TYPE (exp))
302 && ! resolves_to_fixed_type_p (exp, &nonnull)
303 && ! nonnull)
304 {
305 exp = stabilize_reference (exp);
306 cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0));
307 }
308
309 exp = get_tinfo_decl_dynamic (exp);
310
311 if (exp == error_mark_node)
312 return error_mark_node;
313
314 if (cond)
315 {
316 tree bad = throw_bad_typeid ();
317
318 exp = build3 (COND_EXPR, TREE_TYPE (exp), cond, exp, bad);
319 }
320
321 return exp;
322 }
323
324 /* Generate the NTBS name of a type. */
325 static tree
tinfo_name(tree type)326 tinfo_name (tree type)
327 {
328 const char *name;
329 tree name_string;
330
331 name = mangle_type_string (type);
332 name_string = fix_string_type (build_string (strlen (name) + 1, name));
333 return name_string;
334 }
335
336 /* Return a VAR_DECL for the internal ABI defined type_info object for
337 TYPE. You must arrange that the decl is mark_used, if actually use
338 it --- decls in vtables are only used if the vtable is output. */
339
340 tree
get_tinfo_decl(tree type)341 get_tinfo_decl (tree type)
342 {
343 tree name;
344 tree d;
345
346 if (variably_modified_type_p (type, /*fn=*/NULL_TREE))
347 {
348 error ("cannot create type information for type %qT because "
349 "it involves types of variable size",
350 type);
351 return error_mark_node;
352 }
353
354 if (TREE_CODE (type) == METHOD_TYPE)
355 type = build_function_type (TREE_TYPE (type),
356 TREE_CHAIN (TYPE_ARG_TYPES (type)));
357
358 /* For a class type, the variable is cached in the type node
359 itself. */
360 if (CLASS_TYPE_P (type))
361 {
362 d = CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type));
363 if (d)
364 return d;
365 }
366
367 name = mangle_typeinfo_for_type (type);
368
369 d = IDENTIFIER_GLOBAL_VALUE (name);
370 if (!d)
371 {
372 int ix = get_pseudo_ti_index (type);
373 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, ix);
374
375 d = build_lang_decl (VAR_DECL, name, ti->type);
376 SET_DECL_ASSEMBLER_NAME (d, name);
377 /* Remember the type it is for. */
378 TREE_TYPE (name) = type;
379 DECL_TINFO_P (d) = 1;
380 DECL_ARTIFICIAL (d) = 1;
381 DECL_IGNORED_P (d) = 1;
382 TREE_READONLY (d) = 1;
383 TREE_STATIC (d) = 1;
384 /* Mark the variable as undefined -- but remember that we can
385 define it later if we need to do so. */
386 DECL_EXTERNAL (d) = 1;
387 DECL_NOT_REALLY_EXTERN (d) = 1;
388 if (CLASS_TYPE_P (type))
389 CLASSTYPE_TYPEINFO_VAR (TYPE_MAIN_VARIANT (type)) = d;
390 set_linkage_according_to_type (type, d);
391 pushdecl_top_level_and_finish (d, NULL_TREE);
392
393 /* Add decl to the global array of tinfo decls. */
394 VEC_safe_push (tree, gc, unemitted_tinfo_decls, d);
395 }
396
397 return d;
398 }
399
400 /* Return a pointer to a type_info object describing TYPE, suitably
401 cast to the language defined type. */
402
403 static tree
get_tinfo_ptr(tree type)404 get_tinfo_ptr (tree type)
405 {
406 tree decl = get_tinfo_decl (type);
407
408 mark_used (decl);
409 return build_nop (type_info_ptr_type,
410 build_address (decl));
411 }
412
413 /* Return the type_info object for TYPE. */
414
415 tree
get_typeid(tree type)416 get_typeid (tree type)
417 {
418 if (type == error_mark_node || !typeid_ok_p ())
419 return error_mark_node;
420
421 if (processing_template_decl)
422 return build_min (TYPEID_EXPR, const_type_info_type_node, type);
423
424 /* If the type of the type-id is a reference type, the result of the
425 typeid expression refers to a type_info object representing the
426 referenced type. */
427 type = non_reference (type);
428
429 /* The top-level cv-qualifiers of the lvalue expression or the type-id
430 that is the operand of typeid are always ignored. */
431 type = TYPE_MAIN_VARIANT (type);
432
433 if (CLASS_TYPE_P (type))
434 type = complete_type_or_else (type, NULL_TREE);
435
436 if (!type)
437 return error_mark_node;
438
439 return build_indirect_ref (get_tinfo_ptr (type), NULL);
440 }
441
442 /* Check whether TEST is null before returning RESULT. If TEST is used in
443 RESULT, it must have previously had a save_expr applied to it. */
444
445 static tree
ifnonnull(tree test,tree result)446 ifnonnull (tree test, tree result)
447 {
448 return build3 (COND_EXPR, TREE_TYPE (result),
449 build2 (EQ_EXPR, boolean_type_node, test,
450 cp_convert (TREE_TYPE (test), integer_zero_node)),
451 cp_convert (TREE_TYPE (result), integer_zero_node),
452 result);
453 }
454
455 /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
456 paper. */
457
458 static tree
build_dynamic_cast_1(tree type,tree expr)459 build_dynamic_cast_1 (tree type, tree expr)
460 {
461 enum tree_code tc = TREE_CODE (type);
462 tree exprtype = TREE_TYPE (expr);
463 tree dcast_fn;
464 tree old_expr = expr;
465 const char *errstr = NULL;
466
467 /* Save casted types in the function's used types hash table. */
468 used_types_insert (type);
469
470 /* T shall be a pointer or reference to a complete class type, or
471 `pointer to cv void''. */
472 switch (tc)
473 {
474 case POINTER_TYPE:
475 if (TREE_CODE (TREE_TYPE (type)) == VOID_TYPE)
476 break;
477 /* Fall through. */
478 case REFERENCE_TYPE:
479 if (! IS_AGGR_TYPE (TREE_TYPE (type)))
480 {
481 errstr = "target is not pointer or reference to class";
482 goto fail;
483 }
484 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
485 {
486 errstr = "target is not pointer or reference to complete type";
487 goto fail;
488 }
489 break;
490
491 default:
492 errstr = "target is not pointer or reference";
493 goto fail;
494 }
495
496 if (tc == POINTER_TYPE)
497 {
498 /* If T is a pointer type, v shall be an rvalue of a pointer to
499 complete class type, and the result is an rvalue of type T. */
500
501 if (TREE_CODE (exprtype) != POINTER_TYPE)
502 {
503 errstr = "source is not a pointer";
504 goto fail;
505 }
506 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
507 {
508 errstr = "source is not a pointer to class";
509 goto fail;
510 }
511 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
512 {
513 errstr = "source is a pointer to incomplete type";
514 goto fail;
515 }
516 }
517 else
518 {
519 exprtype = build_reference_type (exprtype);
520
521 /* T is a reference type, v shall be an lvalue of a complete class
522 type, and the result is an lvalue of the type referred to by T. */
523
524 if (! IS_AGGR_TYPE (TREE_TYPE (exprtype)))
525 {
526 errstr = "source is not of class type";
527 goto fail;
528 }
529 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (exprtype))))
530 {
531 errstr = "source is of incomplete class type";
532 goto fail;
533 }
534
535 /* Apply trivial conversion T -> T& for dereferenced ptrs. */
536 expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
537 LOOKUP_NORMAL, NULL_TREE);
538 }
539
540 /* The dynamic_cast operator shall not cast away constness. */
541 if (!at_least_as_qualified_p (TREE_TYPE (type),
542 TREE_TYPE (exprtype)))
543 {
544 errstr = "conversion casts away constness";
545 goto fail;
546 }
547
548 /* If *type is an unambiguous accessible base class of *exprtype,
549 convert statically. */
550 {
551 tree binfo;
552
553 binfo = lookup_base (TREE_TYPE (exprtype), TREE_TYPE (type),
554 ba_check, NULL);
555
556 if (binfo)
557 {
558 expr = build_base_path (PLUS_EXPR, convert_from_reference (expr),
559 binfo, 0);
560 if (TREE_CODE (exprtype) == POINTER_TYPE)
561 expr = rvalue (expr);
562 return expr;
563 }
564 }
565
566 /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */
567 if (TYPE_POLYMORPHIC_P (TREE_TYPE (exprtype)))
568 {
569 tree expr1;
570 /* if TYPE is `void *', return pointer to complete object. */
571 if (tc == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type)))
572 {
573 /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */
574 if (TREE_CODE (expr) == ADDR_EXPR
575 && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
576 && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
577 return build1 (NOP_EXPR, type, expr);
578
579 /* Since expr is used twice below, save it. */
580 expr = save_expr (expr);
581
582 expr1 = build_headof (expr);
583 if (TREE_TYPE (expr1) != type)
584 expr1 = build1 (NOP_EXPR, type, expr1);
585 return ifnonnull (expr, expr1);
586 }
587 else
588 {
589 tree retval;
590 tree result, td2, td3, elems;
591 tree static_type, target_type, boff;
592
593 /* If we got here, we can't convert statically. Therefore,
594 dynamic_cast<D&>(b) (b an object) cannot succeed. */
595 if (tc == REFERENCE_TYPE)
596 {
597 if (TREE_CODE (old_expr) == VAR_DECL
598 && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE)
599 {
600 tree expr = throw_bad_cast ();
601 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
602 old_expr, type);
603 /* Bash it to the expected type. */
604 TREE_TYPE (expr) = type;
605 return expr;
606 }
607 }
608 /* Ditto for dynamic_cast<D*>(&b). */
609 else if (TREE_CODE (expr) == ADDR_EXPR)
610 {
611 tree op = TREE_OPERAND (expr, 0);
612 if (TREE_CODE (op) == VAR_DECL
613 && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
614 {
615 warning (0, "dynamic_cast of %q#D to %q#T can never succeed",
616 op, type);
617 retval = build_int_cst (type, 0);
618 return retval;
619 }
620 }
621
622 /* Use of dynamic_cast when -fno-rtti is prohibited. */
623 if (!flag_rtti)
624 {
625 error ("%<dynamic_cast%> not permitted with -fno-rtti");
626 return error_mark_node;
627 }
628
629 target_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
630 static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype));
631 td2 = get_tinfo_decl (target_type);
632 mark_used (td2);
633 td2 = build_unary_op (ADDR_EXPR, td2, 0);
634 td3 = get_tinfo_decl (static_type);
635 mark_used (td3);
636 td3 = build_unary_op (ADDR_EXPR, td3, 0);
637
638 /* Determine how T and V are related. */
639 boff = dcast_base_hint (static_type, target_type);
640
641 /* Since expr is used twice below, save it. */
642 expr = save_expr (expr);
643
644 expr1 = expr;
645 if (tc == REFERENCE_TYPE)
646 expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
647
648 elems = tree_cons
649 (NULL_TREE, expr1, tree_cons
650 (NULL_TREE, td3, tree_cons
651 (NULL_TREE, td2, tree_cons
652 (NULL_TREE, boff, NULL_TREE))));
653
654 dcast_fn = dynamic_cast_node;
655 if (!dcast_fn)
656 {
657 tree tmp;
658 tree tinfo_ptr;
659 tree ns = abi_node;
660 const char *name;
661
662 push_nested_namespace (ns);
663 tinfo_ptr = xref_tag (class_type,
664 get_identifier ("__class_type_info"),
665 /*tag_scope=*/ts_current, false);
666
667 tinfo_ptr = build_pointer_type
668 (build_qualified_type
669 (tinfo_ptr, TYPE_QUAL_CONST));
670 name = "__dynamic_cast";
671 tmp = tree_cons
672 (NULL_TREE, const_ptr_type_node, tree_cons
673 (NULL_TREE, tinfo_ptr, tree_cons
674 (NULL_TREE, tinfo_ptr, tree_cons
675 (NULL_TREE, ptrdiff_type_node, void_list_node))));
676 tmp = build_function_type (ptr_type_node, tmp);
677 dcast_fn = build_library_fn_ptr (name, tmp);
678 DECL_IS_PURE (dcast_fn) = 1;
679 pop_nested_namespace (ns);
680 dynamic_cast_node = dcast_fn;
681 }
682 result = build_cxx_call (dcast_fn, elems);
683
684 if (tc == REFERENCE_TYPE)
685 {
686 tree bad = throw_bad_cast ();
687 tree neq;
688
689 result = save_expr (result);
690 neq = c_common_truthvalue_conversion (result);
691 return build3 (COND_EXPR, type, neq, result, bad);
692 }
693
694 /* Now back to the type we want from a void*. */
695 result = cp_convert (type, result);
696 return ifnonnull (expr, result);
697 }
698 }
699 else
700 errstr = "source type is not polymorphic";
701
702 fail:
703 error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)",
704 expr, exprtype, type, errstr);
705 return error_mark_node;
706 }
707
708 tree
build_dynamic_cast(tree type,tree expr)709 build_dynamic_cast (tree type, tree expr)
710 {
711 if (type == error_mark_node || expr == error_mark_node)
712 return error_mark_node;
713
714 if (processing_template_decl)
715 {
716 expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
717 TREE_SIDE_EFFECTS (expr) = 1;
718
719 return expr;
720 }
721
722 return convert_from_reference (build_dynamic_cast_1 (type, expr));
723 }
724
725 /* Return the runtime bit mask encoding the qualifiers of TYPE. */
726
727 static int
qualifier_flags(tree type)728 qualifier_flags (tree type)
729 {
730 int flags = 0;
731 int quals = cp_type_quals (type);
732
733 if (quals & TYPE_QUAL_CONST)
734 flags |= 1;
735 if (quals & TYPE_QUAL_VOLATILE)
736 flags |= 2;
737 if (quals & TYPE_QUAL_RESTRICT)
738 flags |= 4;
739 return flags;
740 }
741
742 /* Return true, if the pointer chain TYPE ends at an incomplete type, or
743 contains a pointer to member of an incomplete class. */
744
745 static bool
target_incomplete_p(tree type)746 target_incomplete_p (tree type)
747 {
748 while (true)
749 if (TYPE_PTRMEM_P (type))
750 {
751 if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
752 return true;
753 type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
754 }
755 else if (TREE_CODE (type) == POINTER_TYPE)
756 type = TREE_TYPE (type);
757 else
758 return !COMPLETE_OR_VOID_TYPE_P (type);
759 }
760
761 /* Returns true if TYPE involves an incomplete class type; in that
762 case, typeinfo variables for TYPE should be emitted with internal
763 linkage. */
764
765 static bool
involves_incomplete_p(tree type)766 involves_incomplete_p (tree type)
767 {
768 switch (TREE_CODE (type))
769 {
770 case POINTER_TYPE:
771 return target_incomplete_p (TREE_TYPE (type));
772
773 case OFFSET_TYPE:
774 ptrmem:
775 return
776 (target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type))
777 || !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)));
778
779 case RECORD_TYPE:
780 if (TYPE_PTRMEMFUNC_P (type))
781 goto ptrmem;
782 /* Fall through. */
783 case UNION_TYPE:
784 if (!COMPLETE_TYPE_P (type))
785 return true;
786
787 default:
788 /* All other types do not involve incomplete class types. */
789 return false;
790 }
791 }
792
793 /* Return a CONSTRUCTOR for the common part of the type_info objects. This
794 is the vtable pointer and NTBS name. The NTBS name is emitted as a
795 comdat const char array, so it becomes a unique key for the type. Generate
796 and emit that VAR_DECL here. (We can't always emit the type_info itself
797 as comdat, because of pointers to incomplete.) */
798
799 static tree
tinfo_base_init(tinfo_s * ti,tree target)800 tinfo_base_init (tinfo_s *ti, tree target)
801 {
802 tree init = NULL_TREE;
803 tree name_decl;
804 tree vtable_ptr;
805
806 {
807 tree name_name;
808
809 /* Generate the NTBS array variable. */
810 tree name_type = build_cplus_array_type
811 (build_qualified_type (char_type_node, TYPE_QUAL_CONST),
812 NULL_TREE);
813 tree name_string = tinfo_name (target);
814
815 /* Determine the name of the variable -- and remember with which
816 type it is associated. */
817 name_name = mangle_typeinfo_string_for_type (target);
818 TREE_TYPE (name_name) = target;
819
820 name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
821 SET_DECL_ASSEMBLER_NAME (name_decl, name_name);
822 DECL_ARTIFICIAL (name_decl) = 1;
823 DECL_IGNORED_P (name_decl) = 1;
824 TREE_READONLY (name_decl) = 1;
825 TREE_STATIC (name_decl) = 1;
826 DECL_EXTERNAL (name_decl) = 0;
827 DECL_TINFO_P (name_decl) = 1;
828 set_linkage_according_to_type (target, name_decl);
829 import_export_decl (name_decl);
830 DECL_INITIAL (name_decl) = name_string;
831 mark_used (name_decl);
832 pushdecl_top_level_and_finish (name_decl, name_string);
833 }
834
835 vtable_ptr = ti->vtable;
836 if (!vtable_ptr)
837 {
838 tree real_type;
839 push_nested_namespace (abi_node);
840 real_type = xref_tag (class_type, ti->name,
841 /*tag_scope=*/ts_current, false);
842 pop_nested_namespace (abi_node);
843
844 if (!COMPLETE_TYPE_P (real_type))
845 {
846 /* We never saw a definition of this type, so we need to
847 tell the compiler that this is an exported class, as
848 indeed all of the __*_type_info classes are. */
849 SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
850 CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
851 }
852
853 vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
854 vtable_ptr = build_unary_op (ADDR_EXPR, vtable_ptr, 0);
855
856 /* We need to point into the middle of the vtable. */
857 vtable_ptr = build2
858 (PLUS_EXPR, TREE_TYPE (vtable_ptr), vtable_ptr,
859 size_binop (MULT_EXPR,
860 size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
861 TYPE_SIZE_UNIT (vtable_entry_type)));
862
863 ti->vtable = vtable_ptr;
864 }
865
866 init = tree_cons (NULL_TREE, vtable_ptr, init);
867
868 init = tree_cons (NULL_TREE, decay_conversion (name_decl), init);
869
870 init = build_constructor_from_list (NULL_TREE, nreverse (init));
871 TREE_CONSTANT (init) = 1;
872 TREE_INVARIANT (init) = 1;
873 TREE_STATIC (init) = 1;
874 init = tree_cons (NULL_TREE, init, NULL_TREE);
875
876 return init;
877 }
878
879 /* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
880 information about the particular type_info derivation, which adds no
881 additional fields to the type_info base. */
882
883 static tree
generic_initializer(tinfo_s * ti,tree target)884 generic_initializer (tinfo_s *ti, tree target)
885 {
886 tree init = tinfo_base_init (ti, target);
887
888 init = build_constructor_from_list (NULL_TREE, init);
889 TREE_CONSTANT (init) = 1;
890 TREE_INVARIANT (init) = 1;
891 TREE_STATIC (init) = 1;
892 return init;
893 }
894
895 /* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
896 TI provides information about the particular type_info derivation,
897 which adds target type and qualifier flags members to the type_info base. */
898
899 static tree
ptr_initializer(tinfo_s * ti,tree target)900 ptr_initializer (tinfo_s *ti, tree target)
901 {
902 tree init = tinfo_base_init (ti, target);
903 tree to = TREE_TYPE (target);
904 int flags = qualifier_flags (to);
905 bool incomplete = target_incomplete_p (to);
906
907 if (incomplete)
908 flags |= 8;
909 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
910 init = tree_cons (NULL_TREE,
911 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
912 init);
913
914 init = build_constructor_from_list (NULL_TREE, nreverse (init));
915 TREE_CONSTANT (init) = 1;
916 TREE_INVARIANT (init) = 1;
917 TREE_STATIC (init) = 1;
918 return init;
919 }
920
921 /* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
922 TI provides information about the particular type_info derivation,
923 which adds class, target type and qualifier flags members to the type_info
924 base. */
925
926 static tree
ptm_initializer(tinfo_s * ti,tree target)927 ptm_initializer (tinfo_s *ti, tree target)
928 {
929 tree init = tinfo_base_init (ti, target);
930 tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
931 tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
932 int flags = qualifier_flags (to);
933 bool incomplete = target_incomplete_p (to);
934
935 if (incomplete)
936 flags |= 0x8;
937 if (!COMPLETE_TYPE_P (klass))
938 flags |= 0x10;
939 init = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), init);
940 init = tree_cons (NULL_TREE,
941 get_tinfo_ptr (TYPE_MAIN_VARIANT (to)),
942 init);
943 init = tree_cons (NULL_TREE,
944 get_tinfo_ptr (klass),
945 init);
946
947 init = build_constructor_from_list (NULL_TREE, nreverse (init));
948 TREE_CONSTANT (init) = 1;
949 TREE_INVARIANT (init) = 1;
950 TREE_STATIC (init) = 1;
951 return init;
952 }
953
954 /* Return the CONSTRUCTOR expr for a type_info of class TYPE.
955 TI provides information about the particular __class_type_info derivation,
956 which adds hint flags and TRAIL initializers to the type_info base. */
957
958 static tree
class_initializer(tinfo_s * ti,tree target,tree trail)959 class_initializer (tinfo_s *ti, tree target, tree trail)
960 {
961 tree init = tinfo_base_init (ti, target);
962
963 TREE_CHAIN (init) = trail;
964 init = build_constructor_from_list (NULL_TREE, init);
965 TREE_CONSTANT (init) = 1;
966 TREE_INVARIANT (init) = 1;
967 TREE_STATIC (init) = 1;
968 return init;
969 }
970
971 /* Returns true if the typeinfo for type should be placed in
972 the runtime library. */
973
974 static bool
typeinfo_in_lib_p(tree type)975 typeinfo_in_lib_p (tree type)
976 {
977 /* The typeinfo objects for `T*' and `const T*' are in the runtime
978 library for simple types T. */
979 if (TREE_CODE (type) == POINTER_TYPE
980 && (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
981 || cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
982 type = TREE_TYPE (type);
983
984 switch (TREE_CODE (type))
985 {
986 case INTEGER_TYPE:
987 case BOOLEAN_TYPE:
988 case REAL_TYPE:
989 case VOID_TYPE:
990 return true;
991
992 default:
993 return false;
994 }
995 }
996
997 /* Generate the initializer for the type info describing TYPE. TK_INDEX is
998 the index of the descriptor in the tinfo_desc vector. */
999
1000 static tree
get_pseudo_ti_init(tree type,unsigned tk_index)1001 get_pseudo_ti_init (tree type, unsigned tk_index)
1002 {
1003 tinfo_s *ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1004
1005 gcc_assert (at_eof);
1006 switch (tk_index)
1007 {
1008 case TK_POINTER_MEMBER_TYPE:
1009 return ptm_initializer (ti, type);
1010
1011 case TK_POINTER_TYPE:
1012 return ptr_initializer (ti, type);
1013
1014 case TK_BUILTIN_TYPE:
1015 case TK_ENUMERAL_TYPE:
1016 case TK_FUNCTION_TYPE:
1017 case TK_ARRAY_TYPE:
1018 return generic_initializer (ti, type);
1019
1020 case TK_CLASS_TYPE:
1021 return class_initializer (ti, type, NULL_TREE);
1022
1023 case TK_SI_CLASS_TYPE:
1024 {
1025 tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), 0);
1026 tree tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1027 tree base_inits = tree_cons (NULL_TREE, tinfo, NULL_TREE);
1028
1029 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1030 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1031 return class_initializer (ti, type, base_inits);
1032 }
1033
1034 default:
1035 {
1036 int hint = ((CLASSTYPE_REPEATED_BASE_P (type) << 0)
1037 | (CLASSTYPE_DIAMOND_SHAPED_P (type) << 1));
1038 tree binfo = TYPE_BINFO (type);
1039 int nbases = BINFO_N_BASE_BINFOS (binfo);
1040 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1041 tree base_inits = NULL_TREE;
1042 int ix;
1043
1044 gcc_assert (tk_index >= TK_FIXED);
1045
1046 /* Generate the base information initializer. */
1047 for (ix = nbases; ix--;)
1048 {
1049 tree base_binfo = BINFO_BASE_BINFO (binfo, ix);
1050 tree base_init = NULL_TREE;
1051 int flags = 0;
1052 tree tinfo;
1053 tree offset;
1054
1055 if (VEC_index (tree, base_accesses, ix) == access_public_node)
1056 flags |= 2;
1057 tinfo = get_tinfo_ptr (BINFO_TYPE (base_binfo));
1058 if (BINFO_VIRTUAL_P (base_binfo))
1059 {
1060 /* We store the vtable offset at which the virtual
1061 base offset can be found. */
1062 offset = BINFO_VPTR_FIELD (base_binfo);
1063 offset = convert (sizetype, offset);
1064 flags |= 1;
1065 }
1066 else
1067 offset = BINFO_OFFSET (base_binfo);
1068
1069 /* Combine offset and flags into one field. */
1070 offset = cp_build_binary_op (LSHIFT_EXPR, offset,
1071 build_int_cst (NULL_TREE, 8));
1072 offset = cp_build_binary_op (BIT_IOR_EXPR, offset,
1073 build_int_cst (NULL_TREE, flags));
1074 base_init = tree_cons (NULL_TREE, offset, base_init);
1075 base_init = tree_cons (NULL_TREE, tinfo, base_init);
1076 base_init = build_constructor_from_list (NULL_TREE, base_init);
1077 base_inits = tree_cons (NULL_TREE, base_init, base_inits);
1078 }
1079 base_inits = build_constructor_from_list (NULL_TREE, base_inits);
1080 base_inits = tree_cons (NULL_TREE, base_inits, NULL_TREE);
1081 /* Prepend the number of bases. */
1082 base_inits = tree_cons (NULL_TREE,
1083 build_int_cst (NULL_TREE, nbases),
1084 base_inits);
1085 /* Prepend the hint flags. */
1086 base_inits = tree_cons (NULL_TREE,
1087 build_int_cst (NULL_TREE, hint),
1088 base_inits);
1089
1090 /* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1091 ti = VEC_index (tinfo_s, tinfo_descs, tk_index);
1092 return class_initializer (ti, type, base_inits);
1093 }
1094 }
1095 }
1096
1097 /* Generate the RECORD_TYPE containing the data layout of a type_info
1098 derivative as used by the runtime. This layout must be consistent with
1099 that defined in the runtime support. Also generate the VAR_DECL for the
1100 type's vtable. We explicitly manage the vtable member, and name it for
1101 real type as used in the runtime. The RECORD type has a different name,
1102 to avoid collisions. Return a TREE_LIST who's TINFO_PSEUDO_TYPE
1103 is the generated type and TINFO_VTABLE_NAME is the name of the
1104 vtable. We have to delay generating the VAR_DECL of the vtable
1105 until the end of the translation, when we'll have seen the library
1106 definition, if there was one.
1107
1108 REAL_NAME is the runtime's name of the type. Trailing arguments are
1109 additional FIELD_DECL's for the structure. The final argument must be
1110 NULL. */
1111
1112 static void
create_pseudo_type_info(int tk,const char * real_name,...)1113 create_pseudo_type_info (int tk, const char *real_name, ...)
1114 {
1115 tinfo_s *ti;
1116 tree pseudo_type;
1117 char *pseudo_name;
1118 tree fields;
1119 tree field_decl;
1120 va_list ap;
1121
1122 va_start (ap, real_name);
1123
1124 /* Generate the pseudo type name. */
1125 pseudo_name = (char *) alloca (strlen (real_name) + 30);
1126 strcpy (pseudo_name, real_name);
1127 strcat (pseudo_name, "_pseudo");
1128 if (tk >= TK_FIXED)
1129 sprintf (pseudo_name + strlen (pseudo_name), "%d", tk - TK_FIXED);
1130
1131 /* First field is the pseudo type_info base class. */
1132 fields = build_decl (FIELD_DECL, NULL_TREE,
1133 VEC_index (tinfo_s, tinfo_descs,
1134 TK_TYPE_INFO_TYPE)->type);
1135
1136 /* Now add the derived fields. */
1137 while ((field_decl = va_arg (ap, tree)))
1138 {
1139 TREE_CHAIN (field_decl) = fields;
1140 fields = field_decl;
1141 }
1142
1143 /* Create the pseudo type. */
1144 pseudo_type = make_aggr_type (RECORD_TYPE);
1145 finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
1146 CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
1147
1148 ti = VEC_index (tinfo_s, tinfo_descs, tk);
1149 ti->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
1150 ti->name = get_identifier (real_name);
1151 ti->vtable = NULL_TREE;
1152
1153 /* Pretend this is public so determine_visibility doesn't give vtables
1154 internal linkage. */
1155 TREE_PUBLIC (TYPE_MAIN_DECL (ti->type)) = 1;
1156
1157 va_end (ap);
1158 }
1159
1160 /* Return the index of a pseudo type info type node used to describe
1161 TYPE. TYPE must be a complete type (or cv void), except at the end
1162 of the translation unit. */
1163
1164 static unsigned
get_pseudo_ti_index(tree type)1165 get_pseudo_ti_index (tree type)
1166 {
1167 unsigned ix;
1168
1169 switch (TREE_CODE (type))
1170 {
1171 case OFFSET_TYPE:
1172 ix = TK_POINTER_MEMBER_TYPE;
1173 break;
1174
1175 case POINTER_TYPE:
1176 ix = TK_POINTER_TYPE;
1177 break;
1178
1179 case ENUMERAL_TYPE:
1180 ix = TK_ENUMERAL_TYPE;
1181 break;
1182
1183 case FUNCTION_TYPE:
1184 ix = TK_FUNCTION_TYPE;
1185 break;
1186
1187 case ARRAY_TYPE:
1188 ix = TK_ARRAY_TYPE;
1189 break;
1190
1191 case UNION_TYPE:
1192 case RECORD_TYPE:
1193 if (TYPE_PTRMEMFUNC_P (type))
1194 {
1195 ix = TK_POINTER_MEMBER_TYPE;
1196 break;
1197 }
1198 else if (!COMPLETE_TYPE_P (type))
1199 {
1200 if (!at_eof)
1201 cxx_incomplete_type_error (NULL_TREE, type);
1202 ix = TK_CLASS_TYPE;
1203 break;
1204 }
1205 else if (!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
1206 {
1207 ix = TK_CLASS_TYPE;
1208 break;
1209 }
1210 else
1211 {
1212 tree binfo = TYPE_BINFO (type);
1213 VEC(tree,gc) *base_accesses = BINFO_BASE_ACCESSES (binfo);
1214 tree base_binfo = BINFO_BASE_BINFO (binfo, 0);
1215 int num_bases = BINFO_N_BASE_BINFOS (binfo);
1216
1217 if (num_bases == 1
1218 && VEC_index (tree, base_accesses, 0) == access_public_node
1219 && !BINFO_VIRTUAL_P (base_binfo)
1220 && integer_zerop (BINFO_OFFSET (base_binfo)))
1221 {
1222 /* single non-virtual public. */
1223 ix = TK_SI_CLASS_TYPE;
1224 break;
1225 }
1226 else
1227 {
1228 tinfo_s *ti;
1229 tree array_domain, base_array;
1230
1231 ix = TK_FIXED + num_bases;
1232 if (VEC_length (tinfo_s, tinfo_descs) <= ix)
1233 {
1234 /* too short, extend. */
1235 unsigned len = VEC_length (tinfo_s, tinfo_descs);
1236
1237 VEC_safe_grow (tinfo_s, gc, tinfo_descs, ix + 1);
1238 while (VEC_iterate (tinfo_s, tinfo_descs, len++, ti))
1239 ti->type = ti->vtable = ti->name = NULL_TREE;
1240 }
1241 else if (VEC_index (tinfo_s, tinfo_descs, ix)->type)
1242 /* already created. */
1243 break;
1244
1245 /* Create the array of __base_class_type_info entries.
1246 G++ 3.2 allocated an array that had one too many
1247 entries, and then filled that extra entries with
1248 zeros. */
1249 if (abi_version_at_least (2))
1250 array_domain = build_index_type (size_int (num_bases - 1));
1251 else
1252 array_domain = build_index_type (size_int (num_bases));
1253 base_array =
1254 build_array_type (VEC_index (tinfo_s, tinfo_descs,
1255 TK_BASE_TYPE)->type,
1256 array_domain);
1257
1258 push_nested_namespace (abi_node);
1259 create_pseudo_type_info
1260 (ix, "__vmi_class_type_info",
1261 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1262 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1263 build_decl (FIELD_DECL, NULL_TREE, base_array),
1264 NULL);
1265 pop_nested_namespace (abi_node);
1266 break;
1267 }
1268 }
1269 default:
1270 ix = TK_BUILTIN_TYPE;
1271 break;
1272 }
1273 return ix;
1274 }
1275
1276 /* Make sure the required builtin types exist for generating the type_info
1277 variable definitions. */
1278
1279 static void
create_tinfo_types(void)1280 create_tinfo_types (void)
1281 {
1282 tinfo_s *ti;
1283
1284 gcc_assert (!tinfo_descs);
1285
1286 VEC_safe_grow (tinfo_s, gc, tinfo_descs, TK_FIXED);
1287
1288 push_nested_namespace (abi_node);
1289
1290 /* Create the internal type_info structure. This is used as a base for
1291 the other structures. */
1292 {
1293 tree field, fields;
1294
1295 field = build_decl (FIELD_DECL, NULL_TREE, const_ptr_type_node);
1296 fields = field;
1297
1298 field = build_decl (FIELD_DECL, NULL_TREE, const_string_type_node);
1299 TREE_CHAIN (field) = fields;
1300 fields = field;
1301
1302 ti = VEC_index (tinfo_s, tinfo_descs, TK_TYPE_INFO_TYPE);
1303 ti->type = make_aggr_type (RECORD_TYPE);
1304 ti->vtable = NULL_TREE;
1305 ti->name = NULL_TREE;
1306 finish_builtin_struct (ti->type, "__type_info_pseudo",
1307 fields, NULL_TREE);
1308 TYPE_HAS_CONSTRUCTOR (ti->type) = 1;
1309 }
1310
1311 /* Fundamental type_info */
1312 create_pseudo_type_info (TK_BUILTIN_TYPE, "__fundamental_type_info", NULL);
1313
1314 /* Array, function and enum type_info. No additional fields. */
1315 create_pseudo_type_info (TK_ARRAY_TYPE, "__array_type_info", NULL);
1316 create_pseudo_type_info (TK_FUNCTION_TYPE, "__function_type_info", NULL);
1317 create_pseudo_type_info (TK_ENUMERAL_TYPE, "__enum_type_info", NULL);
1318
1319 /* Class type_info. No additional fields. */
1320 create_pseudo_type_info (TK_CLASS_TYPE, "__class_type_info", NULL);
1321
1322 /* Single public non-virtual base class. Add pointer to base class.
1323 This is really a descendant of __class_type_info. */
1324 create_pseudo_type_info (TK_SI_CLASS_TYPE, "__si_class_type_info",
1325 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1326 NULL);
1327
1328 /* Base class internal helper. Pointer to base type, offset to base,
1329 flags. */
1330 {
1331 tree field, fields;
1332
1333 field = build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type);
1334 fields = field;
1335
1336 field = build_decl (FIELD_DECL, NULL_TREE, integer_types[itk_long]);
1337 TREE_CHAIN (field) = fields;
1338 fields = field;
1339
1340 ti = VEC_index (tinfo_s, tinfo_descs, TK_BASE_TYPE);
1341
1342 ti->type = make_aggr_type (RECORD_TYPE);
1343 ti->vtable = NULL_TREE;
1344 ti->name = NULL_TREE;
1345 finish_builtin_struct (ti->type, "__base_class_type_info_pseudo",
1346 fields, NULL_TREE);
1347 TYPE_HAS_CONSTRUCTOR (ti->type) = 1;
1348 }
1349
1350 /* Pointer type_info. Adds two fields, qualification mask
1351 and pointer to the pointed to type. This is really a descendant of
1352 __pbase_type_info. */
1353 create_pseudo_type_info (TK_POINTER_TYPE, "__pointer_type_info",
1354 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1355 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1356 NULL);
1357
1358 /* Pointer to member data type_info. Add qualifications flags,
1359 pointer to the member's type info and pointer to the class.
1360 This is really a descendant of __pbase_type_info. */
1361 create_pseudo_type_info (TK_POINTER_MEMBER_TYPE,
1362 "__pointer_to_member_type_info",
1363 build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
1364 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1365 build_decl (FIELD_DECL, NULL_TREE, type_info_ptr_type),
1366 NULL);
1367
1368 pop_nested_namespace (abi_node);
1369 }
1370
1371 /* Emit the type_info descriptors which are guaranteed to be in the runtime
1372 support. Generating them here guarantees consistency with the other
1373 structures. We use the following heuristic to determine when the runtime
1374 is being generated. If std::__fundamental_type_info is defined, and its
1375 destructor is defined, then the runtime is being built. */
1376
1377 void
emit_support_tinfos(void)1378 emit_support_tinfos (void)
1379 {
1380 static tree *const fundamentals[] =
1381 {
1382 &void_type_node,
1383 &boolean_type_node,
1384 &wchar_type_node,
1385 &char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1386 &short_integer_type_node, &short_unsigned_type_node,
1387 &integer_type_node, &unsigned_type_node,
1388 &long_integer_type_node, &long_unsigned_type_node,
1389 &long_long_integer_type_node, &long_long_unsigned_type_node,
1390 &float_type_node, &double_type_node, &long_double_type_node,
1391 0
1392 };
1393 int ix;
1394 tree bltn_type, dtor;
1395
1396 push_nested_namespace (abi_node);
1397 bltn_type = xref_tag (class_type,
1398 get_identifier ("__fundamental_type_info"),
1399 /*tag_scope=*/ts_current, false);
1400 pop_nested_namespace (abi_node);
1401 if (!COMPLETE_TYPE_P (bltn_type))
1402 return;
1403 dtor = CLASSTYPE_DESTRUCTORS (bltn_type);
1404 if (!dtor || DECL_EXTERNAL (dtor))
1405 return;
1406 doing_runtime = 1;
1407 for (ix = 0; fundamentals[ix]; ix++)
1408 {
1409 tree bltn = *fundamentals[ix];
1410 tree types[3];
1411 int i;
1412
1413 types[0] = bltn;
1414 types[1] = build_pointer_type (bltn);
1415 types[2] = build_pointer_type (build_qualified_type (bltn,
1416 TYPE_QUAL_CONST));
1417
1418 for (i = 0; i < 3; ++i)
1419 {
1420 tree tinfo;
1421
1422 tinfo = get_tinfo_decl (types[i]);
1423 TREE_USED (tinfo) = 1;
1424 mark_needed (tinfo);
1425 /* The C++ ABI requires that these objects be COMDAT. But,
1426 On systems without weak symbols, initialized COMDAT
1427 objects are emitted with internal linkage. (See
1428 comdat_linkage for details.) Since we want these objects
1429 to have external linkage so that copies do not have to be
1430 emitted in code outside the runtime library, we make them
1431 non-COMDAT here.
1432
1433 It might also not be necessary to follow this detail of the
1434 ABI. */
1435 if (!flag_weak || ! targetm.cxx.library_rtti_comdat ())
1436 {
1437 gcc_assert (TREE_PUBLIC (tinfo) && !DECL_COMDAT (tinfo));
1438 DECL_INTERFACE_KNOWN (tinfo) = 1;
1439 }
1440 }
1441 }
1442 }
1443
1444 /* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1445 tinfo decl. Determine whether it needs emitting, and if so
1446 generate the initializer. */
1447
1448 bool
emit_tinfo_decl(tree decl)1449 emit_tinfo_decl (tree decl)
1450 {
1451 tree type = TREE_TYPE (DECL_NAME (decl));
1452 int in_library = typeinfo_in_lib_p (type);
1453
1454 gcc_assert (DECL_TINFO_P (decl));
1455
1456 if (in_library)
1457 {
1458 if (doing_runtime)
1459 DECL_EXTERNAL (decl) = 0;
1460 else
1461 {
1462 /* If we're not in the runtime, then DECL (which is already
1463 DECL_EXTERNAL) will not be defined here. */
1464 DECL_INTERFACE_KNOWN (decl) = 1;
1465 return false;
1466 }
1467 }
1468 else if (involves_incomplete_p (type))
1469 {
1470 if (!decl_needed_p (decl))
1471 return false;
1472 /* If TYPE involves an incomplete class type, then the typeinfo
1473 object will be emitted with internal linkage. There is no
1474 way to know whether or not types are incomplete until the end
1475 of the compilation, so this determination must be deferred
1476 until this point. */
1477 TREE_PUBLIC (decl) = 0;
1478 DECL_EXTERNAL (decl) = 0;
1479 DECL_INTERFACE_KNOWN (decl) = 1;
1480 }
1481
1482 import_export_decl (decl);
1483 if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
1484 {
1485 tree init;
1486
1487 DECL_EXTERNAL (decl) = 0;
1488 init = get_pseudo_ti_init (type, get_pseudo_ti_index (type));
1489 DECL_INITIAL (decl) = init;
1490 mark_used (decl);
1491 finish_decl (decl, init, NULL_TREE);
1492 return true;
1493 }
1494 else
1495 return false;
1496 }
1497
1498 #include "gt-cp-rtti.h"
1499