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