1	/* Language-level data type conversion for GNU C++.
2	Copyright (C) 1987-2024 Free Software Foundation, Inc.
3	Hacked by Michael Tiemann (tiemann@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
22	/* This file contains the functions for converting C++ expressions
23	to different data types. The only entry point is `convert'.
24	Every language front end must have a `convert' function
25	but what kind of conversions it does will depend on the language. */
26
27	#include "config.h"
28	#include "system.h"
29	#include "coretypes.h"
30	#include "target.h"
31	#include "cp-tree.h"
32	#include "stor-layout.h"
33	#include "flags.h"
34	#include "intl.h"
35	#include "convert.h"
36	#include "stringpool.h"
37	#include "attribs.h"
38	#include "escaped_string.h"
39
40	static tree convert_to_pointer_force (tree, tree, tsubst_flags_t);
41	static tree build_type_conversion (tree, tree);
42	static tree build_up_reference (tree, tree, int, tree, tsubst_flags_t);
43	static void diagnose_ref_binding (location_t, tree, tree, tree);
44
45	/* Change of width--truncation and extension of integers or reals--
46	is represented with NOP_EXPR. Proper functioning of many things
47	assumes that no other conversions can be NOP_EXPRs.
48
49	Conversion between integer and pointer is represented with CONVERT_EXPR.
50	Converting integer to real uses FLOAT_EXPR
51	and real to integer uses FIX_TRUNC_EXPR.
52
53	Here is a list of all the functions that assume that widening and
54	narrowing is always done with a NOP_EXPR:
55	In convert.cc, convert_to_integer[_maybe_fold].
56	In c-typeck.cc, build_binary_op_nodefault (boolean ops),
57	and c_common_truthvalue_conversion.
58	In expr.cc: expand_expr, for operands of a MULT_EXPR.
59	In fold-const.cc: fold.
60	In tree.cc: get_narrower and get_unwidened.
61
62	C++: in multiple-inheritance, converting between pointers may involve
63	adjusting them by a delta stored within the class definition. */
64
65	/* Subroutines of `convert'. */
66
67	/* if converting pointer to pointer
68	if dealing with classes, check for derived->base or vice versa
69	else if dealing with method pointers, delegate
70	else convert blindly
71	else if converting class, pass off to build_type_conversion
72	else try C-style pointer conversion. */
73
74	static tree
75	cp_convert_to_pointer (tree type, tree expr, bool dofold,
76	tsubst_flags_t complain)
77	{
78	tree intype = TREE_TYPE (expr);
79	enum tree_code form;
80	tree rval;
81	location_t loc = cp_expr_loc_or_input_loc (t: expr);
82
83	if (intype == error_mark_node)
84	return error_mark_node;
85
86	if (MAYBE_CLASS_TYPE_P (intype))
87	{
88	intype = complete_type (intype);
89	if (!COMPLETE_TYPE_P (intype))
90	{
91	if (complain & tf_error)
92	error_at (loc, "cannot convert from incomplete type %qH to %qI",
93	intype, type);
94	return error_mark_node;
95	}
96
97	rval = build_type_conversion (type, expr);
98	if (rval)
99	{
100	if ((complain & tf_error)
101	&& rval == error_mark_node)
102	error_at (loc, "conversion of %qE from %qH to %qI is ambiguous",
103	expr, intype, type);
104	return rval;
105	}
106	}
107
108	/* Handle anachronistic conversions from (::*)() to cv void* or (*)(). */
109	if (TYPE_PTR_P (type)
110	&& (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
111	|| VOID_TYPE_P (TREE_TYPE (type))))
112	{
113	if (TYPE_PTRMEMFUNC_P (intype)
114	|| TREE_CODE (intype) == METHOD_TYPE)
115	return convert_member_func_to_ptr (type, expr, complain);
116	if (TYPE_PTR_P (TREE_TYPE (expr)))
117	return build_nop (type, expr);
118	intype = TREE_TYPE (expr);
119	}
120
121	if (expr == error_mark_node)
122	return error_mark_node;
123
124	form = TREE_CODE (intype);
125
126	if (INDIRECT_TYPE_P (intype))
127	{
128	intype = TYPE_MAIN_VARIANT (intype);
129
130	if (TYPE_MAIN_VARIANT (type) != intype
131	&& TYPE_PTR_P (type)
132	&& TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
133	&& MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
134	&& MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
135	&& TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
136	{
137	enum tree_code code = PLUS_EXPR;
138	tree binfo;
139	tree intype_class;
140	tree type_class;
141	bool same_p;
142
143	intype_class = TREE_TYPE (intype);
144	type_class = TREE_TYPE (type);
145
146	same_p = same_type_p (TYPE_MAIN_VARIANT (intype_class),
147	TYPE_MAIN_VARIANT (type_class));
148	binfo = NULL_TREE;
149	/* Try derived to base conversion. */
150	if (!same_p)
151	binfo = lookup_base (intype_class, type_class, ba_check,
152	NULL, complain);
153	if (!same_p && !binfo)
154	{
155	/* Try base to derived conversion. */
156	binfo = lookup_base (type_class, intype_class, ba_check,
157	NULL, complain);
158	code = MINUS_EXPR;
159	}
160	if (binfo == error_mark_node)
161	return error_mark_node;
162	if (binfo || same_p)
163	{
164	if (binfo)
165	expr = build_base_path (code, expr, binfo, 0, complain);
166	/* Add any qualifier conversions. */
167	return build_nop (type, expr);
168	}
169	}
170
171	if (TYPE_PTRMEMFUNC_P (type))
172	{
173	if (complain & tf_error)
174	error_at (loc, "cannot convert %qE from type %qH to type %qI",
175	expr, intype, type);
176	return error_mark_node;
177	}
178
179	return build_nop (type, expr);
180	}
181	else if ((TYPE_PTRDATAMEM_P (type) && TYPE_PTRDATAMEM_P (intype))
182	|| (TYPE_PTRMEMFUNC_P (type) && TYPE_PTRMEMFUNC_P (intype)))
183	return convert_ptrmem (type, expr, /*allow_inverse_p=*/false,
184	/*c_cast_p=*/false, complain);
185	else if (TYPE_PTRMEMFUNC_P (intype))
186	{
187	if (!warn_pmf2ptr)
188	{
189	if (TREE_CODE (expr) == PTRMEM_CST)
190	return cp_convert_to_pointer (type, PTRMEM_CST_MEMBER (expr),
191	dofold, complain);
192	else if (TREE_CODE (expr) == OFFSET_REF)
193	{
194	tree object = TREE_OPERAND (expr, 0);
195	return get_member_function_from_ptrfunc (&object,
196	TREE_OPERAND (expr, 1),
197	complain);
198	}
199	}
200	if (complain & tf_error)
201	error_at (loc, "cannot convert %qE from type %qH to type %qI",
202	expr, intype, type);
203	return error_mark_node;
204	}
205
206	if (null_ptr_cst_p (expr))
207	{
208	if (TYPE_PTRMEMFUNC_P (type))
209	return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), expr, 0,
210	/*c_cast_p=*/false, complain);
211
212	if (complain & tf_warning)
213	maybe_warn_zero_as_null_pointer_constant (expr, loc);
214
215	/* A NULL pointer-to-data-member is represented by -1, not by
216	zero. */
217	tree val = (TYPE_PTRDATAMEM_P (type)
218	? build_int_cst_type (type, -1)
219	: build_int_cst (type, 0));
220
221	return (TREE_SIDE_EFFECTS (expr)
222	? build2 (COMPOUND_EXPR, type, expr, val) : val);
223	}
224	else if (TYPE_PTRMEM_P (type) && INTEGRAL_CODE_P (form))
225	{
226	if (complain & tf_error)
227	error_at (loc, "invalid conversion from %qH to %qI", intype, type);
228	return error_mark_node;
229	}
230
231	if (INTEGRAL_CODE_P (form))
232	{
233	if (TYPE_PRECISION (intype) == POINTER_SIZE)
234	return build1 (CONVERT_EXPR, type, expr);
235	expr = cp_convert (c_common_type_for_size (TYPE_PRECISION (type), 0), expr,
236	complain);
237	/* Modes may be different but sizes should be the same. There
238	is supposed to be some integral type that is the same width
239	as a pointer. */
240	gcc_assert (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (expr)))
241	== GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type)));
242
243	/* FIXME needed because convert_to_pointer_maybe_fold still folds
244	conversion of constants. */
245	if (!dofold)
246	return build1 (CONVERT_EXPR, type, expr);
247
248	return convert_to_pointer_maybe_fold (type, expr, dofold);
249	}
250
251	if (type_unknown_p (expr))
252	return instantiate_type (type, expr, complain);
253
254	if (complain & tf_error)
255	error_at (loc, "cannot convert %qE from type %qH to type %qI",
256	expr, intype, type);
257	return error_mark_node;
258	}
259
260	/* Like convert, except permit conversions to take place which
261	are not normally allowed due to access restrictions
262	(such as conversion from sub-type to private super-type). */
263
264	static tree
265	convert_to_pointer_force (tree type, tree expr, tsubst_flags_t complain)
266	{
267	tree intype = TREE_TYPE (expr);
268	enum tree_code form = TREE_CODE (intype);
269
270	if (form == POINTER_TYPE)
271	{
272	intype = TYPE_MAIN_VARIANT (intype);
273
274	if (TYPE_MAIN_VARIANT (type) != intype
275	&& TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
276	&& MAYBE_CLASS_TYPE_P (TREE_TYPE (type))
277	&& MAYBE_CLASS_TYPE_P (TREE_TYPE (intype))
278	&& TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE)
279	{
280	enum tree_code code = PLUS_EXPR;
281	tree binfo;
282
283	binfo = lookup_base (TREE_TYPE (intype), TREE_TYPE (type),
284	ba_unique, NULL, complain);
285	if (!binfo)
286	{
287	binfo = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
288	ba_unique, NULL, complain);
289	code = MINUS_EXPR;
290	}
291	if (binfo == error_mark_node)
292	return error_mark_node;
293	if (binfo)
294	{
295	expr = build_base_path (code, expr, binfo, 0, complain);
296	if (expr == error_mark_node)
297	return error_mark_node;
298	/* Add any qualifier conversions. */
299	if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)),
300	TREE_TYPE (type)))
301	expr = build_nop (type, expr);
302	return expr;
303	}
304	}
305	}
306
307	return cp_convert_to_pointer (type, expr, /*fold*/dofold: false, complain);
308	}
309
310	/* We are passing something to a function which requires a reference.
311	The type we are interested in is in TYPE. The initial
312	value we have to begin with is in ARG.
313
314	FLAGS controls how we manage access checking.
315	DIRECT_BIND in FLAGS controls how any temporaries are generated.
316	If DIRECT_BIND is set, DECL is the reference we're binding to. */
317
318	static tree
319	build_up_reference (tree type, tree arg, int flags, tree decl,
320	tsubst_flags_t complain)
321	{
322	tree rval;
323	tree argtype = TREE_TYPE (arg);
324	tree target_type = TREE_TYPE (type);
325
326	gcc_assert (TYPE_REF_P (type));
327
328	if ((flags & DIRECT_BIND) && ! lvalue_p (arg))
329	{
330	/* Create a new temporary variable. We can't just use a TARGET_EXPR
331	here because it needs to live as long as DECL. */
332	tree targ = arg;
333
334	arg = make_temporary_var_for_ref_to_temp (decl, target_type);
335
336	/* Process the initializer for the declaration. */
337	DECL_INITIAL (arg) = targ;
338	cp_finish_decl (arg, targ, /*init_const_expr_p=*/false, NULL_TREE,
339	LOOKUP_ONLYCONVERTING|DIRECT_BIND);
340	}
341	else if (!(flags & DIRECT_BIND) && ! obvalue_p (arg))
342	return get_target_expr (arg, complain);
343
344	/* If we had a way to wrap this up, and say, if we ever needed its
345	address, transform all occurrences of the register, into a memory
346	reference we could win better. */
347	rval = cp_build_addr_expr (arg, complain);
348	if (rval == error_mark_node)
349	return error_mark_node;
350
351	if ((flags & LOOKUP_PROTECT)
352	&& TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type)
353	&& MAYBE_CLASS_TYPE_P (argtype)
354	&& MAYBE_CLASS_TYPE_P (target_type))
355	{
356	/* We go through lookup_base for the access control. */
357	tree binfo = lookup_base (argtype, target_type, ba_check,
358	NULL, complain);
359	if (binfo == error_mark_node)
360	return error_mark_node;
361	if (binfo == NULL_TREE)
362	return error_not_base_type (target_type, argtype);
363	rval = build_base_path (PLUS_EXPR, rval, binfo, 1, complain);
364	}
365	else
366	rval
367	= convert_to_pointer_force (type: build_pointer_type (target_type),
368	expr: rval, complain);
369	return build_nop (type, rval);
370	}
371
372	/* Subroutine of convert_to_reference. REFTYPE is the target reference type.
373	INTYPE is the original rvalue type and DECL is an optional _DECL node
374	for diagnostics.
375
376	[dcl.init.ref] says that if an rvalue is used to
377	initialize a reference, then the reference must be to a
378	non-volatile const type. */
379
380	static void
381	diagnose_ref_binding (location_t loc, tree reftype, tree intype, tree decl)
382	{
383	tree ttl = TREE_TYPE (reftype);
384
385	if (!TYPE_REF_IS_RVALUE (reftype)
386	&& !CP_TYPE_CONST_NON_VOLATILE_P (ttl))
387	{
388	const char *msg;
389
390	if (CP_TYPE_VOLATILE_P (ttl) && decl)
391	msg = G_("initialization of volatile reference type %q#T from "
392	"rvalue of type %qT");
393	else if (CP_TYPE_VOLATILE_P (ttl))
394	msg = G_("conversion to volatile reference type %q#T "
395	"from rvalue of type %qT");
396	else if (decl)
397	msg = G_("initialization of non-const reference type %q#T from "
398	"rvalue of type %qT");
399	else
400	msg = G_("conversion to non-const reference type %q#T from "
401	"rvalue of type %qT");
402
403	permerror (loc, msg, reftype, intype);
404	}
405	}
406
407	/* For C++: Only need to do one-level references, but cannot
408	get tripped up on signed/unsigned differences.
409
410	DECL is either NULL_TREE or the _DECL node for a reference that is being
411	initialized. It can be error_mark_node if we don't know the _DECL but
412	we know it's an initialization. */
413
414	tree
415	convert_to_reference (tree reftype, tree expr, int convtype,
416	int flags, tree decl, tsubst_flags_t complain)
417	{
418	tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype));
419	tree intype;
420	tree rval = NULL_TREE;
421	tree rval_as_conversion = NULL_TREE;
422	bool can_convert_intype_to_type;
423	location_t loc = cp_expr_loc_or_input_loc (t: expr);
424
425	if (TREE_CODE (type) == FUNCTION_TYPE
426	&& TREE_TYPE (expr) == unknown_type_node)
427	expr = instantiate_type (type, expr, complain);
428
429	if (expr == error_mark_node)
430	return error_mark_node;
431
432	intype = TREE_TYPE (expr);
433
434	gcc_assert (!TYPE_REF_P (intype));
435	gcc_assert (TYPE_REF_P (reftype));
436
437	intype = TYPE_MAIN_VARIANT (intype);
438
439	can_convert_intype_to_type = can_convert_standard (type, intype, complain);
440
441	if (!can_convert_intype_to_type
442	&& (convtype & CONV_IMPLICIT) && MAYBE_CLASS_TYPE_P (intype)
443	&& ! (flags & LOOKUP_NO_CONVERSION))
444	{
445	/* Look for a user-defined conversion to lvalue that we can use. */
446
447	rval_as_conversion
448	= build_type_conversion (reftype, expr);
449
450	if (rval_as_conversion && rval_as_conversion != error_mark_node
451	&& lvalue_p (rval_as_conversion))
452	{
453	expr = rval_as_conversion;
454	rval_as_conversion = NULL_TREE;
455	intype = type;
456	can_convert_intype_to_type = 1;
457	}
458	}
459
460	if (((convtype & CONV_STATIC)
461	&& can_convert_standard (intype, type, complain))
462	|| ((convtype & CONV_IMPLICIT) && can_convert_intype_to_type))
463	{
464	{
465	tree ttl = TREE_TYPE (reftype);
466	tree ttr = lvalue_type (expr);
467
468	if ((complain & tf_error)
469	&& ! lvalue_p (expr))
470	diagnose_ref_binding (loc, reftype, intype, decl);
471
472	if (! (convtype & CONV_CONST)
473	&& !at_least_as_qualified_p (ttl, ttr))
474	{
475	if (complain & tf_error)
476	permerror (loc, "conversion from %qH to %qI discards qualifiers",
477	ttr, reftype);
478	else
479	return error_mark_node;
480	}
481	}
482
483	return build_up_reference (type: reftype, arg: expr, flags, decl, complain);
484	}
485	else if ((convtype & CONV_REINTERPRET) && obvalue_p (expr))
486	{
487	/* When casting an lvalue to a reference type, just convert into
488	a pointer to the new type and deference it. This is allowed
489	by San Diego WP section 5.2.9 paragraph 12, though perhaps it
490	should be done directly (jason). (int &)ri ---> *(int*)&ri */
491
492	/* B* bp; A& ar = (A&)bp; is valid, but it's probably not what they
493	meant. */
494	if ((complain & tf_warning)
495	&& TYPE_PTR_P (intype)
496	&& (comptypes (TREE_TYPE (intype), type,
497	COMPARE_BASE | COMPARE_DERIVED)))
498	warning_at (loc, 0, "casting %qT to %qT does not dereference pointer",
499	intype, reftype);
500
501	rval = cp_build_addr_expr (expr, complain);
502	if (rval != error_mark_node)
503	rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
504	rval, 0, complain);
505	if (rval != error_mark_node)
506	rval = build1 (NOP_EXPR, reftype, rval);
507	}
508	else
509	{
510	rval = convert_for_initialization (NULL_TREE, type, expr, flags,
511	ICR_CONVERTING, 0, 0, complain);
512	if (rval == NULL_TREE || rval == error_mark_node)
513	return rval;
514	if (complain & tf_error)
515	diagnose_ref_binding (loc, reftype, intype, decl);
516	rval = build_up_reference (type: reftype, arg: rval, flags, decl, complain);
517	}
518
519	if (rval)
520	{
521	/* If we found a way to convert earlier, then use it. */
522	return rval;
523	}
524
525	if (complain & tf_error)
526	error_at (loc, "cannot convert type %qH to type %qI", intype, reftype);
527
528	return error_mark_node;
529	}
530
531	/* We are using a reference VAL for its value. Bash that reference all the
532	way down to its lowest form. */
533
534	tree
535	convert_from_reference (tree val)
536	{
537	if (TREE_TYPE (val)
538	&& TYPE_REF_P (TREE_TYPE (val)))
539	{
540	tree t = TREE_TYPE (TREE_TYPE (val));
541	tree ref = build1 (INDIRECT_REF, t, val);
542
543	mark_exp_read (val);
544	/* We *must* set TREE_READONLY when dereferencing a pointer to const,
545	so that we get the proper error message if the result is used
546	to assign to. Also, &* is supposed to be a no-op. */
547	TREE_READONLY (ref) = CP_TYPE_CONST_P (t);
548	TREE_THIS_VOLATILE (ref) = CP_TYPE_VOLATILE_P (t);
549	TREE_SIDE_EFFECTS (ref)
550	= (TREE_THIS_VOLATILE (ref) || TREE_SIDE_EFFECTS (val));
551	val = ref;
552	}
553
554	return val;
555	}
556
557	/* Really perform an lvalue-to-rvalue conversion, including copying an
558	argument of class type into a temporary. */
559
560	tree
561	force_rvalue (tree expr, tsubst_flags_t complain)
562	{
563	tree type = TREE_TYPE (expr);
564	if (MAYBE_CLASS_TYPE_P (type) && TREE_CODE (expr) != TARGET_EXPR)
565	{
566	releasing_vec args (make_tree_vector_single (expr));
567	expr = build_special_member_call (NULL_TREE, complete_ctor_identifier,
568	&args, type, LOOKUP_NORMAL, complain);
569	expr = build_cplus_new (type, expr, complain);
570	}
571	else
572	expr = decay_conversion (expr, complain);
573
574	return expr;
575	}
576
577
578	/* If EXPR and ORIG are INTEGER_CSTs, return a version of EXPR that has
579	TREE_OVERFLOW set only if it is set in ORIG. Otherwise, return EXPR
580	unchanged. */
581
582	static tree
583	ignore_overflows (tree expr, tree orig)
584	{
585	tree stripped_expr = tree_strip_any_location_wrapper (exp: expr);
586	tree stripped_orig = tree_strip_any_location_wrapper (exp: orig);
587
588	if (TREE_CODE (stripped_expr) == INTEGER_CST
589	&& TREE_CODE (stripped_orig) == INTEGER_CST
590	&& TREE_OVERFLOW (stripped_expr) != TREE_OVERFLOW (stripped_orig))
591	{
592	gcc_assert (!TREE_OVERFLOW (stripped_orig));
593	/* Ensure constant sharing. */
594	stripped_expr = wide_int_to_tree (TREE_TYPE (stripped_expr),
595	cst: wi::to_wide (t: stripped_expr));
596	}
597
598	return preserve_any_location_wrapper (result: stripped_expr, orig_expr: expr);
599	}
600
601	/* Fold away simple conversions, but make sure TREE_OVERFLOW is set
602	properly and propagate TREE_NO_WARNING if folding EXPR results
603	in the same expression code. */
604
605	tree
606	cp_fold_convert (tree type, tree expr)
607	{
608	tree conv;
609	if (TREE_TYPE (expr) == type)
610	conv = expr;
611	else if (TREE_CODE (expr) == PTRMEM_CST
612	&& same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
613	PTRMEM_CST_CLASS (expr)))
614	{
615	/* Avoid wrapping a PTRMEM_CST in NOP_EXPR. */
616	conv = copy_node (expr);
617	TREE_TYPE (conv) = type;
618	}
619	else if (TYPE_PTRMEM_P (type))
620	{
621	conv = convert_ptrmem (type, expr, true, false,
622	tf_warning_or_error);
623	conv = cp_fully_fold (conv);
624	}
625	else
626	{
627	conv = fold_convert (type, expr);
628	conv = ignore_overflows (expr: conv, orig: expr);
629	}
630
631	if (TREE_CODE (expr) == TREE_CODE (conv))
632	copy_warning (conv, expr);
633
634	return conv;
635	}
636
637	/* C++ conversions, preference to static cast conversions. */
638
639	tree
640	cp_convert (tree type, tree expr, tsubst_flags_t complain)
641	{
642	return ocp_convert (type, expr, CONV_OLD_CONVERT, LOOKUP_NORMAL, complain);
643	}
644
645	/* C++ equivalent of convert_and_check but using cp_convert as the
646	conversion function.
647
648	Convert EXPR to TYPE, warning about conversion problems with constants.
649	Invoke this function on every expression that is converted implicitly,
650	i.e. because of language rules and not because of an explicit cast. */
651
652	tree
653	cp_convert_and_check (tree type, tree expr, tsubst_flags_t complain)
654	{
655	tree result, expr_for_warning = expr;
656
657	if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
658	expr = TREE_OPERAND (expr, 0);
659	if (TREE_TYPE (expr) == type)
660	return expr;
661	if (expr == error_mark_node)
662	return expr;
663	result = cp_convert (type, expr, complain);
664
665	if ((complain & tf_warning)
666	&& c_inhibit_evaluation_warnings == 0)
667	{
668	tree folded = cp_fully_fold (expr_for_warning);
669	tree folded_result;
670	if (folded == expr)
671	folded_result = result;
672	else
673	{
674	/* Avoid bogus -Wparentheses warnings. */
675	warning_sentinel w (warn_parentheses);
676	warning_sentinel c (warn_int_in_bool_context);
677	folded_result = cp_convert (type, expr: folded, complain: tf_none);
678	}
679	folded_result = fold_simple (folded_result);
680	if (!TREE_OVERFLOW_P (folded)
681	&& folded_result != error_mark_node)
682	warnings_for_convert_and_check (cp_expr_loc_or_input_loc (t: expr),
683	type, folded, folded_result);
684	}
685
686	return result;
687	}
688
689	/* Conversion...
690
691	FLAGS indicates how we should behave. */
692
693	tree
694	ocp_convert (tree type, tree expr, int convtype, int flags,
695	tsubst_flags_t complain)
696	{
697	tree e = expr;
698	enum tree_code code = TREE_CODE (type);
699	const char *invalid_conv_diag;
700	tree e1;
701	location_t loc = cp_expr_loc_or_input_loc (t: expr);
702	bool dofold = (convtype & CONV_FOLD);
703
704	if (error_operand_p (t: e) || type == error_mark_node)
705	return error_mark_node;
706
707	if (TREE_CODE (e) == COMPOUND_EXPR)
708	{
709	e = ocp_convert (type, TREE_OPERAND (e, 1), convtype, flags, complain);
710	if (e == error_mark_node)
711	return error_mark_node;
712	if (e == TREE_OPERAND (expr, 1))
713	return expr;
714	e = build2_loc (EXPR_LOCATION (expr), code: COMPOUND_EXPR, TREE_TYPE (e),
715	TREE_OPERAND (expr, 0), arg1: e);
716	copy_warning (e, expr);
717	return e;
718	}
719
720	complete_type (type);
721	complete_type (TREE_TYPE (expr));
722
723	if ((invalid_conv_diag
724	= targetm.invalid_conversion (TREE_TYPE (expr), type)))
725	{
726	if (complain & tf_error)
727	error (invalid_conv_diag);
728	return error_mark_node;
729	}
730
731	/* FIXME remove when moving to c_fully_fold model. */
732	if (!CLASS_TYPE_P (type))
733	{
734	e = mark_rvalue_use (e);
735	tree v = scalar_constant_value (e);
736	if (!error_operand_p (t: v))
737	e = v;
738	}
739	if (error_operand_p (t: e))
740	return error_mark_node;
741
742	if (NULLPTR_TYPE_P (type) && null_ptr_cst_p (e))
743	{
744	if (complain & tf_warning)
745	maybe_warn_zero_as_null_pointer_constant (e, loc);
746
747	if (!TREE_SIDE_EFFECTS (e))
748	return nullptr_node;
749	}
750
751	if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP))
752	/* We need a new temporary; don't take this shortcut. */;
753	else if (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (e)))
754	{
755	tree etype = TREE_TYPE (e);
756	if (same_type_p (type, etype))
757	/* The call to fold will not always remove the NOP_EXPR as
758	might be expected, since if one of the types is a typedef;
759	the comparison in fold is just equality of pointers, not a
760	call to comptypes. We don't call fold in this case because
761	that can result in infinite recursion; fold will call
762	convert, which will call ocp_convert, etc. */
763	return e;
764	/* For complex data types, we need to perform componentwise
765	conversion. */
766	else if (TREE_CODE (type) == COMPLEX_TYPE)
767	return convert_to_complex_maybe_fold (type, e, dofold);
768	else if (VECTOR_TYPE_P (type))
769	return convert_to_vector (type, rvalue (e));
770	else if (TREE_CODE (e) == TARGET_EXPR)
771	{
772	/* Don't build a NOP_EXPR of class type. Instead, change the
773	type of the temporary. */
774	gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, etype));
775	TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type;
776	return e;
777	}
778	else if (TREE_CODE (e) == CONSTRUCTOR)
779	{
780	gcc_assert (same_type_ignoring_top_level_qualifiers_p (type, etype));
781	TREE_TYPE (e) = type;
782	return e;
783	}
784	else
785	{
786	/* We shouldn't be treating objects of ADDRESSABLE type as
787	rvalues. */
788	gcc_assert (!TREE_ADDRESSABLE (type));
789	return build_nop (type, e);
790	}
791	}
792
793	e1 = targetm.convert_to_type (type, e);
794	if (e1)
795	return e1;
796
797	if (code == VOID_TYPE && (convtype & CONV_STATIC))
798	{
799	e = convert_to_void (e, ICV_CAST, complain);
800	return e;
801	}
802
803	if (INTEGRAL_CODE_P (code))
804	{
805	tree intype = TREE_TYPE (e);
806	tree converted;
807
808	if (TREE_CODE (type) == ENUMERAL_TYPE)
809	{
810	/* enum = enum, enum = int, enum = float, (enum)pointer are all
811	errors. */
812	if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
813	|| SCALAR_FLOAT_TYPE_P (intype))
814	&& ! (convtype & CONV_STATIC))
815	|| TYPE_PTR_P (intype))
816	{
817	if (complain & tf_error)
818	permerror (loc, "conversion from %q#T to %q#T", intype, type);
819	else
820	return error_mark_node;
821	}
822
823	/* [expr.static.cast]
824
825	8. A value of integral or enumeration type can be explicitly
826	converted to an enumeration type. The value is unchanged if
827	the original value is within the range of the enumeration
828	values. Otherwise, the resulting enumeration value is
829	unspecified. */
830	tree val = fold_for_warn (e);
831	if ((complain & tf_warning)
832	&& TREE_CODE (val) == INTEGER_CST
833	&& ENUM_UNDERLYING_TYPE (type)
834	&& !int_fits_type_p (val, ENUM_UNDERLYING_TYPE (type)))
835	warning_at (loc, OPT_Wconversion,
836	"the result of the conversion is unspecified because "
837	"%qE is outside the range of type %qT",
838	expr, type);
839	}
840	if (MAYBE_CLASS_TYPE_P (intype))
841	{
842	tree rval;
843	rval = build_type_conversion (type, e);
844	if (rval)
845	return rval;
846	if (complain & tf_error)
847	error_at (loc, "%q#T used where a %qT was expected", intype, type);
848	return error_mark_node;
849	}
850	if (code == BOOLEAN_TYPE)
851	{
852	if (VOID_TYPE_P (intype))
853	{
854	if (complain & tf_error)
855	error_at (loc,
856	"could not convert %qE from %<void%> to %<bool%>",
857	expr);
858	return error_mark_node;
859	}
860
861	if (VECTOR_TYPE_P (intype) && !gnu_vector_type_p (type: intype))
862	{
863	if (complain & tf_error)
864	error_at (loc, "could not convert %qE from %qH to %qI", expr,
865	TREE_TYPE (expr), type);
866	return error_mark_node;
867	}
868
869	/* We can't implicitly convert a scoped enum to bool, so convert
870	to the underlying type first. */
871	if (SCOPED_ENUM_P (intype) && (convtype & CONV_STATIC))
872	e = build_nop (ENUM_UNDERLYING_TYPE (intype), e);
873	if (complain & tf_warning)
874	return cp_truthvalue_conversion (e, complain);
875	else
876	{
877	/* Prevent bogus -Wint-in-bool-context warnings coming
878	from c_common_truthvalue_conversion down the line. */
879	warning_sentinel w (warn_int_in_bool_context);
880	warning_sentinel c (warn_sign_compare);
881	return cp_truthvalue_conversion (e, complain);
882	}
883	}
884
885	converted = convert_to_integer_maybe_fold (type, e, dofold);
886
887	/* Ignore any integer overflow caused by the conversion. */
888	return ignore_overflows (expr: converted, orig: e);
889	}
890	if (INDIRECT_TYPE_P (type) || TYPE_PTRMEM_P (type))
891	return cp_convert_to_pointer (type, expr: e, dofold, complain);
892	if (code == VECTOR_TYPE)
893	{
894	tree in_vtype = TREE_TYPE (e);
895	if (MAYBE_CLASS_TYPE_P (in_vtype))
896	{
897	tree ret_val;
898	ret_val = build_type_conversion (type, e);
899	if (ret_val)
900	return ret_val;
901	if (complain & tf_error)
902	error_at (loc, "%q#T used where a %qT was expected",
903	in_vtype, type);
904	return error_mark_node;
905	}
906	return convert_to_vector (type, rvalue (e));
907	}
908	if (code == REAL_TYPE || code == COMPLEX_TYPE)
909	{
910	if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e)))
911	{
912	tree rval;
913	rval = build_type_conversion (type, e);
914	if (rval)
915	return rval;
916	else if (complain & tf_error)
917	error_at (loc,
918	"%q#T used where a floating-point value was expected",
919	TREE_TYPE (e));
920	}
921	if (code == REAL_TYPE)
922	return convert_to_real_maybe_fold (type, e, dofold);
923	else if (code == COMPLEX_TYPE)
924	return convert_to_complex_maybe_fold (type, e, dofold);
925	}
926
927	/* New C++ semantics: since assignment is now based on
928	memberwise copying, if the rhs type is derived from the
929	lhs type, then we may still do a conversion. */
930	if (RECORD_OR_UNION_CODE_P (code))
931	{
932	tree dtype = TREE_TYPE (e);
933	tree ctor = NULL_TREE;
934
935	dtype = TYPE_MAIN_VARIANT (dtype);
936
937	/* Conversion between aggregate types. New C++ semantics allow
938	objects of derived type to be cast to objects of base type.
939	Old semantics only allowed this between pointers.
940
941	There may be some ambiguity between using a constructor
942	vs. using a type conversion operator when both apply. */
943
944	ctor = e;
945
946	if (abstract_virtuals_error (NULL_TREE, type, complain))
947	return error_mark_node;
948
949	if (BRACE_ENCLOSED_INITIALIZER_P (ctor))
950	ctor = perform_implicit_conversion (type, ctor, complain);
951	else if ((flags & LOOKUP_ONLYCONVERTING)
952	&& ! (CLASS_TYPE_P (dtype) && DERIVED_FROM_P (type, dtype)))
953	/* For copy-initialization, first we create a temp of the proper type
954	with a user-defined conversion sequence, then we direct-initialize
955	the target with the temp (see [dcl.init]). */
956	ctor = build_user_type_conversion (type, ctor, flags, complain);
957	else
958	{
959	releasing_vec ctor_vec (make_tree_vector_single (ctor));
960	ctor = build_special_member_call (NULL_TREE,
961	complete_ctor_identifier,
962	&ctor_vec,
963	type, flags, complain);
964	}
965	if (ctor)
966	return build_cplus_new (type, ctor, complain);
967	}
968
969	if (complain & tf_error)
970	{
971	/* If the conversion failed and expr was an invalid use of pointer to
972	member function, try to report a meaningful error. */
973	if (invalid_nonstatic_memfn_p (loc, expr, complain))
974	/* We displayed the error message. */;
975	else
976	error_at (loc, "conversion from %qH to non-scalar type %qI requested",
977	TREE_TYPE (expr), type);
978	}
979	return error_mark_node;
980	}
981
982	/* If CALL is a call, return the callee; otherwise null. */
983
984	tree
985	cp_get_callee (tree call)
986	{
987	if (call == NULL_TREE)
988	return call;
989	else if (TREE_CODE (call) == CALL_EXPR)
990	return CALL_EXPR_FN (call);
991	else if (TREE_CODE (call) == AGGR_INIT_EXPR)
992	return AGGR_INIT_EXPR_FN (call);
993	return NULL_TREE;
994	}
995
996	/* FN is the callee of a CALL_EXPR or AGGR_INIT_EXPR; return the FUNCTION_DECL
997	if we can. */
998
999	tree
1000	cp_get_fndecl_from_callee (tree fn, bool fold /* = true */)
1001	{
1002	if (fn == NULL_TREE)
1003	return fn;
1004
1005	/* We evaluate constexpr functions on the original, pre-genericization
1006	bodies. So block-scope extern declarations have not been mapped to
1007	declarations in outer scopes. Use the namespace-scope declaration,
1008	if any, so that retrieve_constexpr_fundef can find it (PR111132). */
1009	auto fn_or_local_alias = [] (tree f)
1010	{
1011	if (DECL_LOCAL_DECL_P (f))
1012	if (tree alias = DECL_LOCAL_DECL_ALIAS (f))
1013	if (alias != error_mark_node)
1014	return alias;
1015	return f;
1016	};
1017
1018	if (TREE_CODE (fn) == FUNCTION_DECL)
1019	return fn_or_local_alias (fn);
1020	tree type = TREE_TYPE (fn);
1021	if (type == NULL_TREE || !INDIRECT_TYPE_P (type))
1022	return NULL_TREE;
1023	if (fold)
1024	fn = maybe_constant_init (fn);
1025	STRIP_NOPS (fn);
1026	if (TREE_CODE (fn) == ADDR_EXPR
1027	|| TREE_CODE (fn) == FDESC_EXPR)
1028	fn = TREE_OPERAND (fn, 0);
1029	if (TREE_CODE (fn) == FUNCTION_DECL)
1030	return fn_or_local_alias (fn);
1031	return NULL_TREE;
1032	}
1033
1034	/* Like get_callee_fndecl, but handles AGGR_INIT_EXPR as well and uses the
1035	constexpr machinery. */
1036
1037	tree
1038	cp_get_callee_fndecl (tree call)
1039	{
1040	return cp_get_fndecl_from_callee (fn: cp_get_callee (call));
1041	}
1042
1043	/* As above, but not using the constexpr machinery. */
1044
1045	tree
1046	cp_get_callee_fndecl_nofold (tree call)
1047	{
1048	return cp_get_fndecl_from_callee (fn: cp_get_callee (call), fold: false);
1049	}
1050
1051	/* Subroutine of convert_to_void. Warn if we're discarding something with
1052	attribute [[nodiscard]]. */
1053
1054	static void
1055	maybe_warn_nodiscard (tree expr, impl_conv_void implicit)
1056	{
1057	if (!warn_unused_result || c_inhibit_evaluation_warnings)
1058	return;
1059
1060	tree call = expr;
1061	if (TREE_CODE (expr) == TARGET_EXPR)
1062	call = TARGET_EXPR_INITIAL (expr);
1063	location_t loc = cp_expr_loc_or_input_loc (t: call);
1064	tree callee = cp_get_callee (call);
1065	if (!callee || !TREE_TYPE (callee))
1066	return;
1067
1068	tree type = TREE_TYPE (callee);
1069	if (TYPE_PTRMEMFUNC_P (type))
1070	type = TYPE_PTRMEMFUNC_FN_TYPE (type);
1071	if (INDIRECT_TYPE_P (type))
1072	type = TREE_TYPE (type);
1073	if (!FUNC_OR_METHOD_TYPE_P (type))
1074	return;
1075
1076	tree rettype = TREE_TYPE (type);
1077	tree fn = cp_get_fndecl_from_callee (fn: callee);
1078	tree attr;
1079	if (implicit != ICV_CAST && fn
1080	&& (attr = lookup_attribute (attr_name: "nodiscard", DECL_ATTRIBUTES (fn))))
1081	{
1082	escaped_string msg;
1083	tree args = TREE_VALUE (attr);
1084	if (args)
1085	msg.escape (TREE_STRING_POINTER (TREE_VALUE (args)));
1086	const char *format
1087	= (msg
1088	? G_("ignoring return value of %qD, "
1089	"declared with attribute %<nodiscard%>: %<%s%>")
1090	: G_("ignoring return value of %qD, "
1091	"declared with attribute %<nodiscard%>%s"));
1092	const char *raw_msg = msg ? (const char *) msg : "";
1093	auto_diagnostic_group d;
1094	if (warning_at (loc, OPT_Wunused_result, format, fn, raw_msg))
1095	inform (DECL_SOURCE_LOCATION (fn), "declared here");
1096	}
1097	else if (implicit != ICV_CAST
1098	&& (attr = lookup_attribute (attr_name: "nodiscard", TYPE_ATTRIBUTES (rettype))))
1099	{
1100	escaped_string msg;
1101	tree args = TREE_VALUE (attr);
1102	if (args)
1103	msg.escape (TREE_STRING_POINTER (TREE_VALUE (args)));
1104	const char *format
1105	= (msg
1106	? G_("ignoring returned value of type %qT, "
1107	"declared with attribute %<nodiscard%>: %<%s%>")
1108	: G_("ignoring returned value of type %qT, "
1109	"declared with attribute %<nodiscard%>%s"));
1110	const char *raw_msg = msg ? (const char *) msg : "";
1111	auto_diagnostic_group d;
1112	if (warning_at (loc, OPT_Wunused_result, format, rettype, raw_msg))
1113	{
1114	if (fn)
1115	inform (DECL_SOURCE_LOCATION (fn),
1116	"in call to %qD, declared here", fn);
1117	inform (DECL_SOURCE_LOCATION (TYPE_NAME (rettype)),
1118	"%qT declared here", rettype);
1119	}
1120	}
1121	else if (TREE_CODE (expr) == TARGET_EXPR
1122	&& lookup_attribute (attr_name: "warn_unused_result", TYPE_ATTRIBUTES (type)))
1123	{
1124	/* The TARGET_EXPR confuses do_warn_unused_result into thinking that the
1125	result is used, so handle that case here. */
1126	if (fn)
1127	{
1128	auto_diagnostic_group d;
1129	if (warning_at (loc, OPT_Wunused_result,
1130	"ignoring return value of %qD, "
1131	"declared with attribute %<warn_unused_result%>",
1132	fn))
1133	inform (DECL_SOURCE_LOCATION (fn), "declared here");
1134	}
1135	else
1136	warning_at (loc, OPT_Wunused_result,
1137	"ignoring return value of function "
1138	"declared with attribute %<warn_unused_result%>");
1139	}
1140	}
1141
1142	/* When an expression is used in a void context, its value is discarded and
1143	no lvalue-rvalue and similar conversions happen [expr.static.cast/4,
1144	stmt.expr/1, expr.comma/1]. This permits dereferencing an incomplete type
1145	in a void context. The C++ standard does not define what an `access' to an
1146	object is, but there is reason to believe that it is the lvalue to rvalue
1147	conversion -- if it were not, `*&*p = 1' would violate [expr]/4 in that it
1148	accesses `*p' not to calculate the value to be stored. But, dcl.type.cv/8
1149	indicates that volatile semantics should be the same between C and C++
1150	where ever possible. C leaves it implementation defined as to what
1151	constitutes an access to a volatile. So, we interpret `*vp' as a read of
1152	the volatile object `vp' points to, unless that is an incomplete type. For
1153	volatile references we do not do this interpretation, because that would
1154	make it impossible to ignore the reference return value from functions. We
1155	issue warnings in the confusing cases.
1156
1157	The IMPLICIT is ICV_CAST when the user is explicitly converting an expression
1158	to void via a cast. If an expression is being implicitly converted, IMPLICIT
1159	indicates the context of the implicit conversion. */
1160
1161	tree
1162	convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain)
1163	{
1164	location_t loc = cp_expr_loc_or_input_loc (t: expr);
1165
1166	if (expr == error_mark_node
1167	|| TREE_TYPE (expr) == error_mark_node)
1168	return error_mark_node;
1169
1170	expr = maybe_undo_parenthesized_ref (expr);
1171
1172	expr = mark_discarded_use (expr);
1173	if (implicit == ICV_CAST)
1174	/* An explicit cast to void avoids all -Wunused-but-set* warnings. */
1175	mark_exp_read (expr);
1176
1177	if (!TREE_TYPE (expr))
1178	return expr;
1179	if (invalid_nonstatic_memfn_p (loc, expr, complain))
1180	return error_mark_node;
1181	if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR)
1182	{
1183	if (complain & tf_error)
1184	error_at (loc, "pseudo-destructor is not called");
1185	return error_mark_node;
1186	}
1187
1188	/* Explicitly evaluate void-converted concept checks since their
1189	satisfaction may produce ill-formed programs. */
1190	if (concept_check_p (t: expr))
1191	expr = evaluate_concept_check (expr);
1192
1193	if (VOID_TYPE_P (TREE_TYPE (expr)))
1194	return expr;
1195	switch (TREE_CODE (expr))
1196	{
1197	case COND_EXPR:
1198	{
1199	/* The two parts of a cond expr might be separate lvalues. */
1200	tree op1 = TREE_OPERAND (expr,1);
1201	tree op2 = TREE_OPERAND (expr,2);
1202	bool side_effects = ((op1 && TREE_SIDE_EFFECTS (op1))
1203	|| TREE_SIDE_EFFECTS (op2));
1204	tree new_op1, new_op2;
1205	new_op1 = NULL_TREE;
1206	if (implicit != ICV_CAST && !side_effects)
1207	{
1208	if (op1)
1209	new_op1 = convert_to_void (expr: op1, implicit: ICV_SECOND_OF_COND, complain);
1210	new_op2 = convert_to_void (expr: op2, implicit: ICV_THIRD_OF_COND, complain);
1211	}
1212	else
1213	{
1214	if (op1)
1215	new_op1 = convert_to_void (expr: op1, implicit: ICV_CAST, complain);
1216	new_op2 = convert_to_void (expr: op2, implicit: ICV_CAST, complain);
1217	}
1218
1219	expr = build3_loc (loc, code: COND_EXPR, TREE_TYPE (new_op2),
1220	TREE_OPERAND (expr, 0), arg1: new_op1, arg2: new_op2);
1221	break;
1222	}
1223
1224	case COMPOUND_EXPR:
1225	{
1226	/* The second part of a compound expr contains the value. */
1227	tree op1 = TREE_OPERAND (expr,1);
1228	tree new_op1;
1229	if (implicit != ICV_CAST && !warning_suppressed_p (expr /* What warning? */))
1230	new_op1 = convert_to_void (expr: op1, implicit: ICV_RIGHT_OF_COMMA, complain);
1231	else
1232	new_op1 = convert_to_void (expr: op1, implicit: ICV_CAST, complain);
1233
1234	if (new_op1 != op1)
1235	{
1236	tree t = build2_loc (loc, code: COMPOUND_EXPR, TREE_TYPE (new_op1),
1237	TREE_OPERAND (expr, 0), arg1: new_op1);
1238	expr = t;
1239	}
1240
1241	break;
1242	}
1243
1244	case NON_LVALUE_EXPR:
1245	case NOP_EXPR:
1246	/* These have already decayed to rvalue. */
1247	break;
1248
1249	case CALL_EXPR: /* We have a special meaning for volatile void fn(). */
1250	/* cdtors may return this or void, depending on
1251	targetm.cxx.cdtor_returns_this, but this shouldn't affect our
1252	decisions here: neither nodiscard warnings (nodiscard dtors
1253	are nonsensical and ctors have a different behavior with that
1254	attribute that is handled in the TARGET_EXPR case), nor should
1255	any constexpr or template instantiations be affected by an ABI
1256	property that is, or at least ought to be transparent to the
1257	language. */
1258	if (tree fn = cp_get_callee_fndecl_nofold (call: expr))
1259	if (DECL_CONSTRUCTOR_P (fn) || DECL_DESTRUCTOR_P (fn))
1260	return expr;
1261
1262	if (complain & tf_warning)
1263	maybe_warn_nodiscard (expr, implicit);
1264	break;
1265
1266	case INDIRECT_REF:
1267	{
1268	tree type = TREE_TYPE (expr);
1269	int is_reference = TYPE_REF_P (TREE_TYPE (TREE_OPERAND (expr, 0)));
1270	int is_volatile = TYPE_VOLATILE (type);
1271	if (is_volatile)
1272	complete_type (type);
1273	int is_complete = COMPLETE_TYPE_P (type);
1274
1275	/* Can't load the value if we don't know the type. */
1276	if (is_volatile && !is_complete)
1277	{
1278	if (complain & tf_warning)
1279	switch (implicit)
1280	{
1281	case ICV_CAST:
1282	warning_at (loc, 0, "conversion to void will not access "
1283	"object of incomplete type %qT", type);
1284	break;
1285	case ICV_SECOND_OF_COND:
1286	warning_at (loc, 0, "indirection will not access object of "
1287	"incomplete type %qT in second operand "
1288	"of conditional expression", type);
1289	break;
1290	case ICV_THIRD_OF_COND:
1291	warning_at (loc, 0, "indirection will not access object of "
1292	"incomplete type %qT in third operand "
1293	"of conditional expression", type);
1294	break;
1295	case ICV_RIGHT_OF_COMMA:
1296	warning_at (loc, 0, "indirection will not access object of "
1297	"incomplete type %qT in right operand of "
1298	"comma operator", type);
1299	break;
1300	case ICV_LEFT_OF_COMMA:
1301	warning_at (loc, 0, "indirection will not access object of "
1302	"incomplete type %qT in left operand of "
1303	"comma operator", type);
1304	break;
1305	case ICV_STATEMENT:
1306	warning_at (loc, 0, "indirection will not access object of "
1307	"incomplete type %qT in statement", type);
1308	break;
1309	case ICV_THIRD_IN_FOR:
1310	warning_at (loc, 0, "indirection will not access object of "
1311	"incomplete type %qT in for increment "
1312	"expression", type);
1313	break;
1314	default:
1315	gcc_unreachable ();
1316	}
1317	}
1318	/* Don't load the value if this is an implicit dereference, or if
1319	the type needs to be handled by ctors/dtors. */
1320	else if (is_volatile && is_reference)
1321	{
1322	if (complain & tf_warning)
1323	switch (implicit)
1324	{
1325	case ICV_CAST:
1326	warning_at (loc, 0, "conversion to void will not access "
1327	"object of type %qT", type);
1328	break;
1329	case ICV_SECOND_OF_COND:
1330	warning_at (loc, 0, "implicit dereference will not access "
1331	"object of type %qT in second operand of "
1332	"conditional expression", type);
1333	break;
1334	case ICV_THIRD_OF_COND:
1335	warning_at (loc, 0, "implicit dereference will not access "
1336	"object of type %qT in third operand of "
1337	"conditional expression", type);
1338	break;
1339	case ICV_RIGHT_OF_COMMA:
1340	warning_at (loc, 0, "implicit dereference will not access "
1341	"object of type %qT in right operand of "
1342	"comma operator", type);
1343	break;
1344	case ICV_LEFT_OF_COMMA:
1345	warning_at (loc, 0, "implicit dereference will not access "
1346	"object of type %qT in left operand of comma "
1347	"operator", type);
1348	break;
1349	case ICV_STATEMENT:
1350	warning_at (loc, 0, "implicit dereference will not access "
1351	"object of type %qT in statement", type);
1352	break;
1353	case ICV_THIRD_IN_FOR:
1354	warning_at (loc, 0, "implicit dereference will not access "
1355	"object of type %qT in for increment expression",
1356	type);
1357	break;
1358	default:
1359	gcc_unreachable ();
1360	}
1361	}
1362	else if (is_volatile && TREE_ADDRESSABLE (type))
1363	{
1364	if (complain & tf_warning)
1365	switch (implicit)
1366	{
1367	case ICV_CAST:
1368	warning_at (loc, 0, "conversion to void will not access "
1369	"object of non-trivially-copyable type %qT",
1370	type);
1371	break;
1372	case ICV_SECOND_OF_COND:
1373	warning_at (loc, 0, "indirection will not access object of "
1374	"non-trivially-copyable type %qT in second "
1375	"operand of conditional expression", type);
1376	break;
1377	case ICV_THIRD_OF_COND:
1378	warning_at (loc, 0, "indirection will not access object of "
1379	"non-trivially-copyable type %qT in third "
1380	"operand of conditional expression", type);
1381	break;
1382	case ICV_RIGHT_OF_COMMA:
1383	warning_at (loc, 0, "indirection will not access object of "
1384	"non-trivially-copyable type %qT in right "
1385	"operand of comma operator", type);
1386	break;
1387	case ICV_LEFT_OF_COMMA:
1388	warning_at (loc, 0, "indirection will not access object of "
1389	"non-trivially-copyable type %qT in left "
1390	"operand of comma operator", type);
1391	break;
1392	case ICV_STATEMENT:
1393	warning_at (loc, 0, "indirection will not access object of "
1394	"non-trivially-copyable type %qT in statement",
1395	type);
1396	break;
1397	case ICV_THIRD_IN_FOR:
1398	warning_at (loc, 0, "indirection will not access object of "
1399	"non-trivially-copyable type %qT in for "
1400	"increment expression", type);
1401	break;
1402	default:
1403	gcc_unreachable ();
1404	}
1405	}
1406	if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type))
1407	{
1408	/* Emit a warning (if enabled) when the "effect-less" INDIRECT_REF
1409	operation is stripped off. Note that we don't warn about
1410	- an expression with TREE_NO_WARNING set. (For an example of
1411	such expressions, see build_over_call in call.cc.)
1412	- automatic dereferencing of references, since the user cannot
1413	control it. (See also warn_if_unused_value() in c-common.cc.) */
1414	if (warn_unused_value
1415	&& implicit != ICV_CAST
1416	&& (complain & tf_warning)
1417	&& !warning_suppressed_p (expr, OPT_Wunused_value)
1418	&& !is_reference)
1419	warning_at (loc, OPT_Wunused_value, "value computed is not used");
1420	expr = TREE_OPERAND (expr, 0);
1421	if (TREE_CODE (expr) == CALL_EXPR
1422	&& (complain & tf_warning))
1423	maybe_warn_nodiscard (expr, implicit);
1424	}
1425
1426	break;
1427	}
1428
1429	case VAR_DECL:
1430	{
1431	/* External variables might be incomplete. */
1432	tree type = TREE_TYPE (expr);
1433
1434	if (TYPE_VOLATILE (type)
1435	&& !COMPLETE_TYPE_P (complete_type (type))
1436	&& (complain & tf_warning))
1437	switch (implicit)
1438	{
1439	case ICV_CAST:
1440	warning_at (loc, 0, "conversion to void will not access "
1441	"object %qE of incomplete type %qT", expr, type);
1442	break;
1443	case ICV_SECOND_OF_COND:
1444	warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1445	"not be accessed in second operand of "
1446	"conditional expression", expr, type);
1447	break;
1448	case ICV_THIRD_OF_COND:
1449	warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1450	"not be accessed in third operand of "
1451	"conditional expression", expr, type);
1452	break;
1453	case ICV_RIGHT_OF_COMMA:
1454	warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1455	"not be accessed in right operand of comma operator",
1456	expr, type);
1457	break;
1458	case ICV_LEFT_OF_COMMA:
1459	warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1460	"not be accessed in left operand of comma operator",
1461	expr, type);
1462	break;
1463	case ICV_STATEMENT:
1464	warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1465	"not be accessed in statement", expr, type);
1466	break;
1467	case ICV_THIRD_IN_FOR:
1468	warning_at (loc, 0, "variable %qE of incomplete type %qT will "
1469	"not be accessed in for increment expression",
1470	expr, type);
1471	break;
1472	default:
1473	gcc_unreachable ();
1474	}
1475
1476	break;
1477	}
1478
1479	case TARGET_EXPR:
1480	/* Don't bother with the temporary object returned from a function if
1481	we don't use it, don't need to destroy it, and won't abort in
1482	assign_temp. We'll still
1483	allocate space for it in expand_call or declare_return_variable,
1484	but we don't need to track it through all the tree phases. */
1485	if (TARGET_EXPR_IMPLICIT_P (expr)
1486	&& !TREE_ADDRESSABLE (TREE_TYPE (expr)))
1487	{
1488	tree init = TARGET_EXPR_INITIAL (expr);
1489	if (TREE_CODE (init) == AGGR_INIT_EXPR
1490	&& !AGGR_INIT_VIA_CTOR_P (init))
1491	{
1492	tree fn = AGGR_INIT_EXPR_FN (init);
1493	expr = build_call_array_loc (input_location,
1494	TREE_TYPE (TREE_TYPE
1495	(TREE_TYPE (fn))),
1496	fn,
1497	aggr_init_expr_nargs (init),
1498	AGGR_INIT_EXPR_ARGP (init));
1499	}
1500	}
1501	if (complain & tf_warning)
1502	maybe_warn_nodiscard (expr, implicit);
1503	break;
1504
1505	default:;
1506	}
1507	expr = resolve_nondeduced_context (expr, complain);
1508	if (!mark_single_function (expr, complain))
1509	return error_mark_node;
1510
1511	{
1512	tree probe = expr;
1513
1514	if (TREE_CODE (probe) == ADDR_EXPR)
1515	probe = TREE_OPERAND (expr, 0);
1516	if (type_unknown_p (expr: probe))
1517	{
1518	/* [over.over] enumerates the places where we can take the address
1519	of an overloaded function, and this is not one of them. */
1520	if (complain & tf_error)
1521	switch (implicit)
1522	{
1523	case ICV_CAST:
1524	error_at (loc, "conversion to void "
1525	"cannot resolve address of overloaded function");
1526	break;
1527	case ICV_SECOND_OF_COND:
1528	error_at (loc, "second operand of conditional expression "
1529	"cannot resolve address of overloaded function");
1530	break;
1531	case ICV_THIRD_OF_COND:
1532	error_at (loc, "third operand of conditional expression "
1533	"cannot resolve address of overloaded function");
1534	break;
1535	case ICV_RIGHT_OF_COMMA:
1536	error_at (loc, "right operand of comma operator "
1537	"cannot resolve address of overloaded function");
1538	break;
1539	case ICV_LEFT_OF_COMMA:
1540	error_at (loc, "left operand of comma operator "
1541	"cannot resolve address of overloaded function");
1542	break;
1543	case ICV_STATEMENT:
1544	error_at (loc, "statement "
1545	"cannot resolve address of overloaded function");
1546	break;
1547	case ICV_THIRD_IN_FOR:
1548	error_at (loc, "for increment expression "
1549	"cannot resolve address of overloaded function");
1550	break;
1551	}
1552	else
1553	return error_mark_node;
1554	expr = void_node;
1555	}
1556	else if (implicit != ICV_CAST && probe == expr && is_overloaded_fn (probe))
1557	{
1558	/* Only warn when there is no &. */
1559	if (complain & tf_warning)
1560	switch (implicit)
1561	{
1562	case ICV_SECOND_OF_COND:
1563	warning_at (loc, OPT_Waddress,
1564	"second operand of conditional expression "
1565	"is a reference, not call, to function %qE", expr);
1566	break;
1567	case ICV_THIRD_OF_COND:
1568	warning_at (loc, OPT_Waddress,
1569	"third operand of conditional expression "
1570	"is a reference, not call, to function %qE", expr);
1571	break;
1572	case ICV_RIGHT_OF_COMMA:
1573	warning_at (loc, OPT_Waddress,
1574	"right operand of comma operator "
1575	"is a reference, not call, to function %qE", expr);
1576	break;
1577	case ICV_LEFT_OF_COMMA:
1578	warning_at (loc, OPT_Waddress,
1579	"left operand of comma operator "
1580	"is a reference, not call, to function %qE", expr);
1581	break;
1582	case ICV_STATEMENT:
1583	warning_at (loc, OPT_Waddress,
1584	"statement is a reference, not call, to function %qE",
1585	expr);
1586	break;
1587	case ICV_THIRD_IN_FOR:
1588	warning_at (loc, OPT_Waddress,
1589	"for increment expression "
1590	"is a reference, not call, to function %qE", expr);
1591	break;
1592	default:
1593	gcc_unreachable ();
1594	}
1595
1596	if (TREE_CODE (expr) == COMPONENT_REF)
1597	expr = TREE_OPERAND (expr, 0);
1598	}
1599	}
1600
1601	if (expr != error_mark_node && !VOID_TYPE_P (TREE_TYPE (expr)))
1602	{
1603	if (implicit != ICV_CAST
1604	&& warn_unused_value
1605	&& !warning_suppressed_p (expr, OPT_Wunused_value)
1606	&& !processing_template_decl
1607	&& !cp_unevaluated_operand
1608	&& (complain & tf_warning))
1609	{
1610	/* The middle end does not warn about expressions that have
1611	been explicitly cast to void, so we must do so here. */
1612	if (!TREE_SIDE_EFFECTS (expr))
1613	{
1614	switch (implicit)
1615	{
1616	case ICV_SECOND_OF_COND:
1617	warning_at (loc, OPT_Wunused_value,
1618	"second operand of conditional expression "
1619	"has no effect");
1620	break;
1621	case ICV_THIRD_OF_COND:
1622	warning_at (loc, OPT_Wunused_value,
1623	"third operand of conditional expression "
1624	"has no effect");
1625	break;
1626	case ICV_RIGHT_OF_COMMA:
1627	warning_at (loc, OPT_Wunused_value,
1628	"right operand of comma operator has no effect");
1629	break;
1630	case ICV_LEFT_OF_COMMA:
1631	warning_at (loc, OPT_Wunused_value,
1632	"left operand of comma operator has no effect");
1633	break;
1634	case ICV_STATEMENT:
1635	warning_at (loc, OPT_Wunused_value,
1636	"statement has no effect");
1637	break;
1638	case ICV_THIRD_IN_FOR:
1639	warning_at (loc, OPT_Wunused_value,
1640	"for increment expression has no effect");
1641	break;
1642	default:
1643	gcc_unreachable ();
1644	}
1645	}
1646	else
1647	{
1648	tree e = expr;
1649	/* We might like to warn about (say) "(int) f()", as the
1650	cast has no effect, but the compiler itself will
1651	generate implicit conversions under some
1652	circumstances. (For example a block copy will be
1653	turned into a call to "__builtin_memcpy", with a
1654	conversion of the return value to an appropriate
1655	type.) So, to avoid false positives, we strip
1656	conversions. Do not use STRIP_NOPs because it will
1657	not strip conversions to "void", as that is not a
1658	mode-preserving conversion. */
1659	while (TREE_CODE (e) == NOP_EXPR)
1660	e = TREE_OPERAND (e, 0);
1661
1662	enum tree_code code = TREE_CODE (e);
1663	enum tree_code_class tclass = TREE_CODE_CLASS (code);
1664	if (tclass == tcc_comparison
1665	|| tclass == tcc_unary
1666	|| tclass == tcc_binary
1667	|| code == VEC_PERM_EXPR
1668	|| code == VEC_COND_EXPR)
1669	warn_if_unused_value (e, loc);
1670	}
1671	}
1672	expr = build1 (CONVERT_EXPR, void_type_node, expr);
1673	}
1674	if (! TREE_SIDE_EFFECTS (expr))
1675	expr = void_node;
1676	return expr;
1677	}
1678
1679	/* Create an expression whose value is that of EXPR,
1680	converted to type TYPE. The TREE_TYPE of the value
1681	is always TYPE. This function implements all reasonable
1682	conversions; callers should filter out those that are
1683	not permitted by the language being compiled.
1684
1685	Most of this routine is from build_reinterpret_cast.
1686
1687	The back end cannot call cp_convert (what was convert) because
1688	conversions to/from basetypes may involve memory references
1689	(vbases) and adding or subtracting small values (multiple
1690	inheritance), but it calls convert from the constant folding code
1691	on subtrees of already built trees after it has ripped them apart.
1692
1693	Also, if we ever support range variables, we'll probably also have to
1694	do a little bit more work. */
1695
1696	tree
1697	convert (tree type, tree expr)
1698	{
1699	tree intype;
1700
1701	if (type == error_mark_node || expr == error_mark_node)
1702	return error_mark_node;
1703
1704	intype = TREE_TYPE (expr);
1705
1706	if (INDIRECT_TYPE_P (type) && INDIRECT_TYPE_P (intype))
1707	return build_nop (type, expr);
1708
1709	return ocp_convert (type, expr, CONV_BACKEND_CONVERT,
1710	LOOKUP_NORMAL|LOOKUP_NO_CONVERSION,
1711	complain: tf_warning_or_error);
1712	}
1713
1714	/* Like convert, but in a static initializer (called from
1715	convert_and_check). */
1716
1717	tree
1718	convert_init (tree type, tree expr)
1719	{
1720	return convert (type, expr);
1721	}
1722
1723	/* Like cp_convert, except permit conversions to take place which
1724	are not normally allowed due to access restrictions
1725	(such as conversion from sub-type to private super-type). */
1726
1727	tree
1728	convert_force (tree type, tree expr, int convtype, tsubst_flags_t complain)
1729	{
1730	tree e = expr;
1731	enum tree_code code = TREE_CODE (type);
1732
1733	if (code == REFERENCE_TYPE)
1734	return convert_to_reference (reftype: type, expr: e, CONV_C_CAST, flags: 0,
1735	NULL_TREE, complain);
1736
1737	if (code == POINTER_TYPE)
1738	return convert_to_pointer_force (type, expr: e, complain);
1739
1740	/* From typeck.cc convert_for_assignment */
1741	if (((TYPE_PTR_P (TREE_TYPE (e)) && TREE_CODE (e) == ADDR_EXPR
1742	&& TREE_CODE (TREE_TYPE (TREE_TYPE (e))) == METHOD_TYPE)
1743	|| integer_zerop (e)
1744	|| TYPE_PTRMEMFUNC_P (TREE_TYPE (e)))
1745	&& TYPE_PTRMEMFUNC_P (type))
1746	/* compatible pointer to member functions. */
1747	return build_ptrmemfunc (TYPE_PTRMEMFUNC_FN_TYPE (type), e, 1,
1748	/*c_cast_p=*/1, complain);
1749
1750	return ocp_convert (type, expr: e, CONV_C_CAST|convtype, LOOKUP_NORMAL, complain);
1751	}
1752
1753	/* Convert an aggregate EXPR to type XTYPE. If a conversion
1754	exists, return the attempted conversion. This may
1755	return ERROR_MARK_NODE if the conversion is not
1756	allowed (references private members, etc).
1757	If no conversion exists, NULL_TREE is returned.
1758
1759	FIXME: Ambiguity checking is wrong. Should choose one by the implicit
1760	object parameter, or by the second standard conversion sequence if
1761	that doesn't do it. This will probably wait for an overloading rewrite.
1762	(jason 8/9/95) */
1763
1764	static tree
1765	build_type_conversion (tree xtype, tree expr)
1766	{
1767	/* C++: check to see if we can convert this aggregate type
1768	into the required type. */
1769	return build_user_type_conversion (xtype, expr, LOOKUP_NORMAL,
1770	tf_warning_or_error);
1771	}
1772
1773	/* Convert the given EXPR to one of a group of types suitable for use in an
1774	expression. DESIRES is a combination of various WANT_* flags (q.v.)
1775	which indicates which types are suitable. If COMPLAIN is true, complain
1776	about ambiguity; otherwise, the caller will deal with it. */
1777
1778	tree
1779	build_expr_type_conversion (int desires, tree expr, bool complain)
1780	{
1781	tree basetype = TREE_TYPE (expr);
1782	tree conv = NULL_TREE;
1783	tree winner = NULL_TREE;
1784
1785	if (null_node_p (expr)
1786	&& (desires & WANT_INT)
1787	&& !(desires & WANT_NULL))
1788	{
1789	location_t loc =
1790	expansion_point_location_if_in_system_header (input_location);
1791
1792	warning_at (loc, OPT_Wconversion_null,
1793	"converting NULL to non-pointer type");
1794	}
1795
1796	if (basetype == error_mark_node)
1797	return error_mark_node;
1798
1799	if (! MAYBE_CLASS_TYPE_P (basetype))
1800	switch (TREE_CODE (basetype))
1801	{
1802	case INTEGER_TYPE:
1803	if ((desires & WANT_NULL) && null_ptr_cst_p (expr))
1804	return expr;
1805	/* fall through. */
1806
1807	case BOOLEAN_TYPE:
1808	return (desires & WANT_INT) ? expr : NULL_TREE;
1809	case ENUMERAL_TYPE:
1810	return (desires & WANT_ENUM) ? expr : NULL_TREE;
1811	case REAL_TYPE:
1812	return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1813	case POINTER_TYPE:
1814	return (desires & WANT_POINTER) ? expr : NULL_TREE;
1815
1816	case FUNCTION_TYPE:
1817	case ARRAY_TYPE:
1818	return (desires & WANT_POINTER) ? decay_conversion (expr,
1819	tf_warning_or_error)
1820	: NULL_TREE;
1821
1822	case VECTOR_TYPE:
1823	if (!gnu_vector_type_p (type: basetype))
1824	return NULL_TREE;
1825	/* FALLTHROUGH */
1826	case COMPLEX_TYPE:
1827	if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1828	return NULL_TREE;
1829	switch (TREE_CODE (TREE_TYPE (basetype)))
1830	{
1831	case INTEGER_TYPE:
1832	case BOOLEAN_TYPE:
1833	return (desires & WANT_INT) ? expr : NULL_TREE;
1834	case ENUMERAL_TYPE:
1835	return (desires & WANT_ENUM) ? expr : NULL_TREE;
1836	case REAL_TYPE:
1837	return (desires & WANT_FLOAT) ? expr : NULL_TREE;
1838	default:
1839	return NULL_TREE;
1840	}
1841
1842	default:
1843	return NULL_TREE;
1844	}
1845
1846	/* The code for conversions from class type is currently only used for
1847	delete expressions. Other expressions are handled by build_new_op. */
1848	if (!complete_type_or_maybe_complain (basetype, expr, complain))
1849	return error_mark_node;
1850	if (!TYPE_HAS_CONVERSION (basetype))
1851	return NULL_TREE;
1852
1853	for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
1854	{
1855	int win = 0;
1856	tree candidate;
1857	tree cand = TREE_VALUE (conv);
1858	cand = OVL_FIRST (cand);
1859
1860	if (winner && winner == cand)
1861	continue;
1862
1863	if (DECL_NONCONVERTING_P (cand))
1864	continue;
1865
1866	candidate = non_reference (TREE_TYPE (TREE_TYPE (cand)));
1867
1868	switch (TREE_CODE (candidate))
1869	{
1870	case BOOLEAN_TYPE:
1871	case INTEGER_TYPE:
1872	win = (desires & WANT_INT); break;
1873	case ENUMERAL_TYPE:
1874	win = (desires & WANT_ENUM); break;
1875	case REAL_TYPE:
1876	win = (desires & WANT_FLOAT); break;
1877	case POINTER_TYPE:
1878	win = (desires & WANT_POINTER); break;
1879
1880	case COMPLEX_TYPE:
1881	case VECTOR_TYPE:
1882	if ((desires & WANT_VECTOR_OR_COMPLEX) == 0)
1883	break;
1884	switch (TREE_CODE (TREE_TYPE (candidate)))
1885	{
1886	case BOOLEAN_TYPE:
1887	case INTEGER_TYPE:
1888	win = (desires & WANT_INT); break;
1889	case ENUMERAL_TYPE:
1890	win = (desires & WANT_ENUM); break;
1891	case REAL_TYPE:
1892	win = (desires & WANT_FLOAT); break;
1893	default:
1894	break;
1895	}
1896	break;
1897
1898	default:
1899	/* A wildcard could be instantiated to match any desired
1900	type, but we can't deduce the template argument. */
1901	if (WILDCARD_TYPE_P (candidate))
1902	win = true;
1903	break;
1904	}
1905
1906	if (win)
1907	{
1908	if (TREE_CODE (cand) == TEMPLATE_DECL)
1909	{
1910	if (complain)
1911	error ("default type conversion cannot deduce template"
1912	" argument for %qD", cand);
1913	return error_mark_node;
1914	}
1915
1916	if (winner)
1917	{
1918	tree winner_type
1919	= non_reference (TREE_TYPE (TREE_TYPE (winner)));
1920
1921	if (!same_type_ignoring_top_level_qualifiers_p (winner_type,
1922	candidate))
1923	{
1924	if (complain)
1925	{
1926	error ("ambiguous default type conversion from %qT",
1927	basetype);
1928	inform (input_location,
1929	" candidate conversions include %qD and %qD",
1930	winner, cand);
1931	}
1932	return error_mark_node;
1933	}
1934	}
1935
1936	winner = cand;
1937	}
1938	}
1939
1940	if (winner)
1941	{
1942	tree type = non_reference (TREE_TYPE (TREE_TYPE (winner)));
1943	return build_user_type_conversion (type, expr, LOOKUP_NORMAL,
1944	tf_warning_or_error);
1945	}
1946
1947	return NULL_TREE;
1948	}
1949
1950	/* Implements integral promotion (4.1) and float->double promotion. */
1951
1952	tree
1953	type_promotes_to (tree type)
1954	{
1955	tree promoted_type;
1956
1957	if (type == error_mark_node)
1958	return error_mark_node;
1959
1960	type = TYPE_MAIN_VARIANT (type);
1961
1962	/* Check for promotions of target-defined types first. */
1963	promoted_type = targetm.promoted_type (type);
1964	if (promoted_type)
1965	return promoted_type;
1966
1967	/* bool always promotes to int (not unsigned), even if it's the same
1968	size. */
1969	if (TREE_CODE (type) == BOOLEAN_TYPE)
1970	type = integer_type_node;
1971
1972	/* Normally convert enums to int, but convert wide enums to something
1973	wider. Scoped enums don't promote, but pretend they do for backward
1974	ABI bug compatibility wrt varargs. */
1975	else if (TREE_CODE (type) == ENUMERAL_TYPE
1976	|| type == char8_type_node
1977	|| type == char16_type_node
1978	|| type == char32_type_node
1979	|| type == wchar_type_node)
1980	{
1981	tree prom = type;
1982
1983	if (TREE_CODE (type) == ENUMERAL_TYPE)
1984	{
1985	prom = ENUM_UNDERLYING_TYPE (prom);
1986	if (!ENUM_IS_SCOPED (type)
1987	&& ENUM_FIXED_UNDERLYING_TYPE_P (type))
1988	{
1989	/* ISO C++17, 7.6/4. A prvalue of an unscoped enumeration type
1990	whose underlying type is fixed (10.2) can be converted to a
1991	prvalue of its underlying type. Moreover, if integral promotion
1992	can be applied to its underlying type, a prvalue of an unscoped
1993	enumeration type whose underlying type is fixed can also be
1994	converted to a prvalue of the promoted underlying type. */
1995	return type_promotes_to (type: prom);
1996	}
1997	}
1998
1999	int precision = MAX (TYPE_PRECISION (type),
2000	TYPE_PRECISION (integer_type_node));
2001	tree totype = c_common_type_for_size (precision, 0);
2002	if (TYPE_UNSIGNED (prom)
2003	&& ! int_fits_type_p (TYPE_MAX_VALUE (prom), totype))
2004	prom = c_common_type_for_size (precision, 1);
2005	else
2006	prom = totype;
2007	if (SCOPED_ENUM_P (type))
2008	{
2009	if (abi_version_crosses (6)
2010	&& TYPE_MODE (prom) != TYPE_MODE (type))
2011	warning (OPT_Wabi, "scoped enum %qT passed through %<...%> as "
2012	"%qT before %<-fabi-version=6%>, %qT after",
2013	type, prom, ENUM_UNDERLYING_TYPE (type));
2014	if (!abi_version_at_least (6))
2015	type = prom;
2016	}
2017	else
2018	type = prom;
2019	}
2020	else if (c_promoting_integer_type_p (type))
2021	{
2022	/* Retain unsignedness if really not getting bigger. */
2023	if (TYPE_UNSIGNED (type)
2024	&& TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2025	type = unsigned_type_node;
2026	else
2027	type = integer_type_node;
2028	}
2029	else if (type == float_type_node)
2030	type = double_type_node;
2031
2032	return type;
2033	}
2034
2035	/* The routines below this point are carefully written to conform to
2036	the standard. They use the same terminology, and follow the rules
2037	closely. Although they are used only in pt.cc at the moment, they
2038	should presumably be used everywhere in the future. */
2039
2040	/* True iff EXPR can be converted to TYPE via a qualification conversion.
2041	Callers should check for identical types before calling this function. */
2042
2043	bool
2044	can_convert_qual (tree type, tree expr)
2045	{
2046	tree expr_type = TREE_TYPE (expr);
2047	gcc_assert (!same_type_p (type, expr_type));
2048
2049	/* A function pointer conversion also counts as a Qualification Adjustment
2050	under [over.ics.scs]. */
2051	if (fnptr_conv_p (type, expr_type))
2052	return true;
2053
2054	if (TYPE_PTR_P (type) && TYPE_PTR_P (expr_type))
2055	return comp_ptr_ttypes (TREE_TYPE (type), TREE_TYPE (expr_type));
2056	else if (TYPE_PTRMEM_P (type) && TYPE_PTRMEM_P (expr_type))
2057	return (same_type_p (TYPE_PTRMEM_CLASS_TYPE (type),
2058	TYPE_PTRMEM_CLASS_TYPE (expr_type))
2059	&& comp_ptr_ttypes (TYPE_PTRMEM_POINTED_TO_TYPE (type),
2060	TYPE_PTRMEM_POINTED_TO_TYPE (expr_type)));
2061	else
2062	return false;
2063	}
2064
2065	/* Attempt to perform qualification conversions on EXPR to convert it
2066	to TYPE. Return the resulting expression, or error_mark_node if
2067	the conversion was impossible. Since this is only used by
2068	convert_nontype_argument, we fold the conversion. */
2069
2070	tree
2071	perform_qualification_conversions (tree type, tree expr)
2072	{
2073	tree expr_type;
2074
2075	expr_type = TREE_TYPE (expr);
2076
2077	if (same_type_p (type, expr_type))
2078	return expr;
2079	else if (can_convert_qual (type, expr))
2080	return cp_fold_convert (type, expr);
2081	else
2082	return error_mark_node;
2083	}
2084
2085	/* True iff T is a transaction-safe function type. */
2086
2087	bool
2088	tx_safe_fn_type_p (tree t)
2089	{
2090	if (!FUNC_OR_METHOD_TYPE_P (t))
2091	return false;
2092	return !!lookup_attribute (attr_name: "transaction_safe", TYPE_ATTRIBUTES (t));
2093	}
2094
2095	/* Return the transaction-unsafe variant of transaction-safe function type
2096	T. */
2097
2098	tree
2099	tx_unsafe_fn_variant (tree t)
2100	{
2101	gcc_assert (tx_safe_fn_type_p (t));
2102	tree attrs = remove_attribute ("transaction_safe",
2103	TYPE_ATTRIBUTES (t));
2104	return cp_build_type_attribute_variant (t, attrs);
2105	}
2106
2107	/* Return true iff FROM can convert to TO by a transaction-safety
2108	conversion. */
2109
2110	static bool
2111	can_convert_tx_safety (tree to, tree from)
2112	{
2113	return (flag_tm && tx_safe_fn_type_p (t: from)
2114	&& same_type_p (to, tx_unsafe_fn_variant (from)));
2115	}
2116
2117	/* Return true iff FROM can convert to TO by dropping noexcept.
2118	This is just a subroutine of fnptr_conv_p. */
2119
2120	static bool
2121	noexcept_conv_p (tree to, tree from)
2122	{
2123	if (!flag_noexcept_type)
2124	return false;
2125
2126	if (TREE_CODE (to) != TREE_CODE (from))
2127	return false;
2128	if (!FUNC_OR_METHOD_TYPE_P (from))
2129	return false;
2130	if (!type_throw_all_p (to)
2131	|| type_throw_all_p (from))
2132	return false;
2133	tree v = build_exception_variant (from, NULL_TREE);
2134	return same_type_p (to, v);
2135	}
2136
2137	/* Return true iff FROM can convert to TO by a function pointer conversion. */
2138
2139	bool
2140	fnptr_conv_p (tree to, tree from)
2141	{
2142	tree t = to;
2143	tree f = from;
2144	if (TYPE_PTRMEMFUNC_P (t)
2145	&& TYPE_PTRMEMFUNC_P (f))
2146	{
2147	t = TYPE_PTRMEMFUNC_FN_TYPE (t);
2148	f = TYPE_PTRMEMFUNC_FN_TYPE (f);
2149	}
2150	if (INDIRECT_TYPE_P (t)
2151	&& INDIRECT_TYPE_P (f))
2152	{
2153	t = TREE_TYPE (t);
2154	f = TREE_TYPE (f);
2155	}
2156
2157	return (noexcept_conv_p (to: t, from: f)
2158	|| can_convert_tx_safety (to: t, from: f));
2159	}
2160
2161	/* Return FN with any NOP_EXPRs stripped that represent function pointer
2162	conversions or conversions to the same type. */
2163
2164	tree
2165	strip_fnptr_conv (tree fn)
2166	{
2167	while (TREE_CODE (fn) == NOP_EXPR)
2168	{
2169	tree op = TREE_OPERAND (fn, 0);
2170	tree ft = TREE_TYPE (fn);
2171	tree ot = TREE_TYPE (op);
2172	if (same_type_p (ft, ot)
2173	|| fnptr_conv_p (to: ft, from: ot))
2174	fn = op;
2175	else
2176	break;
2177	}
2178	return fn;
2179	}
2180