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