1	/* RunTime Type Identification
2	Copyright (C) 1995-2024 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
147	init_rtti_processing (void)
148	{
149	vec_alloc (v&: unemitted_tinfo_decls, nelems: 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
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
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 (id: 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
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 (id: 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
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
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
251	get_void_tinfo_ptr (tree type)
252	{
253	return get_tinfo_ptr (type, voidp: 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
262	get_tinfo_decl_dynamic (tree exp, tsubst_flags_t complain)
263	{
264	tree type;
265	tree t;
266
267	if (error_operand_p (t: 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
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
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
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 (s: 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 (dest: buf + 1, src: name, n: 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
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
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 (id: 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 (v: 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 (v&: unemitted_tinfo_decls, obj: d);
497	}
498
499	return d;
500	}
501
502	/* Return the type_info object for TYPE. */
503
504	tree
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
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
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 (exp: expr);
693	if (TREE_TYPE (expr1) != type)
694	expr1 = build1 (NOP_EXPR, type, expr1);
695	return build_if_nonnull (test: expr, result: 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 (type: 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 (type: 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	/* As with __cxa_atexit in get_atexit_node. */
791	DECL_CONTEXT (dcast_fn) = FROB_CONTEXT (current_namespace);
792	DECL_SOURCE_LOCATION (dcast_fn) = BUILTINS_LOCATION;
793	dcast_fn = pushdecl (dcast_fn, /*hiding=*/true);
794	pop_abi_namespace (flags);
795	dynamic_cast_node = dcast_fn;
796	}
797	result = build_cxx_call (dcast_fn, 4, elems, complain);
798	SET_EXPR_LOCATION (result, loc);
799
800	if (tc == REFERENCE_TYPE)
801	{
802	tree bad = throw_bad_cast ();
803	tree neq;
804
805	result = save_expr (result);
806	neq = cp_truthvalue_conversion (result, complain);
807	return cp_convert (type,
808	build3 (COND_EXPR, TREE_TYPE (result),
809	neq, result, bad), complain);
810	}
811
812	/* Now back to the type we want from a void*. */
813	result = cp_convert (type, result, complain);
814	return build_if_nonnull (test: expr, result, complain);
815	}
816	}
817	else
818	errstr = _("source type is not polymorphic");
819
820	fail:
821	if (complain & tf_error)
822	error_at (loc, "cannot %<dynamic_cast%> %qE (of type %q#T) "
823	"to type %q#T (%s)",
824	old_expr, TREE_TYPE (old_expr), type, errstr);
825	return error_mark_node;
826	}
827
828	tree
829	build_dynamic_cast (location_t loc, tree type, tree expr,
830	tsubst_flags_t complain)
831	{
832	tree r;
833
834	if (type == error_mark_node || expr == error_mark_node)
835	return error_mark_node;
836
837	if (processing_template_decl)
838	{
839	expr = build_min (DYNAMIC_CAST_EXPR, type, expr);
840	TREE_SIDE_EFFECTS (expr) = 1;
841	r = convert_from_reference (expr);
842	protected_set_expr_location (r, loc);
843	return r;
844	}
845
846	r = convert_from_reference (build_dynamic_cast_1 (loc, type, expr,
847	complain));
848	if (r != error_mark_node)
849	maybe_warn_about_useless_cast (loc, type, expr, complain);
850	protected_set_expr_location (r, loc);
851	return r;
852	}
853
854	/* Return the runtime bit mask encoding the qualifiers of TYPE. */
855
856	static int
857	qualifier_flags (tree type)
858	{
859	int flags = 0;
860	int quals = cp_type_quals (type);
861
862	if (quals & TYPE_QUAL_CONST)
863	flags |= 1;
864	if (quals & TYPE_QUAL_VOLATILE)
865	flags |= 2;
866	if (quals & TYPE_QUAL_RESTRICT)
867	flags |= 4;
868	return flags;
869	}
870
871	/* Return true, if the pointer chain TYPE ends at an incomplete type, or
872	contains a pointer to member of an incomplete class. */
873
874	static bool
875	target_incomplete_p (tree type)
876	{
877	while (true)
878	if (TYPE_PTRDATAMEM_P (type))
879	{
880	if (!COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)))
881	return true;
882	type = TYPE_PTRMEM_POINTED_TO_TYPE (type);
883	}
884	else if (TYPE_PTR_P (type))
885	type = TREE_TYPE (type);
886	else
887	return !COMPLETE_OR_VOID_TYPE_P (type);
888	}
889
890	/* Returns true if TYPE involves an incomplete class type; in that
891	case, typeinfo variables for TYPE should be emitted with internal
892	linkage. */
893
894	static bool
895	involves_incomplete_p (tree type)
896	{
897	switch (TREE_CODE (type))
898	{
899	case POINTER_TYPE:
900	return target_incomplete_p (TREE_TYPE (type));
901
902	case OFFSET_TYPE:
903	ptrmem:
904	return
905	(target_incomplete_p (TYPE_PTRMEM_POINTED_TO_TYPE (type))
906	|| !COMPLETE_TYPE_P (TYPE_PTRMEM_CLASS_TYPE (type)));
907
908	case RECORD_TYPE:
909	if (TYPE_PTRMEMFUNC_P (type))
910	goto ptrmem;
911	/* Fall through. */
912	case UNION_TYPE:
913	if (!COMPLETE_TYPE_P (type))
914	return true;
915	/* Fall through. */
916	default:
917	/* All other types do not involve incomplete class types. */
918	return false;
919	}
920	}
921
922	/* Return a CONSTRUCTOR for the common part of the type_info objects. This
923	is the vtable pointer and NTBS name. The NTBS name is emitted as a
924	comdat const char array, so it becomes a unique key for the type. Generate
925	and emit that VAR_DECL here. (We can't always emit the type_info itself
926	as comdat, because of pointers to incomplete.) */
927
928	static tree
929	tinfo_base_init (tinfo_s *ti, tree target)
930	{
931	tree init;
932	tree name_decl;
933	tree vtable_ptr;
934	vec<constructor_elt, va_gc> *v;
935
936	{
937	tree name_name, name_string;
938
939	/* Generate the NTBS array variable. */
940	tree name_type = build_cplus_array_type
941	(cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST),
942	NULL_TREE);
943
944	/* Determine the name of the variable -- and remember with which
945	type it is associated. */
946	name_name = mangle_typeinfo_string_for_type (target);
947	TREE_TYPE (name_name) = target;
948
949	name_decl = build_lang_decl (VAR_DECL, name_name, name_type);
950	SET_DECL_ASSEMBLER_NAME (name_decl, name_name);
951	DECL_ARTIFICIAL (name_decl) = 1;
952	DECL_IGNORED_P (name_decl) = 1;
953	TREE_READONLY (name_decl) = 1;
954	TREE_STATIC (name_decl) = 1;
955	DECL_EXTERNAL (name_decl) = 0;
956	DECL_TINFO_P (name_decl) = 1;
957	set_linkage_according_to_type (target, name_decl);
958	import_export_decl (name_decl);
959	name_string = tinfo_name (type: target, mark_private: !TREE_PUBLIC (name_decl));
960	DECL_INITIAL (name_decl) = name_string;
961	mark_used (name_decl);
962	pushdecl_top_level_and_finish (name_decl, name_string);
963	}
964
965	vtable_ptr = ti->vtable;
966	if (!vtable_ptr)
967	{
968	int flags = push_abi_namespace ();
969	tree real_type = xref_tag (class_type, ti->name);
970	tree real_decl = TYPE_NAME (real_type);
971	DECL_SOURCE_LOCATION (real_decl) = BUILTINS_LOCATION;
972	pop_abi_namespace (flags);
973
974	if (!COMPLETE_TYPE_P (real_type))
975	{
976	/* We never saw a definition of this type, so we need to
977	tell the compiler that this is an exported class, as
978	indeed all of the __*_type_info classes are. */
979	SET_CLASSTYPE_INTERFACE_KNOWN (real_type);
980	CLASSTYPE_INTERFACE_ONLY (real_type) = 1;
981	}
982
983	vtable_ptr = get_vtable_decl (real_type, /*complete=*/1);
984	vtable_ptr = cp_build_addr_expr (vtable_ptr, tf_warning_or_error);
985
986	/* We need to point into the middle of the vtable. */
987	vtable_ptr = fold_build_pointer_plus
988	(vtable_ptr,
989	size_binop (MULT_EXPR,
990	size_int (2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE),
991	TYPE_SIZE_UNIT (vtable_entry_type)));
992
993	ti->vtable = vtable_ptr;
994	}
995
996	vec_alloc (v, nelems: 2);
997	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, vtable_ptr);
998	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
999	decay_conversion (name_decl, tf_warning_or_error));
1000
1001	init = build_constructor (init_list_type_node, v);
1002	TREE_CONSTANT (init) = 1;
1003	TREE_STATIC (init) = 1;
1004
1005	return init;
1006	}
1007
1008	/* Return the CONSTRUCTOR expr for a type_info of TYPE. TI provides the
1009	information about the particular type_info derivation, which adds no
1010	additional fields to the type_info base. */
1011
1012	static tree
1013	generic_initializer (tinfo_s *ti, tree target)
1014	{
1015	tree init = tinfo_base_init (ti, target);
1016
1017	init = build_constructor_single (init_list_type_node, NULL_TREE, init);
1018	TREE_CONSTANT (init) = 1;
1019	TREE_STATIC (init) = 1;
1020	return init;
1021	}
1022
1023	/* Return the CONSTRUCTOR expr for a type_info of pointer TYPE.
1024	TI provides information about the particular type_info derivation,
1025	which adds target type and qualifier flags members to the type_info base. */
1026
1027	static tree
1028	ptr_initializer (tinfo_s *ti, tree target)
1029	{
1030	tree init = tinfo_base_init (ti, target);
1031	tree to = TREE_TYPE (target);
1032	int flags = qualifier_flags (type: to);
1033	bool incomplete = target_incomplete_p (type: to);
1034	vec<constructor_elt, va_gc> *v;
1035	vec_alloc (v, nelems: 3);
1036
1037	if (incomplete)
1038	flags |= 8;
1039	if (tx_safe_fn_type_p (to))
1040	{
1041	flags |= 0x20;
1042	to = tx_unsafe_fn_variant (to);
1043	}
1044	if (flag_noexcept_type
1045	&& FUNC_OR_METHOD_TYPE_P (to)
1046	&& TYPE_NOTHROW_P (to))
1047	{
1048	flags |= 0x40;
1049	to = build_exception_variant (to, NULL_TREE);
1050	}
1051	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
1052	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, flags));
1053	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
1054	get_void_tinfo_ptr (TYPE_MAIN_VARIANT (to)));
1055
1056	init = build_constructor (init_list_type_node, v);
1057	TREE_CONSTANT (init) = 1;
1058	TREE_STATIC (init) = 1;
1059	return init;
1060	}
1061
1062	/* Return the CONSTRUCTOR expr for a type_info of pointer to member data TYPE.
1063	TI provides information about the particular type_info derivation,
1064	which adds class, target type and qualifier flags members to the type_info
1065	base. */
1066
1067	static tree
1068	ptm_initializer (tinfo_s *ti, tree target)
1069	{
1070	tree init = tinfo_base_init (ti, target);
1071	tree to = TYPE_PTRMEM_POINTED_TO_TYPE (target);
1072	tree klass = TYPE_PTRMEM_CLASS_TYPE (target);
1073	int flags = qualifier_flags (type: to);
1074	bool incomplete = target_incomplete_p (type: to);
1075	vec<constructor_elt, va_gc> *v;
1076	vec_alloc (v, nelems: 4);
1077
1078	if (incomplete)
1079	flags |= 0x8;
1080	if (!COMPLETE_TYPE_P (klass))
1081	flags |= 0x10;
1082	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
1083	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, flags));
1084	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
1085	get_void_tinfo_ptr (TYPE_MAIN_VARIANT (to)));
1086	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, get_void_tinfo_ptr (klass));
1087
1088	init = build_constructor (init_list_type_node, v);
1089	TREE_CONSTANT (init) = 1;
1090	TREE_STATIC (init) = 1;
1091	return init;
1092	}
1093
1094	/* Return the CONSTRUCTOR expr for a type_info of class TYPE.
1095	TI provides information about the particular __class_type_info derivation,
1096	which adds hint flags and N extra initializers to the type_info base. */
1097
1098	static tree
1099	class_initializer (tinfo_s *ti, tree target, unsigned n, ...)
1100	{
1101	tree init = tinfo_base_init (ti, target);
1102	va_list extra_inits;
1103	unsigned i;
1104	vec<constructor_elt, va_gc> *v;
1105	vec_alloc (v, nelems: n+1);
1106
1107	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
1108	va_start (extra_inits, n);
1109	for (i = 0; i < n; i++)
1110	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, va_arg (extra_inits, tree));
1111	va_end (extra_inits);
1112
1113	init = build_constructor (init_list_type_node, v);
1114	TREE_CONSTANT (init) = 1;
1115	TREE_STATIC (init) = 1;
1116	return init;
1117	}
1118
1119	/* Returns true if the typeinfo for type should be placed in
1120	the runtime library. */
1121
1122	static bool
1123	typeinfo_in_lib_p (tree type)
1124	{
1125	/* The typeinfo objects for `T*' and `const T*' are in the runtime
1126	library for simple types T. */
1127	if (TYPE_PTR_P (type)
1128	&& (cp_type_quals (TREE_TYPE (type)) == TYPE_QUAL_CONST
1129	|| cp_type_quals (TREE_TYPE (type)) == TYPE_UNQUALIFIED))
1130	type = TREE_TYPE (type);
1131
1132	switch (TREE_CODE (type))
1133	{
1134	case INTEGER_TYPE:
1135	case BOOLEAN_TYPE:
1136	case REAL_TYPE:
1137	case VOID_TYPE:
1138	case NULLPTR_TYPE:
1139	return true;
1140
1141	case LANG_TYPE:
1142	/* fall through. */
1143
1144	default:
1145	return false;
1146	}
1147	}
1148
1149	/* Generate the initializer for the type info describing TYPE. TK_INDEX is
1150	the index of the descriptor in the tinfo_desc vector. */
1151
1152	static tree
1153	get_pseudo_ti_init (tree type, unsigned tk_index)
1154	{
1155	tinfo_s *ti = get_tinfo_desc (tk_index);
1156
1157	gcc_assert (at_eof);
1158	switch (tk_index)
1159	{
1160	case TK_POINTER_MEMBER_TYPE:
1161	return ptm_initializer (ti, target: type);
1162
1163	case TK_POINTER_TYPE:
1164	return ptr_initializer (ti, target: type);
1165
1166	case TK_BUILTIN_TYPE:
1167	case TK_ENUMERAL_TYPE:
1168	case TK_FUNCTION_TYPE:
1169	case TK_ARRAY_TYPE:
1170	return generic_initializer (ti, target: type);
1171
1172	case TK_CLASS_TYPE:
1173	return class_initializer (ti, target: type, n: 0);
1174
1175	case TK_SI_CLASS_TYPE:
1176	{
1177	tree base_binfo = BINFO_BASE_BINFO (TYPE_BINFO (type), 0);
1178	tree tinfo = get_void_tinfo_ptr (BINFO_TYPE (base_binfo));
1179
1180	/* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1181	ti = &(*tinfo_descs)[tk_index];
1182	return class_initializer (ti, target: type, n: 1, tinfo);
1183	}
1184
1185	default:
1186	{
1187	int hint = ((CLASSTYPE_REPEATED_BASE_P (type) << 0)
1188	| (CLASSTYPE_DIAMOND_SHAPED_P (type) << 1));
1189	tree binfo = TYPE_BINFO (type);
1190	unsigned nbases = BINFO_N_BASE_BINFOS (binfo);
1191	vec<tree, va_gc> *base_accesses = BINFO_BASE_ACCESSES (binfo);
1192	tree offset_type = LONGPTR_T;
1193	vec<constructor_elt, va_gc> *init_vec = NULL;
1194
1195	gcc_assert (tk_index - TK_VMI_CLASS_TYPES + 1 == nbases);
1196
1197	vec_safe_grow (v&: init_vec, len: nbases, exact: true);
1198	/* Generate the base information initializer. */
1199	for (unsigned ix = nbases; ix--;)
1200	{
1201	tree base_binfo = BINFO_BASE_BINFO (binfo, ix);
1202	int flags = 0;
1203	tree tinfo;
1204	tree offset;
1205	vec<constructor_elt, va_gc> *v;
1206
1207	if ((*base_accesses)[ix] == access_public_node)
1208	flags |= 2;
1209	tinfo = get_void_tinfo_ptr (BINFO_TYPE (base_binfo));
1210	if (BINFO_VIRTUAL_P (base_binfo))
1211	{
1212	/* We store the vtable offset at which the virtual
1213	base offset can be found. */
1214	offset = BINFO_VPTR_FIELD (base_binfo);
1215	flags |= 1;
1216	}
1217	else
1218	offset = BINFO_OFFSET (base_binfo);
1219
1220	/* Combine offset and flags into one field. */
1221	offset = fold_convert (offset_type, offset);
1222	offset = fold_build2_loc (input_location,
1223	LSHIFT_EXPR, offset_type, offset,
1224	build_int_cst (offset_type, 8));
1225	offset = fold_build2_loc (input_location,
1226	BIT_IOR_EXPR, offset_type, offset,
1227	build_int_cst (offset_type, flags));
1228	vec_alloc (v, nelems: 2);
1229	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, tinfo);
1230	CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, offset);
1231	tree base_init = build_constructor (init_list_type_node, v);
1232	constructor_elt *e = &(*init_vec)[ix];
1233	e->index = NULL_TREE;
1234	e->value = base_init;
1235	}
1236	tree base_inits = build_constructor (init_list_type_node, init_vec);
1237
1238	/* get_tinfo_ptr might have reallocated the tinfo_descs vector. */
1239	ti = &(*tinfo_descs)[tk_index];
1240	return class_initializer (ti, target: type, n: 3,
1241	build_int_cst (NULL_TREE, hint),
1242	build_int_cst (NULL_TREE, nbases),
1243	base_inits);
1244	}
1245	}
1246	}
1247
1248	/* Return the index of a pseudo type info type node used to describe
1249	TYPE. TYPE must be a complete type (or cv void), except at the end
1250	of the translation unit. */
1251
1252	static unsigned
1253	get_pseudo_ti_index (tree type)
1254	{
1255	unsigned ix;
1256
1257	switch (TREE_CODE (type))
1258	{
1259	case OFFSET_TYPE:
1260	ix = TK_POINTER_MEMBER_TYPE;
1261	break;
1262
1263	case POINTER_TYPE:
1264	ix = TK_POINTER_TYPE;
1265	break;
1266
1267	case ENUMERAL_TYPE:
1268	ix = TK_ENUMERAL_TYPE;
1269	break;
1270
1271	case FUNCTION_TYPE:
1272	ix = TK_FUNCTION_TYPE;
1273	break;
1274
1275	case ARRAY_TYPE:
1276	ix = TK_ARRAY_TYPE;
1277	break;
1278
1279	case UNION_TYPE:
1280	case RECORD_TYPE:
1281	if (TYPE_PTRMEMFUNC_P (type))
1282	ix = TK_POINTER_MEMBER_TYPE;
1283	else if (!COMPLETE_TYPE_P (type))
1284	{
1285	if (!at_eof)
1286	cxx_incomplete_type_error (NULL_TREE, type);
1287	ix = TK_CLASS_TYPE;
1288	}
1289	else if (!TYPE_BINFO (type)
1290	|| !BINFO_N_BASE_BINFOS (TYPE_BINFO (type)))
1291	ix = TK_CLASS_TYPE;
1292	else
1293	{
1294	tree binfo = TYPE_BINFO (type);
1295	vec<tree, va_gc> *base_accesses = BINFO_BASE_ACCESSES (binfo);
1296	tree base_binfo = BINFO_BASE_BINFO (binfo, 0);
1297	int num_bases = BINFO_N_BASE_BINFOS (binfo);
1298
1299	if (num_bases == 1
1300	&& (*base_accesses)[0] == access_public_node
1301	&& !BINFO_VIRTUAL_P (base_binfo)
1302	&& integer_zerop (BINFO_OFFSET (base_binfo)))
1303	/* single non-virtual public. */
1304	ix = TK_SI_CLASS_TYPE;
1305	else
1306	ix = TK_VMI_CLASS_TYPES + num_bases - 1;
1307	}
1308	break;
1309
1310	default:
1311	ix = TK_BUILTIN_TYPE;
1312	break;
1313	}
1314	return ix;
1315	}
1316
1317	/* Return pointer to tinfo descriptor. Possibly creating the tinfo
1318	descriptor in the first place. */
1319
1320	static tinfo_s *
1321	get_tinfo_desc (unsigned ix)
1322	{
1323	unsigned len = tinfo_descs->length ();
1324
1325	if (len <= ix)
1326	{
1327	/* too short, extend. */
1328	len = ix + 1 - len;
1329	vec_safe_reserve (v&: tinfo_descs, nelems: len);
1330	tinfo_s elt;
1331	elt.type = elt.vtable = elt.name = NULL_TREE;
1332	while (len--)
1333	tinfo_descs->quick_push (obj: elt);
1334	}
1335
1336	tinfo_s *res = &(*tinfo_descs)[ix];
1337
1338	if (res->type)
1339	return res;
1340
1341	/* Ok, we have to create it. This layout must be consistent with
1342	that defined in the runtime support. We explicitly manage the
1343	vtable member, and name it for real type as used in the runtime.
1344	The RECORD type has a different name, to avoid collisions. We
1345	have to delay generating the VAR_DECL of the vtable until the end
1346	of the translation, when we'll have seen the library definition,
1347	if there was one. */
1348
1349	/* Fields to add, chained in reverse order. */
1350	tree fields = NULL_TREE;
1351
1352	if (ix >= TK_DERIVED_TYPES)
1353	{
1354	/* First field is the pseudo type_info base class. */
1355	tree fld_base = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
1356	get_tinfo_desc (ix: TK_TYPE_INFO_TYPE)->type);
1357
1358	DECL_CHAIN (fld_base) = fields;
1359	fields = fld_base;
1360	}
1361
1362	switch (ix)
1363	{
1364	case TK_TYPE_INFO_TYPE:
1365	{
1366	tree fld_ptr = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1367	NULL_TREE, const_ptr_type_node);
1368	fields = fld_ptr;
1369
1370	tree fld_str = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1371	NULL_TREE, const_string_type_node);
1372	DECL_CHAIN (fld_str) = fields;
1373	fields = fld_str;
1374	break;
1375	}
1376
1377	case TK_BASE_TYPE:
1378	{
1379	/* Base class internal helper. Pointer to base type, offset to
1380	base, flags. */
1381	tree fld_ptr = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1382	NULL_TREE, const_ptr_type_node);
1383	DECL_CHAIN (fld_ptr) = fields;
1384	fields = fld_ptr;
1385
1386	tree fld_flag = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1387	NULL_TREE, LONGPTR_T);
1388	DECL_CHAIN (fld_flag) = fields;
1389	fields = fld_flag;
1390	break;
1391	}
1392
1393	case TK_BUILTIN_TYPE:
1394	/* Fundamental type_info */
1395	break;
1396
1397	case TK_ARRAY_TYPE:
1398	break;
1399
1400	case TK_FUNCTION_TYPE:
1401	break;
1402
1403	case TK_ENUMERAL_TYPE:
1404	break;
1405
1406	case TK_POINTER_TYPE:
1407	case TK_POINTER_MEMBER_TYPE:
1408	{
1409	/* Pointer type_info. Adds two fields, qualification mask and
1410	pointer to the pointed to type. This is really a
1411	descendant of __pbase_type_info. */
1412	tree fld_mask = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1413	NULL_TREE, integer_type_node);
1414	DECL_CHAIN (fld_mask) = fields;
1415	fields = fld_mask;
1416
1417	tree fld_ptr = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1418	NULL_TREE, const_ptr_type_node);
1419	DECL_CHAIN (fld_ptr) = fields;
1420	fields = fld_ptr;
1421
1422	if (ix == TK_POINTER_MEMBER_TYPE)
1423	{
1424	/* Add a pointer to the class too. */
1425	tree fld_cls = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1426	NULL_TREE, const_ptr_type_node);
1427	DECL_CHAIN (fld_cls) = fields;
1428	fields = fld_cls;
1429	}
1430	break;
1431	}
1432
1433	case TK_CLASS_TYPE:
1434	/* Class type_info. No additional fields. */
1435	break;
1436
1437	case TK_SI_CLASS_TYPE:
1438	{
1439	/* Single public non-virtual base class. Add pointer to base
1440	class. This is really a descendant of
1441	__class_type_info. */
1442	tree fld_ptr = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1443	NULL_TREE, const_ptr_type_node);
1444	DECL_CHAIN (fld_ptr) = fields;
1445	fields = fld_ptr;
1446	break;
1447	}
1448
1449	default: /* Multiple inheritance. */
1450	{
1451	unsigned num_bases = ix - TK_VMI_CLASS_TYPES + 1;
1452
1453	tree fld_flg = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1454	NULL_TREE, integer_type_node);
1455	DECL_CHAIN (fld_flg) = fields;
1456	fields = fld_flg;
1457
1458	tree fld_cnt = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1459	NULL_TREE, integer_type_node);
1460	DECL_CHAIN (fld_cnt) = fields;
1461	fields = fld_cnt;
1462
1463	/* Create the array of __base_class_type_info entries. */
1464	tree domain = build_index_type (size_int (num_bases - 1));
1465	tree array = build_array_type (get_tinfo_desc (ix: TK_BASE_TYPE)->type,
1466	domain);
1467	tree fld_ary = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1468	NULL_TREE, array);
1469	DECL_CHAIN (fld_ary) = fields;
1470	fields = fld_ary;
1471	break;
1472	}
1473	}
1474
1475	/* Generate the pseudo type name. */
1476	const char *real_name = tinfo_names[ix < TK_VMI_CLASS_TYPES
1477	? ix : unsigned (TK_VMI_CLASS_TYPES)];
1478	size_t name_len = strlen (s: real_name);
1479	char *pseudo_name = (char *) alloca (name_len + 30);
1480	memcpy (dest: pseudo_name, src: real_name, n: name_len);
1481	/* Those >= TK_VMI_CLASS_TYPES need a discriminator, may as well
1482	apply it to all. See get_peudo_tinfo_index where we make use of
1483	this. */
1484	sprintf (s: pseudo_name + name_len, format: "_pseudo_%d", ix);
1485
1486	/* Create the pseudo type. */
1487	tree pseudo_type = make_class_type (RECORD_TYPE);
1488	/* Pass the fields chained in reverse. */
1489	finish_builtin_struct (pseudo_type, pseudo_name, fields, NULL_TREE);
1490	CLASSTYPE_AS_BASE (pseudo_type) = pseudo_type;
1491	DECL_CONTEXT (TYPE_NAME (pseudo_type)) = FROB_CONTEXT (global_namespace);
1492	DECL_TINFO_P (TYPE_NAME (pseudo_type)) = true;
1493	xref_basetypes (pseudo_type, /*bases=*/NULL_TREE);
1494
1495	res->type = cp_build_qualified_type (pseudo_type, TYPE_QUAL_CONST);
1496	res->name = get_identifier (real_name);
1497
1498	/* Pretend this is public so determine_visibility doesn't give vtables
1499	internal linkage. */
1500	TREE_PUBLIC (TYPE_MAIN_DECL (res->type)) = 1;
1501
1502	return res;
1503	}
1504
1505	/* Return an identifying index for the pseudo type_info TYPE.
1506	We wrote the index at the end of the name, so just scan it from
1507	there. This isn't critical, as it's only on the first use of this
1508	type during module stream out. */
1509
1510	unsigned
1511	get_pseudo_tinfo_index (tree type)
1512	{
1513	tree name = DECL_NAME (TYPE_NAME (type));
1514	unsigned ix = 0, scale = 1;
1515	size_t len = IDENTIFIER_LENGTH (name);
1516	const char *ptr = IDENTIFIER_POINTER (name) + len;
1517
1518	for (; *--ptr != '_'; scale *= 10)
1519	{
1520	len--;
1521	gcc_checking_assert (len && ISDIGIT (*ptr));
1522	ix += (*ptr - '0') * scale;
1523	}
1524
1525	gcc_assert (len != IDENTIFIER_LENGTH (name));
1526	return ix;
1527	}
1528
1529	tree
1530	get_pseudo_tinfo_type (unsigned ix)
1531	{
1532	return get_tinfo_desc (ix)->type;
1533	}
1534
1535	/* We lazily create the type info types. */
1536
1537	static void
1538	create_tinfo_types (void)
1539	{
1540	gcc_assert (!tinfo_descs);
1541
1542	vec_alloc (v&: tinfo_descs, nelems: TK_MAX + 20);
1543	}
1544
1545	/* Helper for emit_support_tinfos. Emits the type_info descriptor of
1546	a single type. */
1547
1548	void
1549	emit_support_tinfo_1 (tree bltn)
1550	{
1551	tree types[3];
1552
1553	if (bltn == NULL_TREE)
1554	return;
1555	types[0] = bltn;
1556	types[1] = build_pointer_type (bltn);
1557	types[2] = build_pointer_type (cp_build_qualified_type (bltn,
1558	TYPE_QUAL_CONST));
1559
1560	for (int i = 0; i < 3; ++i)
1561	{
1562	tree tinfo = get_tinfo_decl (type: types[i]);
1563	TREE_USED (tinfo) = 1;
1564	mark_needed (tinfo);
1565	/* The C++ ABI requires that these objects be COMDAT. But,
1566	On systems without weak symbols, initialized COMDAT
1567	objects are emitted with internal linkage. (See
1568	comdat_linkage for details.) Since we want these objects
1569	to have external linkage so that copies do not have to be
1570	emitted in code outside the runtime library, we make them
1571	non-COMDAT here.
1572
1573	It might also not be necessary to follow this detail of the
1574	ABI. */
1575	if (!flag_weak || ! targetm.cxx.library_rtti_comdat ())
1576	{
1577	gcc_assert (TREE_PUBLIC (tinfo) && !DECL_COMDAT (tinfo));
1578	DECL_INTERFACE_KNOWN (tinfo) = 1;
1579	}
1580
1581	/* Emit it right away if not emitted already. */
1582	if (DECL_INITIAL (tinfo) == NULL_TREE)
1583	{
1584	bool ok = emit_tinfo_decl (tinfo);
1585	gcc_assert (ok);
1586	/* When compiling libsupc++.a (fundamental_type_info.o),
1587	unemitted_tinfo_decls->last () will be tinfo, so pop it
1588	from the vector as it is emitted now. If one uses typeid
1589	etc. in the same TU as the definition of
1590	~fundamental_type_info (), the tinfo might be emitted
1591	already earlier, in such case keep it in the vector
1592	(as otherwise we'd need to walk the whole vector) and
1593	let c_parse_final_cleanups ignore it when it will have
1594	non-NULL DECL_INITIAL. */
1595	if (unemitted_tinfo_decls->last () == tinfo)
1596	unemitted_tinfo_decls->pop ();
1597	}
1598	}
1599	}
1600
1601	/* Emit the type_info descriptors which are guaranteed to be in the runtime
1602	support. Generating them here guarantees consistency with the other
1603	structures. We use the following heuristic to determine when the runtime
1604	is being generated. If std::__fundamental_type_info is defined, and its
1605	destructor is defined, then the runtime is being built. */
1606
1607	void
1608	emit_support_tinfos (void)
1609	{
1610	/* Dummy static variable so we can put nullptr in the array; it will be
1611	set before we actually start to walk the array. */
1612	static tree *const fundamentals[] =
1613	{
1614	&void_type_node,
1615	&boolean_type_node,
1616	&wchar_type_node, &char8_type_node, &char16_type_node, &char32_type_node,
1617	&char_type_node, &signed_char_type_node, &unsigned_char_type_node,
1618	&short_integer_type_node, &short_unsigned_type_node,
1619	&integer_type_node, &unsigned_type_node,
1620	&long_integer_type_node, &long_unsigned_type_node,
1621	&long_long_integer_type_node, &long_long_unsigned_type_node,
1622	&float_type_node, &double_type_node, &long_double_type_node,
1623	&bfloat16_type_node, &float16_type_node, &float32_type_node,
1624	&float64_type_node, &float128_type_node, &float32x_type_node,
1625	&float64x_type_node, &float128x_type_node, &nullptr_type_node,
1626	0
1627	};
1628	/* Similar, but for floating point types only which should get type info
1629	regardless whether they are non-NULL or NULL. */
1630	static tree *const fundamentals_with_fallback[] =
1631	{
1632	&dfloat32_type_node, &dfloat64_type_node, &dfloat128_type_node,
1633	0
1634	};
1635	int ix;
1636
1637	/* Look for a defined class. */
1638	tree bltn_type = lookup_qualified_name
1639	(abi_node, name: "__fundamental_type_info", LOOK_want::TYPE, false);
1640	if (TREE_CODE (bltn_type) != TYPE_DECL)
1641	return;
1642
1643	bltn_type = TREE_TYPE (bltn_type);
1644	if (!COMPLETE_TYPE_P (bltn_type))
1645	return;
1646	tree dtor = CLASSTYPE_DESTRUCTOR (bltn_type);
1647	if (!dtor || DECL_EXTERNAL (dtor))
1648	return;
1649
1650	/* All these are really builtins. So set the location. */
1651	location_t saved_loc = input_location;
1652	input_location = BUILTINS_LOCATION;
1653	doing_runtime = 1;
1654	tree fallback = NULL_TREE;
1655	for (ix = 0; fundamentals[ix]; ix++)
1656	emit_support_tinfo_1 (bltn: *fundamentals[ix]);
1657	for (ix = 0; fundamentals_with_fallback[ix]; ix++)
1658	if (*fundamentals_with_fallback[ix])
1659	emit_support_tinfo_1 (bltn: *fundamentals_with_fallback[ix]);
1660	else
1661	{
1662	if (fallback == NULL_TREE)
1663	fallback = make_node (REAL_TYPE);
1664	*fundamentals_with_fallback[ix] = fallback;
1665	emit_support_tinfo_1 (bltn: fallback);
1666	*fundamentals_with_fallback[ix] = NULL_TREE;
1667	}
1668	for (ix = 0; ix < NUM_INT_N_ENTS; ix ++)
1669	if (int_n_enabled_p[ix])
1670	{
1671	emit_support_tinfo_1 (bltn: int_n_trees[ix].signed_type);
1672	emit_support_tinfo_1 (bltn: int_n_trees[ix].unsigned_type);
1673	}
1674	for (tree t = registered_builtin_types; t; t = TREE_CHAIN (t))
1675	emit_support_tinfo_1 (TREE_VALUE (t));
1676
1677	/* Emit additional typeinfos as requested by target. */
1678	targetm.emit_support_tinfos (emit_support_tinfo_1);
1679
1680	input_location = saved_loc;
1681	}
1682
1683	/* Finish a type info decl. DECL_PTR is a pointer to an unemitted
1684	tinfo decl. Determine whether it needs emitting, and if so
1685	generate the initializer. */
1686
1687	bool
1688	emit_tinfo_decl (tree decl)
1689	{
1690	gcc_assert (DECL_TINFO_P (decl));
1691
1692	tree type = TREE_TYPE (DECL_NAME (decl));
1693	if (typeinfo_in_lib_p (type))
1694	{
1695	if (doing_runtime)
1696	DECL_EXTERNAL (decl) = 0;
1697	else
1698	{
1699	/* If we're not in the runtime, then DECL (which is already
1700	DECL_EXTERNAL) will not be defined here. */
1701	DECL_INTERFACE_KNOWN (decl) = 1;
1702	return false;
1703	}
1704	}
1705	else if (involves_incomplete_p (type))
1706	{
1707	if (!decl_needed_p (decl))
1708	return false;
1709	/* If TYPE involves an incomplete class type, then the typeinfo
1710	object will be emitted with internal linkage. There is no
1711	way to know whether or not types are incomplete until the end
1712	of the compilation, so this determination must be deferred
1713	until this point. */
1714	TREE_PUBLIC (decl) = 0;
1715	DECL_EXTERNAL (decl) = 0;
1716	DECL_INTERFACE_KNOWN (decl) = 1;
1717	}
1718
1719	import_export_decl (decl);
1720	if (DECL_NOT_REALLY_EXTERN (decl) && decl_needed_p (decl))
1721	{
1722	tree init;
1723
1724	DECL_EXTERNAL (decl) = 0;
1725	int pseudo_ix = get_pseudo_ti_index (type);
1726	const tinfo_s *ti = get_tinfo_desc (ix: pseudo_ix);
1727	if (TREE_TYPE (decl) != ti->type)
1728	{
1729	/* If the class became complete since we first called get_tinfo_decl,
1730	its type_info descriptor may have switched from __class_type_info
1731	to e.g. __si_class_type_info. */
1732	TREE_TYPE (decl) = ti->type;
1733	relayout_decl (decl);
1734	}
1735	init = get_pseudo_ti_init (type, tk_index: pseudo_ix);
1736	DECL_INITIAL (decl) = init;
1737	mark_used (decl);
1738	cp_finish_decl (decl, init, false, NULL_TREE, 0);
1739	/* Avoid targets optionally bumping up the alignment to improve
1740	vector instruction accesses, tinfo are never accessed this way. */
1741	#ifdef DATA_ABI_ALIGNMENT
1742	SET_DECL_ALIGN (decl, DATA_ABI_ALIGNMENT (decl, TYPE_ALIGN (TREE_TYPE (decl))));
1743	DECL_USER_ALIGN (decl) = true;
1744	#endif
1745	return true;
1746	}
1747	else
1748	return false;
1749	}
1750
1751	#include "gt-cp-rtti.h"
1752