1	/* Gimple IR support functions.
2
3	Copyright (C) 2007-2023 Free Software Foundation, Inc.
4	Contributed by Aldy Hernandez <aldyh@redhat.com>
5
6	This file is part of GCC.
7
8	GCC is free software; you can redistribute it and/or modify it under
9	the terms of the GNU General Public License as published by the Free
10	Software Foundation; either version 3, or (at your option) any later
11	version.
12
13	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14	WARRANTY; without even the implied warranty of MERCHANTABILITY or
15	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16	for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with GCC; see the file COPYING3. If not see
20	<http://www.gnu.org/licenses/>. */
21
22	#include "config.h"
23	#include "system.h"
24	#include "coretypes.h"
25	#include "backend.h"
26	#include "tree.h"
27	#include "gimple.h"
28	#include "ssa.h"
29	#include "cgraph.h"
30	#include "diagnostic.h"
31	#include "alias.h"
32	#include "fold-const.h"
33	#include "calls.h"
34	#include "stor-layout.h"
35	#include "internal-fn.h"
36	#include "tree-eh.h"
37	#include "gimple-iterator.h"
38	#include "gimple-walk.h"
39	#include "gimplify.h"
40	#include "target.h"
41	#include "builtins.h"
42	#include "selftest.h"
43	#include "gimple-pretty-print.h"
44	#include "stringpool.h"
45	#include "attribs.h"
46	#include "asan.h"
47	#include "ubsan.h"
48	#include "langhooks.h"
49	#include "attr-fnspec.h"
50	#include "ipa-modref-tree.h"
51	#include "ipa-modref.h"
52	#include "dbgcnt.h"
53
54	/* All the tuples have their operand vector (if present) at the very bottom
55	of the structure. Therefore, the offset required to find the
56	operands vector the size of the structure minus the size of the 1
57	element tree array at the end (see gimple_ops). */
58	#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
59	(HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
60	EXPORTED_CONST size_t gimple_ops_offset_[] = {
61	#include "gsstruct.def"
62	};
63	#undef DEFGSSTRUCT
64
65	#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
66	static const size_t gsstruct_code_size[] = {
67	#include "gsstruct.def"
68	};
69	#undef DEFGSSTRUCT
70
71	#define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
72	const char *const gimple_code_name[] = {
73	#include "gimple.def"
74	};
75	#undef DEFGSCODE
76
77	#define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
78	EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
79	#include "gimple.def"
80	};
81	#undef DEFGSCODE
82
83	/* Gimple stats. */
84
85	uint64_t gimple_alloc_counts[(int) gimple_alloc_kind_all];
86	uint64_t gimple_alloc_sizes[(int) gimple_alloc_kind_all];
87
88	/* Keep in sync with gimple.h:enum gimple_alloc_kind. */
89	static const char * const gimple_alloc_kind_names[] = {
90	"assignments",
91	"phi nodes",
92	"conditionals",
93	"everything else"
94	};
95
96	/* Static gimple tuple members. */
97	const enum gimple_code gassign::code_;
98	const enum gimple_code gcall::code_;
99	const enum gimple_code gcond::code_;
100
101
102	/* Gimple tuple constructors.
103	Note: Any constructor taking a ``gimple_seq'' as a parameter, can
104	be passed a NULL to start with an empty sequence. */
105
106	/* Set the code for statement G to CODE. */
107
108	static inline void
109	gimple_set_code (gimple *g, enum gimple_code code)
110	{
111	g->code = code;
112	}
113
114	/* Return the number of bytes needed to hold a GIMPLE statement with
115	code CODE. */
116
117	size_t
118	gimple_size (enum gimple_code code, unsigned num_ops)
119	{
120	size_t size = gsstruct_code_size[gss_for_code (code)];
121	if (num_ops > 0)
122	size += (sizeof (tree) * (num_ops - 1));
123	return size;
124	}
125
126	/* Initialize GIMPLE statement G with CODE and NUM_OPS. */
127
128	void
129	gimple_init (gimple *g, enum gimple_code code, unsigned num_ops)
130	{
131	gimple_set_code (g, code);
132	gimple_set_num_ops (gs: g, num_ops);
133
134	/* Do not call gimple_set_modified here as it has other side
135	effects and this tuple is still not completely built. */
136	g->modified = 1;
137	gimple_init_singleton (g);
138	}
139
140	/* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
141	operands. */
142
143	gimple *
144	gimple_alloc (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
145	{
146	size_t size;
147	gimple *stmt;
148
149	size = gimple_size (code, num_ops);
150	if (GATHER_STATISTICS)
151	{
152	enum gimple_alloc_kind kind = gimple_alloc_kind (code);
153	gimple_alloc_counts[(int) kind]++;
154	gimple_alloc_sizes[(int) kind] += size;
155	}
156
157	stmt = ggc_alloc_cleared_gimple_statement_stat (s: size PASS_MEM_STAT);
158	gimple_init (g: stmt, code, num_ops);
159	return stmt;
160	}
161
162	/* Set SUBCODE to be the code of the expression computed by statement G. */
163
164	static inline void
165	gimple_set_subcode (gimple *g, unsigned subcode)
166	{
167	/* We only have 16 bits for the RHS code. Assert that we are not
168	overflowing it. */
169	gcc_assert (subcode < (1 << 16));
170	g->subcode = subcode;
171	}
172
173
174
175	/* Build a tuple with operands. CODE is the statement to build (which
176	must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the subcode
177	for the new tuple. NUM_OPS is the number of operands to allocate. */
178
179	#define gimple_build_with_ops(c, s, n) \
180	gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
181
182	static gimple *
183	gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
184	unsigned num_ops MEM_STAT_DECL)
185	{
186	gimple *s = gimple_alloc (code, num_ops PASS_MEM_STAT);
187	gimple_set_subcode (g: s, subcode);
188
189	return s;
190	}
191
192
193	/* Build a GIMPLE_RETURN statement returning RETVAL. */
194
195	greturn *
196	gimple_build_return (tree retval)
197	{
198	greturn *s
199	= as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
200	2));
201	if (retval)
202	gimple_return_set_retval (gs: s, retval);
203	return s;
204	}
205
206	/* Reset alias information on call S. */
207
208	void
209	gimple_call_reset_alias_info (gcall *s)
210	{
211	if (gimple_call_flags (s) & ECF_CONST)
212	memset (s: gimple_call_use_set (call_stmt: s), c: 0, n: sizeof (struct pt_solution));
213	else
214	pt_solution_reset (gimple_call_use_set (call_stmt: s));
215	if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
216	memset (s: gimple_call_clobber_set (call_stmt: s), c: 0, n: sizeof (struct pt_solution));
217	else
218	pt_solution_reset (gimple_call_clobber_set (call_stmt: s));
219	}
220
221	/* Helper for gimple_build_call, gimple_build_call_valist,
222	gimple_build_call_vec and gimple_build_call_from_tree. Build the basic
223	components of a GIMPLE_CALL statement to function FN with NARGS
224	arguments. */
225
226	static inline gcall *
227	gimple_build_call_1 (tree fn, unsigned nargs)
228	{
229	gcall *s
230	= as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
231	nargs + 3));
232	if (TREE_CODE (fn) == FUNCTION_DECL)
233	fn = build_fold_addr_expr (fn);
234	gimple_set_op (gs: s, i: 1, op: fn);
235	gimple_call_set_fntype (call_stmt: s, TREE_TYPE (TREE_TYPE (fn)));
236	gimple_call_reset_alias_info (s);
237	return s;
238	}
239
240
241	/* Build a GIMPLE_CALL statement to function FN with the arguments
242	specified in vector ARGS. */
243
244	gcall *
245	gimple_build_call_vec (tree fn, const vec<tree> &args)
246	{
247	unsigned i;
248	unsigned nargs = args.length ();
249	gcall *call = gimple_build_call_1 (fn, nargs);
250
251	for (i = 0; i < nargs; i++)
252	gimple_call_set_arg (gs: call, index: i, arg: args[i]);
253
254	return call;
255	}
256
257
258	/* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
259	arguments. The ... are the arguments. */
260
261	gcall *
262	gimple_build_call (tree fn, unsigned nargs, ...)
263	{
264	va_list ap;
265	gcall *call;
266	unsigned i;
267
268	gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
269
270	call = gimple_build_call_1 (fn, nargs);
271
272	va_start (ap, nargs);
273	for (i = 0; i < nargs; i++)
274	gimple_call_set_arg (gs: call, index: i, va_arg (ap, tree));
275	va_end (ap);
276
277	return call;
278	}
279
280
281	/* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
282	arguments. AP contains the arguments. */
283
284	gcall *
285	gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
286	{
287	gcall *call;
288	unsigned i;
289
290	gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
291
292	call = gimple_build_call_1 (fn, nargs);
293
294	for (i = 0; i < nargs; i++)
295	gimple_call_set_arg (gs: call, index: i, va_arg (ap, tree));
296
297	return call;
298	}
299
300
301	/* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
302	Build the basic components of a GIMPLE_CALL statement to internal
303	function FN with NARGS arguments. */
304
305	static inline gcall *
306	gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
307	{
308	gcall *s
309	= as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
310	nargs + 3));
311	s->subcode |= GF_CALL_INTERNAL;
312	gimple_call_set_internal_fn (call_stmt: s, fn);
313	gimple_call_reset_alias_info (s);
314	return s;
315	}
316
317
318	/* Build a GIMPLE_CALL statement to internal function FN. NARGS is
319	the number of arguments. The ... are the arguments. */
320
321	gcall *
322	gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
323	{
324	va_list ap;
325	gcall *call;
326	unsigned i;
327
328	call = gimple_build_call_internal_1 (fn, nargs);
329	va_start (ap, nargs);
330	for (i = 0; i < nargs; i++)
331	gimple_call_set_arg (gs: call, index: i, va_arg (ap, tree));
332	va_end (ap);
333
334	return call;
335	}
336
337
338	/* Build a GIMPLE_CALL statement to internal function FN with the arguments
339	specified in vector ARGS. */
340
341	gcall *
342	gimple_build_call_internal_vec (enum internal_fn fn, const vec<tree> &args)
343	{
344	unsigned i, nargs;
345	gcall *call;
346
347	nargs = args.length ();
348	call = gimple_build_call_internal_1 (fn, nargs);
349	for (i = 0; i < nargs; i++)
350	gimple_call_set_arg (gs: call, index: i, arg: args[i]);
351
352	return call;
353	}
354
355
356	/* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
357	assumed to be in GIMPLE form already. Minimal checking is done of
358	this fact. */
359
360	gcall *
361	gimple_build_call_from_tree (tree t, tree fnptrtype)
362	{
363	unsigned i, nargs;
364	gcall *call;
365
366	gcc_assert (TREE_CODE (t) == CALL_EXPR);
367
368	nargs = call_expr_nargs (t);
369
370	tree fndecl = NULL_TREE;
371	if (CALL_EXPR_FN (t) == NULL_TREE)
372	call = gimple_build_call_internal_1 (CALL_EXPR_IFN (t), nargs);
373	else
374	{
375	fndecl = get_callee_fndecl (t);
376	call = gimple_build_call_1 (fn: fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
377	}
378
379	for (i = 0; i < nargs; i++)
380	gimple_call_set_arg (gs: call, index: i, CALL_EXPR_ARG (t, i));
381
382	gimple_set_block (g: call, TREE_BLOCK (t));
383	gimple_set_location (g: call, EXPR_LOCATION (t));
384
385	/* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
386	gimple_call_set_chain (call_stmt: call, CALL_EXPR_STATIC_CHAIN (t));
387	gimple_call_set_tail (s: call, CALL_EXPR_TAILCALL (t));
388	gimple_call_set_must_tail (s: call, CALL_EXPR_MUST_TAIL_CALL (t));
389	gimple_call_set_return_slot_opt (s: call, CALL_EXPR_RETURN_SLOT_OPT (t));
390	if (fndecl
391	&& fndecl_built_in_p (node: fndecl, klass: BUILT_IN_NORMAL)
392	&& ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
393	gimple_call_set_alloca_for_var (s: call, CALL_ALLOCA_FOR_VAR_P (t));
394	else if (fndecl
395	&& (DECL_IS_OPERATOR_NEW_P (fndecl)
396	|| DECL_IS_OPERATOR_DELETE_P (fndecl)))
397	gimple_call_set_from_new_or_delete (s: call, CALL_FROM_NEW_OR_DELETE_P (t));
398	else
399	gimple_call_set_from_thunk (s: call, CALL_FROM_THUNK_P (t));
400	gimple_call_set_va_arg_pack (s: call, CALL_EXPR_VA_ARG_PACK (t));
401	gimple_call_set_nothrow (s: call, TREE_NOTHROW (t));
402	if (fndecl)
403	gimple_call_set_expected_throw (s: call,
404	expected_throw_p: flags_from_decl_or_type (fndecl)
405	& ECF_XTHROW);
406	gimple_call_set_by_descriptor (s: call, CALL_EXPR_BY_DESCRIPTOR (t));
407	copy_warning (call, t);
408
409	if (fnptrtype)
410	{
411	gimple_call_set_fntype (call_stmt: call, TREE_TYPE (fnptrtype));
412
413	/* Check if it's an indirect CALL and the type has the
414	nocf_check attribute. In that case propagate the information
415	to the gimple CALL insn. */
416	if (!fndecl)
417	{
418	gcc_assert (POINTER_TYPE_P (fnptrtype));
419	tree fntype = TREE_TYPE (fnptrtype);
420
421	if (lookup_attribute (attr_name: "nocf_check", TYPE_ATTRIBUTES (fntype)))
422	gimple_call_set_nocf_check (gs: call, nocf_check: true);
423	}
424	}
425
426	return call;
427	}
428
429	/* Build a gcall to __builtin_unreachable as rewritten by
430	-fsanitize=unreachable. */
431
432	gcall *
433	gimple_build_builtin_unreachable (location_t loc)
434	{
435	tree data = NULL_TREE;
436	tree fn = sanitize_unreachable_fn (data: &data, loc);
437	gcall *g = gimple_build_call (fn, nargs: data != NULL_TREE, data);
438	gimple_call_set_ctrl_altering (s: g, ctrl_altering_p: true);
439	gimple_set_location (g, location: loc);
440	return g;
441	}
442
443	/* Build a GIMPLE_ASSIGN statement.
444
445	LHS of the assignment.
446	RHS of the assignment which can be unary or binary. */
447
448	gassign *
449	gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
450	{
451	enum tree_code subcode;
452	tree op1, op2, op3;
453
454	extract_ops_from_tree (rhs, &subcode, &op1, &op2, &op3);
455	return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
456	}
457
458
459	/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
460	OP1, OP2 and OP3. */
461
462	static inline gassign *
463	gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
464	tree op2, tree op3 MEM_STAT_DECL)
465	{
466	unsigned num_ops;
467	gassign *p;
468
469	/* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
470	code). */
471	num_ops = get_gimple_rhs_num_ops (subcode) + 1;
472
473	p = as_a <gassign *> (
474	p: gimple_build_with_ops_stat (code: GIMPLE_ASSIGN, subcode: (unsigned)subcode, num_ops
475	PASS_MEM_STAT));
476	gimple_assign_set_lhs (gs: p, lhs);
477	gimple_assign_set_rhs1 (gs: p, rhs: op1);
478	if (op2)
479	{
480	gcc_assert (num_ops > 2);
481	gimple_assign_set_rhs2 (gs: p, rhs: op2);
482	}
483
484	if (op3)
485	{
486	gcc_assert (num_ops > 3);
487	gimple_assign_set_rhs3 (gs: p, rhs: op3);
488	}
489
490	return p;
491	}
492
493	/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
494	OP1, OP2 and OP3. */
495
496	gassign *
497	gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
498	tree op2, tree op3 MEM_STAT_DECL)
499	{
500	return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
501	}
502
503	/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
504	OP1 and OP2. */
505
506	gassign *
507	gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
508	tree op2 MEM_STAT_DECL)
509	{
510	return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
511	PASS_MEM_STAT);
512	}
513
514	/* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1. */
515
516	gassign *
517	gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
518	{
519	return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
520	PASS_MEM_STAT);
521	}
522
523
524	/* Build a GIMPLE_COND statement.
525
526	PRED is the condition used to compare LHS and the RHS.
527	T_LABEL is the label to jump to if the condition is true.
528	F_LABEL is the label to jump to otherwise. */
529
530	gcond *
531	gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
532	tree t_label, tree f_label)
533	{
534	gcond *p;
535
536	gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
537	p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
538	gimple_cond_set_lhs (gs: p, lhs);
539	gimple_cond_set_rhs (gs: p, rhs);
540	gimple_cond_set_true_label (gs: p, label: t_label);
541	gimple_cond_set_false_label (gs: p, label: f_label);
542	return p;
543	}
544
545	/* Build a GIMPLE_COND statement from the conditional expression tree
546	COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
547
548	gcond *
549	gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
550	{
551	enum tree_code code;
552	tree lhs, rhs;
553
554	gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
555	return gimple_build_cond (pred_code: code, lhs, rhs, t_label, f_label);
556	}
557
558	/* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
559	boolean expression tree COND. */
560
561	void
562	gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
563	{
564	enum tree_code code;
565	tree lhs, rhs;
566
567	gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
568	gimple_cond_set_condition (stmt, code, lhs, rhs);
569	}
570
571	/* Build a GIMPLE_LABEL statement for LABEL. */
572
573	glabel *
574	gimple_build_label (tree label)
575	{
576	glabel *p
577	= as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
578	gimple_label_set_label (gs: p, label);
579	return p;
580	}
581
582	/* Build a GIMPLE_GOTO statement to label DEST. */
583
584	ggoto *
585	gimple_build_goto (tree dest)
586	{
587	ggoto *p
588	= as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
589	gimple_goto_set_dest (gs: p, dest);
590	return p;
591	}
592
593
594	/* Build a GIMPLE_NOP statement. */
595
596	gimple *
597	gimple_build_nop (void)
598	{
599	return gimple_alloc (code: GIMPLE_NOP, num_ops: 0);
600	}
601
602
603	/* Build a GIMPLE_BIND statement.
604	VARS are the variables in BODY.
605	BLOCK is the containing block. */
606
607	gbind *
608	gimple_build_bind (tree vars, gimple_seq body, tree block)
609	{
610	gbind *p = as_a <gbind *> (p: gimple_alloc (code: GIMPLE_BIND, num_ops: 0));
611	gimple_bind_set_vars (bind_stmt: p, vars);
612	if (body)
613	gimple_bind_set_body (bind_stmt: p, seq: body);
614	if (block)
615	gimple_bind_set_block (bind_stmt: p, block);
616	return p;
617	}
618
619	/* Helper function to set the simple fields of a asm stmt.
620
621	STRING is a pointer to a string that is the asm blocks assembly code.
622	NINPUT is the number of register inputs.
623	NOUTPUT is the number of register outputs.
624	NCLOBBERS is the number of clobbered registers.
625	*/
626
627	static inline gasm *
628	gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
629	unsigned nclobbers, unsigned nlabels)
630	{
631	gasm *p;
632	int size = strlen (s: string);
633
634	p = as_a <gasm *> (
635	gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
636	ninputs + noutputs + nclobbers + nlabels));
637
638	p->ni = ninputs;
639	p->no = noutputs;
640	p->nc = nclobbers;
641	p->nl = nlabels;
642	p->string = ggc_alloc_string (contents: string, length: size);
643
644	if (GATHER_STATISTICS)
645	gimple_alloc_sizes[(int) gimple_alloc_kind (code: GIMPLE_ASM)] += size;
646
647	return p;
648	}
649
650	/* Build a GIMPLE_ASM statement.
651
652	STRING is the assembly code.
653	NINPUT is the number of register inputs.
654	NOUTPUT is the number of register outputs.
655	NCLOBBERS is the number of clobbered registers.
656	INPUTS is a vector of the input register parameters.
657	OUTPUTS is a vector of the output register parameters.
658	CLOBBERS is a vector of the clobbered register parameters.
659	LABELS is a vector of destination labels. */
660
661	gasm *
662	gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
663	vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
664	vec<tree, va_gc> *labels)
665	{
666	gasm *p;
667	unsigned i;
668
669	p = gimple_build_asm_1 (string,
670	ninputs: vec_safe_length (v: inputs),
671	noutputs: vec_safe_length (v: outputs),
672	nclobbers: vec_safe_length (v: clobbers),
673	nlabels: vec_safe_length (v: labels));
674
675	for (i = 0; i < vec_safe_length (v: inputs); i++)
676	gimple_asm_set_input_op (asm_stmt: p, index: i, in_op: (*inputs)[i]);
677
678	for (i = 0; i < vec_safe_length (v: outputs); i++)
679	gimple_asm_set_output_op (asm_stmt: p, index: i, out_op: (*outputs)[i]);
680
681	for (i = 0; i < vec_safe_length (v: clobbers); i++)
682	gimple_asm_set_clobber_op (asm_stmt: p, index: i, clobber_op: (*clobbers)[i]);
683
684	for (i = 0; i < vec_safe_length (v: labels); i++)
685	gimple_asm_set_label_op (asm_stmt: p, index: i, label_op: (*labels)[i]);
686
687	return p;
688	}
689
690	/* Build a GIMPLE_CATCH statement.
691
692	TYPES are the catch types.
693	HANDLER is the exception handler. */
694
695	gcatch *
696	gimple_build_catch (tree types, gimple_seq handler)
697	{
698	gcatch *p = as_a <gcatch *> (p: gimple_alloc (code: GIMPLE_CATCH, num_ops: 0));
699	gimple_catch_set_types (catch_stmt: p, t: types);
700	if (handler)
701	gimple_catch_set_handler (catch_stmt: p, handler);
702
703	return p;
704	}
705
706	/* Build a GIMPLE_EH_FILTER statement.
707
708	TYPES are the filter's types.
709	FAILURE is the filter's failure action. */
710
711	geh_filter *
712	gimple_build_eh_filter (tree types, gimple_seq failure)
713	{
714	geh_filter *p = as_a <geh_filter *> (p: gimple_alloc (code: GIMPLE_EH_FILTER, num_ops: 0));
715	gimple_eh_filter_set_types (eh_filter_stmt: p, types);
716	if (failure)
717	gimple_eh_filter_set_failure (eh_filter_stmt: p, failure);
718
719	return p;
720	}
721
722	/* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
723
724	geh_mnt *
725	gimple_build_eh_must_not_throw (tree decl)
726	{
727	geh_mnt *p = as_a <geh_mnt *> (p: gimple_alloc (code: GIMPLE_EH_MUST_NOT_THROW, num_ops: 0));
728
729	gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
730	gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
731	gimple_eh_must_not_throw_set_fndecl (eh_mnt_stmt: p, decl);
732
733	return p;
734	}
735
736	/* Build a GIMPLE_EH_ELSE statement. */
737
738	geh_else *
739	gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
740	{
741	geh_else *p = as_a <geh_else *> (p: gimple_alloc (code: GIMPLE_EH_ELSE, num_ops: 0));
742	gimple_eh_else_set_n_body (eh_else_stmt: p, seq: n_body);
743	gimple_eh_else_set_e_body (eh_else_stmt: p, seq: e_body);
744	return p;
745	}
746
747	/* Build a GIMPLE_TRY statement.
748
749	EVAL is the expression to evaluate.
750	CLEANUP is the cleanup expression.
751	KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
752	whether this is a try/catch or a try/finally respectively. */
753
754	gtry *
755	gimple_build_try (gimple_seq eval, gimple_seq cleanup,
756	enum gimple_try_flags kind)
757	{
758	gtry *p;
759
760	gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
761	p = as_a <gtry *> (p: gimple_alloc (code: GIMPLE_TRY, num_ops: 0));
762	gimple_set_subcode (g: p, subcode: kind);
763	if (eval)
764	gimple_try_set_eval (try_stmt: p, eval);
765	if (cleanup)
766	gimple_try_set_cleanup (try_stmt: p, cleanup);
767
768	return p;
769	}
770
771	/* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
772
773	CLEANUP is the cleanup expression. */
774
775	gimple *
776	gimple_build_wce (gimple_seq cleanup)
777	{
778	gimple *p = gimple_alloc (code: GIMPLE_WITH_CLEANUP_EXPR, num_ops: 0);
779	if (cleanup)
780	gimple_wce_set_cleanup (gs: p, cleanup);
781
782	return p;
783	}
784
785
786	/* Build a GIMPLE_RESX statement. */
787
788	gresx *
789	gimple_build_resx (int region)
790	{
791	gresx *p
792	= as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
793	p->region = region;
794	return p;
795	}
796
797
798	/* The helper for constructing a gimple switch statement.
799	INDEX is the switch's index.
800	NLABELS is the number of labels in the switch excluding the default.
801	DEFAULT_LABEL is the default label for the switch statement. */
802
803	gswitch *
804	gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
805	{
806	/* nlabels + 1 default label + 1 index. */
807	gcc_checking_assert (default_label);
808	gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
809	ERROR_MARK,
810	1 + 1 + nlabels));
811	gimple_switch_set_index (gs: p, index);
812	gimple_switch_set_default_label (gs: p, label: default_label);
813	return p;
814	}
815
816	/* Build a GIMPLE_SWITCH statement.
817
818	INDEX is the switch's index.
819	DEFAULT_LABEL is the default label
820	ARGS is a vector of labels excluding the default. */
821
822	gswitch *
823	gimple_build_switch (tree index, tree default_label, const vec<tree> &args)
824	{
825	unsigned i, nlabels = args.length ();
826
827	gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
828
829	/* Copy the labels from the vector to the switch statement. */
830	for (i = 0; i < nlabels; i++)
831	gimple_switch_set_label (gs: p, index: i + 1, label: args[i]);
832
833	return p;
834	}
835
836	/* Build a GIMPLE_EH_DISPATCH statement. */
837
838	geh_dispatch *
839	gimple_build_eh_dispatch (int region)
840	{
841	geh_dispatch *p
842	= as_a <geh_dispatch *> (
843	gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
844	p->region = region;
845	return p;
846	}
847
848	/* Build a new GIMPLE_DEBUG_BIND statement.
849
850	VAR is bound to VALUE; block and location are taken from STMT. */
851
852	gdebug *
853	gimple_build_debug_bind (tree var, tree value, gimple *stmt MEM_STAT_DECL)
854	{
855	gdebug *p
856	= as_a <gdebug *> (p: gimple_build_with_ops_stat (code: GIMPLE_DEBUG,
857	subcode: (unsigned)GIMPLE_DEBUG_BIND, num_ops: 2
858	PASS_MEM_STAT));
859	gimple_debug_bind_set_var (dbg: p, var);
860	gimple_debug_bind_set_value (dbg: p, value);
861	if (stmt)
862	gimple_set_location (g: p, location: gimple_location (g: stmt));
863
864	return p;
865	}
866
867
868	/* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
869
870	VAR is bound to VALUE; block and location are taken from STMT. */
871
872	gdebug *
873	gimple_build_debug_source_bind (tree var, tree value,
874	gimple *stmt MEM_STAT_DECL)
875	{
876	gdebug *p
877	= as_a <gdebug *> (
878	p: gimple_build_with_ops_stat (code: GIMPLE_DEBUG,
879	subcode: (unsigned)GIMPLE_DEBUG_SOURCE_BIND, num_ops: 2
880	PASS_MEM_STAT));
881
882	gimple_debug_source_bind_set_var (dbg: p, var);
883	gimple_debug_source_bind_set_value (dbg: p, value);
884	if (stmt)
885	gimple_set_location (g: p, location: gimple_location (g: stmt));
886
887	return p;
888	}
889
890
891	/* Build a new GIMPLE_DEBUG_BEGIN_STMT statement in BLOCK at
892	LOCATION. */
893
894	gdebug *
895	gimple_build_debug_begin_stmt (tree block, location_t location
896	MEM_STAT_DECL)
897	{
898	gdebug *p
899	= as_a <gdebug *> (
900	p: gimple_build_with_ops_stat (code: GIMPLE_DEBUG,
901	subcode: (unsigned)GIMPLE_DEBUG_BEGIN_STMT, num_ops: 0
902	PASS_MEM_STAT));
903
904	gimple_set_location (g: p, location);
905	gimple_set_block (g: p, block);
906	cfun->debug_marker_count++;
907
908	return p;
909	}
910
911
912	/* Build a new GIMPLE_DEBUG_INLINE_ENTRY statement in BLOCK at
913	LOCATION. The BLOCK links to the inlined function. */
914
915	gdebug *
916	gimple_build_debug_inline_entry (tree block, location_t location
917	MEM_STAT_DECL)
918	{
919	gdebug *p
920	= as_a <gdebug *> (
921	p: gimple_build_with_ops_stat (code: GIMPLE_DEBUG,
922	subcode: (unsigned)GIMPLE_DEBUG_INLINE_ENTRY, num_ops: 0
923	PASS_MEM_STAT));
924
925	gimple_set_location (g: p, location);
926	gimple_set_block (g: p, block);
927	cfun->debug_marker_count++;
928
929	return p;
930	}
931
932
933	/* Build a GIMPLE_OMP_CRITICAL statement.
934
935	BODY is the sequence of statements for which only one thread can execute.
936	NAME is optional identifier for this critical block.
937	CLAUSES are clauses for this critical block. */
938
939	gomp_critical *
940	gimple_build_omp_critical (gimple_seq body, tree name, tree clauses)
941	{
942	gomp_critical *p
943	= as_a <gomp_critical *> (p: gimple_alloc (code: GIMPLE_OMP_CRITICAL, num_ops: 0));
944	gimple_omp_critical_set_name (crit_stmt: p, name);
945	gimple_omp_critical_set_clauses (crit_stmt: p, clauses);
946	if (body)
947	gimple_omp_set_body (gs: p, body);
948
949	return p;
950	}
951
952	/* Build a GIMPLE_OMP_FOR statement.
953
954	BODY is sequence of statements inside the for loop.
955	KIND is the `for' variant.
956	CLAUSES are any of the construct's clauses.
957	COLLAPSE is the collapse count.
958	PRE_BODY is the sequence of statements that are loop invariant. */
959
960	gomp_for *
961	gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
962	gimple_seq pre_body)
963	{
964	gomp_for *p = as_a <gomp_for *> (p: gimple_alloc (code: GIMPLE_OMP_FOR, num_ops: 0));
965	if (body)
966	gimple_omp_set_body (gs: p, body);
967	gimple_omp_for_set_clauses (gs: p, clauses);
968	gimple_omp_for_set_kind (g: p, kind);
969	p->collapse = collapse;
970	p->iter = ggc_cleared_vec_alloc<gimple_omp_for_iter> (c: collapse);
971
972	if (pre_body)
973	gimple_omp_for_set_pre_body (gs: p, pre_body);
974
975	return p;
976	}
977
978
979	/* Build a GIMPLE_OMP_PARALLEL statement.
980
981	BODY is sequence of statements which are executed in parallel.
982	CLAUSES are the OMP parallel construct's clauses.
983	CHILD_FN is the function created for the parallel threads to execute.
984	DATA_ARG are the shared data argument(s). */
985
986	gomp_parallel *
987	gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
988	tree data_arg)
989	{
990	gomp_parallel *p
991	= as_a <gomp_parallel *> (p: gimple_alloc (code: GIMPLE_OMP_PARALLEL, num_ops: 0));
992	if (body)
993	gimple_omp_set_body (gs: p, body);
994	gimple_omp_parallel_set_clauses (omp_parallel_stmt: p, clauses);
995	gimple_omp_parallel_set_child_fn (omp_parallel_stmt: p, child_fn);
996	gimple_omp_parallel_set_data_arg (omp_parallel_stmt: p, data_arg);
997
998	return p;
999	}
1000
1001
1002	/* Build a GIMPLE_OMP_TASK statement.
1003
1004	BODY is sequence of statements which are executed by the explicit task.
1005	CLAUSES are the OMP task construct's clauses.
1006	CHILD_FN is the function created for the parallel threads to execute.
1007	DATA_ARG are the shared data argument(s).
1008	COPY_FN is the optional function for firstprivate initialization.
1009	ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
1010
1011	gomp_task *
1012	gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
1013	tree data_arg, tree copy_fn, tree arg_size,
1014	tree arg_align)
1015	{
1016	gomp_task *p = as_a <gomp_task *> (p: gimple_alloc (code: GIMPLE_OMP_TASK, num_ops: 0));
1017	if (body)
1018	gimple_omp_set_body (gs: p, body);
1019	gimple_omp_task_set_clauses (gs: p, clauses);
1020	gimple_omp_task_set_child_fn (gs: p, child_fn);
1021	gimple_omp_task_set_data_arg (gs: p, data_arg);
1022	gimple_omp_task_set_copy_fn (gs: p, copy_fn);
1023	gimple_omp_task_set_arg_size (gs: p, arg_size);
1024	gimple_omp_task_set_arg_align (gs: p, arg_align);
1025
1026	return p;
1027	}
1028
1029
1030	/* Build a GIMPLE_OMP_SECTION statement for a sections statement.
1031
1032	BODY is the sequence of statements in the section. */
1033
1034	gimple *
1035	gimple_build_omp_section (gimple_seq body)
1036	{
1037	gimple *p = gimple_alloc (code: GIMPLE_OMP_SECTION, num_ops: 0);
1038	if (body)
1039	gimple_omp_set_body (gs: p, body);
1040
1041	return p;
1042	}
1043
1044
1045	/* Build a GIMPLE_OMP_STRUCTURED_BLOCK statement.
1046
1047	BODY is the structured block sequence. */
1048
1049	gimple *
1050	gimple_build_omp_structured_block (gimple_seq body)
1051	{
1052	gimple *p = gimple_alloc (code: GIMPLE_OMP_STRUCTURED_BLOCK, num_ops: 0);
1053	if (body)
1054	gimple_omp_set_body (gs: p, body);
1055
1056	return p;
1057	}
1058
1059
1060	/* Build a GIMPLE_OMP_MASTER statement.
1061
1062	BODY is the sequence of statements to be executed by just the master. */
1063
1064	gimple *
1065	gimple_build_omp_master (gimple_seq body)
1066	{
1067	gimple *p = gimple_alloc (code: GIMPLE_OMP_MASTER, num_ops: 0);
1068	if (body)
1069	gimple_omp_set_body (gs: p, body);
1070
1071	return p;
1072	}
1073
1074	/* Build a GIMPLE_OMP_MASKED statement.
1075
1076	BODY is the sequence of statements to be executed by the selected thread(s). */
1077
1078	gimple *
1079	gimple_build_omp_masked (gimple_seq body, tree clauses)
1080	{
1081	gimple *p = gimple_alloc (code: GIMPLE_OMP_MASKED, num_ops: 0);
1082	gimple_omp_masked_set_clauses (gs: p, clauses);
1083	if (body)
1084	gimple_omp_set_body (gs: p, body);
1085
1086	return p;
1087	}
1088
1089	/* Build a GIMPLE_OMP_TASKGROUP statement.
1090
1091	BODY is the sequence of statements to be executed by the taskgroup
1092	construct.
1093	CLAUSES are any of the construct's clauses. */
1094
1095	gimple *
1096	gimple_build_omp_taskgroup (gimple_seq body, tree clauses)
1097	{
1098	gimple *p = gimple_alloc (code: GIMPLE_OMP_TASKGROUP, num_ops: 0);
1099	gimple_omp_taskgroup_set_clauses (gs: p, clauses);
1100	if (body)
1101	gimple_omp_set_body (gs: p, body);
1102
1103	return p;
1104	}
1105
1106
1107	/* Build a GIMPLE_OMP_CONTINUE statement.
1108
1109	CONTROL_DEF is the definition of the control variable.
1110	CONTROL_USE is the use of the control variable. */
1111
1112	gomp_continue *
1113	gimple_build_omp_continue (tree control_def, tree control_use)
1114	{
1115	gomp_continue *p
1116	= as_a <gomp_continue *> (p: gimple_alloc (code: GIMPLE_OMP_CONTINUE, num_ops: 0));
1117	gimple_omp_continue_set_control_def (cont_stmt: p, def: control_def);
1118	gimple_omp_continue_set_control_use (cont_stmt: p, use: control_use);
1119	return p;
1120	}
1121
1122	/* Build a GIMPLE_OMP_ORDERED statement.
1123
1124	BODY is the sequence of statements inside a loop that will executed in
1125	sequence.
1126	CLAUSES are clauses for this statement. */
1127
1128	gomp_ordered *
1129	gimple_build_omp_ordered (gimple_seq body, tree clauses)
1130	{
1131	gomp_ordered *p
1132	= as_a <gomp_ordered *> (p: gimple_alloc (code: GIMPLE_OMP_ORDERED, num_ops: 0));
1133	gimple_omp_ordered_set_clauses (ord_stmt: p, clauses);
1134	if (body)
1135	gimple_omp_set_body (gs: p, body);
1136
1137	return p;
1138	}
1139
1140
1141	/* Build a GIMPLE_OMP_RETURN statement.
1142	WAIT_P is true if this is a non-waiting return. */
1143
1144	gimple *
1145	gimple_build_omp_return (bool wait_p)
1146	{
1147	gimple *p = gimple_alloc (code: GIMPLE_OMP_RETURN, num_ops: 0);
1148	if (wait_p)
1149	gimple_omp_return_set_nowait (s: p);
1150
1151	return p;
1152	}
1153
1154
1155	/* Build a GIMPLE_OMP_SCAN statement.
1156
1157	BODY is the sequence of statements to be executed by the scan
1158	construct.
1159	CLAUSES are any of the construct's clauses. */
1160
1161	gomp_scan *
1162	gimple_build_omp_scan (gimple_seq body, tree clauses)
1163	{
1164	gomp_scan *p
1165	= as_a <gomp_scan *> (p: gimple_alloc (code: GIMPLE_OMP_SCAN, num_ops: 0));
1166	gimple_omp_scan_set_clauses (scan_stmt: p, clauses);
1167	if (body)
1168	gimple_omp_set_body (gs: p, body);
1169
1170	return p;
1171	}
1172
1173
1174	/* Build a GIMPLE_OMP_SECTIONS statement.
1175
1176	BODY is a sequence of section statements.
1177	CLAUSES are any of the OMP sections contsruct's clauses: private,
1178	firstprivate, lastprivate, reduction, and nowait. */
1179
1180	gomp_sections *
1181	gimple_build_omp_sections (gimple_seq body, tree clauses)
1182	{
1183	gomp_sections *p
1184	= as_a <gomp_sections *> (p: gimple_alloc (code: GIMPLE_OMP_SECTIONS, num_ops: 0));
1185	if (body)
1186	gimple_omp_set_body (gs: p, body);
1187	gimple_omp_sections_set_clauses (gs: p, clauses);
1188
1189	return p;
1190	}
1191
1192
1193	/* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
1194
1195	gimple *
1196	gimple_build_omp_sections_switch (void)
1197	{
1198	return gimple_alloc (code: GIMPLE_OMP_SECTIONS_SWITCH, num_ops: 0);
1199	}
1200
1201
1202	/* Build a GIMPLE_OMP_SINGLE statement.
1203
1204	BODY is the sequence of statements that will be executed once.
1205	CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1206	copyprivate, nowait. */
1207
1208	gomp_single *
1209	gimple_build_omp_single (gimple_seq body, tree clauses)
1210	{
1211	gomp_single *p
1212	= as_a <gomp_single *> (p: gimple_alloc (code: GIMPLE_OMP_SINGLE, num_ops: 0));
1213	if (body)
1214	gimple_omp_set_body (gs: p, body);
1215	gimple_omp_single_set_clauses (omp_single_stmt: p, clauses);
1216
1217	return p;
1218	}
1219
1220
1221	/* Build a GIMPLE_OMP_SCOPE statement.
1222
1223	BODY is the sequence of statements that will be executed once.
1224	CLAUSES are any of the OMP scope construct's clauses: private, reduction,
1225	nowait. */
1226
1227	gimple *
1228	gimple_build_omp_scope (gimple_seq body, tree clauses)
1229	{
1230	gimple *p = gimple_alloc (code: GIMPLE_OMP_SCOPE, num_ops: 0);
1231	gimple_omp_scope_set_clauses (gs: p, clauses);
1232	if (body)
1233	gimple_omp_set_body (gs: p, body);
1234
1235	return p;
1236	}
1237
1238
1239	/* Build a GIMPLE_OMP_TARGET statement.
1240
1241	BODY is the sequence of statements that will be executed.
1242	KIND is the kind of the region.
1243	CLAUSES are any of the construct's clauses. */
1244
1245	gomp_target *
1246	gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
1247	{
1248	gomp_target *p
1249	= as_a <gomp_target *> (p: gimple_alloc (code: GIMPLE_OMP_TARGET, num_ops: 0));
1250	if (body)
1251	gimple_omp_set_body (gs: p, body);
1252	gimple_omp_target_set_clauses (omp_target_stmt: p, clauses);
1253	gimple_omp_target_set_kind (g: p, kind);
1254
1255	return p;
1256	}
1257
1258
1259	/* Build a GIMPLE_OMP_TEAMS statement.
1260
1261	BODY is the sequence of statements that will be executed.
1262	CLAUSES are any of the OMP teams construct's clauses. */
1263
1264	gomp_teams *
1265	gimple_build_omp_teams (gimple_seq body, tree clauses)
1266	{
1267	gomp_teams *p = as_a <gomp_teams *> (p: gimple_alloc (code: GIMPLE_OMP_TEAMS, num_ops: 0));
1268	if (body)
1269	gimple_omp_set_body (gs: p, body);
1270	gimple_omp_teams_set_clauses (omp_teams_stmt: p, clauses);
1271
1272	return p;
1273	}
1274
1275
1276	/* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
1277
1278	gomp_atomic_load *
1279	gimple_build_omp_atomic_load (tree lhs, tree rhs, enum omp_memory_order mo)
1280	{
1281	gomp_atomic_load *p
1282	= as_a <gomp_atomic_load *> (p: gimple_alloc (code: GIMPLE_OMP_ATOMIC_LOAD, num_ops: 0));
1283	gimple_omp_atomic_load_set_lhs (load_stmt: p, lhs);
1284	gimple_omp_atomic_load_set_rhs (load_stmt: p, rhs);
1285	gimple_omp_atomic_set_memory_order (g: p, mo);
1286	return p;
1287	}
1288
1289	/* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1290
1291	VAL is the value we are storing. */
1292
1293	gomp_atomic_store *
1294	gimple_build_omp_atomic_store (tree val, enum omp_memory_order mo)
1295	{
1296	gomp_atomic_store *p
1297	= as_a <gomp_atomic_store *> (p: gimple_alloc (code: GIMPLE_OMP_ATOMIC_STORE, num_ops: 0));
1298	gimple_omp_atomic_store_set_val (store_stmt: p, val);
1299	gimple_omp_atomic_set_memory_order (g: p, mo);
1300	return p;
1301	}
1302
1303	/* Build a GIMPLE_ASSUME statement. */
1304
1305	gimple *
1306	gimple_build_assume (tree guard, gimple_seq body)
1307	{
1308	gimple_statement_assume *p
1309	= as_a <gimple_statement_assume *> (p: gimple_alloc (code: GIMPLE_ASSUME, num_ops: 0));
1310	gimple_assume_set_guard (gs: p, guard);
1311	*gimple_assume_body_ptr (gs: p) = body;
1312	return p;
1313	}
1314
1315	/* Build a GIMPLE_TRANSACTION statement. */
1316
1317	gtransaction *
1318	gimple_build_transaction (gimple_seq body)
1319	{
1320	gtransaction *p
1321	= as_a <gtransaction *> (p: gimple_alloc (code: GIMPLE_TRANSACTION, num_ops: 0));
1322	gimple_transaction_set_body (transaction_stmt: p, body);
1323	gimple_transaction_set_label_norm (transaction_stmt: p, label: 0);
1324	gimple_transaction_set_label_uninst (transaction_stmt: p, label: 0);
1325	gimple_transaction_set_label_over (transaction_stmt: p, label: 0);
1326	return p;
1327	}
1328
1329	#if defined ENABLE_GIMPLE_CHECKING
1330	/* Complain of a gimple type mismatch and die. */
1331
1332	void
1333	gimple_check_failed (const gimple *gs, const char *file, int line,
1334	const char *function, enum gimple_code code,
1335	enum tree_code subcode)
1336	{
1337	internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1338	gimple_code_name[code],
1339	get_tree_code_name (subcode),
1340	gimple_code_name[gimple_code (g: gs)],
1341	gs->subcode > 0
1342	? get_tree_code_name ((enum tree_code) gs->subcode)
1343	: "",
1344	function, trim_filename (file), line);
1345	}
1346	#endif /* ENABLE_GIMPLE_CHECKING */
1347
1348
1349	/* Link gimple statement GS to the end of the sequence *SEQ_P. If
1350	*SEQ_P is NULL, a new sequence is allocated. */
1351
1352	void
1353	gimple_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
1354	{
1355	gimple_stmt_iterator si;
1356	if (gs == NULL)
1357	return;
1358
1359	si = gsi_last (seq&: *seq_p);
1360	gsi_insert_after (&si, gs, GSI_NEW_STMT);
1361	}
1362
1363	/* Link gimple statement GS to the end of the sequence *SEQ_P. If
1364	*SEQ_P is NULL, a new sequence is allocated. This function is
1365	similar to gimple_seq_add_stmt, but does not scan the operands.
1366	During gimplification, we need to manipulate statement sequences
1367	before the def/use vectors have been constructed. */
1368
1369	void
1370	gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple *gs)
1371	{
1372	gimple_stmt_iterator si;
1373
1374	if (gs == NULL)
1375	return;
1376
1377	si = gsi_last (seq&: *seq_p);
1378	gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1379	}
1380
1381	/* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1382	NULL, a new sequence is allocated. */
1383
1384	void
1385	gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1386	{
1387	gimple_stmt_iterator si;
1388	if (src == NULL)
1389	return;
1390
1391	si = gsi_last (seq&: *dst_p);
1392	gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1393	}
1394
1395	/* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
1396	NULL, a new sequence is allocated. This function is
1397	similar to gimple_seq_add_seq, but does not scan the operands. */
1398
1399	void
1400	gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1401	{
1402	gimple_stmt_iterator si;
1403	if (src == NULL)
1404	return;
1405
1406	si = gsi_last (seq&: *dst_p);
1407	gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1408	}
1409
1410	/* Determine whether to assign a location to the statement GS. */
1411
1412	static bool
1413	should_carry_location_p (gimple *gs)
1414	{
1415	/* Don't emit a line note for a label. We particularly don't want to
1416	emit one for the break label, since it doesn't actually correspond
1417	to the beginning of the loop/switch. */
1418	if (gimple_code (g: gs) == GIMPLE_LABEL)
1419	return false;
1420
1421	return true;
1422	}
1423
1424	/* Set the location for gimple statement GS to LOCATION. */
1425
1426	static void
1427	annotate_one_with_location (gimple *gs, location_t location)
1428	{
1429	if (!gimple_has_location (g: gs)
1430	&& !gimple_do_not_emit_location_p (g: gs)
1431	&& should_carry_location_p (gs))
1432	gimple_set_location (g: gs, location);
1433	}
1434
1435	/* Set LOCATION for all the statements after iterator GSI in sequence
1436	SEQ. If GSI is pointing to the end of the sequence, start with the
1437	first statement in SEQ. */
1438
1439	void
1440	annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1441	location_t location)
1442	{
1443	if (gsi_end_p (i: gsi))
1444	gsi = gsi_start (seq);
1445	else
1446	gsi_next (i: &gsi);
1447
1448	for (; !gsi_end_p (i: gsi); gsi_next (i: &gsi))
1449	annotate_one_with_location (gs: gsi_stmt (i: gsi), location);
1450	}
1451
1452	/* Set the location for all the statements in a sequence STMT_P to LOCATION. */
1453
1454	void
1455	annotate_all_with_location (gimple_seq stmt_p, location_t location)
1456	{
1457	gimple_stmt_iterator i;
1458
1459	if (gimple_seq_empty_p (s: stmt_p))
1460	return;
1461
1462	for (i = gsi_start (seq&: stmt_p); !gsi_end_p (i); gsi_next (i: &i))
1463	{
1464	gimple *gs = gsi_stmt (i);
1465	annotate_one_with_location (gs, location);
1466	}
1467	}
1468
1469	/* Helper function of empty_body_p. Return true if STMT is an empty
1470	statement. */
1471
1472	static bool
1473	empty_stmt_p (gimple *stmt)
1474	{
1475	if (gimple_code (g: stmt) == GIMPLE_NOP)
1476	return true;
1477	if (gbind *bind_stmt = dyn_cast <gbind *> (p: stmt))
1478	return empty_body_p (gimple_bind_body (gs: bind_stmt));
1479	return false;
1480	}
1481
1482
1483	/* Return true if BODY contains nothing but empty statements. */
1484
1485	bool
1486	empty_body_p (gimple_seq body)
1487	{
1488	gimple_stmt_iterator i;
1489
1490	if (gimple_seq_empty_p (s: body))
1491	return true;
1492	for (i = gsi_start (seq&: body); !gsi_end_p (i); gsi_next (i: &i))
1493	if (!empty_stmt_p (stmt: gsi_stmt (i))
1494	&& !is_gimple_debug (gs: gsi_stmt (i)))
1495	return false;
1496
1497	return true;
1498	}
1499
1500
1501	/* Perform a deep copy of sequence SRC and return the result. */
1502
1503	gimple_seq
1504	gimple_seq_copy (gimple_seq src)
1505	{
1506	gimple_stmt_iterator gsi;
1507	gimple_seq new_seq = NULL;
1508	gimple *stmt;
1509
1510	for (gsi = gsi_start (seq&: src); !gsi_end_p (i: gsi); gsi_next (i: &gsi))
1511	{
1512	stmt = gimple_copy (gsi_stmt (i: gsi));
1513	gimple_seq_add_stmt (seq_p: &new_seq, gs: stmt);
1514	}
1515
1516	return new_seq;
1517	}
1518
1519
1520
1521	/* Return true if calls C1 and C2 are known to go to the same function. */
1522
1523	bool
1524	gimple_call_same_target_p (const gimple *c1, const gimple *c2)
1525	{
1526	if (gimple_call_internal_p (gs: c1))
1527	return (gimple_call_internal_p (gs: c2)
1528	&& gimple_call_internal_fn (gs: c1) == gimple_call_internal_fn (gs: c2)
1529	&& (!gimple_call_internal_unique_p (gs: as_a <const gcall *> (p: c1))
1530	|| c1 == c2));
1531	else
1532	return (gimple_call_fn (gs: c1) == gimple_call_fn (gs: c2)
1533	|| (gimple_call_fndecl (gs: c1)
1534	&& gimple_call_fndecl (gs: c1) == gimple_call_fndecl (gs: c2)));
1535	}
1536
1537	/* Detect flags from a GIMPLE_CALL. This is just like
1538	call_expr_flags, but for gimple tuples. */
1539
1540	int
1541	gimple_call_flags (const gimple *stmt)
1542	{
1543	int flags = 0;
1544
1545	if (gimple_call_internal_p (gs: stmt))
1546	flags = internal_fn_flags (fn: gimple_call_internal_fn (gs: stmt));
1547	else
1548	{
1549	tree decl = gimple_call_fndecl (gs: stmt);
1550	if (decl)
1551	flags = flags_from_decl_or_type (decl);
1552	flags |= flags_from_decl_or_type (gimple_call_fntype (gs: stmt));
1553	}
1554
1555	if (stmt->subcode & GF_CALL_NOTHROW)
1556	flags |= ECF_NOTHROW;
1557	if (stmt->subcode & GF_CALL_XTHROW)
1558	flags |= ECF_XTHROW;
1559
1560	if (stmt->subcode & GF_CALL_BY_DESCRIPTOR)
1561	flags |= ECF_BY_DESCRIPTOR;
1562
1563	return flags;
1564	}
1565
1566	/* Return the "fn spec" string for call STMT. */
1567
1568	attr_fnspec
1569	gimple_call_fnspec (const gcall *stmt)
1570	{
1571	tree type, attr;
1572
1573	if (gimple_call_internal_p (gs: stmt))
1574	{
1575	const_tree spec = internal_fn_fnspec (fn: gimple_call_internal_fn (gs: stmt));
1576	if (spec)
1577	return spec;
1578	else
1579	return "";
1580	}
1581
1582	type = gimple_call_fntype (gs: stmt);
1583	if (type)
1584	{
1585	attr = lookup_attribute (attr_name: "fn spec", TYPE_ATTRIBUTES (type));
1586	if (attr)
1587	return TREE_VALUE (TREE_VALUE (attr));
1588	}
1589	if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
1590	return builtin_fnspec (gimple_call_fndecl (gs: stmt));
1591	tree fndecl = gimple_call_fndecl (gs: stmt);
1592	/* If the call is to a replaceable operator delete and results
1593	from a delete expression as opposed to a direct call to
1594	such operator, then we can treat it as free. */
1595	if (fndecl
1596	&& DECL_IS_OPERATOR_DELETE_P (fndecl)
1597	&& DECL_IS_REPLACEABLE_OPERATOR (fndecl)
1598	&& gimple_call_from_new_or_delete (s: stmt))
1599	return ". o ";
1600	/* Similarly operator new can be treated as malloc. */
1601	if (fndecl
1602	&& DECL_IS_REPLACEABLE_OPERATOR_NEW_P (fndecl)
1603	&& gimple_call_from_new_or_delete (s: stmt))
1604	return "m ";
1605	return "";
1606	}
1607
1608	/* Detects argument flags for argument number ARG on call STMT. */
1609
1610	int
1611	gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1612	{
1613	attr_fnspec fnspec = gimple_call_fnspec (stmt);
1614	int flags = 0;
1615
1616	if (fnspec.known_p ())
1617	flags = fnspec.arg_eaf_flags (i: arg);
1618	tree callee = gimple_call_fndecl (gs: stmt);
1619	if (callee)
1620	{
1621	cgraph_node *node = cgraph_node::get (decl: callee);
1622	modref_summary *summary = node ? get_modref_function_summary (func: node)
1623	: NULL;
1624
1625	if (summary && summary->arg_flags.length () > arg)
1626	{
1627	int modref_flags = summary->arg_flags[arg];
1628
1629	/* We have possibly optimized out load. Be conservative here. */
1630	if (!node->binds_to_current_def_p ())
1631	modref_flags = interposable_eaf_flags (modref_flags, flags);
1632	if (dbg_cnt (index: ipa_mod_ref_pta))
1633	flags |= modref_flags;
1634	}
1635	}
1636	return flags;
1637	}
1638
1639	/* Detects argument flags for return slot on call STMT. */
1640
1641	int
1642	gimple_call_retslot_flags (const gcall *stmt)
1643	{
1644	int flags = implicit_retslot_eaf_flags;
1645
1646	tree callee = gimple_call_fndecl (gs: stmt);
1647	if (callee)
1648	{
1649	cgraph_node *node = cgraph_node::get (decl: callee);
1650	modref_summary *summary = node ? get_modref_function_summary (func: node)
1651	: NULL;
1652
1653	if (summary)
1654	{
1655	int modref_flags = summary->retslot_flags;
1656
1657	/* We have possibly optimized out load. Be conservative here. */
1658	if (!node->binds_to_current_def_p ())
1659	modref_flags = interposable_eaf_flags (modref_flags, flags);
1660	if (dbg_cnt (index: ipa_mod_ref_pta))
1661	flags |= modref_flags;
1662	}
1663	}
1664	return flags;
1665	}
1666
1667	/* Detects argument flags for static chain on call STMT. */
1668
1669	int
1670	gimple_call_static_chain_flags (const gcall *stmt)
1671	{
1672	int flags = 0;
1673
1674	tree callee = gimple_call_fndecl (gs: stmt);
1675	if (callee)
1676	{
1677	cgraph_node *node = cgraph_node::get (decl: callee);
1678	modref_summary *summary = node ? get_modref_function_summary (func: node)
1679	: NULL;
1680
1681	/* Nested functions should always bind to current def since
1682	there is no public ABI for them. */
1683	gcc_checking_assert (node->binds_to_current_def_p ());
1684	if (summary)
1685	{
1686	int modref_flags = summary->static_chain_flags;
1687
1688	if (dbg_cnt (index: ipa_mod_ref_pta))
1689	flags |= modref_flags;
1690	}
1691	}
1692	return flags;
1693	}
1694
1695	/* Detects return flags for the call STMT. */
1696
1697	int
1698	gimple_call_return_flags (const gcall *stmt)
1699	{
1700	if (gimple_call_flags (stmt) & ECF_MALLOC)
1701	return ERF_NOALIAS;
1702
1703	attr_fnspec fnspec = gimple_call_fnspec (stmt);
1704
1705	unsigned int arg_no;
1706	if (fnspec.returns_arg (arg_no: &arg_no))
1707	return ERF_RETURNS_ARG | arg_no;
1708
1709	if (fnspec.returns_noalias_p ())
1710	return ERF_NOALIAS;
1711	return 0;
1712	}
1713
1714
1715	/* Return true if call STMT is known to return a non-zero result. */
1716
1717	bool
1718	gimple_call_nonnull_result_p (gcall *call)
1719	{
1720	tree fndecl = gimple_call_fndecl (gs: call);
1721	if (!fndecl)
1722	return false;
1723	if (flag_delete_null_pointer_checks && !flag_check_new
1724	&& DECL_IS_OPERATOR_NEW_P (fndecl)
1725	&& !TREE_NOTHROW (fndecl))
1726	return true;
1727
1728	/* References are always non-NULL. */
1729	if (flag_delete_null_pointer_checks
1730	&& TREE_CODE (TREE_TYPE (fndecl)) == REFERENCE_TYPE)
1731	return true;
1732
1733	if (flag_delete_null_pointer_checks
1734	&& lookup_attribute (attr_name: "returns_nonnull",
1735	TYPE_ATTRIBUTES (gimple_call_fntype (call))))
1736	return true;
1737	return gimple_alloca_call_p (call);
1738	}
1739
1740
1741	/* If CALL returns a non-null result in an argument, return that arg. */
1742
1743	tree
1744	gimple_call_nonnull_arg (gcall *call)
1745	{
1746	tree fndecl = gimple_call_fndecl (gs: call);
1747	if (!fndecl)
1748	return NULL_TREE;
1749
1750	unsigned rf = gimple_call_return_flags (stmt: call);
1751	if (rf & ERF_RETURNS_ARG)
1752	{
1753	unsigned argnum = rf & ERF_RETURN_ARG_MASK;
1754	if (argnum < gimple_call_num_args (gs: call))
1755	{
1756	tree arg = gimple_call_arg (gs: call, index: argnum);
1757	if (SSA_VAR_P (arg)
1758	&& infer_nonnull_range_by_attribute (call, arg))
1759	return arg;
1760	}
1761	}
1762	return NULL_TREE;
1763	}
1764
1765
1766	/* Return true if GS is a copy assignment. */
1767
1768	bool
1769	gimple_assign_copy_p (gimple *gs)
1770	{
1771	return (gimple_assign_single_p (gs)
1772	&& is_gimple_val (gimple_op (gs, i: 1)));
1773	}
1774
1775
1776	/* Return true if GS is a SSA_NAME copy assignment. */
1777
1778	bool
1779	gimple_assign_ssa_name_copy_p (gimple *gs)
1780	{
1781	return (gimple_assign_single_p (gs)
1782	&& TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1783	&& TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1784	}
1785
1786
1787	/* Return true if GS is an assignment with a unary RHS, but the
1788	operator has no effect on the assigned value. The logic is adapted
1789	from STRIP_NOPS. This predicate is intended to be used in tuplifying
1790	instances in which STRIP_NOPS was previously applied to the RHS of
1791	an assignment.
1792
1793	NOTE: In the use cases that led to the creation of this function
1794	and of gimple_assign_single_p, it is typical to test for either
1795	condition and to proceed in the same manner. In each case, the
1796	assigned value is represented by the single RHS operand of the
1797	assignment. I suspect there may be cases where gimple_assign_copy_p,
1798	gimple_assign_single_p, or equivalent logic is used where a similar
1799	treatment of unary NOPs is appropriate. */
1800
1801	bool
1802	gimple_assign_unary_nop_p (gimple *gs)
1803	{
1804	return (is_gimple_assign (gs)
1805	&& (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1806	|| gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1807	&& gimple_assign_rhs1 (gs) != error_mark_node
1808	&& (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1809	== TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1810	}
1811
1812	/* Return true if GS is an assignment that loads from its rhs1. */
1813
1814	bool
1815	gimple_assign_load_p (const gimple *gs)
1816	{
1817	tree rhs;
1818	if (!gimple_assign_single_p (gs))
1819	return false;
1820	rhs = gimple_assign_rhs1 (gs);
1821	if (TREE_CODE (rhs) == WITH_SIZE_EXPR)
1822	return true;
1823	if (handled_component_p (t: rhs))
1824	rhs = TREE_OPERAND (rhs, 0);
1825	return (handled_component_p (t: rhs)
1826	|| DECL_P (rhs)
1827	|| TREE_CODE (rhs) == MEM_REF
1828	|| TREE_CODE (rhs) == TARGET_MEM_REF);
1829	}
1830
1831
1832	/* Set BB to be the basic block holding G. */
1833
1834	void
1835	gimple_set_bb (gimple *stmt, basic_block bb)
1836	{
1837	stmt->bb = bb;
1838
1839	if (gimple_code (g: stmt) != GIMPLE_LABEL)
1840	return;
1841
1842	/* If the statement is a label, add the label to block-to-labels map
1843	so that we can speed up edge creation for GIMPLE_GOTOs. */
1844	if (cfun->cfg)
1845	{
1846	tree t;
1847	int uid;
1848
1849	t = gimple_label_label (gs: as_a <glabel *> (p: stmt));
1850	uid = LABEL_DECL_UID (t);
1851	if (uid == -1)
1852	{
1853	unsigned old_len =
1854	vec_safe_length (label_to_block_map_for_fn (cfun));
1855	LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1856	if (old_len <= (unsigned) uid)
1857	vec_safe_grow_cleared (label_to_block_map_for_fn (cfun), len: uid + 1);
1858	}
1859
1860	(*label_to_block_map_for_fn (cfun))[uid] = bb;
1861	}
1862	}
1863
1864
1865	/* Modify the RHS of the assignment pointed-to by GSI using the
1866	operands in the expression tree EXPR.
1867
1868	NOTE: The statement pointed-to by GSI may be reallocated if it
1869	did not have enough operand slots.
1870
1871	This function is useful to convert an existing tree expression into
1872	the flat representation used for the RHS of a GIMPLE assignment.
1873	It will reallocate memory as needed to expand or shrink the number
1874	of operand slots needed to represent EXPR.
1875
1876	NOTE: If you find yourself building a tree and then calling this
1877	function, you are most certainly doing it the slow way. It is much
1878	better to build a new assignment or to use the function
1879	gimple_assign_set_rhs_with_ops, which does not require an
1880	expression tree to be built. */
1881
1882	void
1883	gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1884	{
1885	enum tree_code subcode;
1886	tree op1, op2, op3;
1887
1888	extract_ops_from_tree (expr, &subcode, &op1, &op2, &op3);
1889	gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1890	}
1891
1892
1893	/* Set the RHS of assignment statement pointed-to by GSI to CODE with
1894	operands OP1, OP2 and OP3.
1895
1896	NOTE: The statement pointed-to by GSI may be reallocated if it
1897	did not have enough operand slots. */
1898
1899	void
1900	gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1901	tree op1, tree op2, tree op3)
1902	{
1903	unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1904	gimple *stmt = gsi_stmt (i: *gsi);
1905	gimple *old_stmt = stmt;
1906
1907	/* If the new CODE needs more operands, allocate a new statement. */
1908	if (gimple_num_ops (gs: stmt) < new_rhs_ops + 1)
1909	{
1910	tree lhs = gimple_assign_lhs (gs: old_stmt);
1911	stmt = gimple_alloc (code: gimple_code (g: old_stmt), num_ops: new_rhs_ops + 1);
1912	memcpy (dest: stmt, src: old_stmt, n: gimple_size (code: gimple_code (g: old_stmt)));
1913	gimple_init_singleton (g: stmt);
1914
1915	/* The LHS needs to be reset as this also changes the SSA name
1916	on the LHS. */
1917	gimple_assign_set_lhs (gs: stmt, lhs);
1918	}
1919
1920	gimple_set_num_ops (gs: stmt, num_ops: new_rhs_ops + 1);
1921	gimple_set_subcode (g: stmt, subcode: code);
1922	gimple_assign_set_rhs1 (gs: stmt, rhs: op1);
1923	if (new_rhs_ops > 1)
1924	gimple_assign_set_rhs2 (gs: stmt, rhs: op2);
1925	if (new_rhs_ops > 2)
1926	gimple_assign_set_rhs3 (gs: stmt, rhs: op3);
1927	if (stmt != old_stmt)
1928	gsi_replace (gsi, stmt, false);
1929	}
1930
1931
1932	/* Return the LHS of a statement that performs an assignment,
1933	either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
1934	for a call to a function that returns no value, or for a
1935	statement other than an assignment or a call. */
1936
1937	tree
1938	gimple_get_lhs (const gimple *stmt)
1939	{
1940	enum gimple_code code = gimple_code (g: stmt);
1941
1942	if (code == GIMPLE_ASSIGN)
1943	return gimple_assign_lhs (gs: stmt);
1944	else if (code == GIMPLE_CALL)
1945	return gimple_call_lhs (gs: stmt);
1946	else if (code == GIMPLE_PHI)
1947	return gimple_phi_result (gs: stmt);
1948	else
1949	return NULL_TREE;
1950	}
1951
1952
1953	/* Set the LHS of a statement that performs an assignment,
1954	either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
1955
1956	void
1957	gimple_set_lhs (gimple *stmt, tree lhs)
1958	{
1959	enum gimple_code code = gimple_code (g: stmt);
1960
1961	if (code == GIMPLE_ASSIGN)
1962	gimple_assign_set_lhs (gs: stmt, lhs);
1963	else if (code == GIMPLE_CALL)
1964	gimple_call_set_lhs (gs: stmt, lhs);
1965	else
1966	gcc_unreachable ();
1967	}
1968
1969
1970	/* Return a deep copy of statement STMT. All the operands from STMT
1971	are reallocated and copied using unshare_expr. The DEF, USE, VDEF
1972	and VUSE operand arrays are set to empty in the new copy. The new
1973	copy isn't part of any sequence. */
1974
1975	gimple *
1976	gimple_copy (gimple *stmt)
1977	{
1978	enum gimple_code code = gimple_code (g: stmt);
1979	unsigned num_ops = gimple_num_ops (gs: stmt);
1980	gimple *copy = gimple_alloc (code, num_ops);
1981	unsigned i;
1982
1983	/* Shallow copy all the fields from STMT. */
1984	memcpy (dest: copy, src: stmt, n: gimple_size (code));
1985	gimple_init_singleton (g: copy);
1986
1987	/* If STMT has sub-statements, deep-copy them as well. */
1988	if (gimple_has_substatements (g: stmt))
1989	{
1990	gimple_seq new_seq;
1991	tree t;
1992
1993	switch (gimple_code (g: stmt))
1994	{
1995	case GIMPLE_BIND:
1996	{
1997	gbind *bind_stmt = as_a <gbind *> (p: stmt);
1998	gbind *bind_copy = as_a <gbind *> (p: copy);
1999	new_seq = gimple_seq_copy (src: gimple_bind_body (gs: bind_stmt));
2000	gimple_bind_set_body (bind_stmt: bind_copy, seq: new_seq);
2001	gimple_bind_set_vars (bind_stmt: bind_copy,
2002	vars: unshare_expr (gimple_bind_vars (bind_stmt)));
2003	gimple_bind_set_block (bind_stmt: bind_copy, block: gimple_bind_block (bind_stmt));
2004	}
2005	break;
2006
2007	case GIMPLE_CATCH:
2008	{
2009	gcatch *catch_stmt = as_a <gcatch *> (p: stmt);
2010	gcatch *catch_copy = as_a <gcatch *> (p: copy);
2011	new_seq = gimple_seq_copy (src: gimple_catch_handler (catch_stmt));
2012	gimple_catch_set_handler (catch_stmt: catch_copy, handler: new_seq);
2013	t = unshare_expr (gimple_catch_types (catch_stmt));
2014	gimple_catch_set_types (catch_stmt: catch_copy, t);
2015	}
2016	break;
2017
2018	case GIMPLE_EH_FILTER:
2019	{
2020	geh_filter *eh_filter_stmt = as_a <geh_filter *> (p: stmt);
2021	geh_filter *eh_filter_copy = as_a <geh_filter *> (p: copy);
2022	new_seq
2023	= gimple_seq_copy (src: gimple_eh_filter_failure (gs: eh_filter_stmt));
2024	gimple_eh_filter_set_failure (eh_filter_stmt: eh_filter_copy, failure: new_seq);
2025	t = unshare_expr (gimple_eh_filter_types (gs: eh_filter_stmt));
2026	gimple_eh_filter_set_types (eh_filter_stmt: eh_filter_copy, types: t);
2027	}
2028	break;
2029
2030	case GIMPLE_EH_ELSE:
2031	{
2032	geh_else *eh_else_stmt = as_a <geh_else *> (p: stmt);
2033	geh_else *eh_else_copy = as_a <geh_else *> (p: copy);
2034	new_seq = gimple_seq_copy (src: gimple_eh_else_n_body (eh_else_stmt));
2035	gimple_eh_else_set_n_body (eh_else_stmt: eh_else_copy, seq: new_seq);
2036	new_seq = gimple_seq_copy (src: gimple_eh_else_e_body (eh_else_stmt));
2037	gimple_eh_else_set_e_body (eh_else_stmt: eh_else_copy, seq: new_seq);
2038	}
2039	break;
2040
2041	case GIMPLE_TRY:
2042	{
2043	gtry *try_stmt = as_a <gtry *> (p: stmt);
2044	gtry *try_copy = as_a <gtry *> (p: copy);
2045	new_seq = gimple_seq_copy (src: gimple_try_eval (gs: try_stmt));
2046	gimple_try_set_eval (try_stmt: try_copy, eval: new_seq);
2047	new_seq = gimple_seq_copy (src: gimple_try_cleanup (gs: try_stmt));
2048	gimple_try_set_cleanup (try_stmt: try_copy, cleanup: new_seq);
2049	}
2050	break;
2051
2052	case GIMPLE_OMP_FOR:
2053	new_seq = gimple_seq_copy (src: gimple_omp_for_pre_body (gs: stmt));
2054	gimple_omp_for_set_pre_body (gs: copy, pre_body: new_seq);
2055	t = unshare_expr (gimple_omp_for_clauses (gs: stmt));
2056	gimple_omp_for_set_clauses (gs: copy, clauses: t);
2057	{
2058	gomp_for *omp_for_copy = as_a <gomp_for *> (p: copy);
2059	omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
2060	( c: gimple_omp_for_collapse (gs: stmt));
2061	}
2062	for (i = 0; i < gimple_omp_for_collapse (gs: stmt); i++)
2063	{
2064	gimple_omp_for_set_cond (gs: copy, i,
2065	cond: gimple_omp_for_cond (gs: stmt, i));
2066	gimple_omp_for_set_index (gs: copy, i,
2067	index: gimple_omp_for_index (gs: stmt, i));
2068	t = unshare_expr (gimple_omp_for_initial (gs: stmt, i));
2069	gimple_omp_for_set_initial (gs: copy, i, initial: t);
2070	t = unshare_expr (gimple_omp_for_final (gs: stmt, i));
2071	gimple_omp_for_set_final (gs: copy, i, final: t);
2072	t = unshare_expr (gimple_omp_for_incr (gs: stmt, i));
2073	gimple_omp_for_set_incr (gs: copy, i, incr: t);
2074	}
2075	goto copy_omp_body;
2076
2077	case GIMPLE_OMP_PARALLEL:
2078	{
2079	gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (p: stmt);
2080	gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (p: copy);
2081	t = unshare_expr (gimple_omp_parallel_clauses (gs: omp_par_stmt));
2082	gimple_omp_parallel_set_clauses (omp_parallel_stmt: omp_par_copy, clauses: t);
2083	t = unshare_expr (gimple_omp_parallel_child_fn (omp_parallel_stmt: omp_par_stmt));
2084	gimple_omp_parallel_set_child_fn (omp_parallel_stmt: omp_par_copy, child_fn: t);
2085	t = unshare_expr (gimple_omp_parallel_data_arg (omp_parallel_stmt: omp_par_stmt));
2086	gimple_omp_parallel_set_data_arg (omp_parallel_stmt: omp_par_copy, data_arg: t);
2087	}
2088	goto copy_omp_body;
2089
2090	case GIMPLE_OMP_TASK:
2091	t = unshare_expr (gimple_omp_task_clauses (gs: stmt));
2092	gimple_omp_task_set_clauses (gs: copy, clauses: t);
2093	t = unshare_expr (gimple_omp_task_child_fn (gs: stmt));
2094	gimple_omp_task_set_child_fn (gs: copy, child_fn: t);
2095	t = unshare_expr (gimple_omp_task_data_arg (gs: stmt));
2096	gimple_omp_task_set_data_arg (gs: copy, data_arg: t);
2097	t = unshare_expr (gimple_omp_task_copy_fn (gs: stmt));
2098	gimple_omp_task_set_copy_fn (gs: copy, copy_fn: t);
2099	t = unshare_expr (gimple_omp_task_arg_size (gs: stmt));
2100	gimple_omp_task_set_arg_size (gs: copy, arg_size: t);
2101	t = unshare_expr (gimple_omp_task_arg_align (gs: stmt));
2102	gimple_omp_task_set_arg_align (gs: copy, arg_align: t);
2103	goto copy_omp_body;
2104
2105	case GIMPLE_OMP_CRITICAL:
2106	t = unshare_expr (gimple_omp_critical_name
2107	(crit_stmt: as_a <gomp_critical *> (p: stmt)));
2108	gimple_omp_critical_set_name (crit_stmt: as_a <gomp_critical *> (p: copy), name: t);
2109	t = unshare_expr (gimple_omp_critical_clauses
2110	(crit_stmt: as_a <gomp_critical *> (p: stmt)));
2111	gimple_omp_critical_set_clauses (crit_stmt: as_a <gomp_critical *> (p: copy), clauses: t);
2112	goto copy_omp_body;
2113
2114	case GIMPLE_OMP_ORDERED:
2115	t = unshare_expr (gimple_omp_ordered_clauses
2116	(ord_stmt: as_a <gomp_ordered *> (p: stmt)));
2117	gimple_omp_ordered_set_clauses (ord_stmt: as_a <gomp_ordered *> (p: copy), clauses: t);
2118	goto copy_omp_body;
2119
2120	case GIMPLE_OMP_SCAN:
2121	t = gimple_omp_scan_clauses (scan_stmt: as_a <gomp_scan *> (p: stmt));
2122	t = unshare_expr (t);
2123	gimple_omp_scan_set_clauses (scan_stmt: as_a <gomp_scan *> (p: copy), clauses: t);
2124	goto copy_omp_body;
2125
2126	case GIMPLE_OMP_TASKGROUP:
2127	t = unshare_expr (gimple_omp_taskgroup_clauses (gs: stmt));
2128	gimple_omp_taskgroup_set_clauses (gs: copy, clauses: t);
2129	goto copy_omp_body;
2130
2131	case GIMPLE_OMP_SECTIONS:
2132	t = unshare_expr (gimple_omp_sections_clauses (gs: stmt));
2133	gimple_omp_sections_set_clauses (gs: copy, clauses: t);
2134	t = unshare_expr (gimple_omp_sections_control (gs: stmt));
2135	gimple_omp_sections_set_control (gs: copy, control: t);
2136	goto copy_omp_body;
2137
2138	case GIMPLE_OMP_SINGLE:
2139	{
2140	gomp_single *omp_single_copy = as_a <gomp_single *> (p: copy);
2141	t = unshare_expr (gimple_omp_single_clauses (gs: stmt));
2142	gimple_omp_single_set_clauses (omp_single_stmt: omp_single_copy, clauses: t);
2143	}
2144	goto copy_omp_body;
2145
2146	case GIMPLE_OMP_SCOPE:
2147	t = unshare_expr (gimple_omp_scope_clauses (gs: stmt));
2148	gimple_omp_scope_set_clauses (gs: copy, clauses: t);
2149	goto copy_omp_body;
2150
2151	case GIMPLE_OMP_TARGET:
2152	{
2153	gomp_target *omp_target_stmt = as_a <gomp_target *> (p: stmt);
2154	gomp_target *omp_target_copy = as_a <gomp_target *> (p: copy);
2155	t = unshare_expr (gimple_omp_target_clauses (gs: omp_target_stmt));
2156	gimple_omp_target_set_clauses (omp_target_stmt: omp_target_copy, clauses: t);
2157	t = unshare_expr (gimple_omp_target_data_arg (omp_target_stmt));
2158	gimple_omp_target_set_data_arg (omp_target_stmt: omp_target_copy, data_arg: t);
2159	}
2160	goto copy_omp_body;
2161
2162	case GIMPLE_OMP_TEAMS:
2163	{
2164	gomp_teams *omp_teams_copy = as_a <gomp_teams *> (p: copy);
2165	t = unshare_expr (gimple_omp_teams_clauses (gs: stmt));
2166	gimple_omp_teams_set_clauses (omp_teams_stmt: omp_teams_copy, clauses: t);
2167	}
2168	/* FALLTHRU */
2169
2170	case GIMPLE_OMP_SECTION:
2171	case GIMPLE_OMP_MASTER:
2172	case GIMPLE_OMP_STRUCTURED_BLOCK:
2173	copy_omp_body:
2174	new_seq = gimple_seq_copy (src: gimple_omp_body (gs: stmt));
2175	gimple_omp_set_body (gs: copy, body: new_seq);
2176	break;
2177
2178	case GIMPLE_OMP_MASKED:
2179	t = unshare_expr (gimple_omp_masked_clauses (gs: stmt));
2180	gimple_omp_masked_set_clauses (gs: copy, clauses: t);
2181	goto copy_omp_body;
2182
2183	case GIMPLE_ASSUME:
2184	new_seq = gimple_seq_copy (src: gimple_assume_body (gs: stmt));
2185	*gimple_assume_body_ptr (gs: copy) = new_seq;
2186	gimple_assume_set_guard (gs: copy,
2187	guard: unshare_expr (gimple_assume_guard (gs: stmt)));
2188	break;
2189
2190	case GIMPLE_TRANSACTION:
2191	new_seq = gimple_seq_copy (src: gimple_transaction_body (
2192	transaction_stmt: as_a <gtransaction *> (p: stmt)));
2193	gimple_transaction_set_body (transaction_stmt: as_a <gtransaction *> (p: copy),
2194	body: new_seq);
2195	break;
2196
2197	case GIMPLE_WITH_CLEANUP_EXPR:
2198	new_seq = gimple_seq_copy (src: gimple_wce_cleanup (gs: stmt));
2199	gimple_wce_set_cleanup (gs: copy, cleanup: new_seq);
2200	break;
2201
2202	default:
2203	gcc_unreachable ();
2204	}
2205	}
2206
2207	/* Make copy of operands. */
2208	for (i = 0; i < num_ops; i++)
2209	gimple_set_op (gs: copy, i, op: unshare_expr (gimple_op (gs: stmt, i)));
2210
2211	if (gimple_has_mem_ops (g: stmt))
2212	{
2213	gimple_set_vdef (g: copy, vdef: gimple_vdef (g: stmt));
2214	gimple_set_vuse (g: copy, vuse: gimple_vuse (g: stmt));
2215	}
2216
2217	/* Clear out SSA operand vectors on COPY. */
2218	if (gimple_has_ops (g: stmt))
2219	{
2220	gimple_set_use_ops (g: copy, NULL);
2221
2222	/* SSA operands need to be updated. */
2223	gimple_set_modified (s: copy, modifiedp: true);
2224	}
2225
2226	if (gimple_debug_nonbind_marker_p (s: stmt))
2227	cfun->debug_marker_count++;
2228
2229	return copy;
2230	}
2231
2232	/* Move OLD_STMT's vuse and vdef operands to NEW_STMT, on the assumption
2233	that OLD_STMT is about to be removed. */
2234
2235	void
2236	gimple_move_vops (gimple *new_stmt, gimple *old_stmt)
2237	{
2238	tree vdef = gimple_vdef (g: old_stmt);
2239	gimple_set_vuse (g: new_stmt, vuse: gimple_vuse (g: old_stmt));
2240	gimple_set_vdef (g: new_stmt, vdef);
2241	if (vdef && TREE_CODE (vdef) == SSA_NAME)
2242	SSA_NAME_DEF_STMT (vdef) = new_stmt;
2243	}
2244
2245	/* Return true if statement S has side-effects. We consider a
2246	statement to have side effects if:
2247
2248	- It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
2249	- Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
2250
2251	bool
2252	gimple_has_side_effects (const gimple *s)
2253	{
2254	if (is_gimple_debug (gs: s))
2255	return false;
2256
2257	/* We don't have to scan the arguments to check for
2258	volatile arguments, though, at present, we still
2259	do a scan to check for TREE_SIDE_EFFECTS. */
2260	if (gimple_has_volatile_ops (stmt: s))
2261	return true;
2262
2263	if (gimple_code (g: s) == GIMPLE_ASM
2264	&& gimple_asm_volatile_p (asm_stmt: as_a <const gasm *> (p: s)))
2265	return true;
2266
2267	if (is_gimple_call (gs: s))
2268	{
2269	int flags = gimple_call_flags (stmt: s);
2270
2271	/* An infinite loop is considered a side effect. */
2272	if (!(flags & (ECF_CONST | ECF_PURE))
2273	|| (flags & ECF_LOOPING_CONST_OR_PURE))
2274	return true;
2275
2276	return false;
2277	}
2278
2279	return false;
2280	}
2281
2282	/* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
2283	Return true if S can trap. When INCLUDE_MEM is true, check whether
2284	the memory operations could trap. When INCLUDE_STORES is true and
2285	S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */
2286
2287	bool
2288	gimple_could_trap_p_1 (const gimple *s, bool include_mem, bool include_stores)
2289	{
2290	tree t, div = NULL_TREE;
2291	enum tree_code op;
2292
2293	if (include_mem)
2294	{
2295	unsigned i, start = (is_gimple_assign (gs: s) && !include_stores) ? 1 : 0;
2296
2297	for (i = start; i < gimple_num_ops (gs: s); i++)
2298	if (tree_could_trap_p (gimple_op (gs: s, i)))
2299	return true;
2300	}
2301
2302	switch (gimple_code (g: s))
2303	{
2304	case GIMPLE_ASM:
2305	return gimple_asm_volatile_p (asm_stmt: as_a <const gasm *> (p: s));
2306
2307	case GIMPLE_CALL:
2308	if (gimple_call_internal_p (gs: s))
2309	return false;
2310	t = gimple_call_fndecl (gs: s);
2311	/* Assume that indirect and calls to weak functions may trap. */
2312	if (!t || !DECL_P (t) || DECL_WEAK (t))
2313	return true;
2314	return false;
2315
2316	case GIMPLE_ASSIGN:
2317	op = gimple_assign_rhs_code (gs: s);
2318
2319	/* For COND_EXPR only the condition may trap. */
2320	if (op == COND_EXPR)
2321	return tree_could_trap_p (gimple_assign_rhs1 (gs: s));
2322
2323	/* For comparisons we need to check rhs operand types instead of lhs type
2324	(which is BOOLEAN_TYPE). */
2325	if (TREE_CODE_CLASS (op) == tcc_comparison)
2326	t = TREE_TYPE (gimple_assign_rhs1 (s));
2327	else
2328	t = TREE_TYPE (gimple_assign_lhs (s));
2329
2330	if (get_gimple_rhs_class (code: op) == GIMPLE_BINARY_RHS)
2331	div = gimple_assign_rhs2 (gs: s);
2332
2333	return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
2334	(INTEGRAL_TYPE_P (t)
2335	&& TYPE_OVERFLOW_TRAPS (t)),
2336	div));
2337
2338	case GIMPLE_COND:
2339	t = TREE_TYPE (gimple_cond_lhs (s));
2340	return operation_could_trap_p (gimple_cond_code (gs: s),
2341	FLOAT_TYPE_P (t), false, NULL_TREE);
2342
2343	default:
2344	break;
2345	}
2346
2347	return false;
2348	}
2349
2350	/* Return true if statement S can trap. */
2351
2352	bool
2353	gimple_could_trap_p (const gimple *s)
2354	{
2355	return gimple_could_trap_p_1 (s, include_mem: true, include_stores: true);
2356	}
2357
2358	/* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
2359
2360	bool
2361	gimple_assign_rhs_could_trap_p (gimple *s)
2362	{
2363	gcc_assert (is_gimple_assign (s));
2364	return gimple_could_trap_p_1 (s, include_mem: true, include_stores: false);
2365	}
2366
2367
2368	/* Print debugging information for gimple stmts generated. */
2369
2370	void
2371	dump_gimple_statistics (void)
2372	{
2373	int i;
2374	uint64_t total_tuples = 0, total_bytes = 0;
2375
2376	if (! GATHER_STATISTICS)
2377	{
2378	fprintf (stderr, format: "No GIMPLE statistics\n");
2379	return;
2380	}
2381
2382	fprintf (stderr, format: "\nGIMPLE statements\n");
2383	fprintf (stderr, format: "Kind Stmts Bytes\n");
2384	fprintf (stderr, format: "---------------------------------------\n");
2385	for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
2386	{
2387	fprintf (stderr, format: "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n",
2388	gimple_alloc_kind_names[i],
2389	SIZE_AMOUNT (gimple_alloc_counts[i]),
2390	SIZE_AMOUNT (gimple_alloc_sizes[i]));
2391	total_tuples += gimple_alloc_counts[i];
2392	total_bytes += gimple_alloc_sizes[i];
2393	}
2394	fprintf (stderr, format: "---------------------------------------\n");
2395	fprintf (stderr, format: "%-20s %7" PRIu64 "%c %10" PRIu64 "%c\n", "Total",
2396	SIZE_AMOUNT (total_tuples), SIZE_AMOUNT (total_bytes));
2397	fprintf (stderr, format: "---------------------------------------\n");
2398	}
2399
2400
2401	/* Return the number of operands needed on the RHS of a GIMPLE
2402	assignment for an expression with tree code CODE. */
2403
2404	unsigned
2405	get_gimple_rhs_num_ops (enum tree_code code)
2406	{
2407	switch (get_gimple_rhs_class (code))
2408	{
2409	case GIMPLE_UNARY_RHS:
2410	case GIMPLE_SINGLE_RHS:
2411	return 1;
2412	case GIMPLE_BINARY_RHS:
2413	return 2;
2414	case GIMPLE_TERNARY_RHS:
2415	return 3;
2416	default:
2417	gcc_unreachable ();
2418	}
2419	}
2420
2421	#define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
2422	(unsigned char) \
2423	((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
2424	: ((TYPE) == tcc_binary \
2425	|| (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
2426	: ((TYPE) == tcc_constant \
2427	|| (TYPE) == tcc_declaration \
2428	|| (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
2429	: ((SYM) == TRUTH_AND_EXPR \
2430	|| (SYM) == TRUTH_OR_EXPR \
2431	|| (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
2432	: (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
2433	: ((SYM) == COND_EXPR \
2434	|| (SYM) == WIDEN_MULT_PLUS_EXPR \
2435	|| (SYM) == WIDEN_MULT_MINUS_EXPR \
2436	|| (SYM) == DOT_PROD_EXPR \
2437	|| (SYM) == SAD_EXPR \
2438	|| (SYM) == REALIGN_LOAD_EXPR \
2439	|| (SYM) == VEC_COND_EXPR \
2440	|| (SYM) == VEC_PERM_EXPR \
2441	|| (SYM) == BIT_INSERT_EXPR) ? GIMPLE_TERNARY_RHS \
2442	: ((SYM) == CONSTRUCTOR \
2443	|| (SYM) == OBJ_TYPE_REF \
2444	|| (SYM) == ADDR_EXPR \
2445	|| (SYM) == WITH_SIZE_EXPR \
2446	|| (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS \
2447	: GIMPLE_INVALID_RHS),
2448	#define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2449
2450	const unsigned char gimple_rhs_class_table[] = {
2451	#include "all-tree.def"
2452	};
2453
2454	#undef DEFTREECODE
2455	#undef END_OF_BASE_TREE_CODES
2456
2457	/* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2458	the positions marked by the set ARGS_TO_SKIP. */
2459
2460	gcall *
2461	gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2462	{
2463	int i;
2464	int nargs = gimple_call_num_args (gs: stmt);
2465	auto_vec<tree> vargs (nargs);
2466	gcall *new_stmt;
2467
2468	for (i = 0; i < nargs; i++)
2469	if (!bitmap_bit_p (args_to_skip, i))
2470	vargs.quick_push (obj: gimple_call_arg (gs: stmt, index: i));
2471
2472	if (gimple_call_internal_p (gs: stmt))
2473	new_stmt = gimple_build_call_internal_vec (fn: gimple_call_internal_fn (gs: stmt),
2474	args: vargs);
2475	else
2476	new_stmt = gimple_build_call_vec (fn: gimple_call_fn (gs: stmt), args: vargs);
2477
2478	if (gimple_call_lhs (gs: stmt))
2479	gimple_call_set_lhs (gs: new_stmt, lhs: gimple_call_lhs (gs: stmt));
2480
2481	gimple_set_vuse (g: new_stmt, vuse: gimple_vuse (g: stmt));
2482	gimple_set_vdef (g: new_stmt, vdef: gimple_vdef (g: stmt));
2483
2484	if (gimple_has_location (g: stmt))
2485	gimple_set_location (g: new_stmt, location: gimple_location (g: stmt));
2486	gimple_call_copy_flags (dest_call: new_stmt, orig_call: stmt);
2487	gimple_call_set_chain (call_stmt: new_stmt, chain: gimple_call_chain (gs: stmt));
2488
2489	gimple_set_modified (s: new_stmt, modifiedp: true);
2490
2491	return new_stmt;
2492	}
2493
2494
2495
2496	/* Return true if the field decls F1 and F2 are at the same offset.
2497
2498	This is intended to be used on GIMPLE types only. */
2499
2500	bool
2501	gimple_compare_field_offset (tree f1, tree f2)
2502	{
2503	if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2504	{
2505	tree offset1 = DECL_FIELD_OFFSET (f1);
2506	tree offset2 = DECL_FIELD_OFFSET (f2);
2507	return ((offset1 == offset2
2508	/* Once gimplification is done, self-referential offsets are
2509	instantiated as operand #2 of the COMPONENT_REF built for
2510	each access and reset. Therefore, they are not relevant
2511	anymore and fields are interchangeable provided that they
2512	represent the same access. */
2513	|| (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2514	&& TREE_CODE (offset2) == PLACEHOLDER_EXPR
2515	&& (DECL_SIZE (f1) == DECL_SIZE (f2)
2516	|| (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2517	&& TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2518	|| operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), flags: 0))
2519	&& DECL_ALIGN (f1) == DECL_ALIGN (f2))
2520	|| operand_equal_p (offset1, offset2, flags: 0))
2521	&& tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2522	DECL_FIELD_BIT_OFFSET (f2)));
2523	}
2524
2525	/* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2526	should be, so handle differing ones specially by decomposing
2527	the offset into a byte and bit offset manually. */
2528	if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2529	&& tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2530	{
2531	unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2532	unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2533	bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2534	byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2535	+ bit_offset1 / BITS_PER_UNIT);
2536	bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2537	byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2538	+ bit_offset2 / BITS_PER_UNIT);
2539	if (byte_offset1 != byte_offset2)
2540	return false;
2541	return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2542	}
2543
2544	return false;
2545	}
2546
2547
2548	/* Return a type the same as TYPE except unsigned or
2549	signed according to UNSIGNEDP. */
2550
2551	static tree
2552	gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2553	{
2554	tree type1;
2555	int i;
2556
2557	type1 = TYPE_MAIN_VARIANT (type);
2558	if (type1 == signed_char_type_node
2559	|| type1 == char_type_node
2560	|| type1 == unsigned_char_type_node)
2561	return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2562	if (type1 == integer_type_node || type1 == unsigned_type_node)
2563	return unsignedp ? unsigned_type_node : integer_type_node;
2564	if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2565	return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2566	if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2567	return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2568	if (type1 == long_long_integer_type_node
2569	|| type1 == long_long_unsigned_type_node)
2570	return unsignedp
2571	? long_long_unsigned_type_node
2572	: long_long_integer_type_node;
2573
2574	for (i = 0; i < NUM_INT_N_ENTS; i ++)
2575	if (int_n_enabled_p[i]
2576	&& (type1 == int_n_trees[i].unsigned_type
2577	|| type1 == int_n_trees[i].signed_type))
2578	return unsignedp
2579	? int_n_trees[i].unsigned_type
2580	: int_n_trees[i].signed_type;
2581
2582	#if HOST_BITS_PER_WIDE_INT >= 64
2583	if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2584	return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2585	#endif
2586	if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2587	return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2588	if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2589	return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2590	if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2591	return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2592	if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2593	return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2594
2595	#define GIMPLE_FIXED_TYPES(NAME) \
2596	if (type1 == short_ ## NAME ## _type_node \
2597	|| type1 == unsigned_short_ ## NAME ## _type_node) \
2598	return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2599	: short_ ## NAME ## _type_node; \
2600	if (type1 == NAME ## _type_node \
2601	|| type1 == unsigned_ ## NAME ## _type_node) \
2602	return unsignedp ? unsigned_ ## NAME ## _type_node \
2603	: NAME ## _type_node; \
2604	if (type1 == long_ ## NAME ## _type_node \
2605	|| type1 == unsigned_long_ ## NAME ## _type_node) \
2606	return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2607	: long_ ## NAME ## _type_node; \
2608	if (type1 == long_long_ ## NAME ## _type_node \
2609	|| type1 == unsigned_long_long_ ## NAME ## _type_node) \
2610	return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2611	: long_long_ ## NAME ## _type_node;
2612
2613	#define GIMPLE_FIXED_MODE_TYPES(NAME) \
2614	if (type1 == NAME ## _type_node \
2615	|| type1 == u ## NAME ## _type_node) \
2616	return unsignedp ? u ## NAME ## _type_node \
2617	: NAME ## _type_node;
2618
2619	#define GIMPLE_FIXED_TYPES_SAT(NAME) \
2620	if (type1 == sat_ ## short_ ## NAME ## _type_node \
2621	|| type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2622	return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2623	: sat_ ## short_ ## NAME ## _type_node; \
2624	if (type1 == sat_ ## NAME ## _type_node \
2625	|| type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2626	return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2627	: sat_ ## NAME ## _type_node; \
2628	if (type1 == sat_ ## long_ ## NAME ## _type_node \
2629	|| type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2630	return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2631	: sat_ ## long_ ## NAME ## _type_node; \
2632	if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2633	|| type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2634	return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2635	: sat_ ## long_long_ ## NAME ## _type_node;
2636
2637	#define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
2638	if (type1 == sat_ ## NAME ## _type_node \
2639	|| type1 == sat_ ## u ## NAME ## _type_node) \
2640	return unsignedp ? sat_ ## u ## NAME ## _type_node \
2641	: sat_ ## NAME ## _type_node;
2642
2643	GIMPLE_FIXED_TYPES (fract);
2644	GIMPLE_FIXED_TYPES_SAT (fract);
2645	GIMPLE_FIXED_TYPES (accum);
2646	GIMPLE_FIXED_TYPES_SAT (accum);
2647
2648	GIMPLE_FIXED_MODE_TYPES (qq);
2649	GIMPLE_FIXED_MODE_TYPES (hq);
2650	GIMPLE_FIXED_MODE_TYPES (sq);
2651	GIMPLE_FIXED_MODE_TYPES (dq);
2652	GIMPLE_FIXED_MODE_TYPES (tq);
2653	GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2654	GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2655	GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2656	GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2657	GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2658	GIMPLE_FIXED_MODE_TYPES (ha);
2659	GIMPLE_FIXED_MODE_TYPES (sa);
2660	GIMPLE_FIXED_MODE_TYPES (da);
2661	GIMPLE_FIXED_MODE_TYPES (ta);
2662	GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2663	GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2664	GIMPLE_FIXED_MODE_TYPES_SAT (da);
2665	GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2666
2667	/* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2668	the precision; they have precision set to match their range, but
2669	may use a wider mode to match an ABI. If we change modes, we may
2670	wind up with bad conversions. For INTEGER_TYPEs in C, must check
2671	the precision as well, so as to yield correct results for
2672	bit-field types. C++ does not have these separate bit-field
2673	types, and producing a signed or unsigned variant of an
2674	ENUMERAL_TYPE may cause other problems as well. */
2675	if (!INTEGRAL_TYPE_P (type)
2676	|| TYPE_UNSIGNED (type) == unsignedp)
2677	return type;
2678
2679	#define TYPE_OK(node) \
2680	(TYPE_MODE (type) == TYPE_MODE (node) \
2681	&& TYPE_PRECISION (type) == TYPE_PRECISION (node))
2682	if (TYPE_OK (signed_char_type_node))
2683	return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2684	if (TYPE_OK (integer_type_node))
2685	return unsignedp ? unsigned_type_node : integer_type_node;
2686	if (TYPE_OK (short_integer_type_node))
2687	return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2688	if (TYPE_OK (long_integer_type_node))
2689	return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2690	if (TYPE_OK (long_long_integer_type_node))
2691	return (unsignedp
2692	? long_long_unsigned_type_node
2693	: long_long_integer_type_node);
2694
2695	for (i = 0; i < NUM_INT_N_ENTS; i ++)
2696	if (int_n_enabled_p[i]
2697	&& TYPE_MODE (type) == int_n_data[i].m
2698	&& TYPE_PRECISION (type) == int_n_data[i].bitsize)
2699	return unsignedp
2700	? int_n_trees[i].unsigned_type
2701	: int_n_trees[i].signed_type;
2702
2703	#if HOST_BITS_PER_WIDE_INT >= 64
2704	if (TYPE_OK (intTI_type_node))
2705	return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2706	#endif
2707	if (TYPE_OK (intDI_type_node))
2708	return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2709	if (TYPE_OK (intSI_type_node))
2710	return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2711	if (TYPE_OK (intHI_type_node))
2712	return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2713	if (TYPE_OK (intQI_type_node))
2714	return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2715
2716	#undef GIMPLE_FIXED_TYPES
2717	#undef GIMPLE_FIXED_MODE_TYPES
2718	#undef GIMPLE_FIXED_TYPES_SAT
2719	#undef GIMPLE_FIXED_MODE_TYPES_SAT
2720	#undef TYPE_OK
2721
2722	return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2723	}
2724
2725
2726	/* Return an unsigned type the same as TYPE in other respects. */
2727
2728	tree
2729	gimple_unsigned_type (tree type)
2730	{
2731	return gimple_signed_or_unsigned_type (unsignedp: true, type);
2732	}
2733
2734
2735	/* Return a signed type the same as TYPE in other respects. */
2736
2737	tree
2738	gimple_signed_type (tree type)
2739	{
2740	return gimple_signed_or_unsigned_type (unsignedp: false, type);
2741	}
2742
2743
2744	/* Return the typed-based alias set for T, which may be an expression
2745	or a type. Return -1 if we don't do anything special. */
2746
2747	alias_set_type
2748	gimple_get_alias_set (tree t)
2749	{
2750	/* That's all the expressions we handle specially. */
2751	if (!TYPE_P (t))
2752	return -1;
2753
2754	/* For convenience, follow the C standard when dealing with
2755	character types. Any object may be accessed via an lvalue that
2756	has character type. */
2757	if (t == char_type_node
2758	|| t == signed_char_type_node
2759	|| t == unsigned_char_type_node)
2760	return 0;
2761
2762	/* Allow aliasing between signed and unsigned variants of the same
2763	type. We treat the signed variant as canonical. */
2764	if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2765	{
2766	tree t1 = gimple_signed_type (type: t);
2767
2768	/* t1 == t can happen for boolean nodes which are always unsigned. */
2769	if (t1 != t)
2770	return get_alias_set (t1);
2771	}
2772
2773	/* Allow aliasing between enumeral types and the underlying
2774	integer type. This is required for C since those are
2775	compatible types. */
2776	else if (TREE_CODE (t) == ENUMERAL_TYPE)
2777	{
2778	tree t1 = lang_hooks.types.type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
2779	false /* short-cut above */);
2780	return get_alias_set (t1);
2781	}
2782
2783	return -1;
2784	}
2785
2786
2787	/* Helper for gimple_ior_addresses_taken_1. */
2788
2789	static bool
2790	gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
2791	{
2792	bitmap addresses_taken = (bitmap)data;
2793	addr = get_base_address (t: addr);
2794	if (addr
2795	&& DECL_P (addr))
2796	{
2797	bitmap_set_bit (addresses_taken, DECL_UID (addr));
2798	return true;
2799	}
2800	return false;
2801	}
2802
2803	/* Set the bit for the uid of all decls that have their address taken
2804	in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
2805	were any in this stmt. */
2806
2807	bool
2808	gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
2809	{
2810	return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2811	gimple_ior_addresses_taken_1);
2812	}
2813
2814
2815	/* Return true when STMTs arguments and return value match those of FNDECL,
2816	a decl of a builtin function. */
2817
2818	bool
2819	gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
2820	{
2821	gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2822
2823	if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
2824	if (tree decl = builtin_decl_explicit (fncode: DECL_FUNCTION_CODE (decl: fndecl)))
2825	fndecl = decl;
2826
2827	tree ret = gimple_call_lhs (gs: stmt);
2828	if (ret
2829	&& !useless_type_conversion_p (TREE_TYPE (ret),
2830	TREE_TYPE (TREE_TYPE (fndecl))))
2831	return false;
2832
2833	tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2834	unsigned nargs = gimple_call_num_args (gs: stmt);
2835	for (unsigned i = 0; i < nargs; ++i)
2836	{
2837	/* Variadic args follow. */
2838	if (!targs)
2839	return true;
2840	tree arg = gimple_call_arg (gs: stmt, index: i);
2841	tree type = TREE_VALUE (targs);
2842	if (!useless_type_conversion_p (type, TREE_TYPE (arg))
2843	/* char/short integral arguments are promoted to int
2844	by several frontends if targetm.calls.promote_prototypes
2845	is true. Allow such promotion too. */
2846	&& !(INTEGRAL_TYPE_P (type)
2847	&& TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
2848	&& targetm.calls.promote_prototypes (TREE_TYPE (fndecl))
2849	&& useless_type_conversion_p (integer_type_node,
2850	TREE_TYPE (arg))))
2851	return false;
2852	targs = TREE_CHAIN (targs);
2853	}
2854	if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2855	return false;
2856	return true;
2857	}
2858
2859	/* Return true when STMT is operator a replaceable delete call. */
2860
2861	bool
2862	gimple_call_operator_delete_p (const gcall *stmt)
2863	{
2864	tree fndecl;
2865
2866	if ((fndecl = gimple_call_fndecl (gs: stmt)) != NULL_TREE)
2867	return DECL_IS_OPERATOR_DELETE_P (fndecl);
2868	return false;
2869	}
2870
2871	/* Return true when STMT is builtins call. */
2872
2873	bool
2874	gimple_call_builtin_p (const gimple *stmt)
2875	{
2876	tree fndecl;
2877	if (is_gimple_call (gs: stmt)
2878	&& (fndecl = gimple_call_fndecl (gs: stmt)) != NULL_TREE
2879	&& DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2880	return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2881	return false;
2882	}
2883
2884	/* Return true when STMT is builtins call to CLASS. */
2885
2886	bool
2887	gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
2888	{
2889	tree fndecl;
2890	if (is_gimple_call (gs: stmt)
2891	&& (fndecl = gimple_call_fndecl (gs: stmt)) != NULL_TREE
2892	&& DECL_BUILT_IN_CLASS (fndecl) == klass)
2893	return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2894	return false;
2895	}
2896
2897	/* Return true when STMT is builtins call to CODE of CLASS. */
2898
2899	bool
2900	gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
2901	{
2902	tree fndecl;
2903	if (is_gimple_call (gs: stmt)
2904	&& (fndecl = gimple_call_fndecl (gs: stmt)) != NULL_TREE
2905	&& fndecl_built_in_p (node: fndecl, name1: code))
2906	return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2907	return false;
2908	}
2909
2910	/* If CALL is a call to a combined_fn (i.e. an internal function or
2911	a normal built-in function), return its code, otherwise return
2912	CFN_LAST. */
2913
2914	combined_fn
2915	gimple_call_combined_fn (const gimple *stmt)
2916	{
2917	if (const gcall *call = dyn_cast <const gcall *> (p: stmt))
2918	{
2919	if (gimple_call_internal_p (gs: call))
2920	return as_combined_fn (fn: gimple_call_internal_fn (gs: call));
2921
2922	tree fndecl = gimple_call_fndecl (gs: stmt);
2923	if (fndecl
2924	&& fndecl_built_in_p (node: fndecl, klass: BUILT_IN_NORMAL)
2925	&& gimple_builtin_call_types_compatible_p (stmt, fndecl))
2926	return as_combined_fn (fn: DECL_FUNCTION_CODE (decl: fndecl));
2927	}
2928	return CFN_LAST;
2929	}
2930
2931	/* Return true if STMT clobbers memory. STMT is required to be a
2932	GIMPLE_ASM. */
2933
2934	bool
2935	gimple_asm_clobbers_memory_p (const gasm *stmt)
2936	{
2937	unsigned i;
2938
2939	for (i = 0; i < gimple_asm_nclobbers (asm_stmt: stmt); i++)
2940	{
2941	tree op = gimple_asm_clobber_op (asm_stmt: stmt, index: i);
2942	if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), s2: "memory") == 0)
2943	return true;
2944	}
2945
2946	/* Non-empty basic ASM implicitly clobbers memory. */
2947	if (gimple_asm_input_p (asm_stmt: stmt) && strlen (s: gimple_asm_string (asm_stmt: stmt)) != 0)
2948	return true;
2949
2950	return false;
2951	}
2952
2953	/* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE. */
2954
2955	void
2956	dump_decl_set (FILE *file, bitmap set)
2957	{
2958	if (set)
2959	{
2960	bitmap_iterator bi;
2961	unsigned i;
2962
2963	fprintf (stream: file, format: "{ ");
2964
2965	EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2966	{
2967	fprintf (stream: file, format: "D.%u", i);
2968	fprintf (stream: file, format: " ");
2969	}
2970
2971	fprintf (stream: file, format: "}");
2972	}
2973	else
2974	fprintf (stream: file, format: "NIL");
2975	}
2976
2977	/* Return true when CALL is a call stmt that definitely doesn't
2978	free any memory or makes it unavailable otherwise. */
2979	bool
2980	nonfreeing_call_p (gimple *call)
2981	{
2982	if (gimple_call_builtin_p (stmt: call, klass: BUILT_IN_NORMAL)
2983	&& gimple_call_flags (stmt: call) & ECF_LEAF)
2984	switch (DECL_FUNCTION_CODE (decl: gimple_call_fndecl (gs: call)))
2985	{
2986	/* Just in case these become ECF_LEAF in the future. */
2987	case BUILT_IN_FREE:
2988	case BUILT_IN_TM_FREE:
2989	case BUILT_IN_REALLOC:
2990	case BUILT_IN_STACK_RESTORE:
2991	return false;
2992	default:
2993	return true;
2994	}
2995	else if (gimple_call_internal_p (gs: call))
2996	switch (gimple_call_internal_fn (gs: call))
2997	{
2998	case IFN_ABNORMAL_DISPATCHER:
2999	return true;
3000	case IFN_ASAN_MARK:
3001	return tree_to_uhwi (gimple_call_arg (gs: call, index: 0)) == ASAN_MARK_UNPOISON;
3002	default:
3003	if (gimple_call_flags (stmt: call) & ECF_LEAF)
3004	return true;
3005	return false;
3006	}
3007
3008	tree fndecl = gimple_call_fndecl (gs: call);
3009	if (!fndecl)
3010	return false;
3011	struct cgraph_node *n = cgraph_node::get (decl: fndecl);
3012	if (!n)
3013	return false;
3014	enum availability availability;
3015	n = n->function_symbol (avail: &availability);
3016	if (!n || availability <= AVAIL_INTERPOSABLE)
3017	return false;
3018	return n->nonfreeing_fn;
3019	}
3020
3021	/* Return true when CALL is a call stmt that definitely need not
3022	be considered to be a memory barrier. */
3023	bool
3024	nonbarrier_call_p (gimple *call)
3025	{
3026	if (gimple_call_flags (stmt: call) & (ECF_PURE | ECF_CONST))
3027	return true;
3028	/* Should extend this to have a nonbarrier_fn flag, just as above in
3029	the nonfreeing case. */
3030	return false;
3031	}
3032
3033	/* Callback for walk_stmt_load_store_ops.
3034
3035	Return TRUE if OP will dereference the tree stored in DATA, FALSE
3036	otherwise.
3037
3038	This routine only makes a superficial check for a dereference. Thus
3039	it must only be used if it is safe to return a false negative. */
3040	static bool
3041	check_loadstore (gimple *, tree op, tree, void *data)
3042	{
3043	if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
3044	{
3045	/* Some address spaces may legitimately dereference zero. */
3046	addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
3047	if (targetm.addr_space.zero_address_valid (as))
3048	return false;
3049
3050	return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, flags: 0);
3051	}
3052	return false;
3053	}
3054
3055
3056	/* Return true if OP can be inferred to be non-NULL after STMT executes,
3057	either by using a pointer dereference or attributes. */
3058	bool
3059	infer_nonnull_range (gimple *stmt, tree op)
3060	{
3061	return (infer_nonnull_range_by_dereference (stmt, op)
3062	|| infer_nonnull_range_by_attribute (stmt, op));
3063	}
3064
3065	/* Return true if OP can be inferred to be non-NULL after STMT
3066	executes by using a pointer dereference. */
3067	bool
3068	infer_nonnull_range_by_dereference (gimple *stmt, tree op)
3069	{
3070	/* We can only assume that a pointer dereference will yield
3071	non-NULL if -fdelete-null-pointer-checks is enabled. */
3072	if (!flag_delete_null_pointer_checks
3073	|| !POINTER_TYPE_P (TREE_TYPE (op))
3074	|| gimple_code (g: stmt) == GIMPLE_ASM
3075	|| gimple_clobber_p (s: stmt))
3076	return false;
3077
3078	if (walk_stmt_load_store_ops (stmt, (void *)op,
3079	check_loadstore, check_loadstore))
3080	return true;
3081
3082	return false;
3083	}
3084
3085	/* Return true if OP can be inferred to be a non-NULL after STMT
3086	executes by using attributes. */
3087	bool
3088	infer_nonnull_range_by_attribute (gimple *stmt, tree op)
3089	{
3090	/* We can only assume that a pointer dereference will yield
3091	non-NULL if -fdelete-null-pointer-checks is enabled. */
3092	if (!flag_delete_null_pointer_checks
3093	|| !POINTER_TYPE_P (TREE_TYPE (op))
3094	|| gimple_code (g: stmt) == GIMPLE_ASM)
3095	return false;
3096
3097	if (is_gimple_call (gs: stmt) && !gimple_call_internal_p (gs: stmt))
3098	{
3099	tree fntype = gimple_call_fntype (gs: stmt);
3100	tree attrs = TYPE_ATTRIBUTES (fntype);
3101	for (; attrs; attrs = TREE_CHAIN (attrs))
3102	{
3103	attrs = lookup_attribute (attr_name: "nonnull", list: attrs);
3104
3105	/* If "nonnull" wasn't specified, we know nothing about
3106	the argument. */
3107	if (attrs == NULL_TREE)
3108	return false;
3109
3110	/* If "nonnull" applies to all the arguments, then ARG
3111	is non-null if it's in the argument list. */
3112	if (TREE_VALUE (attrs) == NULL_TREE)
3113	{
3114	for (unsigned int i = 0; i < gimple_call_num_args (gs: stmt); i++)
3115	{
3116	if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
3117	&& operand_equal_p (op, gimple_call_arg (gs: stmt, index: i), flags: 0))
3118	return true;
3119	}
3120	return false;
3121	}
3122
3123	/* Now see if op appears in the nonnull list. */
3124	for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
3125	{
3126	unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
3127	if (idx < gimple_call_num_args (gs: stmt))
3128	{
3129	tree arg = gimple_call_arg (gs: stmt, index: idx);
3130	if (operand_equal_p (op, arg, flags: 0))
3131	return true;
3132	}
3133	}
3134	}
3135	}
3136
3137	/* If this function is marked as returning non-null, then we can
3138	infer OP is non-null if it is used in the return statement. */
3139	if (greturn *return_stmt = dyn_cast <greturn *> (p: stmt))
3140	if (gimple_return_retval (gs: return_stmt)
3141	&& operand_equal_p (gimple_return_retval (gs: return_stmt), op, flags: 0)
3142	&& lookup_attribute (attr_name: "returns_nonnull",
3143	TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
3144	return true;
3145
3146	return false;
3147	}
3148
3149	/* Compare two case labels. Because the front end should already have
3150	made sure that case ranges do not overlap, it is enough to only compare
3151	the CASE_LOW values of each case label. */
3152
3153	static int
3154	compare_case_labels (const void *p1, const void *p2)
3155	{
3156	const_tree const case1 = *(const_tree const*)p1;
3157	const_tree const case2 = *(const_tree const*)p2;
3158
3159	/* The 'default' case label always goes first. */
3160	if (!CASE_LOW (case1))
3161	return -1;
3162	else if (!CASE_LOW (case2))
3163	return 1;
3164	else
3165	return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
3166	}
3167
3168	/* Sort the case labels in LABEL_VEC in place in ascending order. */
3169
3170	void
3171	sort_case_labels (vec<tree> &label_vec)
3172	{
3173	label_vec.qsort (compare_case_labels);
3174	}
3175
3176	/* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3177
3178	LABELS is a vector that contains all case labels to look at.
3179
3180	INDEX_TYPE is the type of the switch index expression. Case labels
3181	in LABELS are discarded if their values are not in the value range
3182	covered by INDEX_TYPE. The remaining case label values are folded
3183	to INDEX_TYPE.
3184
3185	If a default case exists in LABELS, it is removed from LABELS and
3186	returned in DEFAULT_CASEP. If no default case exists, but the
3187	case labels already cover the whole range of INDEX_TYPE, a default
3188	case is returned pointing to one of the existing case labels.
3189	Otherwise DEFAULT_CASEP is set to NULL_TREE.
3190
3191	DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3192	apply and no action is taken regardless of whether a default case is
3193	found or not. */
3194
3195	void
3196	preprocess_case_label_vec_for_gimple (vec<tree> &labels,
3197	tree index_type,
3198	tree *default_casep)
3199	{
3200	tree min_value, max_value;
3201	tree default_case = NULL_TREE;
3202	size_t i, len;
3203
3204	i = 0;
3205	min_value = TYPE_MIN_VALUE (index_type);
3206	max_value = TYPE_MAX_VALUE (index_type);
3207	while (i < labels.length ())
3208	{
3209	tree elt = labels[i];
3210	tree low = CASE_LOW (elt);
3211	tree high = CASE_HIGH (elt);
3212	bool remove_element = false;
3213
3214	if (low)
3215	{
3216	gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
3217	gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
3218
3219	/* This is a non-default case label, i.e. it has a value.
3220
3221	See if the case label is reachable within the range of
3222	the index type. Remove out-of-range case values. Turn
3223	case ranges into a canonical form (high > low strictly)
3224	and convert the case label values to the index type.
3225
3226	NB: The type of gimple_switch_index() may be the promoted
3227	type, but the case labels retain the original type. */
3228
3229	if (high)
3230	{
3231	/* This is a case range. Discard empty ranges.
3232	If the bounds or the range are equal, turn this
3233	into a simple (one-value) case. */
3234	int cmp = tree_int_cst_compare (t1: high, t2: low);
3235	if (cmp < 0)
3236	remove_element = true;
3237	else if (cmp == 0)
3238	high = NULL_TREE;
3239	}
3240
3241	if (! high)
3242	{
3243	/* If the simple case value is unreachable, ignore it. */
3244	if ((TREE_CODE (min_value) == INTEGER_CST
3245	&& tree_int_cst_compare (t1: low, t2: min_value) < 0)
3246	|| (TREE_CODE (max_value) == INTEGER_CST
3247	&& tree_int_cst_compare (t1: low, t2: max_value) > 0))
3248	remove_element = true;
3249	else
3250	low = fold_convert (index_type, low);
3251	}
3252	else
3253	{
3254	/* If the entire case range is unreachable, ignore it. */
3255	if ((TREE_CODE (min_value) == INTEGER_CST
3256	&& tree_int_cst_compare (t1: high, t2: min_value) < 0)
3257	|| (TREE_CODE (max_value) == INTEGER_CST
3258	&& tree_int_cst_compare (t1: low, t2: max_value) > 0))
3259	remove_element = true;
3260	else
3261	{
3262	/* If the lower bound is less than the index type's
3263	minimum value, truncate the range bounds. */
3264	if (TREE_CODE (min_value) == INTEGER_CST
3265	&& tree_int_cst_compare (t1: low, t2: min_value) < 0)
3266	low = min_value;
3267	low = fold_convert (index_type, low);
3268
3269	/* If the upper bound is greater than the index type's
3270	maximum value, truncate the range bounds. */
3271	if (TREE_CODE (max_value) == INTEGER_CST
3272	&& tree_int_cst_compare (t1: high, t2: max_value) > 0)
3273	high = max_value;
3274	high = fold_convert (index_type, high);
3275
3276	/* We may have folded a case range to a one-value case. */
3277	if (tree_int_cst_equal (low, high))
3278	high = NULL_TREE;
3279	}
3280	}
3281
3282	CASE_LOW (elt) = low;
3283	CASE_HIGH (elt) = high;
3284	}
3285	else
3286	{
3287	gcc_assert (!default_case);
3288	default_case = elt;
3289	/* The default case must be passed separately to the
3290	gimple_build_switch routine. But if DEFAULT_CASEP
3291	is NULL, we do not remove the default case (it would
3292	be completely lost). */
3293	if (default_casep)
3294	remove_element = true;
3295	}
3296
3297	if (remove_element)
3298	labels.ordered_remove (ix: i);
3299	else
3300	i++;
3301	}
3302	len = i;
3303
3304	if (!labels.is_empty ())
3305	sort_case_labels (label_vec&: labels);
3306
3307	if (default_casep && !default_case)
3308	{
3309	/* If the switch has no default label, add one, so that we jump
3310	around the switch body. If the labels already cover the whole
3311	range of the switch index_type, add the default label pointing
3312	to one of the existing labels. */
3313	if (len
3314	&& TYPE_MIN_VALUE (index_type)
3315	&& TYPE_MAX_VALUE (index_type)
3316	&& tree_int_cst_equal (CASE_LOW (labels[0]),
3317	TYPE_MIN_VALUE (index_type)))
3318	{
3319	tree low, high = CASE_HIGH (labels[len - 1]);
3320	if (!high)
3321	high = CASE_LOW (labels[len - 1]);
3322	if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
3323	{
3324	tree widest_label = labels[0];
3325	for (i = 1; i < len; i++)
3326	{
3327	high = CASE_LOW (labels[i]);
3328	low = CASE_HIGH (labels[i - 1]);
3329	if (!low)
3330	low = CASE_LOW (labels[i - 1]);
3331
3332	if (CASE_HIGH (labels[i]) != NULL_TREE
3333	&& (CASE_HIGH (widest_label) == NULL_TREE
3334	|| (wi::gtu_p
3335	(x: wi::to_wide (CASE_HIGH (labels[i]))
3336	- wi::to_wide (CASE_LOW (labels[i])),
3337	y: wi::to_wide (CASE_HIGH (widest_label))
3338	- wi::to_wide (CASE_LOW (widest_label))))))
3339	widest_label = labels[i];
3340
3341	if (wi::to_wide (t: low) + 1 != wi::to_wide (t: high))
3342	break;
3343	}
3344	if (i == len)
3345	{
3346	/* Designate the label with the widest range to be the
3347	default label. */
3348	tree label = CASE_LABEL (widest_label);
3349	default_case = build_case_label (NULL_TREE, NULL_TREE,
3350	label);
3351	}
3352	}
3353	}
3354	}
3355
3356	if (default_casep)
3357	*default_casep = default_case;
3358	}
3359
3360	/* Set the location of all statements in SEQ to LOC. */
3361
3362	void
3363	gimple_seq_set_location (gimple_seq seq, location_t loc)
3364	{
3365	for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (i: &i))
3366	gimple_set_location (g: gsi_stmt (i), location: loc);
3367	}
3368
3369	/* Release SSA_NAMEs in SEQ as well as the GIMPLE statements. */
3370
3371	void
3372	gimple_seq_discard (gimple_seq seq)
3373	{
3374	gimple_stmt_iterator gsi;
3375
3376	for (gsi = gsi_start (seq); !gsi_end_p (i: gsi); )
3377	{
3378	gimple *stmt = gsi_stmt (i: gsi);
3379	gsi_remove (&gsi, true);
3380	release_defs (stmt);
3381	ggc_free (stmt);
3382	}
3383	}
3384
3385	/* See if STMT now calls function that takes no parameters and if so, drop
3386	call arguments. This is used when devirtualization machinery redirects
3387	to __builtin_unreachable or __cxa_pure_virtual. */
3388
3389	void
3390	maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
3391	{
3392	tree decl = gimple_call_fndecl (gs: stmt);
3393	if (TYPE_ARG_TYPES (TREE_TYPE (decl))
3394	&& TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
3395	&& gimple_call_num_args (gs: stmt))
3396	{
3397	gimple_set_num_ops (gs: stmt, num_ops: 3);
3398	update_stmt_fn (fn, s: stmt);
3399	}
3400	}
3401
3402	/* Return false if STMT will likely expand to real function call. */
3403
3404	bool
3405	gimple_inexpensive_call_p (gcall *stmt)
3406	{
3407	if (gimple_call_internal_p (gs: stmt))
3408	return true;
3409	tree decl = gimple_call_fndecl (gs: stmt);
3410	if (decl && is_inexpensive_builtin (decl))
3411	return true;
3412	return false;
3413	}
3414
3415	/* Return a non-artificial location for STMT. If STMT does not have
3416	location information, get the location from EXPR. */
3417
3418	location_t
3419	gimple_or_expr_nonartificial_location (gimple *stmt, tree expr)
3420	{
3421	location_t loc = gimple_nonartificial_location (g: stmt);
3422	if (loc == UNKNOWN_LOCATION && EXPR_HAS_LOCATION (expr))
3423	loc = tree_nonartificial_location (expr);
3424	return expansion_point_location_if_in_system_header (loc);
3425	}
3426
3427
3428	#if CHECKING_P
3429
3430	namespace selftest {
3431
3432	/* Selftests for core gimple structures. */
3433
3434	/* Verify that STMT is pretty-printed as EXPECTED.
3435	Helper function for selftests. */
3436
3437	static void
3438	verify_gimple_pp (const char *expected, gimple *stmt)
3439	{
3440	pretty_printer pp;
3441	pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, TDF_NONE /* flags */);
3442	ASSERT_STREQ (expected, pp_formatted_text (&pp));
3443	}
3444
3445	/* Build a GIMPLE_ASSIGN equivalent to
3446	tmp = 5;
3447	and verify various properties of it. */
3448
3449	static void
3450	test_assign_single ()
3451	{
3452	tree type = integer_type_node;
3453	tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3454	get_identifier ("tmp"),
3455	type);
3456	tree rhs = build_int_cst (type, 5);
3457	gassign *stmt = gimple_build_assign (lhs, rhs);
3458	verify_gimple_pp (expected: "tmp = 5;", stmt);
3459
3460	ASSERT_TRUE (is_gimple_assign (stmt));
3461	ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3462	ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3463	ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
3464	ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
3465	ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3466	ASSERT_TRUE (gimple_assign_single_p (stmt));
3467	ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
3468	}
3469
3470	/* Build a GIMPLE_ASSIGN equivalent to
3471	tmp = a * b;
3472	and verify various properties of it. */
3473
3474	static void
3475	test_assign_binop ()
3476	{
3477	tree type = integer_type_node;
3478	tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3479	get_identifier ("tmp"),
3480	type);
3481	tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3482	get_identifier ("a"),
3483	type);
3484	tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3485	get_identifier ("b"),
3486	type);
3487	gassign *stmt = gimple_build_assign (lhs, subcode: MULT_EXPR, op1: a, op2: b);
3488	verify_gimple_pp (expected: "tmp = a * b;", stmt);
3489
3490	ASSERT_TRUE (is_gimple_assign (stmt));
3491	ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3492	ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3493	ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
3494	ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
3495	ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3496	ASSERT_FALSE (gimple_assign_single_p (stmt));
3497	ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
3498	}
3499
3500	/* Build a GIMPLE_NOP and verify various properties of it. */
3501
3502	static void
3503	test_nop_stmt ()
3504	{
3505	gimple *stmt = gimple_build_nop ();
3506	verify_gimple_pp (expected: "GIMPLE_NOP", stmt);
3507	ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
3508	ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3509	ASSERT_FALSE (gimple_assign_single_p (stmt));
3510	}
3511
3512	/* Build a GIMPLE_RETURN equivalent to
3513	return 7;
3514	and verify various properties of it. */
3515
3516	static void
3517	test_return_stmt ()
3518	{
3519	tree type = integer_type_node;
3520	tree val = build_int_cst (type, 7);
3521	greturn *stmt = gimple_build_return (retval: val);
3522	verify_gimple_pp (expected: "return 7;", stmt);
3523
3524	ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3525	ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3526	ASSERT_EQ (val, gimple_return_retval (stmt));
3527	ASSERT_FALSE (gimple_assign_single_p (stmt));
3528	}
3529
3530	/* Build a GIMPLE_RETURN equivalent to
3531	return;
3532	and verify various properties of it. */
3533
3534	static void
3535	test_return_without_value ()
3536	{
3537	greturn *stmt = gimple_build_return (NULL);
3538	verify_gimple_pp (expected: "return;", stmt);
3539
3540	ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3541	ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3542	ASSERT_EQ (NULL, gimple_return_retval (stmt));
3543	ASSERT_FALSE (gimple_assign_single_p (stmt));
3544	}
3545
3546	/* Run all of the selftests within this file. */
3547
3548	void
3549	gimple_cc_tests ()
3550	{
3551	test_assign_single ();
3552	test_assign_binop ();
3553	test_nop_stmt ();
3554	test_return_stmt ();
3555	test_return_without_value ();
3556	}
3557
3558	} // namespace selftest
3559
3560
3561	#endif /* CHECKING_P */
3562