1	/* Top level of GCC compilers (cc1, cc1plus, etc.)
2	Copyright (C) 1987-2024 Free Software Foundation, Inc.
3
4	This file is part of GCC.
5
6	GCC is free software; you can redistribute it and/or modify it under
7	the terms of the GNU General Public License as published by the Free
8	Software Foundation; either version 3, or (at your option) any later
9	version.
10
11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14	for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with GCC; see the file COPYING3. If not see
18	<http://www.gnu.org/licenses/>. */
19
20	/* This is the top level of cc1/c++.
21	It parses command args, opens files, invokes the various passes
22	in the proper order, and counts the time used by each.
23	Error messages and low-level interface to malloc also handled here. */
24
25	#include "config.h"
26	#include "system.h"
27	#include "coretypes.h"
28	#include "backend.h"
29	#include "target.h"
30	#include "rtl.h"
31	#include "tree.h"
32	#include "gimple.h"
33	#include "cfghooks.h"
34	#include "df.h"
35	#include "memmodel.h"
36	#include "tm_p.h"
37	#include "ssa.h"
38	#include "emit-rtl.h"
39	#include "cgraph.h"
40	#include "lto-streamer.h"
41	#include "fold-const.h"
42	#include "varasm.h"
43	#include "output.h"
44	#include "graph.h"
45	#include "debug.h"
46	#include "cfgloop.h"
47	#include "value-prof.h"
48	#include "tree-cfg.h"
49	#include "tree-ssa-loop-manip.h"
50	#include "tree-into-ssa.h"
51	#include "tree-dfa.h"
52	#include "tree-ssa.h"
53	#include "tree-pass.h"
54	#include "plugin.h"
55	#include "ipa-utils.h"
56	#include "tree-pretty-print.h" /* for dump_function_header */
57	#include "context.h"
58	#include "pass_manager.h"
59	#include "cfgrtl.h"
60	#include "tree-ssa-live.h" /* For remove_unused_locals. */
61	#include "tree-cfgcleanup.h"
62	#include "insn-addr.h" /* for INSN_ADDRESSES_ALLOC. */
63	#include "diagnostic-core.h" /* for fnotice */
64	#include "stringpool.h"
65	#include "attribs.h"
66
67	using namespace gcc;
68
69	/* This is used for debugging. It allows the current pass to printed
70	from anywhere in compilation.
71	The variable current_pass is also used for statistics and plugins. */
72	opt_pass *current_pass;
73
74	/* Most passes are single-instance (within their context) and thus don't
75	need to implement cloning, but passes that support multiple instances
76	*must* provide their own implementation of the clone method.
77
78	Handle this by providing a default implemenation, but make it a fatal
79	error to call it. */
80
81	opt_pass *
82	opt_pass::clone ()
83	{
84	internal_error ("pass %s does not support cloning", name);
85	}
86
87	void
88	opt_pass::set_pass_param (unsigned int, bool)
89	{
90	internal_error ("pass %s needs a %<set_pass_param%> implementation "
91	"to handle the extra argument in %<NEXT_PASS%>", name);
92	}
93
94	bool
95	opt_pass::gate (function *)
96	{
97	return true;
98	}
99
100	unsigned int
101	opt_pass::execute (function *)
102	{
103	return 0;
104	}
105
106	opt_pass::opt_pass (const pass_data &data, context *ctxt)
107	: pass_data (data),
108	sub (NULL),
109	next (NULL),
110	static_pass_number (0),
111	m_ctxt (ctxt)
112	{
113	}
114
115
116	void
117	pass_manager::execute_early_local_passes ()
118	{
119	execute_pass_list (cfun, pass_build_ssa_passes_1->sub);
120	execute_pass_list (cfun, pass_local_optimization_passes_1->sub);
121	}
122
123	unsigned int
124	pass_manager::execute_pass_mode_switching ()
125	{
126	return pass_mode_switching_1->execute (cfun);
127	}
128
129
130	/* Call from anywhere to find out what pass this is. Useful for
131	printing out debugging information deep inside an service
132	routine. */
133	void
134	print_current_pass (FILE *file)
135	{
136	if (current_pass)
137	fprintf (stream: file, format: "current pass = %s (%d)\n",
138	current_pass->name, current_pass->static_pass_number);
139	else
140	fprintf (stream: file, format: "no current pass.\n");
141	}
142
143
144	/* Call from the debugger to get the current pass name. */
145	DEBUG_FUNCTION void
146	debug_pass (void)
147	{
148	print_current_pass (stderr);
149	}
150
151
152
153	/* Global variables used to communicate with passes. */
154	bool in_gimple_form;
155
156
157	/* This is called from various places for FUNCTION_DECL, VAR_DECL,
158	and TYPE_DECL nodes.
159
160	This does nothing for local (non-static) variables, unless the
161	variable is a register variable with DECL_ASSEMBLER_NAME set. In
162	that case, or if the variable is not an automatic, it sets up the
163	RTL and outputs any assembler code (label definition, storage
164	allocation and initialization).
165
166	DECL is the declaration. TOP_LEVEL is nonzero
167	if this declaration is not within a function. */
168
169	void
170	rest_of_decl_compilation (tree decl,
171	int top_level,
172	int at_end)
173	{
174	bool finalize = true;
175
176	/* We deferred calling assemble_alias so that we could collect
177	other attributes such as visibility. Emit the alias now. */
178	if (!in_lto_p)
179	{
180	tree alias;
181	alias = lookup_attribute (attr_name: "alias", DECL_ATTRIBUTES (decl));
182	if (alias)
183	{
184	alias = TREE_VALUE (TREE_VALUE (alias));
185	alias = get_identifier (TREE_STRING_POINTER (alias));
186	/* A quirk of the initial implementation of aliases required that the
187	user add "extern" to all of them. Which is silly, but now
188	historical. Do note that the symbol is in fact locally defined. */
189	DECL_EXTERNAL (decl) = 0;
190	TREE_STATIC (decl) = 1;
191	assemble_alias (decl, alias);
192	finalize = false;
193	}
194	}
195
196	/* Can't defer this, because it needs to happen before any
197	later function definitions are processed. */
198	if (HAS_DECL_ASSEMBLER_NAME_P (decl)
199	&& DECL_ASSEMBLER_NAME_SET_P (decl)
200	&& DECL_REGISTER (decl))
201	make_decl_rtl (decl);
202
203	/* Forward declarations for nested functions are not "external",
204	but we need to treat them as if they were. */
205	if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
206	|| TREE_CODE (decl) == FUNCTION_DECL)
207	{
208	timevar_push (tv: TV_VARCONST);
209
210	/* Don't output anything when a tentative file-scope definition
211	is seen. But at end of compilation, do output code for them.
212
213	We do output all variables and rely on
214	callgraph code to defer them except for forward declarations
215	(see gcc.c-torture/compile/920624-1.c) */
216	if ((at_end
217	|| !DECL_DEFER_OUTPUT (decl)
218	|| DECL_INITIAL (decl))
219	&& (!VAR_P (decl) || !DECL_HAS_VALUE_EXPR_P (decl))
220	&& !DECL_EXTERNAL (decl))
221	{
222	/* When reading LTO unit, we also read varpool, so do not
223	rebuild it. */
224	if (in_lto_p && !at_end)
225	;
226	else if (finalize && TREE_CODE (decl) != FUNCTION_DECL)
227	varpool_node::finalize_decl (decl);
228	}
229
230	#ifdef ASM_FINISH_DECLARE_OBJECT
231	if (decl == last_assemble_variable_decl)
232	{
233	ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
234	top_level, at_end);
235	}
236	#endif
237
238	/* Now that we have activated any function-specific attributes
239	that might affect function decl, particularly align, relayout it. */
240	if (TREE_CODE (decl) == FUNCTION_DECL)
241	targetm.target_option.relayout_function (decl);
242
243	timevar_pop (tv: TV_VARCONST);
244	}
245	else if (TREE_CODE (decl) == TYPE_DECL
246	/* Like in rest_of_type_compilation, avoid confusing the debug
247	information machinery when there are errors. */
248	&& !seen_error ())
249	{
250	timevar_push (tv: TV_SYMOUT);
251	debug_hooks->type_decl (decl, !top_level);
252	timevar_pop (tv: TV_SYMOUT);
253	}
254
255	/* Let cgraph know about the existence of variables. */
256	if (in_lto_p && !at_end)
257	;
258	else if (VAR_P (decl) && !DECL_EXTERNAL (decl)
259	&& TREE_STATIC (decl))
260	varpool_node::get_create (decl);
261
262	/* Generate early debug for global variables. Any local variables will
263	be handled by either handling reachable functions from
264	finalize_compilation_unit (and by consequence, locally scoped
265	symbols), or by rest_of_type_compilation below.
266
267	For Go's hijack of the debug_hooks to implement -fdump-go-spec, pick up
268	function prototypes. Go's debug_hooks will not forward them to the
269	wrapped hooks. */
270	if (!in_lto_p
271	&& (TREE_CODE (decl) != FUNCTION_DECL
272	/* This will pick up function prototypes with no bodies,
273	which are not visible in finalize_compilation_unit()
274	while iterating with FOR_EACH_*_FUNCTION through the
275	symbol table. */
276	|| (flag_dump_go_spec != NULL
277	&& !DECL_SAVED_TREE (decl)
278	&& DECL_STRUCT_FUNCTION (decl) == NULL))
279
280	/* We need to check both decl_function_context and
281	current_function_decl here to make sure local extern
282	declarations end up with the correct context.
283
284	For local extern declarations, decl_function_context is
285	empty, but current_function_decl is set to the function where
286	the extern was declared . Without the check for
287	!current_function_decl below, the local extern ends up
288	incorrectly with a top-level context.
289
290	For example:
291
292	namespace S
293	{
294	int
295	f()
296	{
297	{
298	int i = 42;
299	{
300	extern int i; // Local extern declaration.
301	return i;
302	}
303	}
304	}
305	}
306	*/
307	&& !decl_function_context (decl)
308	&& !current_function_decl
309	&& DECL_SOURCE_LOCATION (decl) != BUILTINS_LOCATION
310	&& (!decl_type_context (decl)
311	/* If we created a varpool node for the decl make sure to
312	call early_global_decl. Otherwise we miss changes
313	introduced by member definitions like
314	struct A { static int staticdatamember; };
315	int A::staticdatamember;
316	and thus have incomplete early debug and late debug
317	called from varpool node removal fails to handle it
318	properly. */
319	|| (finalize
320	&& VAR_P (decl)
321	&& TREE_STATIC (decl) && !DECL_EXTERNAL (decl)))
322	/* Avoid confusing the debug information machinery when there are
323	errors. */
324	&& !seen_error ())
325	(*debug_hooks->early_global_decl) (decl);
326	}
327
328	/* Called after finishing a record, union or enumeral type. */
329
330	void
331	rest_of_type_compilation (tree type, int toplev)
332	{
333	/* Avoid confusing the debug information machinery when there are
334	errors. */
335	if (seen_error ())
336	return;
337
338	timevar_push (tv: TV_SYMOUT);
339	debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
340	timevar_pop (tv: TV_SYMOUT);
341	}
342
343
344
345	void
346	pass_manager::
347	finish_optimization_passes (void)
348	{
349	int i;
350	struct dump_file_info *dfi;
351	char *name;
352	gcc::dump_manager *dumps = m_ctxt->get_dumps ();
353
354	timevar_push (tv: TV_DUMP);
355	if (profile_arc_flag || condition_coverage_flag || flag_test_coverage
356	|| flag_branch_probabilities)
357	{
358	dumps->dump_start (phase: pass_profile_1->static_pass_number, NULL);
359	end_branch_prob ();
360	dumps->dump_finish (phase: pass_profile_1->static_pass_number);
361	}
362
363	/* Do whatever is necessary to finish printing the graphs. */
364	for (i = TDI_end; (dfi = dumps->get_dump_file_info (phase: i)) != NULL; ++i)
365	if (dfi->graph_dump_initialized)
366	{
367	name = dumps->get_dump_file_name (dfi);
368	finish_graph_dump_file (name);
369	free (ptr: name);
370	}
371
372	timevar_pop (tv: TV_DUMP);
373	}
374
375	static unsigned int
376	execute_build_ssa_passes (void)
377	{
378	/* Once this pass (and its sub-passes) are complete, all functions
379	will be in SSA form. Technically this state change is happening
380	a tad early, since the sub-passes have not yet run, but since
381	none of the sub-passes are IPA passes and do not create new
382	functions, this is ok. We're setting this value for the benefit
383	of IPA passes that follow. */
384	if (symtab->state < IPA_SSA)
385	symtab->state = IPA_SSA;
386	return 0;
387	}
388
389	namespace {
390
391	const pass_data pass_data_build_ssa_passes =
392	{
393	.type: SIMPLE_IPA_PASS, /* type */
394	.name: "build_ssa_passes", /* name */
395	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
396	.tv_id: TV_EARLY_LOCAL, /* tv_id */
397	.properties_required: 0, /* properties_required */
398	.properties_provided: 0, /* properties_provided */
399	.properties_destroyed: 0, /* properties_destroyed */
400	.todo_flags_start: 0, /* todo_flags_start */
401	/* todo_flags_finish is executed before subpases. For this reason
402	it makes no sense to remove unreachable functions here. */
403	.todo_flags_finish: 0, /* todo_flags_finish */
404	};
405
406	class pass_build_ssa_passes : public simple_ipa_opt_pass
407	{
408	public:
409	pass_build_ssa_passes (gcc::context *ctxt)
410	: simple_ipa_opt_pass (pass_data_build_ssa_passes, ctxt)
411	{}
412
413	/* opt_pass methods: */
414	bool gate (function *) final override
415	{
416	/* Don't bother doing anything if the program has errors. */
417	return (!seen_error () && !in_lto_p);
418	}
419
420	unsigned int execute (function *) final override
421	{
422	return execute_build_ssa_passes ();
423	}
424
425	}; // class pass_build_ssa_passes
426
427	const pass_data pass_data_local_optimization_passes =
428	{
429	.type: SIMPLE_IPA_PASS, /* type */
430	.name: "opt_local_passes", /* name */
431	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
432	.tv_id: TV_NONE, /* tv_id */
433	.properties_required: 0, /* properties_required */
434	.properties_provided: 0, /* properties_provided */
435	.properties_destroyed: 0, /* properties_destroyed */
436	.todo_flags_start: 0, /* todo_flags_start */
437	.todo_flags_finish: 0, /* todo_flags_finish */
438	};
439
440	class pass_local_optimization_passes : public simple_ipa_opt_pass
441	{
442	public:
443	pass_local_optimization_passes (gcc::context *ctxt)
444	: simple_ipa_opt_pass (pass_data_local_optimization_passes, ctxt)
445	{}
446
447	/* opt_pass methods: */
448	bool gate (function *) final override
449	{
450	/* Don't bother doing anything if the program has errors. */
451	return (!seen_error () && !in_lto_p);
452	}
453
454	}; // class pass_local_optimization_passes
455
456	const pass_data pass_data_ipa_remove_symbols =
457	{
458	.type: SIMPLE_IPA_PASS, /* type */
459	.name: "remove_symbols", /* name */
460	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
461	.tv_id: TV_NONE, /* tv_id */
462	.properties_required: 0, /* properties_required */
463	.properties_provided: 0, /* properties_provided */
464	.properties_destroyed: 0, /* properties_destroyed */
465	.todo_flags_start: 0, /* todo_flags_start */
466	TODO_remove_functions | TODO_dump_symtab, /* todo_flags_finish */
467	};
468
469	class pass_ipa_remove_symbols : public simple_ipa_opt_pass
470	{
471	public:
472	pass_ipa_remove_symbols (gcc::context *ctxt)
473	: simple_ipa_opt_pass (pass_data_ipa_remove_symbols, ctxt)
474	{}
475
476	/* opt_pass methods: */
477	bool gate (function *) final override
478	{
479	/* Don't bother doing anything if the program has errors. */
480	return (!seen_error () && !in_lto_p);
481	}
482
483	}; // class pass_local_optimization_passes
484
485	} // anon namespace
486
487	simple_ipa_opt_pass *
488	make_pass_build_ssa_passes (gcc::context *ctxt)
489	{
490	return new pass_build_ssa_passes (ctxt);
491	}
492
493	simple_ipa_opt_pass *
494	make_pass_local_optimization_passes (gcc::context *ctxt)
495	{
496	return new pass_local_optimization_passes (ctxt);
497	}
498
499	simple_ipa_opt_pass *
500	make_pass_ipa_remove_symbols (gcc::context *ctxt)
501	{
502	return new pass_ipa_remove_symbols (ctxt);
503	}
504
505	namespace {
506
507	const pass_data pass_data_all_early_optimizations =
508	{
509	.type: GIMPLE_PASS, /* type */
510	.name: "early_optimizations", /* name */
511	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
512	.tv_id: TV_NONE, /* tv_id */
513	.properties_required: 0, /* properties_required */
514	.properties_provided: 0, /* properties_provided */
515	.properties_destroyed: 0, /* properties_destroyed */
516	.todo_flags_start: 0, /* todo_flags_start */
517	.todo_flags_finish: 0, /* todo_flags_finish */
518	};
519
520	class pass_all_early_optimizations : public gimple_opt_pass
521	{
522	public:
523	pass_all_early_optimizations (gcc::context *ctxt)
524	: gimple_opt_pass (pass_data_all_early_optimizations, ctxt)
525	{}
526
527	/* opt_pass methods: */
528	bool gate (function *) final override
529	{
530	return (optimize >= 1
531	/* Don't bother doing anything if the program has errors. */
532	&& !seen_error ());
533	}
534
535	}; // class pass_all_early_optimizations
536
537	} // anon namespace
538
539	static gimple_opt_pass *
540	make_pass_all_early_optimizations (gcc::context *ctxt)
541	{
542	return new pass_all_early_optimizations (ctxt);
543	}
544
545	namespace {
546
547	const pass_data pass_data_all_optimizations =
548	{
549	.type: GIMPLE_PASS, /* type */
550	.name: "*all_optimizations", /* name */
551	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
552	.tv_id: TV_OPTIMIZE, /* tv_id */
553	.properties_required: 0, /* properties_required */
554	.properties_provided: 0, /* properties_provided */
555	.properties_destroyed: 0, /* properties_destroyed */
556	.todo_flags_start: 0, /* todo_flags_start */
557	.todo_flags_finish: 0, /* todo_flags_finish */
558	};
559
560	class pass_all_optimizations : public gimple_opt_pass
561	{
562	public:
563	pass_all_optimizations (gcc::context *ctxt)
564	: gimple_opt_pass (pass_data_all_optimizations, ctxt)
565	{}
566
567	/* opt_pass methods: */
568	bool gate (function *) final override
569	{
570	return optimize >= 1 && !optimize_debug;
571	}
572
573	}; // class pass_all_optimizations
574
575	} // anon namespace
576
577	static gimple_opt_pass *
578	make_pass_all_optimizations (gcc::context *ctxt)
579	{
580	return new pass_all_optimizations (ctxt);
581	}
582
583	namespace {
584
585	const pass_data pass_data_all_optimizations_g =
586	{
587	.type: GIMPLE_PASS, /* type */
588	.name: "*all_optimizations_g", /* name */
589	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
590	.tv_id: TV_OPTIMIZE, /* tv_id */
591	.properties_required: 0, /* properties_required */
592	.properties_provided: 0, /* properties_provided */
593	.properties_destroyed: 0, /* properties_destroyed */
594	.todo_flags_start: 0, /* todo_flags_start */
595	.todo_flags_finish: 0, /* todo_flags_finish */
596	};
597
598	class pass_all_optimizations_g : public gimple_opt_pass
599	{
600	public:
601	pass_all_optimizations_g (gcc::context *ctxt)
602	: gimple_opt_pass (pass_data_all_optimizations_g, ctxt)
603	{}
604
605	/* opt_pass methods: */
606	bool gate (function *) final override
607	{
608	return optimize >= 1 && optimize_debug;
609	}
610
611	}; // class pass_all_optimizations_g
612
613	} // anon namespace
614
615	static gimple_opt_pass *
616	make_pass_all_optimizations_g (gcc::context *ctxt)
617	{
618	return new pass_all_optimizations_g (ctxt);
619	}
620
621	namespace {
622
623	const pass_data pass_data_rest_of_compilation =
624	{
625	.type: RTL_PASS, /* type */
626	.name: "*rest_of_compilation", /* name */
627	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
628	.tv_id: TV_REST_OF_COMPILATION, /* tv_id */
629	PROP_rtl, /* properties_required */
630	.properties_provided: 0, /* properties_provided */
631	.properties_destroyed: 0, /* properties_destroyed */
632	.todo_flags_start: 0, /* todo_flags_start */
633	.todo_flags_finish: 0, /* todo_flags_finish */
634	};
635
636	class pass_rest_of_compilation : public rtl_opt_pass
637	{
638	public:
639	pass_rest_of_compilation (gcc::context *ctxt)
640	: rtl_opt_pass (pass_data_rest_of_compilation, ctxt)
641	{}
642
643	/* opt_pass methods: */
644	bool gate (function *) final override
645	{
646	/* Early return if there were errors. We can run afoul of our
647	consistency checks, and there's not really much point in fixing them. */
648	return !(rtl_dump_and_exit || flag_syntax_only || seen_error ());
649	}
650
651	}; // class pass_rest_of_compilation
652
653	} // anon namespace
654
655	static rtl_opt_pass *
656	make_pass_rest_of_compilation (gcc::context *ctxt)
657	{
658	return new pass_rest_of_compilation (ctxt);
659	}
660
661	namespace {
662
663	const pass_data pass_data_postreload =
664	{
665	.type: RTL_PASS, /* type */
666	.name: "*all-postreload", /* name */
667	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
668	.tv_id: TV_POSTRELOAD, /* tv_id */
669	PROP_rtl, /* properties_required */
670	.properties_provided: 0, /* properties_provided */
671	.properties_destroyed: 0, /* properties_destroyed */
672	.todo_flags_start: 0, /* todo_flags_start */
673	.todo_flags_finish: 0, /* todo_flags_finish */
674	};
675
676	class pass_postreload : public rtl_opt_pass
677	{
678	public:
679	pass_postreload (gcc::context *ctxt)
680	: rtl_opt_pass (pass_data_postreload, ctxt)
681	{}
682
683	/* opt_pass methods: */
684	bool gate (function *) final override { return reload_completed; }
685
686	}; // class pass_postreload
687
688	} // anon namespace
689
690	static rtl_opt_pass *
691	make_pass_postreload (gcc::context *ctxt)
692	{
693	return new pass_postreload (ctxt);
694	}
695
696	namespace {
697
698	const pass_data pass_data_late_compilation =
699	{
700	.type: RTL_PASS, /* type */
701	.name: "*all-late_compilation", /* name */
702	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
703	.tv_id: TV_LATE_COMPILATION, /* tv_id */
704	PROP_rtl, /* properties_required */
705	.properties_provided: 0, /* properties_provided */
706	.properties_destroyed: 0, /* properties_destroyed */
707	.todo_flags_start: 0, /* todo_flags_start */
708	.todo_flags_finish: 0, /* todo_flags_finish */
709	};
710
711	class pass_late_compilation : public rtl_opt_pass
712	{
713	public:
714	pass_late_compilation (gcc::context *ctxt)
715	: rtl_opt_pass (pass_data_late_compilation, ctxt)
716	{}
717
718	/* opt_pass methods: */
719	bool gate (function *) final override
720	{
721	return reload_completed || targetm.no_register_allocation;
722	}
723
724	}; // class pass_late_compilation
725
726	} // anon namespace
727
728	static rtl_opt_pass *
729	make_pass_late_compilation (gcc::context *ctxt)
730	{
731	return new pass_late_compilation (ctxt);
732	}
733
734	/* Pre-SLP scalar cleanup, it has several cleanup passes like FRE, DSE. */
735
736	namespace {
737
738	const pass_data pass_data_pre_slp_scalar_cleanup =
739	{
740	.type: GIMPLE_PASS, /* type */
741	.name: "*pre_slp_scalar_cleanup", /* name */
742	.optinfo_flags: OPTGROUP_LOOP, /* optinfo_flags */
743	.tv_id: TV_SCALAR_CLEANUP, /* tv_id */
744	.properties_required: ( PROP_cfg | PROP_ssa ), /* properties_required */
745	.properties_provided: 0, /* properties_provided */
746	.properties_destroyed: 0, /* properties_destroyed */
747	.todo_flags_start: 0, /* todo_flags_start */
748	.todo_flags_finish: 0, /* todo_flags_finish */
749	};
750
751	class pass_pre_slp_scalar_cleanup : public gimple_opt_pass
752	{
753	public:
754	pass_pre_slp_scalar_cleanup (gcc::context *ctxt)
755	: gimple_opt_pass (pass_data_pre_slp_scalar_cleanup, ctxt)
756	{
757	}
758
759	bool
760	gate (function *fun) final override
761	{
762	return flag_tree_slp_vectorize
763	&& (fun->pending_TODOs & PENDING_TODO_force_next_scalar_cleanup);
764	}
765
766	unsigned int
767	execute (function *fun) final override
768	{
769	fun->pending_TODOs &= ~PENDING_TODO_force_next_scalar_cleanup;
770	return 0;
771	}
772
773	}; // class pass_pre_slp_scalar_cleanup
774
775	} // anon namespace
776
777	gimple_opt_pass *
778	make_pass_pre_slp_scalar_cleanup (gcc::context *ctxt)
779	{
780	return new pass_pre_slp_scalar_cleanup (ctxt);
781	}
782
783	/* Set the static pass number of pass PASS to ID and record that
784	in the mapping from static pass number to pass. */
785
786	void
787	pass_manager::
788	set_pass_for_id (int id, opt_pass *pass)
789	{
790	pass->static_pass_number = id;
791	if (passes_by_id_size <= id)
792	{
793	passes_by_id = XRESIZEVEC (opt_pass *, passes_by_id, id + 1);
794	memset (s: passes_by_id + passes_by_id_size, c: 0,
795	n: (id + 1 - passes_by_id_size) * sizeof (void *));
796	passes_by_id_size = id + 1;
797	}
798	passes_by_id[id] = pass;
799	}
800
801	/* Return the pass with the static pass number ID. */
802
803	opt_pass *
804	pass_manager::get_pass_for_id (int id) const
805	{
806	if (id >= passes_by_id_size)
807	return NULL;
808	return passes_by_id[id];
809	}
810
811	/* Iterate over the pass tree allocating dump file numbers. We want
812	to do this depth first, and independent of whether the pass is
813	enabled or not. */
814
815	void
816	register_one_dump_file (opt_pass *pass)
817	{
818	g->get_passes ()->register_one_dump_file (pass);
819	}
820
821	void
822	pass_manager::register_one_dump_file (opt_pass *pass)
823	{
824	char *dot_name, *flag_name, *glob_name;
825	const char *name, *full_name, *prefix;
826
827	/* Buffer big enough to format a 32-bit UINT_MAX into. */
828	char num[11];
829	dump_kind dkind;
830	int id;
831	optgroup_flags_t optgroup_flags = OPTGROUP_NONE;
832	gcc::dump_manager *dumps = m_ctxt->get_dumps ();
833
834	/* See below in next_pass_1. */
835	num[0] = '\0';
836	if (pass->static_pass_number != -1)
837	sprintf (s: num, format: "%u", ((int) pass->static_pass_number < 0
838	? 1 : pass->static_pass_number));
839
840	/* The name is both used to identify the pass for the purposes of plugins,
841	and to specify dump file name and option.
842	The latter two might want something short which is not quite unique; for
843	that reason, we may have a disambiguating prefix, followed by a space
844	to mark the start of the following dump file name / option string. */
845	name = strchr (s: pass->name, c: ' ');
846	name = name ? name + 1 : pass->name;
847	dot_name = concat (".", name, num, NULL);
848	if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
849	{
850	prefix = "ipa-";
851	dkind = DK_ipa;
852	optgroup_flags |= OPTGROUP_IPA;
853	}
854	else if (pass->type == GIMPLE_PASS)
855	{
856	prefix = "tree-";
857	dkind = DK_tree;
858	}
859	else
860	{
861	prefix = "rtl-";
862	dkind = DK_rtl;
863	}
864
865	flag_name = concat (prefix, name, num, NULL);
866	glob_name = concat (prefix, name, NULL);
867	optgroup_flags |= pass->optinfo_flags;
868	/* For any passes that do not have an optgroup set, and which are not
869	IPA passes setup above, set the optgroup to OPTGROUP_OTHER so that
870	any dump messages are emitted properly under -fopt-info(-optall). */
871	if (optgroup_flags == OPTGROUP_NONE)
872	optgroup_flags = OPTGROUP_OTHER;
873	id = dumps->dump_register (suffix: dot_name, swtch: flag_name, glob: glob_name, dkind,
874	optgroup_flags,
875	take_ownership: true);
876	set_pass_for_id (id, pass);
877	full_name = concat (prefix, pass->name, num, NULL);
878	register_pass_name (pass, name: full_name);
879	free (CONST_CAST (char *, full_name));
880	}
881
882	/* Register the dump files for the pass_manager starting at PASS. */
883
884	void
885	pass_manager::register_dump_files (opt_pass *pass)
886	{
887	do
888	{
889	if (pass->name && pass->name[0] != '*')
890	register_one_dump_file (pass);
891
892	if (pass->sub)
893	register_dump_files (pass: pass->sub);
894
895	pass = pass->next;
896	}
897	while (pass);
898	}
899
900	/* Register PASS with NAME. */
901
902	void
903	pass_manager::register_pass_name (opt_pass *pass, const char *name)
904	{
905	if (!m_name_to_pass_map)
906	m_name_to_pass_map = new hash_map<free_string_hash, opt_pass *> (256);
907
908	if (m_name_to_pass_map->get (k: name))
909	return; /* Ignore plugin passes. */
910
911	const char *unique_name = xstrdup (name);
912	m_name_to_pass_map->put (k: unique_name, v: pass);
913	}
914
915	/* Map from pass id to canonicalized pass name. */
916
917	typedef const char *char_ptr;
918	static vec<char_ptr> pass_tab;
919
920	/* Callback function for traversing NAME_TO_PASS_MAP. */
921
922	bool
923	passes_pass_traverse (const char *const &name, opt_pass *const &pass, void *)
924	{
925	gcc_assert (pass->static_pass_number > 0);
926	gcc_assert (pass_tab.exists ());
927
928	pass_tab[pass->static_pass_number] = name;
929
930	return 1;
931	}
932
933	/* The function traverses NAME_TO_PASS_MAP and creates a pass info
934	table for dumping purpose. */
935
936	void
937	pass_manager::create_pass_tab (void) const
938	{
939	if (!flag_dump_passes)
940	return;
941
942	pass_tab.safe_grow_cleared (len: passes_by_id_size + 1, exact: true);
943	m_name_to_pass_map->traverse <void *, passes_pass_traverse> (NULL);
944	}
945
946	static bool override_gate_status (opt_pass *, tree, bool);
947
948	/* Dump the instantiated name for PASS. IS_ON indicates if PASS
949	is turned on or not. */
950
951	static void
952	dump_one_pass (opt_pass *pass, int pass_indent)
953	{
954	int indent = 3 * pass_indent;
955	const char *pn;
956	bool is_on, is_really_on;
957
958	is_on = pass->gate (cfun);
959	is_really_on = override_gate_status (pass, current_function_decl, is_on);
960
961	if (pass->static_pass_number <= 0)
962	pn = pass->name;
963	else
964	pn = pass_tab[pass->static_pass_number];
965
966	fprintf (stderr, format: "%*s%-40s%*s:%s%s\n", indent, " ", pn,
967	(15 - indent < 0 ? 0 : 15 - indent), " ",
968	is_on ? " ON" : " OFF",
969	((!is_on) == (!is_really_on) ? ""
970	: (is_really_on ? " (FORCED_ON)" : " (FORCED_OFF)")));
971	}
972
973	/* Dump pass list PASS with indentation INDENT. */
974
975	static void
976	dump_pass_list (opt_pass *pass, int indent)
977	{
978	do
979	{
980	dump_one_pass (pass, pass_indent: indent);
981	if (pass->sub)
982	dump_pass_list (pass: pass->sub, indent: indent + 1);
983	pass = pass->next;
984	}
985	while (pass);
986	}
987
988	/* Dump all optimization passes. */
989
990	void
991	dump_passes (void)
992	{
993	g->get_passes ()->dump_passes ();
994	}
995
996	void
997	pass_manager::dump_passes () const
998	{
999	push_dummy_function (true);
1000	cgraph_node *node = cgraph_node::get_create (current_function_decl);
1001
1002	create_pass_tab ();
1003
1004	dump_pass_list (pass: all_lowering_passes, indent: 1);
1005	dump_pass_list (pass: all_small_ipa_passes, indent: 1);
1006	dump_pass_list (pass: all_regular_ipa_passes, indent: 1);
1007	dump_pass_list (pass: all_late_ipa_passes, indent: 1);
1008	dump_pass_list (pass: all_passes, indent: 1);
1009
1010	node->remove ();
1011	pop_dummy_function ();
1012	}
1013
1014	/* Returns the pass with NAME. */
1015
1016	opt_pass *
1017	pass_manager::get_pass_by_name (const char *name)
1018	{
1019	opt_pass **p = m_name_to_pass_map->get (k: name);
1020	if (p)
1021	return *p;
1022
1023	return NULL;
1024	}
1025
1026
1027	/* Range [start, last]. */
1028
1029	struct uid_range
1030	{
1031	unsigned int start;
1032	unsigned int last;
1033	const char *assem_name;
1034	struct uid_range *next;
1035	};
1036
1037	typedef struct uid_range *uid_range_p;
1038
1039
1040	static vec<uid_range_p> enabled_pass_uid_range_tab;
1041	static vec<uid_range_p> disabled_pass_uid_range_tab;
1042
1043
1044	/* Parse option string for -fdisable- and -fenable-
1045	The syntax of the options:
1046
1047	-fenable-<pass_name>
1048	-fdisable-<pass_name>
1049
1050	-fenable-<pass_name>=s1:e1,s2:e2,...
1051	-fdisable-<pass_name>=s1:e1,s2:e2,...
1052	*/
1053
1054	static void
1055	enable_disable_pass (const char *arg, bool is_enable)
1056	{
1057	opt_pass *pass;
1058	char *range_str, *phase_name;
1059	char *argstr = xstrdup (arg);
1060	vec<uid_range_p> *tab = 0;
1061
1062	range_str = strchr (s: argstr,c: '=');
1063	if (range_str)
1064	{
1065	*range_str = '\0';
1066	range_str++;
1067	}
1068
1069	phase_name = argstr;
1070	if (!*phase_name)
1071	{
1072	if (is_enable)
1073	error ("unrecognized option %<-fenable%>");
1074	else
1075	error ("unrecognized option %<-fdisable%>");
1076	free (ptr: argstr);
1077	return;
1078	}
1079	pass = g->get_passes ()->get_pass_by_name (name: phase_name);
1080	if (!pass || pass->static_pass_number == -1)
1081	{
1082	if (is_enable)
1083	error ("unknown pass %s specified in %<-fenable%>", phase_name);
1084	else
1085	error ("unknown pass %s specified in %<-fdisable%>", phase_name);
1086	free (ptr: argstr);
1087	return;
1088	}
1089
1090	if (is_enable)
1091	tab = &enabled_pass_uid_range_tab;
1092	else
1093	tab = &disabled_pass_uid_range_tab;
1094
1095	if ((unsigned) pass->static_pass_number >= tab->length ())
1096	tab->safe_grow_cleared (len: pass->static_pass_number + 1, exact: true);
1097
1098	if (!range_str)
1099	{
1100	uid_range_p slot;
1101	uid_range_p new_range = XCNEW (struct uid_range);
1102
1103	new_range->start = 0;
1104	new_range->last = (unsigned)-1;
1105
1106	slot = (*tab)[pass->static_pass_number];
1107	new_range->next = slot;
1108	(*tab)[pass->static_pass_number] = new_range;
1109	if (is_enable)
1110	inform (UNKNOWN_LOCATION, "enable pass %s for functions in the range "
1111	"of [%u, %u]", phase_name, new_range->start, new_range->last);
1112	else
1113	inform (UNKNOWN_LOCATION, "disable pass %s for functions in the range "
1114	"of [%u, %u]", phase_name, new_range->start, new_range->last);
1115	}
1116	else
1117	{
1118	char *next_range = NULL;
1119	char *one_range = range_str;
1120	char *end_val = NULL;
1121
1122	do
1123	{
1124	uid_range_p slot;
1125	uid_range_p new_range;
1126	char *invalid = NULL;
1127	long start;
1128	char *func_name = NULL;
1129
1130	next_range = strchr (s: one_range, c: ',');
1131	if (next_range)
1132	{
1133	*next_range = '\0';
1134	next_range++;
1135	}
1136
1137	end_val = strchr (s: one_range, c: ':');
1138	if (end_val)
1139	{
1140	*end_val = '\0';
1141	end_val++;
1142	}
1143	start = strtol (nptr: one_range, endptr: &invalid, base: 10);
1144	if (*invalid || start < 0)
1145	{
1146	if (end_val || (one_range[0] >= '0'
1147	&& one_range[0] <= '9'))
1148	{
1149	error ("Invalid range %s in option %s",
1150	one_range,
1151	is_enable ? "-fenable" : "-fdisable");
1152	free (ptr: argstr);
1153	return;
1154	}
1155	func_name = one_range;
1156	}
1157	if (!end_val)
1158	{
1159	new_range = XCNEW (struct uid_range);
1160	if (!func_name)
1161	{
1162	new_range->start = (unsigned) start;
1163	new_range->last = (unsigned) start;
1164	}
1165	else
1166	{
1167	new_range->start = (unsigned) -1;
1168	new_range->last = (unsigned) -1;
1169	new_range->assem_name = xstrdup (func_name);
1170	}
1171	}
1172	else
1173	{
1174	long last = strtol (nptr: end_val, endptr: &invalid, base: 10);
1175	if (*invalid || last < start)
1176	{
1177	error ("Invalid range %s in option %s",
1178	end_val,
1179	is_enable ? "-fenable" : "-fdisable");
1180	free (ptr: argstr);
1181	return;
1182	}
1183	new_range = XCNEW (struct uid_range);
1184	new_range->start = (unsigned) start;
1185	new_range->last = (unsigned) last;
1186	}
1187
1188	slot = (*tab)[pass->static_pass_number];
1189	new_range->next = slot;
1190	(*tab)[pass->static_pass_number] = new_range;
1191	if (is_enable)
1192	{
1193	if (new_range->assem_name)
1194	inform (UNKNOWN_LOCATION,
1195	"enable pass %s for function %s",
1196	phase_name, new_range->assem_name);
1197	else
1198	inform (UNKNOWN_LOCATION,
1199	"enable pass %s for functions in the range of [%u, %u]",
1200	phase_name, new_range->start, new_range->last);
1201	}
1202	else
1203	{
1204	if (new_range->assem_name)
1205	inform (UNKNOWN_LOCATION,
1206	"disable pass %s for function %s",
1207	phase_name, new_range->assem_name);
1208	else
1209	inform (UNKNOWN_LOCATION,
1210	"disable pass %s for functions in the range of [%u, %u]",
1211	phase_name, new_range->start, new_range->last);
1212	}
1213
1214	one_range = next_range;
1215	} while (next_range);
1216	}
1217
1218	free (ptr: argstr);
1219	}
1220
1221	/* Enable pass specified by ARG. */
1222
1223	void
1224	enable_pass (const char *arg)
1225	{
1226	enable_disable_pass (arg, is_enable: true);
1227	}
1228
1229	/* Disable pass specified by ARG. */
1230
1231	void
1232	disable_pass (const char *arg)
1233	{
1234	enable_disable_pass (arg, is_enable: false);
1235	}
1236
1237	/* Returns true if PASS is explicitly enabled/disabled for FUNC. */
1238
1239	static bool
1240	is_pass_explicitly_enabled_or_disabled (opt_pass *pass,
1241	tree func,
1242	vec<uid_range_p> tab)
1243	{
1244	uid_range_p slot, range;
1245	int cgraph_uid;
1246	const char *aname = NULL;
1247
1248	if (!tab.exists ()
1249	|| (unsigned) pass->static_pass_number >= tab.length ()
1250	|| pass->static_pass_number == -1)
1251	return false;
1252
1253	slot = tab[pass->static_pass_number];
1254	if (!slot)
1255	return false;
1256
1257	cgraph_uid = func ? cgraph_node::get (decl: func)->get_uid () : 0;
1258	if (func && DECL_ASSEMBLER_NAME_SET_P (func))
1259	aname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func));
1260
1261	range = slot;
1262	while (range)
1263	{
1264	if ((unsigned) cgraph_uid >= range->start
1265	&& (unsigned) cgraph_uid <= range->last)
1266	return true;
1267	if (range->assem_name && aname
1268	&& !strcmp (s1: range->assem_name, s2: aname))
1269	return true;
1270	range = range->next;
1271	}
1272
1273	return false;
1274	}
1275
1276
1277	/* Update static_pass_number for passes (and the flag
1278	TODO_mark_first_instance).
1279
1280	Passes are constructed with static_pass_number preinitialized to 0
1281
1282	This field is used in two different ways: initially as instance numbers
1283	of their kind, and then as ids within the entire pass manager.
1284
1285	Within pass_manager::pass_manager:
1286
1287	* In add_pass_instance(), as called by next_pass_1 in
1288	NEXT_PASS in init_optimization_passes
1289
1290	* When the initial instance of a pass within a pass manager is seen,
1291	it is flagged, and its static_pass_number is set to -1
1292
1293	* On subsequent times that it is seen, the static pass number
1294	is decremented each time, so that if there are e.g. 4 dups,
1295	they have static_pass_number -4, 2, 3, 4 respectively (note
1296	how the initial one is negative and gives the count); these
1297	can be thought of as instance numbers of the specific pass
1298
1299	* Within the register_dump_files () traversal, set_pass_for_id()
1300	is called on each pass, using these instance numbers to create
1301	dumpfile switches, and then overwriting them with a pass id,
1302	which are global to the whole pass manager (based on
1303	(TDI_end + current value of extra_dump_files_in_use) ) */
1304
1305	static void
1306	add_pass_instance (opt_pass *new_pass, bool track_duplicates,
1307	opt_pass *initial_pass)
1308	{
1309	/* Are we dealing with the first pass of its kind, or a clone? */
1310	if (new_pass != initial_pass)
1311	{
1312	/* We're dealing with a clone. */
1313	new_pass->todo_flags_start &= ~TODO_mark_first_instance;
1314
1315	/* Indicate to register_dump_files that this pass has duplicates,
1316	and so it should rename the dump file. The first instance will
1317	be -1, and be number of duplicates = -static_pass_number - 1.
1318	Subsequent instances will be > 0 and just the duplicate number. */
1319	if ((new_pass->name && new_pass->name[0] != '*') || track_duplicates)
1320	{
1321	initial_pass->static_pass_number -= 1;
1322	new_pass->static_pass_number = -initial_pass->static_pass_number;
1323	}
1324	}
1325	else
1326	{
1327	/* We're dealing with the first pass of its kind. */
1328	new_pass->todo_flags_start |= TODO_mark_first_instance;
1329	new_pass->static_pass_number = -1;
1330
1331	invoke_plugin_callbacks (event: PLUGIN_NEW_PASS, gcc_data: new_pass);
1332	}
1333	}
1334
1335	/* Add a pass to the pass list. Duplicate the pass if it's already
1336	in the list. */
1337
1338	static opt_pass **
1339	next_pass_1 (opt_pass **list, opt_pass *pass, opt_pass *initial_pass)
1340	{
1341	/* Every pass should have a name so that plugins can refer to them. */
1342	gcc_assert (pass->name != NULL);
1343
1344	add_pass_instance (new_pass: pass, track_duplicates: false, initial_pass);
1345	*list = pass;
1346
1347	return &(*list)->next;
1348	}
1349
1350	/* List node for an inserted pass instance. We need to keep track of all
1351	the newly-added pass instances (with 'added_pass_nodes' defined below)
1352	so that we can register their dump files after pass-positioning is finished.
1353	Registering dumping files needs to be post-processed or the
1354	static_pass_number of the opt_pass object would be modified and mess up
1355	the dump file names of future pass instances to be added. */
1356
1357	struct pass_list_node
1358	{
1359	opt_pass *pass;
1360	struct pass_list_node *next;
1361	};
1362
1363	static struct pass_list_node *added_pass_nodes = NULL;
1364	static struct pass_list_node *prev_added_pass_node;
1365
1366	/* Insert the pass at the proper position. Return true if the pass
1367	is successfully added.
1368
1369	NEW_PASS_INFO - new pass to be inserted
1370	PASS_LIST - root of the pass list to insert the new pass to */
1371
1372	static bool
1373	position_pass (struct register_pass_info *new_pass_info, opt_pass **pass_list)
1374	{
1375	opt_pass *pass = *pass_list, *prev_pass = NULL;
1376	bool success = false;
1377
1378	for ( ; pass; prev_pass = pass, pass = pass->next)
1379	{
1380	/* Check if the current pass is of the same type as the new pass and
1381	matches the name and the instance number of the reference pass. */
1382	if (pass->type == new_pass_info->pass->type
1383	&& pass->name
1384	&& !strcmp (s1: pass->name, s2: new_pass_info->reference_pass_name)
1385	&& ((new_pass_info->ref_pass_instance_number == 0)
1386	|| (new_pass_info->ref_pass_instance_number ==
1387	pass->static_pass_number)
1388	|| (new_pass_info->ref_pass_instance_number == 1
1389	&& pass->todo_flags_start & TODO_mark_first_instance)))
1390	{
1391	opt_pass *new_pass;
1392	struct pass_list_node *new_pass_node;
1393
1394	if (new_pass_info->ref_pass_instance_number == 0)
1395	{
1396	new_pass = new_pass_info->pass->clone ();
1397	add_pass_instance (new_pass, track_duplicates: true, initial_pass: new_pass_info->pass);
1398	}
1399	else
1400	{
1401	new_pass = new_pass_info->pass;
1402	add_pass_instance (new_pass, track_duplicates: true, initial_pass: new_pass);
1403	}
1404
1405	/* Insert the new pass instance based on the positioning op. */
1406	switch (new_pass_info->pos_op)
1407	{
1408	case PASS_POS_INSERT_AFTER:
1409	new_pass->next = pass->next;
1410	pass->next = new_pass;
1411
1412	/* Skip newly inserted pass to avoid repeated
1413	insertions in the case where the new pass and the
1414	existing one have the same name. */
1415	pass = new_pass;
1416	break;
1417	case PASS_POS_INSERT_BEFORE:
1418	new_pass->next = pass;
1419	if (prev_pass)
1420	prev_pass->next = new_pass;
1421	else
1422	*pass_list = new_pass;
1423	break;
1424	case PASS_POS_REPLACE:
1425	new_pass->next = pass->next;
1426	if (prev_pass)
1427	prev_pass->next = new_pass;
1428	else
1429	*pass_list = new_pass;
1430	new_pass->sub = pass->sub;
1431	new_pass->tv_id = pass->tv_id;
1432	pass = new_pass;
1433	break;
1434	default:
1435	error ("invalid pass positioning operation");
1436	return false;
1437	}
1438
1439	/* Save the newly added pass (instance) in the added_pass_nodes
1440	list so that we can register its dump file later. Note that
1441	we cannot register the dump file now because doing so will modify
1442	the static_pass_number of the opt_pass object and therefore
1443	mess up the dump file name of future instances. */
1444	new_pass_node = XCNEW (struct pass_list_node);
1445	new_pass_node->pass = new_pass;
1446	if (!added_pass_nodes)
1447	added_pass_nodes = new_pass_node;
1448	else
1449	prev_added_pass_node->next = new_pass_node;
1450	prev_added_pass_node = new_pass_node;
1451
1452	success = true;
1453	}
1454
1455	if (pass->sub && position_pass (new_pass_info, pass_list: &pass->sub))
1456	success = true;
1457	}
1458
1459	return success;
1460	}
1461
1462	/* Hooks a new pass into the pass lists.
1463
1464	PASS_INFO - pass information that specifies the opt_pass object,
1465	reference pass, instance number, and how to position
1466	the pass */
1467
1468	void
1469	register_pass (struct register_pass_info *pass_info)
1470	{
1471	g->get_passes ()->register_pass (pass_info);
1472	}
1473
1474	void
1475	register_pass (opt_pass* pass, pass_positioning_ops pos,
1476	const char* ref_pass_name, int ref_pass_inst_number)
1477	{
1478	register_pass_info i;
1479	i.pass = pass;
1480	i.reference_pass_name = ref_pass_name;
1481	i.ref_pass_instance_number = ref_pass_inst_number;
1482	i.pos_op = pos;
1483
1484	g->get_passes ()->register_pass (pass_info: &i);
1485	}
1486
1487	void
1488	pass_manager::register_pass (struct register_pass_info *pass_info)
1489	{
1490	bool all_instances, success;
1491
1492	/* The checks below could fail in buggy plugins. Existing GCC
1493	passes should never fail these checks, so we mention plugin in
1494	the messages. */
1495	if (!pass_info->pass)
1496	fatal_error (input_location, "plugin cannot register a missing pass");
1497
1498	if (!pass_info->pass->name)
1499	fatal_error (input_location, "plugin cannot register an unnamed pass");
1500
1501	if (!pass_info->reference_pass_name)
1502	fatal_error
1503	(input_location,
1504	"plugin cannot register pass %qs without reference pass name",
1505	pass_info->pass->name);
1506
1507	/* Try to insert the new pass to the pass lists. We need to check
1508	all five lists as the reference pass could be in one (or all) of
1509	them. */
1510	all_instances = pass_info->ref_pass_instance_number == 0;
1511	success = position_pass (new_pass_info: pass_info, pass_list: &all_lowering_passes);
1512	if (!success || all_instances)
1513	success |= position_pass (new_pass_info: pass_info, pass_list: &all_small_ipa_passes);
1514	if (!success || all_instances)
1515	success |= position_pass (new_pass_info: pass_info, pass_list: &all_regular_ipa_passes);
1516	if (!success || all_instances)
1517	success |= position_pass (new_pass_info: pass_info, pass_list: &all_late_ipa_passes);
1518	if (!success || all_instances)
1519	success |= position_pass (new_pass_info: pass_info, pass_list: &all_passes);
1520	if (!success)
1521	fatal_error
1522	(input_location,
1523	"pass %qs not found but is referenced by new pass %qs",
1524	pass_info->reference_pass_name, pass_info->pass->name);
1525
1526	/* OK, we have successfully inserted the new pass. We need to register
1527	the dump files for the newly added pass and its duplicates (if any).
1528	While doing so, we also delete the pass_list_node
1529	objects created during pass positioning. */
1530	gcc::dump_manager *dumps = m_ctxt->get_dumps ();
1531	while (added_pass_nodes)
1532	{
1533	struct pass_list_node *next_node = added_pass_nodes->next;
1534
1535	/* Handle -fdump-* and -fopt-info. */
1536	dumps->register_pass (pass: added_pass_nodes->pass);
1537
1538	XDELETE (added_pass_nodes);
1539	added_pass_nodes = next_node;
1540	}
1541	}
1542
1543	/* Construct the pass tree. The sequencing of passes is driven by
1544	the cgraph routines:
1545
1546	finalize_compilation_unit ()
1547	for each node N in the cgraph
1548	cgraph_analyze_function (N)
1549	cgraph_lower_function (N) -> all_lowering_passes
1550
1551	If we are optimizing, compile is then invoked:
1552
1553	compile ()
1554	ipa_passes () -> all_small_ipa_passes
1555	-> Analysis of all_regular_ipa_passes
1556	* possible LTO streaming at compilation time *
1557	-> Execution of all_regular_ipa_passes
1558	* possible LTO streaming at link time *
1559	-> all_late_ipa_passes
1560	expand_all_functions ()
1561	for each node N in the cgraph
1562	expand_function (N) -> Transformation of all_regular_ipa_passes
1563	-> all_passes
1564	*/
1565
1566	pass_manager::pass_manager (context *ctxt)
1567	: all_passes (NULL), all_small_ipa_passes (NULL), all_lowering_passes (NULL),
1568	all_regular_ipa_passes (NULL),
1569	all_late_ipa_passes (NULL), passes_by_id (NULL), passes_by_id_size (0),
1570	m_ctxt (ctxt), m_name_to_pass_map (NULL)
1571	{
1572	opt_pass **p;
1573
1574	/* Zero-initialize pass members. */
1575	#define INSERT_PASSES_AFTER(PASS)
1576	#define PUSH_INSERT_PASSES_WITHIN(PASS)
1577	#define POP_INSERT_PASSES()
1578	#define NEXT_PASS(PASS, NUM) PASS ## _ ## NUM = NULL
1579	#define NEXT_PASS_WITH_ARG(PASS, NUM, ARG) NEXT_PASS (PASS, NUM)
1580	#define TERMINATE_PASS_LIST(PASS)
1581	#include "pass-instances.def"
1582	#undef INSERT_PASSES_AFTER
1583	#undef PUSH_INSERT_PASSES_WITHIN
1584	#undef POP_INSERT_PASSES
1585	#undef NEXT_PASS
1586	#undef NEXT_PASS_WITH_ARG
1587	#undef TERMINATE_PASS_LIST
1588
1589	/* Initialize the pass_lists array. */
1590	#define DEF_PASS_LIST(LIST) pass_lists[PASS_LIST_NO_##LIST] = &LIST;
1591	GCC_PASS_LISTS
1592	#undef DEF_PASS_LIST
1593
1594	/* Build the tree of passes. */
1595
1596	#define INSERT_PASSES_AFTER(PASS) \
1597	{ \
1598	opt_pass **p_start; \
1599	p_start = p = &(PASS);
1600
1601	#define TERMINATE_PASS_LIST(PASS) \
1602	gcc_assert (p_start == &PASS); \
1603	*p = NULL; \
1604	}
1605
1606	#define PUSH_INSERT_PASSES_WITHIN(PASS) \
1607	{ \
1608	opt_pass **p = &(PASS ## _1)->sub;
1609
1610	#define POP_INSERT_PASSES() \
1611	}
1612
1613	#define NEXT_PASS(PASS, NUM) \
1614	do { \
1615	gcc_assert (PASS ## _ ## NUM == NULL); \
1616	if ((NUM) == 1) \
1617	PASS ## _1 = make_##PASS (m_ctxt); \
1618	else \
1619	{ \
1620	gcc_assert (PASS ## _1); \
1621	PASS ## _ ## NUM = PASS ## _1->clone (); \
1622	} \
1623	p = next_pass_1 (p, PASS ## _ ## NUM, PASS ## _1); \
1624	} while (0)
1625
1626	#define NEXT_PASS_WITH_ARG(PASS, NUM, ARG) \
1627	do { \
1628	NEXT_PASS (PASS, NUM); \
1629	PASS ## _ ## NUM->set_pass_param (0, ARG); \
1630	} while (0)
1631
1632	#include "pass-instances.def"
1633
1634	#undef INSERT_PASSES_AFTER
1635	#undef PUSH_INSERT_PASSES_WITHIN
1636	#undef POP_INSERT_PASSES
1637	#undef NEXT_PASS
1638	#undef NEXT_PASS_WITH_ARG
1639	#undef TERMINATE_PASS_LIST
1640
1641	/* Register the passes with the tree dump code. */
1642	register_dump_files (pass: all_lowering_passes);
1643	register_dump_files (pass: all_small_ipa_passes);
1644	register_dump_files (pass: all_regular_ipa_passes);
1645	register_dump_files (pass: all_late_ipa_passes);
1646	register_dump_files (pass: all_passes);
1647	}
1648
1649	static void
1650	delete_pass_tree (opt_pass *pass)
1651	{
1652	while (pass)
1653	{
1654	/* Recurse into child passes. */
1655	delete_pass_tree (pass: pass->sub);
1656
1657	opt_pass *next = pass->next;
1658
1659	/* Delete this pass. */
1660	delete pass;
1661
1662	/* Iterate onto sibling passes. */
1663	pass = next;
1664	}
1665	}
1666
1667	pass_manager::~pass_manager ()
1668	{
1669	XDELETEVEC (passes_by_id);
1670
1671	/* Call delete_pass_tree on each of the pass_lists. */
1672	#define DEF_PASS_LIST(LIST) \
1673	delete_pass_tree (*pass_lists[PASS_LIST_NO_##LIST]);
1674	GCC_PASS_LISTS
1675	#undef DEF_PASS_LIST
1676
1677	delete m_name_to_pass_map;
1678	}
1679
1680	/* If we are in IPA mode (i.e., current_function_decl is NULL), call
1681	function CALLBACK for every function in the call graph. Otherwise,
1682	call CALLBACK on the current function. */
1683
1684	static void
1685	do_per_function (void (*callback) (function *, void *data), void *data)
1686	{
1687	if (current_function_decl)
1688	callback (cfun, data);
1689	else
1690	{
1691	struct cgraph_node *node;
1692	FOR_EACH_DEFINED_FUNCTION (node)
1693	if (node->analyzed && (gimple_has_body_p (node->decl) && !in_lto_p)
1694	&& (!node->clone_of || node->decl != node->clone_of->decl))
1695	callback (DECL_STRUCT_FUNCTION (node->decl), data);
1696	}
1697	}
1698
1699	/* Hook called when NODE is removed and therefore should be
1700	excluded from order vector. DATA is a hash set with removed nodes. */
1701
1702	static void
1703	remove_cgraph_node_from_order (cgraph_node *node, void *data)
1704	{
1705	hash_set<cgraph_node *> *removed_nodes = (hash_set<cgraph_node *> *)data;
1706	removed_nodes->add (k: node);
1707	}
1708
1709	/* Hook called when NODE is insert and therefore should be
1710	excluded from removed_nodes. DATA is a hash set with removed nodes. */
1711
1712	static void
1713	insert_cgraph_node_to_order (cgraph_node *node, void *data)
1714	{
1715	hash_set<cgraph_node *> *removed_nodes = (hash_set<cgraph_node *> *)data;
1716	removed_nodes->remove (k: node);
1717	}
1718
1719	/* Hook called when NODE is duplicated and therefore should be
1720	excluded from removed_nodes. DATA is a hash set with removed nodes. */
1721
1722	static void
1723	duplicate_cgraph_node_to_order (cgraph_node *node, cgraph_node *node2,
1724	void *data)
1725	{
1726	hash_set<cgraph_node *> *removed_nodes = (hash_set<cgraph_node *> *)data;
1727	gcc_checking_assert (!removed_nodes->contains (node));
1728	removed_nodes->remove (k: node2);
1729	}
1730
1731
1732	/* If we are in IPA mode (i.e., current_function_decl is NULL), call
1733	function CALLBACK for every function in the call graph. Otherwise,
1734	call CALLBACK on the current function.
1735	This function is global so that plugins can use it. */
1736	void
1737	do_per_function_toporder (void (*callback) (function *, void *data), void *data)
1738	{
1739	int i;
1740
1741	if (current_function_decl)
1742	callback (cfun, data);
1743	else
1744	{
1745	hash_set<cgraph_node *> removed_nodes;
1746	unsigned nnodes = symtab->cgraph_count;
1747	cgraph_node **order = XNEWVEC (cgraph_node *, nnodes);
1748
1749	nnodes = ipa_reverse_postorder (order);
1750	for (i = nnodes - 1; i >= 0; i--)
1751	order[i]->process = 1;
1752	cgraph_node_hook_list *removal_hook
1753	= symtab->add_cgraph_removal_hook (hook: remove_cgraph_node_from_order,
1754	data: &removed_nodes);
1755	cgraph_node_hook_list *insertion_hook
1756	= symtab->add_cgraph_insertion_hook (hook: insert_cgraph_node_to_order,
1757	data: &removed_nodes);
1758	cgraph_2node_hook_list *duplication_hook
1759	= symtab->add_cgraph_duplication_hook (hook: duplicate_cgraph_node_to_order,
1760	data: &removed_nodes);
1761	for (i = nnodes - 1; i >= 0; i--)
1762	{
1763	cgraph_node *node = order[i];
1764
1765	/* Function could be inlined and removed as unreachable. */
1766	if (node == NULL || removed_nodes.contains (k: node))
1767	continue;
1768
1769	node->process = 0;
1770	if (node->has_gimple_body_p ())
1771	{
1772	struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
1773	push_cfun (new_cfun: fn);
1774	callback (fn, data);
1775	pop_cfun ();
1776	}
1777	}
1778	symtab->remove_cgraph_removal_hook (entry: removal_hook);
1779	symtab->remove_cgraph_insertion_hook (entry: insertion_hook);
1780	symtab->remove_cgraph_duplication_hook (entry: duplication_hook);
1781
1782	free (ptr: order);
1783	}
1784	}
1785
1786	/* Helper function to perform function body dump. */
1787
1788	static void
1789	execute_function_dump (function *fn, void *data)
1790	{
1791	opt_pass *pass = (opt_pass *)data;
1792
1793	if (dump_file)
1794	{
1795	push_cfun (new_cfun: fn);
1796
1797	if (fn->curr_properties & PROP_gimple)
1798	dump_function_to_file (fn->decl, dump_file, dump_flags);
1799	else
1800	print_rtl_with_bb (dump_file, get_insns (), dump_flags);
1801
1802	/* Flush the file. If verification fails, we won't be able to
1803	close the file before aborting. */
1804	fflush (stream: dump_file);
1805
1806	if ((fn->curr_properties & PROP_cfg)
1807	&& (dump_flags & TDF_GRAPH))
1808	{
1809	gcc::dump_manager *dumps = g->get_dumps ();
1810	struct dump_file_info *dfi
1811	= dumps->get_dump_file_info (phase: pass->static_pass_number);
1812	if (!dfi->graph_dump_initialized)
1813	{
1814	clean_graph_dump_file (dump_file_name);
1815	dfi->graph_dump_initialized = true;
1816	}
1817	print_graph_cfg (dump_file_name, fn);
1818	}
1819
1820	pop_cfun ();
1821	}
1822	}
1823
1824	/* This function is called when an internal compiler error is encountered.
1825	Ensure that function dump is made available before compiler is aborted. */
1826
1827	void
1828	emergency_dump_function ()
1829	{
1830	if (!current_pass)
1831	return;
1832	enum opt_pass_type pt = current_pass->type;
1833	fnotice (stderr, "during %s pass: %s\n",
1834	pt == GIMPLE_PASS ? "GIMPLE" : pt == RTL_PASS ? "RTL" : "IPA",
1835	current_pass->name);
1836	if (!dump_file || !cfun)
1837	return;
1838	fnotice (stderr, "dump file: %s\n", dump_file_name);
1839	fprintf (stream: dump_file, format: "\n\n\nEMERGENCY DUMP:\n\n");
1840	execute_function_dump (cfun, data: current_pass);
1841
1842	/* Normally the passmanager will close the graphs as a pass could be wanting
1843	to print multiple digraphs. But during an emergency dump there can only be
1844	one and we must finish the graph manually. */
1845	if ((cfun->curr_properties & PROP_cfg)
1846	&& (dump_flags & TDF_GRAPH))
1847	finish_graph_dump_file (dump_file_name);
1848
1849	if (symtab && current_pass->type == IPA_PASS)
1850	symtab->dump (f: dump_file);
1851	}
1852
1853	static struct profile_record *profile_record;
1854
1855	/* Do profile consistency book-keeping for the pass with static number INDEX.
1856	RUN is true if the pass really runs, or FALSE
1857	if we are only book-keeping on passes that may have selectively disabled
1858	themselves on a given function. */
1859
1860	static void
1861	check_profile_consistency (int index, bool run)
1862	{
1863	pass_manager *passes = g->get_passes ();
1864	if (index == -1)
1865	return;
1866	if (!profile_record)
1867	profile_record = XCNEWVEC (struct profile_record,
1868	passes->passes_by_id_size);
1869	gcc_assert (index < passes->passes_by_id_size && index >= 0);
1870	profile_record[index].run |= run;
1871	profile_record_check_consistency (&profile_record[index]);
1872	}
1873
1874	/* Account profile the pass with static number INDEX.
1875	RUN is true if the pass really runs, or FALSE
1876	if we are only book-keeping on passes that may have selectively disabled
1877	themselves on a given function. */
1878
1879	static void
1880	account_profile (int index, bool run)
1881	{
1882	pass_manager *passes = g->get_passes ();
1883	if (index == -1)
1884	return;
1885	if (!profile_record)
1886	profile_record = XCNEWVEC (struct profile_record,
1887	passes->passes_by_id_size);
1888	gcc_assert (index < passes->passes_by_id_size && index >= 0);
1889	profile_record[index].run |= run;
1890	profile_record_account_profile (&profile_record[index]);
1891	}
1892
1893	/* Account profile for IPA pass. Callback for do_per_function. */
1894
1895	static void
1896	account_profile_1 (function *fn, void *data)
1897	{
1898	opt_pass *pass = (opt_pass *)data;
1899
1900	push_cfun (new_cfun: fn);
1901	check_profile_consistency (index: pass->static_pass_number, run: true);
1902	account_profile (index: pass->static_pass_number, run: true);
1903	pop_cfun ();
1904	}
1905
1906	/* Account profile chnages to all passes in list starting in SUB. */
1907
1908	static void
1909	account_profile_in_list (opt_pass *sub)
1910	{
1911	for (; sub; sub = sub->next)
1912	{
1913	check_profile_consistency (index: sub->static_pass_number, run: false);
1914	account_profile (index: sub->static_pass_number, run: false);
1915	if (sub->sub)
1916	account_profile_in_list (sub: sub->sub);
1917	}
1918	}
1919
1920	/* Output profile consistency. */
1921
1922	void
1923	dump_profile_report (void)
1924	{
1925	g->get_passes ()->dump_profile_report ();
1926	}
1927
1928	void
1929	pass_manager::dump_profile_report () const
1930	{
1931	int last_count_in = 0, last_prob_out = 0;
1932	double last_dyn_count_in = 0, last_dyn_prob_out = 0;
1933	double last_time = 0;
1934	int last_size = 0;
1935	double rel_time_change, rel_size_change;
1936	gcc::dump_manager *dumps = m_ctxt->get_dumps ();
1937
1938	if (!profile_record)
1939	return;
1940
1941	FILE *dump_file = dump_begin (TDI_profile_report, NULL);
1942	if (dump_file == NULL)
1943	dump_file = stderr;
1944
1945	fprintf (stream: dump_file, format: "Profile consistency report:\n\n");
1946	fprintf (stream: dump_file,
1947	format: "Pass dump id and name |static mismatch "
1948	"|dynamic mismatch "
1949	"|overall |\n");
1950	fprintf (stream: dump_file,
1951	format: " |in count |out prob "
1952	"|in count |out prob "
1953	"|size |time |\n");
1954
1955	for (int i = 1; i < passes_by_id_size; i++)
1956	if (profile_record[i].run)
1957	{
1958	if (last_time)
1959	rel_time_change = (profile_record[i].time
1960	- last_time) * 100 / last_time;
1961	else
1962	rel_time_change = 0;
1963	if (last_size)
1964	rel_size_change = (profile_record[i].size
1965	- (double)last_size) * 100 / (double)last_size;
1966	else
1967	rel_size_change = 0;
1968
1969	dump_file_info *dfi = dumps->get_dump_file_info (phase: i);
1970
1971	fprintf (stream: dump_file, format: "%3i%c %-28s| %6i",
1972	dfi->num,
1973	passes_by_id[i]->type == GIMPLE_PASS ? 't'
1974	: passes_by_id[i]->type == RTL_PASS ? 'r'
1975	: 'i',
1976	passes_by_id[i]->name,
1977	profile_record[i].num_mismatched_count_in);
1978	if (profile_record[i].num_mismatched_count_in != last_count_in)
1979	fprintf (stream: dump_file, format: " %+5i",
1980	profile_record[i].num_mismatched_count_in
1981	- last_count_in);
1982	else
1983	fprintf (stream: dump_file, format: " ");
1984	fprintf (stream: dump_file, format: "| %6i",
1985	profile_record[i].num_mismatched_prob_out);
1986	if (profile_record[i].num_mismatched_prob_out != last_prob_out)
1987	fprintf (stream: dump_file, format: " %+5i",
1988	profile_record[i].num_mismatched_prob_out
1989	- last_prob_out);
1990	else
1991	fprintf (stream: dump_file, format: " ");
1992
1993	fprintf (stream: dump_file, format: "| %12.0f",
1994	profile_record[i].dyn_mismatched_count_in);
1995	if (profile_record[i].dyn_mismatched_count_in != last_dyn_count_in)
1996	fprintf (stream: dump_file, format: " %+12.0f",
1997	profile_record[i].dyn_mismatched_count_in
1998	- last_dyn_count_in);
1999	else
2000	fprintf (stream: dump_file, format: " ");
2001	fprintf (stream: dump_file, format: "| %12.0f",
2002	profile_record[i].dyn_mismatched_prob_out);
2003	if (profile_record[i].dyn_mismatched_prob_out != last_dyn_prob_out)
2004	fprintf (stream: dump_file, format: " %+12.0f",
2005	profile_record[i].dyn_mismatched_prob_out
2006	- last_dyn_prob_out);
2007	else
2008	fprintf (stream: dump_file, format: " ");
2009
2010	/* Size/time units change across gimple and RTL. */
2011	if (i == pass_expand_1->static_pass_number)
2012	fprintf (stream: dump_file,
2013	format: "|-------------------|--------------------------");
2014	else
2015	{
2016	fprintf (stream: dump_file, format: "| %8i", profile_record[i].size);
2017	if (rel_size_change)
2018	fprintf (stream: dump_file, format: " %+8.1f%%", rel_size_change);
2019	else
2020	fprintf (stream: dump_file, format: " ");
2021	fprintf (stream: dump_file, format: "| %12.0f", profile_record[i].time);
2022	/* Time units changes with profile estimate and feedback. */
2023	if (i == pass_profile_1->static_pass_number
2024	|| i == pass_ipa_tree_profile_1->static_pass_number)
2025	fprintf (stream: dump_file, format: "-------------");
2026	else if (rel_time_change)
2027	fprintf (stream: dump_file, format: " %+11.1f%%", rel_time_change);
2028	else
2029	fprintf (stream: dump_file, format: " ");
2030	}
2031	fprintf (stream: dump_file, format: "|\n");
2032	last_prob_out = profile_record[i].num_mismatched_prob_out;
2033	last_count_in = profile_record[i].num_mismatched_count_in;
2034	last_dyn_prob_out = profile_record[i].dyn_mismatched_prob_out;
2035	last_dyn_count_in = profile_record[i].dyn_mismatched_count_in;
2036	last_time = profile_record[i].time;
2037	last_size = profile_record[i].size;
2038	}
2039
2040	dump_end (TDI_profile_report, dump_file);
2041	}
2042
2043	/* Perform all TODO actions that ought to be done on each function. */
2044
2045	static void
2046	execute_function_todo (function *fn, void *data)
2047	{
2048	bool from_ipa_pass = (cfun == NULL);
2049	unsigned int flags = (size_t)data;
2050	flags &= ~fn->last_verified;
2051	if (!flags)
2052	return;
2053
2054	push_cfun (new_cfun: fn);
2055
2056	/* If we need to cleanup the CFG let it perform a needed SSA update. */
2057	if (flags & TODO_cleanup_cfg)
2058	cleanup_tree_cfg (flags & TODO_update_ssa_any);
2059	else if (flags & TODO_update_ssa_any)
2060	update_ssa (flags & TODO_update_ssa_any);
2061	gcc_assert (!need_ssa_update_p (fn));
2062
2063	if (flag_tree_pta && (flags & TODO_rebuild_alias))
2064	compute_may_aliases ();
2065
2066	if (optimize && (flags & TODO_update_address_taken))
2067	execute_update_addresses_taken ();
2068
2069	if (flags & TODO_remove_unused_locals)
2070	remove_unused_locals ();
2071
2072	if (flags & TODO_rebuild_cgraph_edges)
2073	cgraph_edge::rebuild_edges ();
2074
2075	gcc_assert (dom_info_state (fn, CDI_POST_DOMINATORS) == DOM_NONE);
2076	/* If we've seen errors do not bother running any verifiers. */
2077	if (flag_checking && !seen_error ())
2078	{
2079	dom_state pre_verify_state = dom_info_state (fn, CDI_DOMINATORS);
2080	dom_state pre_verify_pstate = dom_info_state (fn, CDI_POST_DOMINATORS);
2081
2082	if (flags & TODO_verify_il)
2083	{
2084	if (cfun->curr_properties & PROP_gimple)
2085	{
2086	if (cfun->curr_properties & PROP_cfg)
2087	/* IPA passes leave stmts to be fixed up, so make sure to
2088	not verify stmts really throw. */
2089	verify_gimple_in_cfg (cfun, !from_ipa_pass);
2090	else
2091	verify_gimple_in_seq (gimple_body (cfun->decl));
2092	}
2093	if (cfun->curr_properties & PROP_ssa)
2094	/* IPA passes leave stmts to be fixed up, so make sure to
2095	not verify SSA operands whose verifier will choke on that. */
2096	verify_ssa (true, !from_ipa_pass);
2097	/* IPA passes leave basic-blocks unsplit, so make sure to
2098	not trip on that. */
2099	if ((cfun->curr_properties & PROP_cfg)
2100	&& !from_ipa_pass)
2101	verify_flow_info ();
2102	if (current_loops
2103	&& ! loops_state_satisfies_p (flags: LOOPS_NEED_FIXUP))
2104	{
2105	verify_loop_structure ();
2106	if (loops_state_satisfies_p (flags: LOOP_CLOSED_SSA))
2107	verify_loop_closed_ssa (false);
2108	}
2109	if (cfun->curr_properties & PROP_rtl)
2110	verify_rtl_sharing ();
2111	}
2112
2113	/* Make sure verifiers don't change dominator state. */
2114	gcc_assert (dom_info_state (fn, CDI_DOMINATORS) == pre_verify_state);
2115	gcc_assert (dom_info_state (fn, CDI_POST_DOMINATORS) == pre_verify_pstate);
2116	}
2117
2118	fn->last_verified = flags & TODO_verify_all;
2119
2120	pop_cfun ();
2121
2122	/* For IPA passes make sure to release dominator info, it can be
2123	computed by non-verifying TODOs. */
2124	if (from_ipa_pass)
2125	{
2126	free_dominance_info (fn, CDI_DOMINATORS);
2127	free_dominance_info (fn, CDI_POST_DOMINATORS);
2128	}
2129	}
2130
2131	/* Perform all TODO actions. */
2132	static void
2133	execute_todo (unsigned int flags)
2134	{
2135	if (flag_checking
2136	&& cfun
2137	&& need_ssa_update_p (cfun))
2138	gcc_assert (flags & TODO_update_ssa_any);
2139
2140	statistics_fini_pass ();
2141
2142	if (flags)
2143	do_per_function (callback: execute_function_todo, data: (void *)(size_t) flags);
2144
2145	/* At this point we should not have any unreachable code in the
2146	CFG, so it is safe to flush the pending freelist for SSA_NAMES. */
2147	if (cfun && cfun->gimple_df)
2148	flush_ssaname_freelist ();
2149
2150	/* Always remove functions just as before inlining: IPA passes might be
2151	interested to see bodies of extern inline functions that are not inlined
2152	to analyze side effects. The full removal is done just at the end
2153	of IPA pass queue. */
2154	if (flags & TODO_remove_functions)
2155	{
2156	gcc_assert (!cfun);
2157	symtab->remove_unreachable_nodes (file: dump_file);
2158	}
2159
2160	if ((flags & TODO_dump_symtab) && dump_file && !current_function_decl)
2161	{
2162	gcc_assert (!cfun);
2163	symtab->dump (f: dump_file);
2164	/* Flush the file. If verification fails, we won't be able to
2165	close the file before aborting. */
2166	fflush (stream: dump_file);
2167	}
2168
2169	/* Now that the dumping has been done, we can get rid of the optional
2170	df problems. */
2171	if (flags & TODO_df_finish)
2172	df_finish_pass ((flags & TODO_df_verify) != 0);
2173	}
2174
2175	/* Verify invariants that should hold between passes. This is a place
2176	to put simple sanity checks. */
2177
2178	static void
2179	verify_interpass_invariants (void)
2180	{
2181	gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
2182	}
2183
2184	/* Clear the last verified flag. */
2185
2186	static void
2187	clear_last_verified (function *fn, void *data ATTRIBUTE_UNUSED)
2188	{
2189	fn->last_verified = 0;
2190	}
2191
2192	/* Helper function. Verify that the properties has been turn into the
2193	properties expected by the pass. */
2194
2195	static void
2196	verify_curr_properties (function *fn, void *data)
2197	{
2198	unsigned int props = (size_t)data;
2199	gcc_assert ((fn->curr_properties & props) == props);
2200	}
2201
2202	/* Release dump file name if set. */
2203
2204	static void
2205	release_dump_file_name (void)
2206	{
2207	if (dump_file_name)
2208	{
2209	free (CONST_CAST (char *, dump_file_name));
2210	dump_file_name = NULL;
2211	}
2212	}
2213
2214	/* Initialize pass dump file. */
2215	/* This is non-static so that the plugins can use it. */
2216
2217	bool
2218	pass_init_dump_file (opt_pass *pass)
2219	{
2220	/* If a dump file name is present, open it if enabled. */
2221	if (pass->static_pass_number != -1)
2222	{
2223	timevar_push (tv: TV_DUMP);
2224	gcc::dump_manager *dumps = g->get_dumps ();
2225	bool initializing_dump =
2226	!dumps->dump_initialized_p (phase: pass->static_pass_number);
2227	release_dump_file_name ();
2228	dump_file_name = dumps->get_dump_file_name (phase: pass->static_pass_number);
2229	dumps->dump_start (phase: pass->static_pass_number, flag_ptr: &dump_flags);
2230	if (dump_file && current_function_decl && ! (dump_flags & TDF_GIMPLE))
2231	dump_function_header (dump_file, current_function_decl, dump_flags);
2232	if (initializing_dump
2233	&& dump_file && (dump_flags & TDF_GRAPH)
2234	&& cfun && (cfun->curr_properties & PROP_cfg))
2235	{
2236	clean_graph_dump_file (dump_file_name);
2237	struct dump_file_info *dfi
2238	= dumps->get_dump_file_info (phase: pass->static_pass_number);
2239	dfi->graph_dump_initialized = true;
2240	}
2241	timevar_pop (tv: TV_DUMP);
2242	return initializing_dump;
2243	}
2244	else
2245	return false;
2246	}
2247
2248	/* Flush PASS dump file. */
2249	/* This is non-static so that plugins can use it. */
2250
2251	void
2252	pass_fini_dump_file (opt_pass *pass)
2253	{
2254	timevar_push (tv: TV_DUMP);
2255
2256	/* Flush and close dump file. */
2257	release_dump_file_name ();
2258
2259	g->get_dumps ()->dump_finish (phase: pass->static_pass_number);
2260	timevar_pop (tv: TV_DUMP);
2261	}
2262
2263	/* After executing the pass, apply expected changes to the function
2264	properties. */
2265
2266	static void
2267	update_properties_after_pass (function *fn, void *data)
2268	{
2269	opt_pass *pass = (opt_pass *) data;
2270	fn->curr_properties = (fn->curr_properties | pass->properties_provided)
2271	& ~pass->properties_destroyed;
2272	}
2273
2274	/* Execute summary generation for all of the passes in IPA_PASS. */
2275
2276	void
2277	execute_ipa_summary_passes (ipa_opt_pass_d *ipa_pass)
2278	{
2279	while (ipa_pass)
2280	{
2281	opt_pass *pass = ipa_pass;
2282
2283	/* Execute all of the IPA_PASSes in the list. */
2284	if (ipa_pass->type == IPA_PASS
2285	&& pass->gate (cfun)
2286	&& ipa_pass->generate_summary)
2287	{
2288	pass_init_dump_file (pass);
2289
2290	/* If a timevar is present, start it. */
2291	if (pass->tv_id)
2292	timevar_push (tv: pass->tv_id);
2293
2294	current_pass = pass;
2295	ipa_pass->generate_summary ();
2296
2297	/* Stop timevar. */
2298	if (pass->tv_id)
2299	timevar_pop (tv: pass->tv_id);
2300
2301	pass_fini_dump_file (pass);
2302	}
2303	ipa_pass = (ipa_opt_pass_d *)ipa_pass->next;
2304	}
2305	}
2306
2307	/* Execute IPA_PASS function transform on NODE. */
2308
2309	static void
2310	execute_one_ipa_transform_pass (struct cgraph_node *node,
2311	ipa_opt_pass_d *ipa_pass, bool do_not_collect)
2312	{
2313	opt_pass *pass = ipa_pass;
2314	unsigned int todo_after = 0;
2315
2316	current_pass = pass;
2317	if (!ipa_pass->function_transform)
2318	return;
2319
2320	/* Note that the folders should only create gimple expressions.
2321	This is a hack until the new folder is ready. */
2322	in_gimple_form = (cfun && (cfun->curr_properties & PROP_gimple)) != 0;
2323
2324	pass_init_dump_file (pass);
2325
2326	/* If a timevar is present, start it. */
2327	if (pass->tv_id != TV_NONE)
2328	timevar_push (tv: pass->tv_id);
2329
2330	/* Run pre-pass verification. */
2331	execute_todo (flags: ipa_pass->function_transform_todo_flags_start);
2332
2333	/* Do it! */
2334	todo_after = ipa_pass->function_transform (node);
2335
2336	/* Run post-pass cleanup and verification. */
2337	execute_todo (flags: todo_after);
2338	verify_interpass_invariants ();
2339
2340	/* Stop timevar. */
2341	if (pass->tv_id != TV_NONE)
2342	timevar_pop (tv: pass->tv_id);
2343
2344	if (dump_file)
2345	do_per_function (callback: execute_function_dump, data: pass);
2346	pass_fini_dump_file (pass);
2347
2348	current_pass = NULL;
2349	redirect_edge_var_map_empty ();
2350
2351	/* Signal this is a suitable GC collection point. */
2352	if (!do_not_collect && !(todo_after & TODO_do_not_ggc_collect))
2353	ggc_collect ();
2354	}
2355
2356	/* For the current function, execute all ipa transforms. */
2357
2358	void
2359	execute_all_ipa_transforms (bool do_not_collect)
2360	{
2361	struct cgraph_node *node;
2362	node = cgraph_node::get (decl: current_function_decl);
2363
2364
2365	cgraph_node *next_clone;
2366	for (cgraph_node *n = node->clones; n; n = next_clone)
2367	{
2368	next_clone = n->next_sibling_clone;
2369	if (n->decl != node->decl)
2370	n->materialize_clone ();
2371	}
2372
2373	int j = 0;
2374	gcc::pass_manager *passes = g->get_passes ();
2375	bool report = profile_report && (cfun->curr_properties & PROP_gimple) != 0;
2376
2377	if (report)
2378	push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2379
2380	for (auto p : node->ipa_transforms_to_apply)
2381	{
2382	/* To get consistent statistics, we need to account each functio
2383	to each IPA pass. */
2384	if (report)
2385	{
2386	for (;j < p->static_pass_number; j++)
2387	if (passes->get_pass_for_id (id: j)
2388	&& passes->get_pass_for_id (id: j)->type == IPA_PASS
2389	&& ((ipa_opt_pass_d *)passes->get_pass_for_id (id: j))
2390	->function_transform)
2391	{
2392	check_profile_consistency (index: j, run: true);
2393	account_profile (index: j, run: true);
2394	}
2395	gcc_checking_assert (passes->get_pass_for_id (j) == p);
2396	}
2397	execute_one_ipa_transform_pass (node, ipa_pass: p, do_not_collect);
2398	}
2399	/* Account remaining IPA passes. */
2400	if (report)
2401	{
2402	for (;!passes->get_pass_for_id (id: j)
2403	|| passes->get_pass_for_id (id: j)->type != RTL_PASS; j++)
2404	if (passes->get_pass_for_id (id: j)
2405	&& passes->get_pass_for_id (id: j)->type == IPA_PASS
2406	&& ((ipa_opt_pass_d *)passes->get_pass_for_id (id: j))
2407	->function_transform)
2408	{
2409	check_profile_consistency (index: j, run: true);
2410	account_profile (index: j, run: true);
2411	}
2412	pop_cfun ();
2413	}
2414	node->ipa_transforms_to_apply.release ();
2415	}
2416
2417	/* Check if PASS is explicitly disabled or enabled and return
2418	the gate status. FUNC is the function to be processed, and
2419	GATE_STATUS is the gate status determined by pass manager by
2420	default. */
2421
2422	static bool
2423	override_gate_status (opt_pass *pass, tree func, bool gate_status)
2424	{
2425	bool explicitly_enabled = false;
2426	bool explicitly_disabled = false;
2427
2428	explicitly_enabled
2429	= is_pass_explicitly_enabled_or_disabled (pass, func,
2430	tab: enabled_pass_uid_range_tab);
2431	explicitly_disabled
2432	= is_pass_explicitly_enabled_or_disabled (pass, func,
2433	tab: disabled_pass_uid_range_tab);
2434
2435	gate_status = !explicitly_disabled && (gate_status || explicitly_enabled);
2436
2437	return gate_status;
2438	}
2439
2440	/* Determine if PASS_NAME matches CRITERION.
2441	Not a pure predicate, since it can update CRITERION, to support
2442	matching the Nth invocation of a pass.
2443	Subroutine of should_skip_pass_p. */
2444
2445	static bool
2446	determine_pass_name_match (const char *pass_name, char *criterion)
2447	{
2448	size_t namelen = strlen (s: pass_name);
2449	if (! strncmp (s1: pass_name, s2: criterion, n: namelen))
2450	{
2451	/* The following supports starting with the Nth invocation
2452	of a pass (where N does not necessarily is equal to the
2453	dump file suffix). */
2454	if (criterion[namelen] == '\0'
2455	|| (criterion[namelen] == '1'
2456	&& criterion[namelen + 1] == '\0'))
2457	return true;
2458	else
2459	{
2460	if (criterion[namelen + 1] == '\0')
2461	--criterion[namelen];
2462	return false;
2463	}
2464	}
2465	else
2466	return false;
2467	}
2468
2469	/* For skipping passes until "startwith" pass.
2470	Return true iff PASS should be skipped.
2471	Clear cfun->pass_startwith when encountering the "startwith" pass,
2472	so that all subsequent passes are run. */
2473
2474	static bool
2475	should_skip_pass_p (opt_pass *pass)
2476	{
2477	if (!cfun)
2478	return false;
2479	if (!cfun->pass_startwith)
2480	return false;
2481
2482	/* For __GIMPLE functions, we have to at least start when we leave
2483	SSA. Hence, we need to detect the "expand" pass, and stop skipping
2484	when we encounter it. A cheap way to identify "expand" is it to
2485	detect the destruction of PROP_ssa.
2486	For __RTL functions, we invoke "rest_of_compilation" directly, which
2487	is after "expand", and hence we don't reach this conditional. */
2488	if (pass->properties_destroyed & PROP_ssa)
2489	{
2490	if (!quiet_flag)
2491	fprintf (stderr, format: "starting anyway when leaving SSA: %s\n", pass->name);
2492	cfun->pass_startwith = NULL;
2493	return false;
2494	}
2495
2496	if (determine_pass_name_match (pass_name: pass->name, cfun->pass_startwith))
2497	{
2498	if (!quiet_flag)
2499	fprintf (stderr, format: "found starting pass: %s\n", pass->name);
2500	cfun->pass_startwith = NULL;
2501	return false;
2502	}
2503
2504	/* For GIMPLE passes, run any property provider (but continue skipping
2505	afterwards).
2506	We don't want to force running RTL passes that are property providers:
2507	"expand" is covered above, and the only pass other than "expand" that
2508	provides a property is "into_cfglayout" (PROP_cfglayout), which does
2509	too much for a dumped __RTL function. */
2510	if (pass->type == GIMPLE_PASS
2511	&& pass->properties_provided != 0)
2512	return false;
2513
2514	/* We need to (re-)build cgraph edges as needed. */
2515	if (strstr (haystack: pass->name, needle: "build_cgraph_edges") != NULL)
2516	return false;
2517
2518	/* We need to run ISEL as that lowers VEC_COND_EXPR but doesn't provide
2519	a property. */
2520	if (strstr (haystack: pass->name, needle: "isel") != NULL)
2521	return false;
2522
2523	/* Don't skip df init; later RTL passes need it. */
2524	if (strstr (haystack: pass->name, needle: "dfinit") != NULL
2525	|| strstr (haystack: pass->name, needle: "dfinish") != NULL)
2526	return false;
2527
2528	if (!quiet_flag)
2529	fprintf (stderr, format: "skipping pass: %s\n", pass->name);
2530
2531	/* If we get here, then we have a "startwith" that we haven't seen yet;
2532	skip the pass. */
2533	return true;
2534	}
2535
2536	/* Skip the given pass, for handling passes before "startwith"
2537	in __GIMPLE and__RTL-marked functions.
2538	In theory, this ought to be a no-op, but some of the RTL passes
2539	need additional processing here. */
2540
2541	static void
2542	skip_pass (opt_pass *pass)
2543	{
2544	/* Pass "reload" sets the global "reload_completed", and many
2545	things depend on this (e.g. instructions in .md files). */
2546	if (strcmp (s1: pass->name, s2: "reload") == 0)
2547	reload_completed = 1;
2548
2549	/* Similar for pass "pro_and_epilogue" and the "epilogue_completed" global
2550	variable. */
2551	if (strcmp (s1: pass->name, s2: "pro_and_epilogue") == 0)
2552	epilogue_completed = 1;
2553
2554	/* The INSN_ADDRESSES vec is normally set up by
2555	shorten_branches; set it up for the benefit of passes that
2556	run after this. */
2557	if (strcmp (s1: pass->name, s2: "shorten") == 0)
2558	INSN_ADDRESSES_ALLOC (get_max_uid ());
2559
2560	/* Update the cfg hooks as appropriate. */
2561	if (strcmp (s1: pass->name, s2: "into_cfglayout") == 0)
2562	{
2563	cfg_layout_rtl_register_cfg_hooks ();
2564	cfun->curr_properties |= PROP_cfglayout;
2565	}
2566	if (strcmp (s1: pass->name, s2: "outof_cfglayout") == 0)
2567	{
2568	rtl_register_cfg_hooks ();
2569	cfun->curr_properties &= ~PROP_cfglayout;
2570	}
2571	}
2572
2573	/* Execute PASS. */
2574
2575	bool
2576	execute_one_pass (opt_pass *pass)
2577	{
2578	unsigned int todo_after = 0;
2579
2580	bool gate_status;
2581
2582	/* IPA passes are executed on whole program, so cfun should be NULL.
2583	Other passes need function context set. */
2584	if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
2585	gcc_assert (!cfun && !current_function_decl);
2586	else
2587	gcc_assert (cfun && current_function_decl);
2588
2589	current_pass = pass;
2590
2591	/* Check whether gate check should be avoided.
2592	User controls the value of the gate through the parameter "gate_status". */
2593	gate_status = pass->gate (cfun);
2594	gate_status = override_gate_status (pass, func: current_function_decl, gate_status);
2595
2596	/* Override gate with plugin. */
2597	invoke_plugin_callbacks (event: PLUGIN_OVERRIDE_GATE, gcc_data: &gate_status);
2598
2599	if (!gate_status)
2600	{
2601	/* Run so passes selectively disabling themselves on a given function
2602	are not miscounted. */
2603	if (profile_report && cfun && (cfun->curr_properties & PROP_cfg)
2604	&& pass->type != IPA_PASS && pass->type != SIMPLE_IPA_PASS)
2605	{
2606	check_profile_consistency (index: pass->static_pass_number, run: false);
2607	account_profile (index: pass->static_pass_number, run: false);
2608	if (pass->sub)
2609	account_profile_in_list (sub: pass->sub);
2610	}
2611	current_pass = NULL;
2612	return false;
2613	}
2614
2615	if (should_skip_pass_p (pass))
2616	{
2617	skip_pass (pass);
2618	return true;
2619	}
2620
2621	/* Pass execution event trigger: useful to identify passes being
2622	executed. */
2623	invoke_plugin_callbacks (event: PLUGIN_PASS_EXECUTION, gcc_data: pass);
2624
2625	if (!quiet_flag && !cfun)
2626	fprintf (stderr, format: " <%s>", pass->name ? pass->name : "");
2627
2628	/* Note that the folders should only create gimple expressions.
2629	This is a hack until the new folder is ready. */
2630	in_gimple_form = (cfun && (cfun->curr_properties & PROP_gimple)) != 0;
2631
2632	pass_init_dump_file (pass);
2633
2634	/* If a timevar is present, start it. */
2635	if (pass->tv_id != TV_NONE)
2636	timevar_push (tv: pass->tv_id);
2637
2638
2639	/* Run pre-pass verification. */
2640	execute_todo (flags: pass->todo_flags_start);
2641
2642	if (flag_checking)
2643	do_per_function (callback: verify_curr_properties,
2644	data: (void *)(size_t)pass->properties_required);
2645
2646	/* Do it! */
2647	todo_after = pass->execute (cfun);
2648
2649	if (todo_after & TODO_discard_function)
2650	{
2651	/* Stop timevar. */
2652	if (pass->tv_id != TV_NONE)
2653	timevar_pop (tv: pass->tv_id);
2654
2655	pass_fini_dump_file (pass);
2656
2657	gcc_assert (cfun);
2658	/* As cgraph_node::release_body expects release dominators info,
2659	we have to release it. */
2660	if (dom_info_available_p (CDI_DOMINATORS))
2661	free_dominance_info (CDI_DOMINATORS);
2662
2663	if (dom_info_available_p (CDI_POST_DOMINATORS))
2664	free_dominance_info (CDI_POST_DOMINATORS);
2665
2666	if (cfun->assume_function)
2667	{
2668	/* For assume functions, don't release body, keep it around. */
2669	cfun->curr_properties |= PROP_assumptions_done;
2670	pop_cfun ();
2671	current_pass = NULL;
2672	return true;
2673	}
2674
2675	tree fn = cfun->decl;
2676	pop_cfun ();
2677	gcc_assert (!cfun);
2678	cgraph_node::get (decl: fn)->release_body ();
2679
2680	current_pass = NULL;
2681	redirect_edge_var_map_empty ();
2682
2683	ggc_collect ();
2684
2685	return true;
2686	}
2687
2688	do_per_function (callback: clear_last_verified, NULL);
2689
2690	do_per_function (callback: update_properties_after_pass, data: pass);
2691
2692	/* Run post-pass cleanup and verification. */
2693	execute_todo (flags: todo_after | pass->todo_flags_finish | TODO_verify_il);
2694	if (profile_report)
2695	{
2696	/* IPA passes are accounted at transform time. */
2697	if (pass->type == IPA_PASS)
2698	;
2699	else if (pass->type == SIMPLE_IPA_PASS)
2700	do_per_function (callback: account_profile_1, data: pass);
2701	else if (cfun && (cfun->curr_properties & PROP_cfg))
2702	{
2703	check_profile_consistency (index: pass->static_pass_number, run: true);
2704	account_profile (index: pass->static_pass_number, run: true);
2705	}
2706	}
2707
2708	verify_interpass_invariants ();
2709
2710	/* Stop timevar. */
2711	if (pass->tv_id != TV_NONE)
2712	timevar_pop (tv: pass->tv_id);
2713
2714	if (pass->type == IPA_PASS
2715	&& ((ipa_opt_pass_d *)pass)->function_transform)
2716	{
2717	struct cgraph_node *node;
2718	FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
2719	if (!node->inlined_to)
2720	node->ipa_transforms_to_apply.safe_push (obj: (ipa_opt_pass_d *)pass);
2721	}
2722	else if (dump_file)
2723	do_per_function (callback: execute_function_dump, data: pass);
2724
2725	if (!current_function_decl)
2726	symtab->process_new_functions ();
2727
2728	pass_fini_dump_file (pass);
2729
2730	if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
2731	gcc_assert (!(cfun->curr_properties & PROP_gimple)
2732	|| pass->type != RTL_PASS);
2733
2734	current_pass = NULL;
2735	redirect_edge_var_map_empty ();
2736
2737	/* Signal this is a suitable GC collection point. */
2738	if (!((todo_after | pass->todo_flags_finish) & TODO_do_not_ggc_collect))
2739	ggc_collect ();
2740
2741	if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
2742	report_heap_memory_use ();
2743	return true;
2744	}
2745
2746	static void
2747	execute_pass_list_1 (opt_pass *pass)
2748	{
2749	do
2750	{
2751	gcc_assert (pass->type == GIMPLE_PASS
2752	|| pass->type == RTL_PASS);
2753
2754	if (cfun == NULL)
2755	return;
2756	if (execute_one_pass (pass) && pass->sub)
2757	execute_pass_list_1 (pass: pass->sub);
2758	pass = pass->next;
2759	}
2760	while (pass);
2761	}
2762
2763	void
2764	execute_pass_list (function *fn, opt_pass *pass)
2765	{
2766	gcc_assert (fn == cfun);
2767	execute_pass_list_1 (pass);
2768	if (cfun && fn->cfg)
2769	{
2770	free_dominance_info (CDI_DOMINATORS);
2771	free_dominance_info (CDI_POST_DOMINATORS);
2772	}
2773	}
2774
2775	/* Write out all LTO data. */
2776	static void
2777	write_lto (void)
2778	{
2779	timevar_push (tv: TV_IPA_LTO_GIMPLE_OUT);
2780	lto_output ();
2781	timevar_pop (tv: TV_IPA_LTO_GIMPLE_OUT);
2782	timevar_push (tv: TV_IPA_LTO_DECL_OUT);
2783	produce_asm_for_decls ();
2784	timevar_pop (tv: TV_IPA_LTO_DECL_OUT);
2785	}
2786
2787	/* Same as execute_pass_list but assume that subpasses of IPA passes
2788	are local passes. If SET is not NULL, write out summaries of only
2789	those node in SET. */
2790
2791	static void
2792	ipa_write_summaries_2 (opt_pass *pass, struct lto_out_decl_state *state)
2793	{
2794	while (pass)
2795	{
2796	ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *)pass;
2797	gcc_assert (!current_function_decl);
2798	gcc_assert (!cfun);
2799	gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2800	if (pass->type == IPA_PASS
2801	&& ipa_pass->write_summary
2802	&& pass->gate (cfun))
2803	{
2804	/* If a timevar is present, start it. */
2805	if (pass->tv_id)
2806	timevar_push (tv: pass->tv_id);
2807
2808	pass_init_dump_file (pass);
2809
2810	current_pass = pass;
2811	ipa_pass->write_summary ();
2812
2813	pass_fini_dump_file (pass);
2814
2815	/* If a timevar is present, start it. */
2816	if (pass->tv_id)
2817	timevar_pop (tv: pass->tv_id);
2818	}
2819
2820	if (pass->sub && pass->sub->type != GIMPLE_PASS)
2821	ipa_write_summaries_2 (pass: pass->sub, state);
2822
2823	pass = pass->next;
2824	}
2825	}
2826
2827	/* Helper function of ipa_write_summaries. Creates and destroys the
2828	decl state and calls ipa_write_summaries_2 for all passes that have
2829	summaries. SET is the set of nodes to be written. */
2830
2831	static void
2832	ipa_write_summaries_1 (lto_symtab_encoder_t encoder)
2833	{
2834	pass_manager *passes = g->get_passes ();
2835	struct lto_out_decl_state *state = lto_new_out_decl_state ();
2836	state->symtab_node_encoder = encoder;
2837
2838	lto_output_init_mode_table ();
2839	lto_push_out_decl_state (state);
2840
2841	gcc_assert (!flag_wpa);
2842	ipa_write_summaries_2 (pass: passes->all_regular_ipa_passes, state);
2843
2844	write_lto ();
2845
2846	gcc_assert (lto_get_out_decl_state () == state);
2847	lto_pop_out_decl_state ();
2848	lto_delete_out_decl_state (state);
2849	}
2850
2851	/* Write out summaries for all the nodes in the callgraph. */
2852
2853	void
2854	ipa_write_summaries (void)
2855	{
2856	lto_symtab_encoder_t encoder;
2857	int i, order_pos;
2858	varpool_node *vnode;
2859	struct cgraph_node *node;
2860	struct cgraph_node **order;
2861
2862	if ((!flag_generate_lto && !flag_generate_offload) || seen_error ())
2863	return;
2864
2865	gcc_assert (!dump_file);
2866	streamer_dump_file = dump_begin (TDI_lto_stream_out, NULL);
2867
2868	select_what_to_stream ();
2869
2870	encoder = lto_symtab_encoder_new (false);
2871
2872	/* Create the callgraph set in the same order used in
2873	cgraph_expand_all_functions. This mostly facilitates debugging,
2874	since it causes the gimple file to be processed in the same order
2875	as the source code. */
2876	order = XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
2877	order_pos = ipa_reverse_postorder (order);
2878	gcc_assert (order_pos == symtab->cgraph_count);
2879
2880	for (i = order_pos - 1; i >= 0; i--)
2881	{
2882	struct cgraph_node *node = order[i];
2883
2884	if ((node->definition || node->declare_variant_alt)
2885	&& node->need_lto_streaming)
2886	{
2887	if (gimple_has_body_p (node->decl))
2888	lto_prepare_function_for_streaming (node);
2889	lto_set_symtab_encoder_in_partition (encoder, node);
2890	}
2891	}
2892
2893	FOR_EACH_DEFINED_FUNCTION (node)
2894	if (node->alias && node->need_lto_streaming)
2895	lto_set_symtab_encoder_in_partition (encoder, node);
2896	FOR_EACH_DEFINED_VARIABLE (vnode)
2897	if (vnode->need_lto_streaming)
2898	lto_set_symtab_encoder_in_partition (encoder, vnode);
2899
2900	ipa_write_summaries_1 (encoder: compute_ltrans_boundary (encoder));
2901
2902	free (ptr: order);
2903	if (streamer_dump_file)
2904	{
2905	dump_end (TDI_lto_stream_out, streamer_dump_file);
2906	streamer_dump_file = NULL;
2907	}
2908	}
2909
2910	/* Same as execute_pass_list but assume that subpasses of IPA passes
2911	are local passes. If SET is not NULL, write out optimization summaries of
2912	only those node in SET. */
2913
2914	static void
2915	ipa_write_optimization_summaries_1 (opt_pass *pass,
2916	struct lto_out_decl_state *state)
2917	{
2918	while (pass)
2919	{
2920	ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *)pass;
2921	gcc_assert (!current_function_decl);
2922	gcc_assert (!cfun);
2923	gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2924	if (pass->type == IPA_PASS
2925	&& ipa_pass->write_optimization_summary
2926	&& pass->gate (cfun))
2927	{
2928	/* If a timevar is present, start it. */
2929	if (pass->tv_id)
2930	timevar_push (tv: pass->tv_id);
2931
2932	pass_init_dump_file (pass);
2933
2934	current_pass = pass;
2935	ipa_pass->write_optimization_summary ();
2936
2937	pass_fini_dump_file (pass);
2938
2939	/* If a timevar is present, start it. */
2940	if (pass->tv_id)
2941	timevar_pop (tv: pass->tv_id);
2942	}
2943
2944	if (pass->sub && pass->sub->type != GIMPLE_PASS)
2945	ipa_write_optimization_summaries_1 (pass: pass->sub, state);
2946
2947	pass = pass->next;
2948	}
2949	}
2950
2951	/* Write all the optimization summaries for the cgraph nodes in SET. If SET is
2952	NULL, write out all summaries of all nodes. */
2953
2954	void
2955	ipa_write_optimization_summaries (lto_symtab_encoder_t encoder)
2956	{
2957	struct lto_out_decl_state *state = lto_new_out_decl_state ();
2958	state->symtab_node_encoder = encoder;
2959
2960	lto_output_init_mode_table ();
2961	lto_push_out_decl_state (state);
2962
2963	/* Be sure that we did not forget to renumber stmt uids. */
2964	gcc_checking_assert (flag_wpa);
2965
2966	gcc_assert (flag_wpa);
2967	pass_manager *passes = g->get_passes ();
2968	ipa_write_optimization_summaries_1 (pass: passes->all_regular_ipa_passes, state);
2969
2970	write_lto ();
2971
2972	gcc_assert (lto_get_out_decl_state () == state);
2973	lto_pop_out_decl_state ();
2974	lto_delete_out_decl_state (state);
2975	}
2976
2977	/* Same as execute_pass_list but assume that subpasses of IPA passes
2978	are local passes. */
2979
2980	static void
2981	ipa_read_summaries_1 (opt_pass *pass)
2982	{
2983	while (pass)
2984	{
2985	ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
2986
2987	gcc_assert (!current_function_decl);
2988	gcc_assert (!cfun);
2989	gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
2990
2991	if (pass->gate (cfun))
2992	{
2993	if (pass->type == IPA_PASS && ipa_pass->read_summary)
2994	{
2995	/* If a timevar is present, start it. */
2996	if (pass->tv_id)
2997	timevar_push (tv: pass->tv_id);
2998	if (!quiet_flag)
2999	fprintf (stderr, format: " <%s>", pass->name ? pass->name : "");
3000
3001	pass_init_dump_file (pass);
3002
3003	current_pass = pass;
3004	ipa_pass->read_summary ();
3005
3006	pass_fini_dump_file (pass);
3007
3008	/* Stop timevar. */
3009	if (pass->tv_id)
3010	timevar_pop (tv: pass->tv_id);
3011	ggc_grow ();
3012	report_heap_memory_use ();
3013	}
3014
3015	if (pass->sub && pass->sub->type != GIMPLE_PASS)
3016	ipa_read_summaries_1 (pass: pass->sub);
3017	}
3018	pass = pass->next;
3019	}
3020	}
3021
3022
3023	/* Read all the summaries for all_regular_ipa_passes. */
3024
3025	void
3026	ipa_read_summaries (void)
3027	{
3028	pass_manager *passes = g->get_passes ();
3029	ipa_read_summaries_1 (pass: passes->all_regular_ipa_passes);
3030	}
3031
3032	/* Same as execute_pass_list but assume that subpasses of IPA passes
3033	are local passes. */
3034
3035	static void
3036	ipa_read_optimization_summaries_1 (opt_pass *pass)
3037	{
3038	while (pass)
3039	{
3040	ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
3041
3042	gcc_assert (!current_function_decl);
3043	gcc_assert (!cfun);
3044	gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
3045
3046	if (pass->gate (cfun))
3047	{
3048	if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
3049	{
3050	/* If a timevar is present, start it. */
3051	if (pass->tv_id)
3052	timevar_push (tv: pass->tv_id);
3053	if (!quiet_flag)
3054	fprintf (stderr, format: " <%s>", pass->name ? pass->name : "");
3055
3056	pass_init_dump_file (pass);
3057
3058	current_pass = pass;
3059	ipa_pass->read_optimization_summary ();
3060
3061	pass_fini_dump_file (pass);
3062
3063	/* Stop timevar. */
3064	if (pass->tv_id)
3065	timevar_pop (tv: pass->tv_id);
3066	}
3067
3068	if (pass->sub && pass->sub->type != GIMPLE_PASS)
3069	ipa_read_optimization_summaries_1 (pass: pass->sub);
3070	ggc_grow ();
3071	report_heap_memory_use ();
3072	}
3073	pass = pass->next;
3074	}
3075	}
3076
3077	/* Read all the summaries for all_regular_ipa_passes. */
3078
3079	void
3080	ipa_read_optimization_summaries (void)
3081	{
3082	pass_manager *passes = g->get_passes ();
3083	ipa_read_optimization_summaries_1 (pass: passes->all_regular_ipa_passes);
3084	}
3085
3086	/* Same as execute_pass_list but assume that subpasses of IPA passes
3087	are local passes. */
3088	void
3089	execute_ipa_pass_list (opt_pass *pass)
3090	{
3091	do
3092	{
3093	gcc_assert (!current_function_decl);
3094	gcc_assert (!cfun);
3095	gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
3096	if (execute_one_pass (pass) && pass->sub)
3097	{
3098	if (pass->sub->type == GIMPLE_PASS)
3099	{
3100	invoke_plugin_callbacks (event: PLUGIN_EARLY_GIMPLE_PASSES_START, NULL);
3101	do_per_function_toporder (callback: (void (*)(function *, void *))
3102	execute_pass_list,
3103	data: pass->sub);
3104	invoke_plugin_callbacks (event: PLUGIN_EARLY_GIMPLE_PASSES_END, NULL);
3105	}
3106	else if (pass->sub->type == SIMPLE_IPA_PASS
3107	|| pass->sub->type == IPA_PASS)
3108	execute_ipa_pass_list (pass: pass->sub);
3109	else
3110	gcc_unreachable ();
3111	}
3112	gcc_assert (!current_function_decl);
3113	symtab->process_new_functions ();
3114	pass = pass->next;
3115	}
3116	while (pass);
3117	}
3118
3119	/* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */
3120
3121	static void
3122	execute_ipa_stmt_fixups (opt_pass *pass,
3123	struct cgraph_node *node, gimple **stmts)
3124	{
3125	while (pass)
3126	{
3127	/* Execute all of the IPA_PASSes in the list. */
3128	if (pass->type == IPA_PASS
3129	&& pass->gate (cfun))
3130	{
3131	ipa_opt_pass_d *ipa_pass = (ipa_opt_pass_d *) pass;
3132
3133	if (ipa_pass->stmt_fixup)
3134	{
3135	pass_init_dump_file (pass);
3136	/* If a timevar is present, start it. */
3137	if (pass->tv_id)
3138	timevar_push (tv: pass->tv_id);
3139
3140	current_pass = pass;
3141	ipa_pass->stmt_fixup (node, stmts);
3142
3143	/* Stop timevar. */
3144	if (pass->tv_id)
3145	timevar_pop (tv: pass->tv_id);
3146	pass_fini_dump_file (pass);
3147	}
3148	if (pass->sub)
3149	execute_ipa_stmt_fixups (pass: pass->sub, node, stmts);
3150	}
3151	pass = pass->next;
3152	}
3153	}
3154
3155	/* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */
3156
3157	void
3158	execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple **stmts)
3159	{
3160	pass_manager *passes = g->get_passes ();
3161	execute_ipa_stmt_fixups (pass: passes->all_regular_ipa_passes, node, stmts);
3162	}
3163
3164
3165	extern void debug_properties (unsigned int);
3166	extern void dump_properties (FILE *, unsigned int);
3167
3168	DEBUG_FUNCTION void
3169	dump_properties (FILE *dump, unsigned int props)
3170	{
3171	fprintf (stream: dump, format: "Properties:\n");
3172	if (props & PROP_gimple_any)
3173	fprintf (stream: dump, format: "PROP_gimple_any\n");
3174	if (props & PROP_gimple_lcf)
3175	fprintf (stream: dump, format: "PROP_gimple_lcf\n");
3176	if (props & PROP_gimple_leh)
3177	fprintf (stream: dump, format: "PROP_gimple_leh\n");
3178	if (props & PROP_cfg)
3179	fprintf (stream: dump, format: "PROP_cfg\n");
3180	if (props & PROP_ssa)
3181	fprintf (stream: dump, format: "PROP_ssa\n");
3182	if (props & PROP_no_crit_edges)
3183	fprintf (stream: dump, format: "PROP_no_crit_edges\n");
3184	if (props & PROP_rtl)
3185	fprintf (stream: dump, format: "PROP_rtl\n");
3186	if (props & PROP_gimple_lomp)
3187	fprintf (stream: dump, format: "PROP_gimple_lomp\n");
3188	if (props & PROP_gimple_lomp_dev)
3189	fprintf (stream: dump, format: "PROP_gimple_lomp_dev\n");
3190	if (props & PROP_gimple_lcx)
3191	fprintf (stream: dump, format: "PROP_gimple_lcx\n");
3192	if (props & PROP_gimple_lvec)
3193	fprintf (stream: dump, format: "PROP_gimple_lvec\n");
3194	if (props & PROP_cfglayout)
3195	fprintf (stream: dump, format: "PROP_cfglayout\n");
3196	}
3197
3198	DEBUG_FUNCTION void
3199	debug_properties (unsigned int props)
3200	{
3201	dump_properties (stderr, props);
3202	}
3203
3204	/* Called by local passes to see if function is called by already processed nodes.
3205	Because we process nodes in topological order, this means that function is
3206	in recursive cycle or we introduced new direct calls. */
3207	bool
3208	function_called_by_processed_nodes_p (void)
3209	{
3210	struct cgraph_edge *e;
3211	for (e = cgraph_node::get (decl: current_function_decl)->callers;
3212	e;
3213	e = e->next_caller)
3214	{
3215	if (e->caller->decl == current_function_decl)
3216	continue;
3217	if (!e->caller->has_gimple_body_p ())
3218	continue;
3219	if (TREE_ASM_WRITTEN (e->caller->decl))
3220	continue;
3221	if (!e->caller->process && !e->caller->inlined_to)
3222	break;
3223	}
3224	if (dump_file && e)
3225	{
3226	fprintf (stream: dump_file, format: "Already processed call to:\n");
3227	e->caller->dump (f: dump_file);
3228	}
3229	return e != NULL;
3230	}
3231