1	/* Convert RTL to assembler code and output it, for GNU compiler.
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 final pass of the compiler.
21	It looks at the rtl code for a function and outputs assembler code.
22
23	Call `final_start_function' to output the assembler code for function entry,
24	`final' to output assembler code for some RTL code,
25	`final_end_function' to output assembler code for function exit.
26	If a function is compiled in several pieces, each piece is
27	output separately with `final'.
28
29	Some optimizations are also done at this level.
30	Move instructions that were made unnecessary by good register allocation
31	are detected and omitted from the output. (Though most of these
32	are removed by the last jump pass.)
33
34	Instructions to set the condition codes are omitted when it can be
35	seen that the condition codes already had the desired values.
36
37	In some cases it is sufficient if the inherited condition codes
38	have related values, but this may require the following insn
39	(the one that tests the condition codes) to be modified.
40
41	The code for the function prologue and epilogue are generated
42	directly in assembler by the target functions function_prologue and
43	function_epilogue. Those instructions never exist as rtl. */
44
45	#include "config.h"
46	#define INCLUDE_ALGORITHM /* reverse */
47	#include "system.h"
48	#include "coretypes.h"
49	#include "backend.h"
50	#include "target.h"
51	#include "rtl.h"
52	#include "tree.h"
53	#include "cfghooks.h"
54	#include "df.h"
55	#include "memmodel.h"
56	#include "tm_p.h"
57	#include "insn-config.h"
58	#include "regs.h"
59	#include "emit-rtl.h"
60	#include "recog.h"
61	#include "cgraph.h"
62	#include "tree-pretty-print.h" /* for dump_function_header */
63	#include "varasm.h"
64	#include "insn-attr.h"
65	#include "conditions.h"
66	#include "flags.h"
67	#include "output.h"
68	#include "except.h"
69	#include "rtl-error.h"
70	#include "toplev.h" /* exact_log2, floor_log2 */
71	#include "reload.h"
72	#include "intl.h"
73	#include "cfgrtl.h"
74	#include "debug.h"
75	#include "tree-pass.h"
76	#include "tree-ssa.h"
77	#include "cfgloop.h"
78	#include "stringpool.h"
79	#include "attribs.h"
80	#include "asan.h"
81	#include "rtl-iter.h"
82	#include "print-rtl.h"
83	#include "function-abi.h"
84	#include "common/common-target.h"
85	#include "diagnostic.h"
86
87	#include "dwarf2out.h"
88
89	/* Most ports don't need to define CC_STATUS_INIT.
90	So define a null default for it to save conditionalization later. */
91	#ifndef CC_STATUS_INIT
92	#define CC_STATUS_INIT
93	#endif
94
95	/* Is the given character a logical line separator for the assembler? */
96	#ifndef IS_ASM_LOGICAL_LINE_SEPARATOR
97	#define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) ((C) == ';')
98	#endif
99
100	#ifndef JUMP_TABLES_IN_TEXT_SECTION
101	#define JUMP_TABLES_IN_TEXT_SECTION 0
102	#endif
103
104	/* Bitflags used by final_scan_insn. */
105	#define SEEN_NOTE 1
106	#define SEEN_EMITTED 2
107	#define SEEN_NEXT_VIEW 4
108
109	/* Last insn processed by final_scan_insn. */
110	static rtx_insn *debug_insn;
111	rtx_insn *current_output_insn;
112
113	/* Line number of last NOTE. */
114	static int last_linenum;
115
116	/* Column number of last NOTE. */
117	static int last_columnnum;
118
119	/* Discriminator written to assembly. */
120	static int last_discriminator;
121
122	/* Compute discriminator to be written to assembly for current instruction.
123	Note: actual usage depends on loc_discriminator_kind setting. */
124	static inline int compute_discriminator (location_t loc);
125
126	/* Highest line number in current block. */
127	static int high_block_linenum;
128
129	/* Likewise for function. */
130	static int high_function_linenum;
131
132	/* Filename of last NOTE. */
133	static const char *last_filename;
134
135	/* Override filename, line and column number. */
136	static const char *override_filename;
137	static int override_linenum;
138	static int override_columnnum;
139	static int override_discriminator;
140
141	/* Whether to force emission of a line note before the next insn. */
142	static bool force_source_line = false;
143
144	extern const int length_unit_log; /* This is defined in insn-attrtab.cc. */
145
146	/* Nonzero while outputting an `asm' with operands.
147	This means that inconsistencies are the user's fault, so don't die.
148	The precise value is the insn being output, to pass to error_for_asm. */
149	const rtx_insn *this_is_asm_operands;
150
151	/* Number of operands of this insn, for an `asm' with operands. */
152	static unsigned int insn_noperands;
153
154	/* Compare optimization flag. */
155
156	static rtx last_ignored_compare = 0;
157
158	/* Assign a unique number to each insn that is output.
159	This can be used to generate unique local labels. */
160
161	static int insn_counter = 0;
162
163	/* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen. */
164
165	static int block_depth;
166
167	/* True if have enabled APP processing of our assembler output. */
168
169	static bool app_on;
170
171	/* If we are outputting an insn sequence, this contains the sequence rtx.
172	Zero otherwise. */
173
174	rtx_sequence *final_sequence;
175
176	#ifdef ASSEMBLER_DIALECT
177
178	/* Number of the assembler dialect to use, starting at 0. */
179	static int dialect_number;
180	#endif
181
182	/* Nonnull if the insn currently being emitted was a COND_EXEC pattern. */
183	rtx current_insn_predicate;
184
185	/* True if printing into -fdump-final-insns= dump. */
186	bool final_insns_dump_p;
187
188	/* True if profile_function should be called, but hasn't been called yet. */
189	static bool need_profile_function;
190
191	static int asm_insn_count (rtx);
192	static void profile_function (FILE *);
193	static void profile_after_prologue (FILE *);
194	static bool notice_source_line (rtx_insn *, bool *);
195	static rtx walk_alter_subreg (rtx *, bool *);
196	static void output_asm_name (void);
197	static void output_alternate_entry_point (FILE *, rtx_insn *);
198	static tree get_mem_expr_from_op (rtx, int *);
199	static void output_asm_operand_names (rtx *, int *, int);
200	#ifdef LEAF_REGISTERS
201	static void leaf_renumber_regs (rtx_insn *);
202	#endif
203	static int align_fuzz (rtx, rtx, int, unsigned);
204	static void collect_fn_hard_reg_usage (void);
205
206	/* Initialize data in final at the beginning of a compilation. */
207
208	void
209	init_final (const char *filename ATTRIBUTE_UNUSED)
210	{
211	app_on = 0;
212	final_sequence = 0;
213
214	#ifdef ASSEMBLER_DIALECT
215	dialect_number = ASSEMBLER_DIALECT;
216	#endif
217	}
218
219	/* Default target function prologue and epilogue assembler output.
220
221	If not overridden for epilogue code, then the function body itself
222	contains return instructions wherever needed. */
223	void
224	default_function_pro_epilogue (FILE *)
225	{
226	}
227
228	void
229	default_function_switched_text_sections (FILE *file ATTRIBUTE_UNUSED,
230	tree decl ATTRIBUTE_UNUSED,
231	bool new_is_cold ATTRIBUTE_UNUSED)
232	{
233	}
234
235	/* Default target hook that outputs nothing to a stream. */
236	void
237	no_asm_to_stream (FILE *file ATTRIBUTE_UNUSED)
238	{
239	}
240
241	/* Enable APP processing of subsequent output.
242	Used before the output from an `asm' statement. */
243
244	void
245	app_enable (void)
246	{
247	if (! app_on)
248	{
249	fputs (ASM_APP_ON, stream: asm_out_file);
250	app_on = 1;
251	}
252	}
253
254	/* Disable APP processing of subsequent output.
255	Called from varasm.cc before most kinds of output. */
256
257	void
258	app_disable (void)
259	{
260	if (app_on)
261	{
262	fputs (ASM_APP_OFF, stream: asm_out_file);
263	app_on = 0;
264	}
265	}
266
267	/* Return the number of slots filled in the current
268	delayed branch sequence (we don't count the insn needing the
269	delay slot). Zero if not in a delayed branch sequence. */
270
271	int
272	dbr_sequence_length (void)
273	{
274	if (final_sequence != 0)
275	return XVECLEN (final_sequence, 0) - 1;
276	else
277	return 0;
278	}
279
280	/* The next two pages contain routines used to compute the length of an insn
281	and to shorten branches. */
282
283	/* Arrays for insn lengths, and addresses. The latter is referenced by
284	`insn_current_length'. */
285
286	static int *insn_lengths;
287
288	vec<int> insn_addresses_;
289
290	/* Max uid for which the above arrays are valid. */
291	static int insn_lengths_max_uid;
292
293	/* Address of insn being processed. Used by `insn_current_length'. */
294	int insn_current_address;
295
296	/* Address of insn being processed in previous iteration. */
297	int insn_last_address;
298
299	/* known invariant alignment of insn being processed. */
300	int insn_current_align;
301
302	/* After shorten_branches, for any insn, uid_align[INSN_UID (insn)]
303	gives the next following alignment insn that increases the known
304	alignment, or NULL_RTX if there is no such insn.
305	For any alignment obtained this way, we can again index uid_align with
306	its uid to obtain the next following align that in turn increases the
307	alignment, till we reach NULL_RTX; the sequence obtained this way
308	for each insn we'll call the alignment chain of this insn in the following
309	comments. */
310
311	static rtx *uid_align;
312	static int *uid_shuid;
313	static vec<align_flags> label_align;
314
315	/* Indicate that branch shortening hasn't yet been done. */
316
317	void
318	init_insn_lengths (void)
319	{
320	if (uid_shuid)
321	{
322	free (ptr: uid_shuid);
323	uid_shuid = 0;
324	}
325	if (insn_lengths)
326	{
327	free (ptr: insn_lengths);
328	insn_lengths = 0;
329	insn_lengths_max_uid = 0;
330	}
331	if (HAVE_ATTR_length)
332	INSN_ADDRESSES_FREE ();
333	if (uid_align)
334	{
335	free (ptr: uid_align);
336	uid_align = 0;
337	}
338	}
339
340	/* Obtain the current length of an insn. If branch shortening has been done,
341	get its actual length. Otherwise, use FALLBACK_FN to calculate the
342	length. */
343	static int
344	get_attr_length_1 (rtx_insn *insn, int (*fallback_fn) (rtx_insn *))
345	{
346	rtx body;
347	int i;
348	int length = 0;
349
350	if (!HAVE_ATTR_length)
351	return 0;
352
353	if (insn_lengths_max_uid > INSN_UID (insn))
354	return insn_lengths[INSN_UID (insn)];
355	else
356	switch (GET_CODE (insn))
357	{
358	case NOTE:
359	case BARRIER:
360	case CODE_LABEL:
361	case DEBUG_INSN:
362	return 0;
363
364	case CALL_INSN:
365	case JUMP_INSN:
366	length = fallback_fn (insn);
367	break;
368
369	case INSN:
370	body = PATTERN (insn);
371	if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
372	return 0;
373
374	else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
375	length = asm_insn_count (body) * fallback_fn (insn);
376	else if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (p: body))
377	for (i = 0; i < seq->len (); i++)
378	length += get_attr_length_1 (insn: seq->insn (index: i), fallback_fn);
379	else
380	length = fallback_fn (insn);
381	break;
382
383	default:
384	break;
385	}
386
387	#ifdef ADJUST_INSN_LENGTH
388	ADJUST_INSN_LENGTH (insn, length);
389	#endif
390	return length;
391	}
392
393	/* Obtain the current length of an insn. If branch shortening has been done,
394	get its actual length. Otherwise, get its maximum length. */
395	int
396	get_attr_length (rtx_insn *insn)
397	{
398	return get_attr_length_1 (insn, fallback_fn: insn_default_length);
399	}
400
401	/* Obtain the current length of an insn. If branch shortening has been done,
402	get its actual length. Otherwise, get its minimum length. */
403	int
404	get_attr_min_length (rtx_insn *insn)
405	{
406	return get_attr_length_1 (insn, fallback_fn: insn_min_length);
407	}
408
409	/* Code to handle alignment inside shorten_branches. */
410
411	/* Here is an explanation how the algorithm in align_fuzz can give
412	proper results:
413
414	Call a sequence of instructions beginning with alignment point X
415	and continuing until the next alignment point `block X'. When `X'
416	is used in an expression, it means the alignment value of the
417	alignment point.
418
419	Call the distance between the start of the first insn of block X, and
420	the end of the last insn of block X `IX', for the `inner size of X'.
421	This is clearly the sum of the instruction lengths.
422
423	Likewise with the next alignment-delimited block following X, which we
424	shall call block Y.
425
426	Call the distance between the start of the first insn of block X, and
427	the start of the first insn of block Y `OX', for the `outer size of X'.
428
429	The estimated padding is then OX - IX.
430
431	OX can be safely estimated as
432
433	if (X >= Y)
434	OX = round_up(IX, Y)
435	else
436	OX = round_up(IX, X) + Y - X
437
438	Clearly est(IX) >= real(IX), because that only depends on the
439	instruction lengths, and those being overestimated is a given.
440
441	Clearly round_up(foo, Z) >= round_up(bar, Z) if foo >= bar, so
442	we needn't worry about that when thinking about OX.
443
444	When X >= Y, the alignment provided by Y adds no uncertainty factor
445	for branch ranges starting before X, so we can just round what we have.
446	But when X < Y, we don't know anything about the, so to speak,
447	`middle bits', so we have to assume the worst when aligning up from an
448	address mod X to one mod Y, which is Y - X. */
449
450	#ifndef LABEL_ALIGN
451	#define LABEL_ALIGN(LABEL) align_labels
452	#endif
453
454	#ifndef LOOP_ALIGN
455	#define LOOP_ALIGN(LABEL) align_loops
456	#endif
457
458	#ifndef LABEL_ALIGN_AFTER_BARRIER
459	#define LABEL_ALIGN_AFTER_BARRIER(LABEL) 0
460	#endif
461
462	#ifndef JUMP_ALIGN
463	#define JUMP_ALIGN(LABEL) align_jumps
464	#endif
465
466	#ifndef ADDR_VEC_ALIGN
467	static int
468	final_addr_vec_align (rtx_jump_table_data *addr_vec)
469	{
470	int align = GET_MODE_SIZE (mode: addr_vec->get_data_mode ());
471
472	if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
473	align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
474	return exact_log2 (x: align);
475
476	}
477
478	#define ADDR_VEC_ALIGN(ADDR_VEC) final_addr_vec_align (ADDR_VEC)
479	#endif
480
481	#ifndef INSN_LENGTH_ALIGNMENT
482	#define INSN_LENGTH_ALIGNMENT(INSN) length_unit_log
483	#endif
484
485	#define INSN_SHUID(INSN) (uid_shuid[INSN_UID (INSN)])
486
487	static int min_labelno, max_labelno;
488
489	#define LABEL_TO_ALIGNMENT(LABEL) \
490	(label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno])
491
492	/* For the benefit of port specific code do this also as a function. */
493
494	align_flags
495	label_to_alignment (rtx label)
496	{
497	if (CODE_LABEL_NUMBER (label) <= max_labelno)
498	return LABEL_TO_ALIGNMENT (label);
499	return align_flags ();
500	}
501
502	/* The differences in addresses
503	between a branch and its target might grow or shrink depending on
504	the alignment the start insn of the range (the branch for a forward
505	branch or the label for a backward branch) starts out on; if these
506	differences are used naively, they can even oscillate infinitely.
507	We therefore want to compute a 'worst case' address difference that
508	is independent of the alignment the start insn of the range end
509	up on, and that is at least as large as the actual difference.
510	The function align_fuzz calculates the amount we have to add to the
511	naively computed difference, by traversing the part of the alignment
512	chain of the start insn of the range that is in front of the end insn
513	of the range, and considering for each alignment the maximum amount
514	that it might contribute to a size increase.
515
516	For casesi tables, we also want to know worst case minimum amounts of
517	address difference, in case a machine description wants to introduce
518	some common offset that is added to all offsets in a table.
519	For this purpose, align_fuzz with a growth argument of 0 computes the
520	appropriate adjustment. */
521
522	/* Compute the maximum delta by which the difference of the addresses of
523	START and END might grow / shrink due to a different address for start
524	which changes the size of alignment insns between START and END.
525	KNOWN_ALIGN_LOG is the alignment known for START.
526	GROWTH should be ~0 if the objective is to compute potential code size
527	increase, and 0 if the objective is to compute potential shrink.
528	The return value is undefined for any other value of GROWTH. */
529
530	static int
531	align_fuzz (rtx start, rtx end, int known_align_log, unsigned int growth)
532	{
533	int uid = INSN_UID (insn: start);
534	rtx align_label;
535	int known_align = 1 << known_align_log;
536	int end_shuid = INSN_SHUID (end);
537	int fuzz = 0;
538
539	for (align_label = uid_align[uid]; align_label; align_label = uid_align[uid])
540	{
541	int align_addr, new_align;
542
543	uid = INSN_UID (insn: align_label);
544	align_addr = INSN_ADDRESSES (uid) - insn_lengths[uid];
545	if (uid_shuid[uid] > end_shuid)
546	break;
547	align_flags alignment = LABEL_TO_ALIGNMENT (align_label);
548	new_align = 1 << alignment.levels[0].log;
549	if (new_align < known_align)
550	continue;
551	fuzz += (-align_addr ^ growth) & (new_align - known_align);
552	known_align = new_align;
553	}
554	return fuzz;
555	}
556
557	/* Compute a worst-case reference address of a branch so that it
558	can be safely used in the presence of aligned labels. Since the
559	size of the branch itself is unknown, the size of the branch is
560	not included in the range. I.e. for a forward branch, the reference
561	address is the end address of the branch as known from the previous
562	branch shortening pass, minus a value to account for possible size
563	increase due to alignment. For a backward branch, it is the start
564	address of the branch as known from the current pass, plus a value
565	to account for possible size increase due to alignment.
566	NB.: Therefore, the maximum offset allowed for backward branches needs
567	to exclude the branch size. */
568
569	int
570	insn_current_reference_address (rtx_insn *branch)
571	{
572	rtx dest;
573	int seq_uid;
574
575	if (! INSN_ADDRESSES_SET_P ())
576	return 0;
577
578	rtx_insn *seq = NEXT_INSN (insn: PREV_INSN (insn: branch));
579	seq_uid = INSN_UID (insn: seq);
580	if (!jump_to_label_p (branch))
581	/* This can happen for example on the PA; the objective is to know the
582	offset to address something in front of the start of the function.
583	Thus, we can treat it like a backward branch.
584	We assume here that FUNCTION_BOUNDARY / BITS_PER_UNIT is larger than
585	any alignment we'd encounter, so we skip the call to align_fuzz. */
586	return insn_current_address;
587	dest = JUMP_LABEL (branch);
588
589	/* BRANCH has no proper alignment chain set, so use SEQ.
590	BRANCH also has no INSN_SHUID. */
591	if (INSN_SHUID (seq) < INSN_SHUID (dest))
592	{
593	/* Forward branch. */
594	return (insn_last_address + insn_lengths[seq_uid]
595	- align_fuzz (start: seq, end: dest, known_align_log: length_unit_log, growth: ~0));
596	}
597	else
598	{
599	/* Backward branch. */
600	return (insn_current_address
601	+ align_fuzz (start: dest, end: seq, known_align_log: length_unit_log, growth: ~0));
602	}
603	}
604
605	/* Compute branch alignments based on CFG profile. */
606
607	void
608	compute_alignments (void)
609	{
610	basic_block bb;
611	align_flags max_alignment;
612
613	label_align.truncate (size: 0);
614
615	max_labelno = max_label_num ();
616	min_labelno = get_first_label_num ();
617	label_align.safe_grow_cleared (len: max_labelno - min_labelno + 1, exact: true);
618
619	/* If not optimizing or optimizing for size, don't assign any alignments. */
620	if (! optimize || optimize_function_for_size_p (cfun))
621	return;
622
623	if (dump_file)
624	{
625	dump_reg_info (dump_file);
626	dump_flow_info (dump_file, TDF_DETAILS);
627	flow_loops_dump (dump_file, NULL, 1);
628	}
629	loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
630	profile_count count_threshold = cfun->cfg->count_max / param_align_threshold;
631
632	if (dump_file)
633	{
634	fprintf (stream: dump_file, format: "count_max: ");
635	cfun->cfg->count_max.dump (f: dump_file);
636	fprintf (stream: dump_file, format: "\n");
637	}
638	FOR_EACH_BB_FN (bb, cfun)
639	{
640	rtx_insn *label = BB_HEAD (bb);
641	bool has_fallthru = 0;
642	edge e;
643	edge_iterator ei;
644
645	if (!LABEL_P (label)
646	|| optimize_bb_for_size_p (bb))
647	{
648	if (dump_file)
649	fprintf (stream: dump_file,
650	format: "BB %4i loop %2i loop_depth %2i skipped.\n",
651	bb->index,
652	bb->loop_father->num,
653	bb_loop_depth (bb));
654	continue;
655	}
656	max_alignment = LABEL_ALIGN (label);
657	profile_count fallthru_count = profile_count::zero ();
658	profile_count branch_count = profile_count::zero ();
659
660	FOR_EACH_EDGE (e, ei, bb->preds)
661	{
662	if (e->flags & EDGE_FALLTHRU)
663	has_fallthru = 1, fallthru_count += e->count ();
664	else
665	branch_count += e->count ();
666	}
667	if (dump_file)
668	{
669	fprintf (stream: dump_file, format: "BB %4i loop %2i loop_depth"
670	" %2i fall ",
671	bb->index, bb->loop_father->num,
672	bb_loop_depth (bb));
673	fallthru_count.dump (f: dump_file);
674	fprintf (stream: dump_file, format: " branch ");
675	branch_count.dump (f: dump_file);
676	if (!bb->loop_father->inner && bb->loop_father->num)
677	fprintf (stream: dump_file, format: " inner_loop");
678	if (bb->loop_father->header == bb)
679	fprintf (stream: dump_file, format: " loop_header");
680	fprintf (stream: dump_file, format: "\n");
681	}
682	if (!fallthru_count.initialized_p () || !branch_count.initialized_p ())
683	continue;
684
685	/* There are two purposes to align block with no fallthru incoming edge:
686	1) to avoid fetch stalls when branch destination is near cache boundary
687	2) to improve cache efficiency in case the previous block is not executed
688	(so it does not need to be in the cache).
689
690	We to catch first case, we align frequently executed blocks.
691	To catch the second, we align blocks that are executed more frequently
692	than the predecessor and the predecessor is likely to not be executed
693	when function is called. */
694
695	if (!has_fallthru
696	&& (branch_count > count_threshold
697	|| (bb->count > bb->prev_bb->count * 10
698	&& (bb->prev_bb->count
699	<= ENTRY_BLOCK_PTR_FOR_FN (cfun)->count / 2))))
700	{
701	align_flags alignment = JUMP_ALIGN (label);
702	if (dump_file)
703	fprintf (stream: dump_file, format: " jump alignment added.\n");
704	max_alignment = align_flags::max (f0: max_alignment, f1: alignment);
705	}
706	/* In case block is frequent and reached mostly by non-fallthru edge,
707	align it. It is most likely a first block of loop. */
708	if (has_fallthru
709	&& !(single_succ_p (bb)
710	&& single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun))
711	&& optimize_bb_for_speed_p (bb)
712	&& branch_count + fallthru_count > count_threshold
713	&& (branch_count > fallthru_count * param_align_loop_iterations))
714	{
715	align_flags alignment = LOOP_ALIGN (label);
716	if (dump_file)
717	fprintf (stream: dump_file, format: " internal loop alignment added.\n");
718	max_alignment = align_flags::max (f0: max_alignment, f1: alignment);
719	}
720	LABEL_TO_ALIGNMENT (label) = max_alignment;
721	}
722
723	loop_optimizer_finalize ();
724	free_dominance_info (CDI_DOMINATORS);
725	}
726
727	/* Grow the LABEL_ALIGN array after new labels are created. */
728
729	static void
730	grow_label_align (void)
731	{
732	int old = max_labelno;
733	int n_labels;
734	int n_old_labels;
735
736	max_labelno = max_label_num ();
737
738	n_labels = max_labelno - min_labelno + 1;
739	n_old_labels = old - min_labelno + 1;
740
741	label_align.safe_grow_cleared (len: n_labels, exact: true);
742
743	/* Range of labels grows monotonically in the function. Failing here
744	means that the initialization of array got lost. */
745	gcc_assert (n_old_labels <= n_labels);
746	}
747
748	/* Update the already computed alignment information. LABEL_PAIRS is a vector
749	made up of pairs of labels for which the alignment information of the first
750	element will be copied from that of the second element. */
751
752	void
753	update_alignments (vec<rtx> &label_pairs)
754	{
755	unsigned int i = 0;
756	rtx iter, label = NULL_RTX;
757
758	if (max_labelno != max_label_num ())
759	grow_label_align ();
760
761	FOR_EACH_VEC_ELT (label_pairs, i, iter)
762	if (i & 1)
763	LABEL_TO_ALIGNMENT (label) = LABEL_TO_ALIGNMENT (iter);
764	else
765	label = iter;
766	}
767
768	namespace {
769
770	const pass_data pass_data_compute_alignments =
771	{
772	.type: RTL_PASS, /* type */
773	.name: "alignments", /* name */
774	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
775	.tv_id: TV_NONE, /* tv_id */
776	.properties_required: 0, /* properties_required */
777	.properties_provided: 0, /* properties_provided */
778	.properties_destroyed: 0, /* properties_destroyed */
779	.todo_flags_start: 0, /* todo_flags_start */
780	.todo_flags_finish: 0, /* todo_flags_finish */
781	};
782
783	class pass_compute_alignments : public rtl_opt_pass
784	{
785	public:
786	pass_compute_alignments (gcc::context *ctxt)
787	: rtl_opt_pass (pass_data_compute_alignments, ctxt)
788	{}
789
790	/* opt_pass methods: */
791	unsigned int execute (function *) final override
792	{
793	compute_alignments ();
794	return 0;
795	}
796
797	}; // class pass_compute_alignments
798
799	} // anon namespace
800
801	rtl_opt_pass *
802	make_pass_compute_alignments (gcc::context *ctxt)
803	{
804	return new pass_compute_alignments (ctxt);
805	}
806
807
808	/* Make a pass over all insns and compute their actual lengths by shortening
809	any branches of variable length if possible. */
810
811	/* shorten_branches might be called multiple times: for example, the SH
812	port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG.
813	In order to do this, it needs proper length information, which it obtains
814	by calling shorten_branches. This cannot be collapsed with
815	shorten_branches itself into a single pass unless we also want to integrate
816	reorg.cc, since the branch splitting exposes new instructions with delay
817	slots. */
818
819	void
820	shorten_branches (rtx_insn *first)
821	{
822	rtx_insn *insn;
823	int max_uid;
824	int i;
825	rtx_insn *seq;
826	bool something_changed = true;
827	char *varying_length;
828	rtx body;
829	int uid;
830	rtx align_tab[MAX_CODE_ALIGN + 1];
831
832	/* Compute maximum UID and allocate label_align / uid_shuid. */
833	max_uid = get_max_uid ();
834
835	/* Free uid_shuid before reallocating it. */
836	free (ptr: uid_shuid);
837
838	uid_shuid = XNEWVEC (int, max_uid);
839
840	if (max_labelno != max_label_num ())
841	grow_label_align ();
842
843	/* Initialize label_align and set up uid_shuid to be strictly
844	monotonically rising with insn order. */
845	/* We use alignment here to keep track of the maximum alignment we want to
846	impose on the next CODE_LABEL (or the current one if we are processing
847	the CODE_LABEL itself). */
848
849	align_flags max_alignment;
850
851	for (insn = get_insns (), i = 1; insn; insn = NEXT_INSN (insn))
852	{
853	INSN_SHUID (insn) = i++;
854	if (INSN_P (insn))
855	continue;
856
857	if (rtx_code_label *label = dyn_cast <rtx_code_label *> (p: insn))
858	{
859	/* Merge in alignments computed by compute_alignments. */
860	align_flags alignment = LABEL_TO_ALIGNMENT (label);
861	max_alignment = align_flags::max (f0: max_alignment, f1: alignment);
862
863	rtx_jump_table_data *table = jump_table_for_label (label);
864	if (!table)
865	{
866	align_flags alignment = LABEL_ALIGN (label);
867	max_alignment = align_flags::max (f0: max_alignment, f1: alignment);
868	}
869	/* ADDR_VECs only take room if read-only data goes into the text
870	section. */
871	if ((JUMP_TABLES_IN_TEXT_SECTION
872	|| readonly_data_section == text_section)
873	&& table)
874	{
875	align_flags alignment = align_flags (ADDR_VEC_ALIGN (table));
876	max_alignment = align_flags::max (f0: max_alignment, f1: alignment);
877	}
878	LABEL_TO_ALIGNMENT (label) = max_alignment;
879	max_alignment = align_flags ();
880	}
881	else if (BARRIER_P (insn))
882	{
883	rtx_insn *label;
884
885	for (label = insn; label && ! INSN_P (label);
886	label = NEXT_INSN (insn: label))
887	if (LABEL_P (label))
888	{
889	align_flags alignment
890	= align_flags (LABEL_ALIGN_AFTER_BARRIER (insn));
891	max_alignment = align_flags::max (f0: max_alignment, f1: alignment);
892	break;
893	}
894	}
895	}
896	if (!HAVE_ATTR_length)
897	return;
898
899	/* Allocate the rest of the arrays. */
900	insn_lengths = XNEWVEC (int, max_uid);
901	insn_lengths_max_uid = max_uid;
902	/* Syntax errors can lead to labels being outside of the main insn stream.
903	Initialize insn_addresses, so that we get reproducible results. */
904	INSN_ADDRESSES_ALLOC (max_uid);
905
906	varying_length = XCNEWVEC (char, max_uid);
907
908	/* Initialize uid_align. We scan instructions
909	from end to start, and keep in align_tab[n] the last seen insn
910	that does an alignment of at least n+1, i.e. the successor
911	in the alignment chain for an insn that does / has a known
912	alignment of n. */
913	uid_align = XCNEWVEC (rtx, max_uid);
914
915	for (i = MAX_CODE_ALIGN + 1; --i >= 0;)
916	align_tab[i] = NULL_RTX;
917	seq = get_last_insn ();
918	for (; seq; seq = PREV_INSN (insn: seq))
919	{
920	int uid = INSN_UID (insn: seq);
921	int log;
922	log = (LABEL_P (seq) ? LABEL_TO_ALIGNMENT (seq).levels[0].log : 0);
923	uid_align[uid] = align_tab[0];
924	if (log)
925	{
926	/* Found an alignment label. */
927	gcc_checking_assert (log < MAX_CODE_ALIGN + 1);
928	uid_align[uid] = align_tab[log];
929	for (i = log - 1; i >= 0; i--)
930	align_tab[i] = seq;
931	}
932	}
933
934	/* When optimizing, we start assuming minimum length, and keep increasing
935	lengths as we find the need for this, till nothing changes.
936	When not optimizing, we start assuming maximum lengths, and
937	do a single pass to update the lengths. */
938	bool increasing = optimize != 0;
939
940	#ifdef CASE_VECTOR_SHORTEN_MODE
941	if (optimize)
942	{
943	/* Look for ADDR_DIFF_VECs, and initialize their minimum and maximum
944	label fields. */
945
946	int min_shuid = INSN_SHUID (get_insns ()) - 1;
947	int max_shuid = INSN_SHUID (get_last_insn ()) + 1;
948	int rel;
949
950	for (insn = first; insn != 0; insn = NEXT_INSN (insn))
951	{
952	rtx min_lab = NULL_RTX, max_lab = NULL_RTX, pat;
953	int len, i, min, max, insn_shuid;
954	int min_align;
955	addr_diff_vec_flags flags;
956
957	if (! JUMP_TABLE_DATA_P (insn)
958	|| GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
959	continue;
960	pat = PATTERN (insn);
961	len = XVECLEN (pat, 1);
962	gcc_assert (len > 0);
963	min_align = MAX_CODE_ALIGN;
964	for (min = max_shuid, max = min_shuid, i = len - 1; i >= 0; i--)
965	{
966	rtx lab = XEXP (XVECEXP (pat, 1, i), 0);
967	int shuid = INSN_SHUID (lab);
968	if (shuid < min)
969	{
970	min = shuid;
971	min_lab = lab;
972	}
973	if (shuid > max)
974	{
975	max = shuid;
976	max_lab = lab;
977	}
978
979	int label_alignment = LABEL_TO_ALIGNMENT (lab).levels[0].log;
980	if (min_align > label_alignment)
981	min_align = label_alignment;
982	}
983	XEXP (pat, 2) = gen_rtx_LABEL_REF (Pmode, min_lab);
984	XEXP (pat, 3) = gen_rtx_LABEL_REF (Pmode, max_lab);
985	insn_shuid = INSN_SHUID (insn);
986	rel = INSN_SHUID (XEXP (XEXP (pat, 0), 0));
987	memset (&flags, 0, sizeof (flags));
988	flags.min_align = min_align;
989	flags.base_after_vec = rel > insn_shuid;
990	flags.min_after_vec = min > insn_shuid;
991	flags.max_after_vec = max > insn_shuid;
992	flags.min_after_base = min > rel;
993	flags.max_after_base = max > rel;
994	ADDR_DIFF_VEC_FLAGS (pat) = flags;
995
996	if (increasing)
997	PUT_MODE (pat, CASE_VECTOR_SHORTEN_MODE (0, 0, pat));
998	}
999	}
1000	#endif /* CASE_VECTOR_SHORTEN_MODE */
1001
1002	/* Compute initial lengths, addresses, and varying flags for each insn. */
1003	int (*length_fun) (rtx_insn *) = increasing ? insn_min_length : insn_default_length;
1004
1005	for (insn_current_address = 0, insn = first;
1006	insn != 0;
1007	insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn))
1008	{
1009	uid = INSN_UID (insn);
1010
1011	insn_lengths[uid] = 0;
1012
1013	if (LABEL_P (insn))
1014	{
1015	int log = LABEL_TO_ALIGNMENT (insn).levels[0].log;
1016	if (log)
1017	{
1018	int align = 1 << log;
1019	int new_address = (insn_current_address + align - 1) & -align;
1020	insn_lengths[uid] = new_address - insn_current_address;
1021	}
1022	}
1023
1024	INSN_ADDRESSES (uid) = insn_current_address + insn_lengths[uid];
1025
1026	if (NOTE_P (insn) || BARRIER_P (insn)
1027	|| LABEL_P (insn) || DEBUG_INSN_P (insn))
1028	continue;
1029	if (insn->deleted ())
1030	continue;
1031
1032	body = PATTERN (insn);
1033	if (rtx_jump_table_data *table = dyn_cast <rtx_jump_table_data *> (p: insn))
1034	{
1035	/* This only takes room if read-only data goes into the text
1036	section. */
1037	if (JUMP_TABLES_IN_TEXT_SECTION
1038	|| readonly_data_section == text_section)
1039	insn_lengths[uid] = (XVECLEN (body,
1040	GET_CODE (body) == ADDR_DIFF_VEC)
1041	* GET_MODE_SIZE (mode: table->get_data_mode ()));
1042	/* Alignment is handled by ADDR_VEC_ALIGN. */
1043	}
1044	else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
1045	insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
1046	else if (rtx_sequence *body_seq = dyn_cast <rtx_sequence *> (p: body))
1047	{
1048	int i;
1049	int const_delay_slots;
1050	if (DELAY_SLOTS)
1051	const_delay_slots = const_num_delay_slots (body_seq->insn (index: 0));
1052	else
1053	const_delay_slots = 0;
1054
1055	int (*inner_length_fun) (rtx_insn *)
1056	= const_delay_slots ? length_fun : insn_default_length;
1057	/* Inside a delay slot sequence, we do not do any branch shortening
1058	if the shortening could change the number of delay slots
1059	of the branch. */
1060	for (i = 0; i < body_seq->len (); i++)
1061	{
1062	rtx_insn *inner_insn = body_seq->insn (index: i);
1063	int inner_uid = INSN_UID (insn: inner_insn);
1064	int inner_length;
1065
1066	if (GET_CODE (PATTERN (inner_insn)) == ASM_INPUT
1067	|| asm_noperands (PATTERN (insn: inner_insn)) >= 0)
1068	inner_length = (asm_insn_count (PATTERN (insn: inner_insn))
1069	* insn_default_length (inner_insn));
1070	else
1071	inner_length = inner_length_fun (inner_insn);
1072
1073	insn_lengths[inner_uid] = inner_length;
1074	if (const_delay_slots)
1075	{
1076	if ((varying_length[inner_uid]
1077	= insn_variable_length_p (inner_insn)) != 0)
1078	varying_length[uid] = 1;
1079	INSN_ADDRESSES (inner_uid) = (insn_current_address
1080	+ insn_lengths[uid]);
1081	}
1082	else
1083	varying_length[inner_uid] = 0;
1084	insn_lengths[uid] += inner_length;
1085	}
1086	}
1087	else if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER)
1088	{
1089	insn_lengths[uid] = length_fun (insn);
1090	varying_length[uid] = insn_variable_length_p (insn);
1091	}
1092
1093	/* If needed, do any adjustment. */
1094	#ifdef ADJUST_INSN_LENGTH
1095	ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
1096	if (insn_lengths[uid] < 0)
1097	fatal_insn ("negative insn length", insn);
1098	#endif
1099	}
1100
1101	/* Now loop over all the insns finding varying length insns. For each,
1102	get the current insn length. If it has changed, reflect the change.
1103	When nothing changes for a full pass, we are done. */
1104
1105	while (something_changed)
1106	{
1107	something_changed = false;
1108	insn_current_align = MAX_CODE_ALIGN - 1;
1109	for (insn_current_address = 0, insn = first;
1110	insn != 0;
1111	insn = NEXT_INSN (insn))
1112	{
1113	int new_length;
1114	#ifdef ADJUST_INSN_LENGTH
1115	int tmp_length;
1116	#endif
1117	int length_align;
1118
1119	uid = INSN_UID (insn);
1120
1121	if (rtx_code_label *label = dyn_cast <rtx_code_label *> (p: insn))
1122	{
1123	int log = LABEL_TO_ALIGNMENT (label).levels[0].log;
1124
1125	#ifdef CASE_VECTOR_SHORTEN_MODE
1126	/* If the mode of a following jump table was changed, we
1127	may need to update the alignment of this label. */
1128
1129	if (JUMP_TABLES_IN_TEXT_SECTION
1130	|| readonly_data_section == text_section)
1131	{
1132	rtx_jump_table_data *table = jump_table_for_label (label);
1133	if (table)
1134	{
1135	int newlog = ADDR_VEC_ALIGN (table);
1136	if (newlog != log)
1137	{
1138	log = newlog;
1139	LABEL_TO_ALIGNMENT (insn) = log;
1140	something_changed = true;
1141	}
1142	}
1143	}
1144	#endif
1145
1146	if (log > insn_current_align)
1147	{
1148	int align = 1 << log;
1149	int new_address= (insn_current_address + align - 1) & -align;
1150	insn_lengths[uid] = new_address - insn_current_address;
1151	insn_current_align = log;
1152	insn_current_address = new_address;
1153	}
1154	else
1155	insn_lengths[uid] = 0;
1156	INSN_ADDRESSES (uid) = insn_current_address;
1157	continue;
1158	}
1159
1160	length_align = INSN_LENGTH_ALIGNMENT (insn);
1161	if (length_align < insn_current_align)
1162	insn_current_align = length_align;
1163
1164	insn_last_address = INSN_ADDRESSES (uid);
1165	INSN_ADDRESSES (uid) = insn_current_address;
1166
1167	#ifdef CASE_VECTOR_SHORTEN_MODE
1168	if (optimize
1169	&& JUMP_TABLE_DATA_P (insn)
1170	&& GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
1171	{
1172	rtx_jump_table_data *table = as_a <rtx_jump_table_data *> (insn);
1173	rtx body = PATTERN (insn);
1174	int old_length = insn_lengths[uid];
1175	rtx_insn *rel_lab =
1176	safe_as_a <rtx_insn *> (XEXP (XEXP (body, 0), 0));
1177	rtx min_lab = XEXP (XEXP (body, 2), 0);
1178	rtx max_lab = XEXP (XEXP (body, 3), 0);
1179	int rel_addr = INSN_ADDRESSES (INSN_UID (rel_lab));
1180	int min_addr = INSN_ADDRESSES (INSN_UID (min_lab));
1181	int max_addr = INSN_ADDRESSES (INSN_UID (max_lab));
1182	rtx_insn *prev;
1183	int rel_align = 0;
1184	addr_diff_vec_flags flags;
1185	scalar_int_mode vec_mode;
1186
1187	/* Avoid automatic aggregate initialization. */
1188	flags = ADDR_DIFF_VEC_FLAGS (body);
1189
1190	/* Try to find a known alignment for rel_lab. */
1191	for (prev = rel_lab;
1192	prev
1193	&& ! insn_lengths[INSN_UID (prev)]
1194	&& ! (varying_length[INSN_UID (prev)] & 1);
1195	prev = PREV_INSN (prev))
1196	if (varying_length[INSN_UID (prev)] & 2)
1197	{
1198	rel_align = LABEL_TO_ALIGNMENT (prev).levels[0].log;
1199	break;
1200	}
1201
1202	/* See the comment on addr_diff_vec_flags in rtl.h for the
1203	meaning of the flags values. base: REL_LAB vec: INSN */
1204	/* Anything after INSN has still addresses from the last
1205	pass; adjust these so that they reflect our current
1206	estimate for this pass. */
1207	if (flags.base_after_vec)
1208	rel_addr += insn_current_address - insn_last_address;
1209	if (flags.min_after_vec)
1210	min_addr += insn_current_address - insn_last_address;
1211	if (flags.max_after_vec)
1212	max_addr += insn_current_address - insn_last_address;
1213	/* We want to know the worst case, i.e. lowest possible value
1214	for the offset of MIN_LAB. If MIN_LAB is after REL_LAB,
1215	its offset is positive, and we have to be wary of code shrink;
1216	otherwise, it is negative, and we have to be vary of code
1217	size increase. */
1218	if (flags.min_after_base)
1219	{
1220	/* If INSN is between REL_LAB and MIN_LAB, the size
1221	changes we are about to make can change the alignment
1222	within the observed offset, therefore we have to break
1223	it up into two parts that are independent. */
1224	if (! flags.base_after_vec && flags.min_after_vec)
1225	{
1226	min_addr -= align_fuzz (rel_lab, insn, rel_align, 0);
1227	min_addr -= align_fuzz (insn, min_lab, 0, 0);
1228	}
1229	else
1230	min_addr -= align_fuzz (rel_lab, min_lab, rel_align, 0);
1231	}
1232	else
1233	{
1234	if (flags.base_after_vec && ! flags.min_after_vec)
1235	{
1236	min_addr -= align_fuzz (min_lab, insn, 0, ~0);
1237	min_addr -= align_fuzz (insn, rel_lab, 0, ~0);
1238	}
1239	else
1240	min_addr -= align_fuzz (min_lab, rel_lab, 0, ~0);
1241	}
1242	/* Likewise, determine the highest lowest possible value
1243	for the offset of MAX_LAB. */
1244	if (flags.max_after_base)
1245	{
1246	if (! flags.base_after_vec && flags.max_after_vec)
1247	{
1248	max_addr += align_fuzz (rel_lab, insn, rel_align, ~0);
1249	max_addr += align_fuzz (insn, max_lab, 0, ~0);
1250	}
1251	else
1252	max_addr += align_fuzz (rel_lab, max_lab, rel_align, ~0);
1253	}
1254	else
1255	{
1256	if (flags.base_after_vec && ! flags.max_after_vec)
1257	{
1258	max_addr += align_fuzz (max_lab, insn, 0, 0);
1259	max_addr += align_fuzz (insn, rel_lab, 0, 0);
1260	}
1261	else
1262	max_addr += align_fuzz (max_lab, rel_lab, 0, 0);
1263	}
1264	vec_mode = CASE_VECTOR_SHORTEN_MODE (min_addr - rel_addr,
1265	max_addr - rel_addr, body);
1266	if (!increasing
1267	|| (GET_MODE_SIZE (vec_mode)
1268	>= GET_MODE_SIZE (table->get_data_mode ())))
1269	PUT_MODE (body, vec_mode);
1270	if (JUMP_TABLES_IN_TEXT_SECTION
1271	|| readonly_data_section == text_section)
1272	{
1273	insn_lengths[uid]
1274	= (XVECLEN (body, 1)
1275	* GET_MODE_SIZE (table->get_data_mode ()));
1276	insn_current_address += insn_lengths[uid];
1277	if (insn_lengths[uid] != old_length)
1278	something_changed = true;
1279	}
1280
1281	continue;
1282	}
1283	#endif /* CASE_VECTOR_SHORTEN_MODE */
1284
1285	if (! (varying_length[uid]))
1286	{
1287	if (NONJUMP_INSN_P (insn)
1288	&& GET_CODE (PATTERN (insn)) == SEQUENCE)
1289	{
1290	int i;
1291
1292	body = PATTERN (insn);
1293	for (i = 0; i < XVECLEN (body, 0); i++)
1294	{
1295	rtx inner_insn = XVECEXP (body, 0, i);
1296	int inner_uid = INSN_UID (insn: inner_insn);
1297
1298	INSN_ADDRESSES (inner_uid) = insn_current_address;
1299
1300	insn_current_address += insn_lengths[inner_uid];
1301	}
1302	}
1303	else
1304	insn_current_address += insn_lengths[uid];
1305
1306	continue;
1307	}
1308
1309	if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
1310	{
1311	rtx_sequence *seqn = as_a <rtx_sequence *> (p: PATTERN (insn));
1312	int i;
1313
1314	body = PATTERN (insn);
1315	new_length = 0;
1316	for (i = 0; i < seqn->len (); i++)
1317	{
1318	rtx_insn *inner_insn = seqn->insn (index: i);
1319	int inner_uid = INSN_UID (insn: inner_insn);
1320	int inner_length;
1321
1322	INSN_ADDRESSES (inner_uid) = insn_current_address;
1323
1324	/* insn_current_length returns 0 for insns with a
1325	non-varying length. */
1326	if (! varying_length[inner_uid])
1327	inner_length = insn_lengths[inner_uid];
1328	else
1329	inner_length = insn_current_length (inner_insn);
1330
1331	if (inner_length != insn_lengths[inner_uid])
1332	{
1333	if (!increasing || inner_length > insn_lengths[inner_uid])
1334	{
1335	insn_lengths[inner_uid] = inner_length;
1336	something_changed = true;
1337	}
1338	else
1339	inner_length = insn_lengths[inner_uid];
1340	}
1341	insn_current_address += inner_length;
1342	new_length += inner_length;
1343	}
1344	}
1345	else
1346	{
1347	new_length = insn_current_length (insn);
1348	insn_current_address += new_length;
1349	}
1350
1351	#ifdef ADJUST_INSN_LENGTH
1352	/* If needed, do any adjustment. */
1353	tmp_length = new_length;
1354	ADJUST_INSN_LENGTH (insn, new_length);
1355	insn_current_address += (new_length - tmp_length);
1356	#endif
1357
1358	if (new_length != insn_lengths[uid]
1359	&& (!increasing || new_length > insn_lengths[uid]))
1360	{
1361	insn_lengths[uid] = new_length;
1362	something_changed = true;
1363	}
1364	else
1365	insn_current_address += insn_lengths[uid] - new_length;
1366	}
1367	/* For a non-optimizing compile, do only a single pass. */
1368	if (!increasing)
1369	break;
1370	}
1371	crtl->max_insn_address = insn_current_address;
1372	free (ptr: varying_length);
1373	}
1374
1375	/* Given the body of an INSN known to be generated by an ASM statement, return
1376	the number of machine instructions likely to be generated for this insn.
1377	This is used to compute its length. */
1378
1379	static int
1380	asm_insn_count (rtx body)
1381	{
1382	const char *templ;
1383
1384	if (GET_CODE (body) == ASM_INPUT)
1385	templ = XSTR (body, 0);
1386	else
1387	templ = decode_asm_operands (body, NULL, NULL, NULL, NULL, NULL);
1388
1389	return asm_str_count (templ);
1390	}
1391
1392	/* Return the number of machine instructions likely to be generated for the
1393	inline-asm template. */
1394	int
1395	asm_str_count (const char *templ)
1396	{
1397	int count = 1;
1398
1399	if (!*templ)
1400	return 0;
1401
1402	for (; *templ; templ++)
1403	if (IS_ASM_LOGICAL_LINE_SEPARATOR (*templ, templ)
1404	|| *templ == '\n')
1405	count++;
1406
1407	return count;
1408	}
1409
1410	/* Return true if DWARF2 debug info can be emitted for DECL. */
1411
1412	static bool
1413	dwarf2_debug_info_emitted_p (tree decl)
1414	{
1415	/* When DWARF2 debug info is not generated internally. */
1416	if (!dwarf_debuginfo_p () && !dwarf_based_debuginfo_p ())
1417	return false;
1418
1419	if (DECL_IGNORED_P (decl))
1420	return false;
1421
1422	return true;
1423	}
1424
1425	/* Return scope resulting from combination of S1 and S2. */
1426	static tree
1427	choose_inner_scope (tree s1, tree s2)
1428	{
1429	if (!s1)
1430	return s2;
1431	if (!s2)
1432	return s1;
1433	if (BLOCK_NUMBER (s1) > BLOCK_NUMBER (s2))
1434	return s1;
1435	return s2;
1436	}
1437
1438	/* Emit lexical block notes needed to change scope from S1 to S2. */
1439
1440	static void
1441	change_scope (rtx_insn *orig_insn, tree s1, tree s2)
1442	{
1443	rtx_insn *insn = orig_insn;
1444	tree com = NULL_TREE;
1445	tree ts1 = s1, ts2 = s2;
1446	tree s;
1447
1448	while (ts1 != ts2)
1449	{
1450	gcc_assert (ts1 && ts2);
1451	if (BLOCK_NUMBER (ts1) > BLOCK_NUMBER (ts2))
1452	ts1 = BLOCK_SUPERCONTEXT (ts1);
1453	else if (BLOCK_NUMBER (ts1) < BLOCK_NUMBER (ts2))
1454	ts2 = BLOCK_SUPERCONTEXT (ts2);
1455	else
1456	{
1457	ts1 = BLOCK_SUPERCONTEXT (ts1);
1458	ts2 = BLOCK_SUPERCONTEXT (ts2);
1459	}
1460	}
1461	com = ts1;
1462
1463	/* Close scopes. */
1464	s = s1;
1465	while (s != com)
1466	{
1467	rtx_note *note = emit_note_before (NOTE_INSN_BLOCK_END, insn);
1468	NOTE_BLOCK (note) = s;
1469	s = BLOCK_SUPERCONTEXT (s);
1470	}
1471
1472	/* Open scopes. */
1473	s = s2;
1474	while (s != com)
1475	{
1476	insn = emit_note_before (NOTE_INSN_BLOCK_BEG, insn);
1477	NOTE_BLOCK (insn) = s;
1478	s = BLOCK_SUPERCONTEXT (s);
1479	}
1480	}
1481
1482	/* Rebuild all the NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes based
1483	on the scope tree and the newly reordered instructions. */
1484
1485	static void
1486	reemit_insn_block_notes (void)
1487	{
1488	tree cur_block = DECL_INITIAL (cfun->decl);
1489	rtx_insn *insn;
1490
1491	insn = get_insns ();
1492	for (; insn; insn = NEXT_INSN (insn))
1493	{
1494	tree this_block;
1495
1496	/* Prevent lexical blocks from straddling section boundaries. */
1497	if (NOTE_P (insn))
1498	switch (NOTE_KIND (insn))
1499	{
1500	case NOTE_INSN_SWITCH_TEXT_SECTIONS:
1501	{
1502	for (tree s = cur_block; s != DECL_INITIAL (cfun->decl);
1503	s = BLOCK_SUPERCONTEXT (s))
1504	{
1505	rtx_note *note = emit_note_before (NOTE_INSN_BLOCK_END, insn);
1506	NOTE_BLOCK (note) = s;
1507	note = emit_note_after (NOTE_INSN_BLOCK_BEG, insn);
1508	NOTE_BLOCK (note) = s;
1509	}
1510	}
1511	break;
1512
1513	case NOTE_INSN_BEGIN_STMT:
1514	case NOTE_INSN_INLINE_ENTRY:
1515	this_block = LOCATION_BLOCK (NOTE_MARKER_LOCATION (insn));
1516	goto set_cur_block_to_this_block;
1517
1518	default:
1519	continue;
1520	}
1521
1522	if (!active_insn_p (insn))
1523	continue;
1524
1525	/* Avoid putting scope notes between jump table and its label. */
1526	if (JUMP_TABLE_DATA_P (insn))
1527	continue;
1528
1529	this_block = insn_scope (insn);
1530	/* For sequences compute scope resulting from merging all scopes
1531	of instructions nested inside. */
1532	if (rtx_sequence *body = dyn_cast <rtx_sequence *> (p: PATTERN (insn)))
1533	{
1534	int i;
1535
1536	this_block = NULL;
1537	for (i = 0; i < body->len (); i++)
1538	this_block = choose_inner_scope (s1: this_block,
1539	s2: insn_scope (body->insn (index: i)));
1540	}
1541	set_cur_block_to_this_block:
1542	if (! this_block)
1543	{
1544	if (INSN_LOCATION (insn) == UNKNOWN_LOCATION)
1545	continue;
1546	else
1547	this_block = DECL_INITIAL (cfun->decl);
1548	}
1549
1550	if (this_block != cur_block)
1551	{
1552	change_scope (orig_insn: insn, s1: cur_block, s2: this_block);
1553	cur_block = this_block;
1554	}
1555	}
1556
1557	/* change_scope emits before the insn, not after. */
1558	rtx_note *note = emit_note (NOTE_INSN_DELETED);
1559	change_scope (orig_insn: note, s1: cur_block, DECL_INITIAL (cfun->decl));
1560	delete_insn (note);
1561
1562	reorder_blocks ();
1563	}
1564
1565	static const char *some_local_dynamic_name;
1566
1567	/* Locate some local-dynamic symbol still in use by this function
1568	so that we can print its name in local-dynamic base patterns.
1569	Return null if there are no local-dynamic references. */
1570
1571	const char *
1572	get_some_local_dynamic_name ()
1573	{
1574	subrtx_iterator::array_type array;
1575	rtx_insn *insn;
1576
1577	if (some_local_dynamic_name)
1578	return some_local_dynamic_name;
1579
1580	for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
1581	if (NONDEBUG_INSN_P (insn))
1582	FOR_EACH_SUBRTX (iter, array, PATTERN (insn), ALL)
1583	{
1584	const_rtx x = *iter;
1585	if (GET_CODE (x) == SYMBOL_REF)
1586	{
1587	if (SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
1588	return some_local_dynamic_name = XSTR (x, 0);
1589	if (CONSTANT_POOL_ADDRESS_P (x))
1590	iter.substitute (x: get_pool_constant (x));
1591	}
1592	}
1593
1594	return 0;
1595	}
1596
1597	/* Arrange for us to emit a source location note before any further
1598	real insns or section changes, by setting the SEEN_NEXT_VIEW bit in
1599	*SEEN, as long as we are keeping track of location views. The bit
1600	indicates we have referenced the next view at the current PC, so we
1601	have to emit it. This should be called next to the var_location
1602	debug hook. */
1603
1604	static inline void
1605	set_next_view_needed (int *seen)
1606	{
1607	if (debug_variable_location_views)
1608	*seen |= SEEN_NEXT_VIEW;
1609	}
1610
1611	/* Clear the flag in *SEEN indicating we need to emit the next view.
1612	This should be called next to the source_line debug hook. */
1613
1614	static inline void
1615	clear_next_view_needed (int *seen)
1616	{
1617	*seen &= ~SEEN_NEXT_VIEW;
1618	}
1619
1620	/* Test whether we have a pending request to emit the next view in
1621	*SEEN, and emit it if needed, clearing the request bit. */
1622
1623	static inline void
1624	maybe_output_next_view (int *seen)
1625	{
1626	if ((*seen & SEEN_NEXT_VIEW) != 0)
1627	{
1628	clear_next_view_needed (seen);
1629	(*debug_hooks->source_line) (last_linenum, last_columnnum,
1630	last_filename, last_discriminator,
1631	false);
1632	}
1633	}
1634
1635	/* We want to emit param bindings (before the first begin_stmt) in the
1636	initial view, if we are emitting views. To that end, we may
1637	consume initial notes in the function, processing them in
1638	final_start_function, before signaling the beginning of the
1639	prologue, rather than in final.
1640
1641	We don't test whether the DECLs are PARM_DECLs: the assumption is
1642	that there will be a NOTE_INSN_BEGIN_STMT marker before any
1643	non-parameter NOTE_INSN_VAR_LOCATION. It's ok if the marker is not
1644	there, we'll just have more variable locations bound in the initial
1645	view, which is consistent with their being bound without any code
1646	that would give them a value. */
1647
1648	static inline bool
1649	in_initial_view_p (rtx_insn *insn)
1650	{
1651	return (!DECL_IGNORED_P (current_function_decl)
1652	&& debug_variable_location_views
1653	&& insn && GET_CODE (insn) == NOTE
1654	&& (NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
1655	|| NOTE_KIND (insn) == NOTE_INSN_DELETED));
1656	}
1657
1658	/* Output assembler code for the start of a function,
1659	and initialize some of the variables in this file
1660	for the new function. The label for the function and associated
1661	assembler pseudo-ops have already been output in `assemble_start_function'.
1662
1663	FIRST is the first insn of the rtl for the function being compiled.
1664	FILE is the file to write assembler code to.
1665	SEEN should be initially set to zero, and it may be updated to
1666	indicate we have references to the next location view, that would
1667	require us to emit it at the current PC.
1668	OPTIMIZE_P is nonzero if we should eliminate redundant
1669	test and compare insns. */
1670
1671	static void
1672	final_start_function_1 (rtx_insn **firstp, FILE *file, int *seen,
1673	int optimize_p ATTRIBUTE_UNUSED)
1674	{
1675	block_depth = 0;
1676
1677	this_is_asm_operands = 0;
1678
1679	need_profile_function = false;
1680
1681	last_filename = LOCATION_FILE (prologue_location);
1682	last_linenum = LOCATION_LINE (prologue_location);
1683	last_columnnum = LOCATION_COLUMN (prologue_location);
1684	last_discriminator = 0;
1685	force_source_line = false;
1686
1687	high_block_linenum = high_function_linenum = last_linenum;
1688
1689	rtx_insn *first = *firstp;
1690	if (in_initial_view_p (insn: first))
1691	{
1692	do
1693	{
1694	final_scan_insn (first, file, 0, 0, seen);
1695	first = NEXT_INSN (insn: first);
1696	}
1697	while (in_initial_view_p (insn: first));
1698	*firstp = first;
1699	}
1700
1701	if (!DECL_IGNORED_P (current_function_decl))
1702	debug_hooks->begin_prologue (last_linenum, last_columnnum,
1703	last_filename);
1704
1705	if (!dwarf2_debug_info_emitted_p (decl: current_function_decl))
1706	dwarf2out_begin_prologue (0, 0, NULL);
1707
1708	if (DECL_IGNORED_P (current_function_decl) && last_linenum && last_filename)
1709	debug_hooks->set_ignored_loc (last_linenum, last_columnnum, last_filename);
1710
1711	#ifdef LEAF_REG_REMAP
1712	if (crtl->uses_only_leaf_regs)
1713	leaf_renumber_regs (first);
1714	#endif
1715
1716	/* The Sun386i and perhaps other machines don't work right
1717	if the profiling code comes after the prologue. */
1718	if (targetm.profile_before_prologue () && crtl->profile)
1719	{
1720	if (targetm.asm_out.function_prologue == default_function_pro_epilogue
1721	&& targetm.have_prologue ())
1722	{
1723	rtx_insn *insn;
1724	for (insn = first; insn; insn = NEXT_INSN (insn))
1725	if (!NOTE_P (insn))
1726	{
1727	insn = NULL;
1728	break;
1729	}
1730	else if (NOTE_KIND (insn) == NOTE_INSN_BASIC_BLOCK
1731	|| NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
1732	break;
1733	else if (NOTE_KIND (insn) == NOTE_INSN_DELETED
1734	|| NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION)
1735	continue;
1736	else
1737	{
1738	insn = NULL;
1739	break;
1740	}
1741
1742	if (insn)
1743	need_profile_function = true;
1744	else
1745	profile_function (file);
1746	}
1747	else
1748	profile_function (file);
1749	}
1750
1751	/* If debugging, assign block numbers to all of the blocks in this
1752	function. */
1753	if (write_symbols)
1754	{
1755	reemit_insn_block_notes ();
1756	number_blocks (current_function_decl);
1757	/* We never actually put out begin/end notes for the top-level
1758	block in the function. But, conceptually, that block is
1759	always needed. */
1760	TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl)) = 1;
1761	}
1762
1763	unsigned HOST_WIDE_INT min_frame_size
1764	= constant_lower_bound (a: get_frame_size ());
1765	if (min_frame_size > (unsigned HOST_WIDE_INT) warn_frame_larger_than_size)
1766	{
1767	/* Issue a warning */
1768	warning (OPT_Wframe_larger_than_,
1769	"the frame size of %wu bytes is larger than %wu bytes",
1770	min_frame_size, warn_frame_larger_than_size);
1771	}
1772
1773	/* First output the function prologue: code to set up the stack frame. */
1774	targetm.asm_out.function_prologue (file);
1775
1776	/* If the machine represents the prologue as RTL, the profiling code must
1777	be emitted when NOTE_INSN_PROLOGUE_END is scanned. */
1778	if (! targetm.have_prologue ())
1779	profile_after_prologue (file);
1780	}
1781
1782	/* This is an exported final_start_function_1, callable without SEEN. */
1783
1784	void
1785	final_start_function (rtx_insn *first, FILE *file,
1786	int optimize_p ATTRIBUTE_UNUSED)
1787	{
1788	int seen = 0;
1789	final_start_function_1 (firstp: &first, file, seen: &seen, optimize_p);
1790	gcc_assert (seen == 0);
1791	}
1792
1793	static void
1794	profile_after_prologue (FILE *file ATTRIBUTE_UNUSED)
1795	{
1796	if (!targetm.profile_before_prologue () && crtl->profile)
1797	profile_function (file);
1798	}
1799
1800	static void
1801	profile_function (FILE *file ATTRIBUTE_UNUSED)
1802	{
1803	#ifndef NO_PROFILE_COUNTERS
1804	# define NO_PROFILE_COUNTERS 0
1805	#endif
1806	#ifdef ASM_OUTPUT_REG_PUSH
1807	rtx sval = NULL, chain = NULL;
1808
1809	if (cfun->returns_struct)
1810	sval = targetm.calls.struct_value_rtx (TREE_TYPE (current_function_decl),
1811	true);
1812	if (cfun->static_chain_decl)
1813	chain = targetm.calls.static_chain (current_function_decl, true);
1814	#endif /* ASM_OUTPUT_REG_PUSH */
1815
1816	if (! NO_PROFILE_COUNTERS)
1817	{
1818	int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE);
1819	switch_to_section (data_section);
1820	ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
1821	targetm.asm_out.internal_label (file, "LP", current_function_funcdef_no);
1822	assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, align, 1);
1823	}
1824
1825	switch_to_section (current_function_section ());
1826
1827	#ifdef ASM_OUTPUT_REG_PUSH
1828	if (sval && REG_P (sval))
1829	ASM_OUTPUT_REG_PUSH (file, REGNO (sval));
1830	if (chain && REG_P (chain))
1831	ASM_OUTPUT_REG_PUSH (file, REGNO (chain));
1832	#endif
1833
1834	FUNCTION_PROFILER (file, current_function_funcdef_no);
1835
1836	#ifdef ASM_OUTPUT_REG_PUSH
1837	if (chain && REG_P (chain))
1838	ASM_OUTPUT_REG_POP (file, REGNO (chain));
1839	if (sval && REG_P (sval))
1840	ASM_OUTPUT_REG_POP (file, REGNO (sval));
1841	#endif
1842	}
1843
1844	/* Output assembler code for the end of a function.
1845	For clarity, args are same as those of `final_start_function'
1846	even though not all of them are needed. */
1847
1848	void
1849	final_end_function (void)
1850	{
1851	app_disable ();
1852
1853	if (!DECL_IGNORED_P (current_function_decl))
1854	debug_hooks->end_function (high_function_linenum);
1855
1856	/* Finally, output the function epilogue:
1857	code to restore the stack frame and return to the caller. */
1858	targetm.asm_out.function_epilogue (asm_out_file);
1859
1860	/* And debug output. */
1861	if (!DECL_IGNORED_P (current_function_decl))
1862	debug_hooks->end_epilogue (last_linenum, last_filename);
1863
1864	if (!dwarf2_debug_info_emitted_p (decl: current_function_decl)
1865	&& dwarf2out_do_frame ())
1866	dwarf2out_end_epilogue (last_linenum, last_filename);
1867
1868	some_local_dynamic_name = 0;
1869	}
1870
1871
1872	/* Dumper helper for basic block information. FILE is the assembly
1873	output file, and INSN is the instruction being emitted. */
1874
1875	static void
1876	dump_basic_block_info (FILE *file, rtx_insn *insn, basic_block *start_to_bb,
1877	basic_block *end_to_bb, int bb_map_size, int *bb_seqn)
1878	{
1879	basic_block bb;
1880
1881	if (!flag_debug_asm)
1882	return;
1883
1884	if (INSN_UID (insn) < bb_map_size
1885	&& (bb = start_to_bb[INSN_UID (insn)]) != NULL)
1886	{
1887	edge e;
1888	edge_iterator ei;
1889
1890	fprintf (stream: file, format: "%s BLOCK %d", ASM_COMMENT_START, bb->index);
1891	if (bb->count.initialized_p ())
1892	{
1893	fprintf (stream: file, format: ", count:");
1894	bb->count.dump (f: file);
1895	}
1896	fprintf (stream: file, format: " seq:%d", (*bb_seqn)++);
1897	fprintf (stream: file, format: "\n%s PRED:", ASM_COMMENT_START);
1898	FOR_EACH_EDGE (e, ei, bb->preds)
1899	{
1900	dump_edge_info (file, e, TDF_DETAILS, 0);
1901	}
1902	fprintf (stream: file, format: "\n");
1903	}
1904	if (INSN_UID (insn) < bb_map_size
1905	&& (bb = end_to_bb[INSN_UID (insn)]) != NULL)
1906	{
1907	edge e;
1908	edge_iterator ei;
1909
1910	fprintf (stream: asm_out_file, format: "%s SUCC:", ASM_COMMENT_START);
1911	FOR_EACH_EDGE (e, ei, bb->succs)
1912	{
1913	dump_edge_info (asm_out_file, e, TDF_DETAILS, 1);
1914	}
1915	fprintf (stream: file, format: "\n");
1916	}
1917	}
1918
1919	/* Output assembler code for some insns: all or part of a function.
1920	For description of args, see `final_start_function', above. */
1921
1922	static void
1923	final_1 (rtx_insn *first, FILE *file, int seen, int optimize_p)
1924	{
1925	rtx_insn *insn, *next;
1926
1927	/* Used for -dA dump. */
1928	basic_block *start_to_bb = NULL;
1929	basic_block *end_to_bb = NULL;
1930	int bb_map_size = 0;
1931	int bb_seqn = 0;
1932
1933	last_ignored_compare = 0;
1934
1935	init_recog ();
1936
1937	CC_STATUS_INIT;
1938
1939	if (flag_debug_asm)
1940	{
1941	basic_block bb;
1942
1943	bb_map_size = get_max_uid () + 1;
1944	start_to_bb = XCNEWVEC (basic_block, bb_map_size);
1945	end_to_bb = XCNEWVEC (basic_block, bb_map_size);
1946
1947	/* There is no cfg for a thunk. */
1948	if (!cfun->is_thunk)
1949	FOR_EACH_BB_REVERSE_FN (bb, cfun)
1950	{
1951	start_to_bb[INSN_UID (BB_HEAD (bb))] = bb;
1952	end_to_bb[INSN_UID (BB_END (bb))] = bb;
1953	}
1954	}
1955
1956	/* Output the insns. */
1957	for (insn = first; insn;)
1958	{
1959	if (HAVE_ATTR_length)
1960	{
1961	if ((unsigned) INSN_UID (insn) >= INSN_ADDRESSES_SIZE ())
1962	{
1963	/* This can be triggered by bugs elsewhere in the compiler if
1964	new insns are created after init_insn_lengths is called. */
1965	gcc_assert (NOTE_P (insn));
1966	insn_current_address = -1;
1967	}
1968	else
1969	insn_current_address = INSN_ADDRESSES (INSN_UID (insn));
1970	/* final can be seen as an iteration of shorten_branches that
1971	does nothing (since a fixed point has already been reached). */
1972	insn_last_address = insn_current_address;
1973	}
1974
1975	dump_basic_block_info (file, insn, start_to_bb, end_to_bb,
1976	bb_map_size, bb_seqn: &bb_seqn);
1977	insn = final_scan_insn (insn, file, optimize_p, 0, &seen);
1978	}
1979
1980	maybe_output_next_view (seen: &seen);
1981
1982	if (flag_debug_asm)
1983	{
1984	free (ptr: start_to_bb);
1985	free (ptr: end_to_bb);
1986	}
1987
1988	/* Remove CFI notes, to avoid compare-debug failures. */
1989	for (insn = first; insn; insn = next)
1990	{
1991	next = NEXT_INSN (insn);
1992	if (NOTE_P (insn)
1993	&& (NOTE_KIND (insn) == NOTE_INSN_CFI
1994	|| NOTE_KIND (insn) == NOTE_INSN_CFI_LABEL))
1995	delete_insn (insn);
1996	}
1997	}
1998
1999	/* This is an exported final_1, callable without SEEN. */
2000
2001	void
2002	final (rtx_insn *first, FILE *file, int optimize_p)
2003	{
2004	/* Those that use the internal final_start_function_1/final_1 API
2005	skip initial debug bind notes in final_start_function_1, and pass
2006	the modified FIRST to final_1. But those that use the public
2007	final_start_function/final APIs, final_start_function can't move
2008	FIRST because it's not passed by reference, so if they were
2009	skipped there, skip them again here. */
2010	while (in_initial_view_p (insn: first))
2011	first = NEXT_INSN (insn: first);
2012
2013	final_1 (first, file, seen: 0, optimize_p);
2014	}
2015
2016	const char *
2017	get_insn_template (int code, rtx_insn *insn)
2018	{
2019	switch (insn_data[code].output_format)
2020	{
2021	case INSN_OUTPUT_FORMAT_SINGLE:
2022	return insn_data[code].output.single;
2023	case INSN_OUTPUT_FORMAT_MULTI:
2024	return insn_data[code].output.multi[which_alternative];
2025	case INSN_OUTPUT_FORMAT_FUNCTION:
2026	gcc_assert (insn);
2027	return (*insn_data[code].output.function) (recog_data.operand, insn);
2028
2029	default:
2030	gcc_unreachable ();
2031	}
2032	}
2033
2034	/* Emit the appropriate declaration for an alternate-entry-point
2035	symbol represented by INSN, to FILE. INSN is a CODE_LABEL with
2036	LABEL_KIND != LABEL_NORMAL.
2037
2038	The case fall-through in this function is intentional. */
2039	static void
2040	output_alternate_entry_point (FILE *file, rtx_insn *insn)
2041	{
2042	const char *name = LABEL_NAME (insn);
2043
2044	switch (LABEL_KIND (insn))
2045	{
2046	case LABEL_WEAK_ENTRY:
2047	#ifdef ASM_WEAKEN_LABEL
2048	ASM_WEAKEN_LABEL (file, name);
2049	gcc_fallthrough ();
2050	#endif
2051	case LABEL_GLOBAL_ENTRY:
2052	targetm.asm_out.globalize_label (file, name);
2053	gcc_fallthrough ();
2054	case LABEL_STATIC_ENTRY:
2055	#ifdef ASM_OUTPUT_TYPE_DIRECTIVE
2056	ASM_OUTPUT_TYPE_DIRECTIVE (file, name, "function");
2057	#endif
2058	ASM_OUTPUT_LABEL (file, name);
2059	break;
2060
2061	case LABEL_NORMAL:
2062	default:
2063	gcc_unreachable ();
2064	}
2065	}
2066
2067	/* Given a CALL_INSN, find and return the nested CALL. */
2068	static rtx
2069	call_from_call_insn (rtx_call_insn *insn)
2070	{
2071	rtx x;
2072	gcc_assert (CALL_P (insn));
2073	x = PATTERN (insn);
2074
2075	while (GET_CODE (x) != CALL)
2076	{
2077	switch (GET_CODE (x))
2078	{
2079	default:
2080	gcc_unreachable ();
2081	case COND_EXEC:
2082	x = COND_EXEC_CODE (x);
2083	break;
2084	case PARALLEL:
2085	x = XVECEXP (x, 0, 0);
2086	break;
2087	case SET:
2088	x = XEXP (x, 1);
2089	break;
2090	}
2091	}
2092	return x;
2093	}
2094
2095	/* Print a comment into the asm showing FILENAME, LINENUM, and the
2096	corresponding source line, if available. */
2097
2098	static void
2099	asm_show_source (const char *filename, int linenum)
2100	{
2101	if (!filename)
2102	return;
2103
2104	char_span line
2105	= global_dc->get_file_cache ().get_source_line (file_path: filename, line: linenum);
2106	if (!line)
2107	return;
2108
2109	fprintf (stream: asm_out_file, format: "%s %s:%i: ", ASM_COMMENT_START, filename, linenum);
2110	/* "line" is not 0-terminated, so we must use its length. */
2111	fwrite (ptr: line.get_buffer (), size: 1, n: line.length (), s: asm_out_file);
2112	fputc (c: '\n', stream: asm_out_file);
2113	}
2114
2115	/* Judge if an absolute jump table is relocatable. */
2116
2117	bool
2118	jumptable_relocatable (void)
2119	{
2120	bool relocatable = false;
2121
2122	if (!CASE_VECTOR_PC_RELATIVE
2123	&& !targetm.asm_out.generate_pic_addr_diff_vec ()
2124	&& targetm_common.have_named_sections)
2125	relocatable = targetm.asm_out.reloc_rw_mask ();
2126
2127	return relocatable;
2128	}
2129
2130	/* The final scan for one insn, INSN.
2131	Args are same as in `final', except that INSN
2132	is the insn being scanned.
2133	Value returned is the next insn to be scanned.
2134
2135	NOPEEPHOLES is the flag to disallow peephole processing (currently
2136	used for within delayed branch sequence output).
2137
2138	SEEN is used to track the end of the prologue, for emitting
2139	debug information. We force the emission of a line note after
2140	both NOTE_INSN_PROLOGUE_END and NOTE_INSN_FUNCTION_BEG. */
2141
2142	static rtx_insn *
2143	final_scan_insn_1 (rtx_insn *insn, FILE *file, int optimize_p ATTRIBUTE_UNUSED,
2144	int nopeepholes ATTRIBUTE_UNUSED, int *seen)
2145	{
2146	rtx_insn *next;
2147	rtx_jump_table_data *table;
2148
2149	insn_counter++;
2150
2151	/* Ignore deleted insns. These can occur when we split insns (due to a
2152	template of "#") while not optimizing. */
2153	if (insn->deleted ())
2154	return NEXT_INSN (insn);
2155
2156	switch (GET_CODE (insn))
2157	{
2158	case NOTE:
2159	switch (NOTE_KIND (insn))
2160	{
2161	case NOTE_INSN_DELETED:
2162	case NOTE_INSN_UPDATE_SJLJ_CONTEXT:
2163	break;
2164
2165	case NOTE_INSN_SWITCH_TEXT_SECTIONS:
2166	maybe_output_next_view (seen);
2167
2168	output_function_exception_table (0);
2169
2170	if (targetm.asm_out.unwind_emit)
2171	targetm.asm_out.unwind_emit (asm_out_file, insn);
2172
2173	in_cold_section_p = !in_cold_section_p;
2174
2175	gcc_checking_assert (in_cold_section_p);
2176	if (in_cold_section_p)
2177	cold_function_name
2178	= clone_function_name (decl: current_function_decl, suffix: "cold");
2179
2180	if (dwarf2out_do_frame ())
2181	{
2182	dwarf2out_switch_text_section ();
2183	if (!dwarf2_debug_info_emitted_p (decl: current_function_decl)
2184	&& !DECL_IGNORED_P (current_function_decl))
2185	debug_hooks->switch_text_section ();
2186	}
2187	else if (!DECL_IGNORED_P (current_function_decl))
2188	debug_hooks->switch_text_section ();
2189	if (DECL_IGNORED_P (current_function_decl) && last_linenum
2190	&& last_filename)
2191	debug_hooks->set_ignored_loc (last_linenum, last_columnnum,
2192	last_filename);
2193
2194	switch_to_section (current_function_section ());
2195	targetm.asm_out.function_switched_text_sections (asm_out_file,
2196	current_function_decl,
2197	in_cold_section_p);
2198	/* Emit a label for the split cold section. Form label name by
2199	suffixing "cold" to the original function's name. */
2200	if (in_cold_section_p)
2201	{
2202	#ifdef ASM_DECLARE_COLD_FUNCTION_NAME
2203	ASM_DECLARE_COLD_FUNCTION_NAME (asm_out_file,
2204	IDENTIFIER_POINTER
2205	(cold_function_name),
2206	current_function_decl);
2207	#else
2208	ASM_OUTPUT_LABEL (asm_out_file,
2209	IDENTIFIER_POINTER (cold_function_name));
2210	#endif
2211	if (dwarf2out_do_frame ()
2212	&& cfun->fde->dw_fde_second_begin != NULL)
2213	ASM_OUTPUT_LABEL (asm_out_file, cfun->fde->dw_fde_second_begin);
2214	}
2215	break;
2216
2217	case NOTE_INSN_BASIC_BLOCK:
2218	if (need_profile_function)
2219	{
2220	profile_function (file: asm_out_file);
2221	need_profile_function = false;
2222	}
2223
2224	if (targetm.asm_out.unwind_emit)
2225	targetm.asm_out.unwind_emit (asm_out_file, insn);
2226
2227	break;
2228
2229	case NOTE_INSN_EH_REGION_BEG:
2230	ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHB",
2231	NOTE_EH_HANDLER (insn));
2232	break;
2233
2234	case NOTE_INSN_EH_REGION_END:
2235	ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHE",
2236	NOTE_EH_HANDLER (insn));
2237	break;
2238
2239	case NOTE_INSN_PROLOGUE_END:
2240	targetm.asm_out.function_end_prologue (file);
2241	profile_after_prologue (file);
2242
2243	if ((*seen & (SEEN_EMITTED | SEEN_NOTE)) == SEEN_NOTE)
2244	{
2245	*seen |= SEEN_EMITTED;
2246	force_source_line = true;
2247	}
2248	else
2249	*seen |= SEEN_NOTE;
2250
2251	break;
2252
2253	case NOTE_INSN_EPILOGUE_BEG:
2254	if (!DECL_IGNORED_P (current_function_decl))
2255	(*debug_hooks->begin_epilogue) (last_linenum, last_filename);
2256	targetm.asm_out.function_begin_epilogue (file);
2257	break;
2258
2259	case NOTE_INSN_CFI:
2260	dwarf2out_emit_cfi (NOTE_CFI (insn));
2261	break;
2262
2263	case NOTE_INSN_CFI_LABEL:
2264	ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LCFI",
2265	NOTE_LABEL_NUMBER (insn));
2266	break;
2267
2268	case NOTE_INSN_FUNCTION_BEG:
2269	if (need_profile_function)
2270	{
2271	profile_function (file: asm_out_file);
2272	need_profile_function = false;
2273	}
2274
2275	app_disable ();
2276	if (!DECL_IGNORED_P (current_function_decl))
2277	debug_hooks->end_prologue (last_linenum, last_filename);
2278
2279	if ((*seen & (SEEN_EMITTED | SEEN_NOTE)) == SEEN_NOTE)
2280	{
2281	*seen |= SEEN_EMITTED;
2282	force_source_line = true;
2283	}
2284	else
2285	*seen |= SEEN_NOTE;
2286
2287	break;
2288
2289	case NOTE_INSN_BLOCK_BEG:
2290	if (debug_info_level >= DINFO_LEVEL_NORMAL
2291	|| dwarf_debuginfo_p ()
2292	|| write_symbols == VMS_DEBUG)
2293	{
2294	int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
2295
2296	app_disable ();
2297	++block_depth;
2298	high_block_linenum = last_linenum;
2299
2300	/* Output debugging info about the symbol-block beginning. */
2301	if (!DECL_IGNORED_P (current_function_decl))
2302	debug_hooks->begin_block (last_linenum, n);
2303
2304	/* Mark this block as output. */
2305	TREE_ASM_WRITTEN (NOTE_BLOCK (insn)) = 1;
2306	BLOCK_IN_COLD_SECTION_P (NOTE_BLOCK (insn)) = in_cold_section_p;
2307	}
2308	break;
2309
2310	case NOTE_INSN_BLOCK_END:
2311	maybe_output_next_view (seen);
2312
2313	if (debug_info_level >= DINFO_LEVEL_NORMAL
2314	|| dwarf_debuginfo_p ()
2315	|| write_symbols == VMS_DEBUG)
2316	{
2317	int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
2318
2319	app_disable ();
2320
2321	/* End of a symbol-block. */
2322	--block_depth;
2323	gcc_assert (block_depth >= 0);
2324
2325	if (!DECL_IGNORED_P (current_function_decl))
2326	debug_hooks->end_block (high_block_linenum, n);
2327	gcc_assert (BLOCK_IN_COLD_SECTION_P (NOTE_BLOCK (insn))
2328	== in_cold_section_p);
2329	}
2330	break;
2331
2332	case NOTE_INSN_DELETED_LABEL:
2333	/* Emit the label. We may have deleted the CODE_LABEL because
2334	the label could be proved to be unreachable, though still
2335	referenced (in the form of having its address taken. */
2336	ASM_OUTPUT_DEBUG_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
2337	break;
2338
2339	case NOTE_INSN_DELETED_DEBUG_LABEL:
2340	/* Similarly, but need to use different namespace for it. */
2341	if (CODE_LABEL_NUMBER (insn) != -1)
2342	ASM_OUTPUT_DEBUG_LABEL (file, "LDL", CODE_LABEL_NUMBER (insn));
2343	break;
2344
2345	case NOTE_INSN_VAR_LOCATION:
2346	if (!DECL_IGNORED_P (current_function_decl))
2347	{
2348	debug_hooks->var_location (insn);
2349	set_next_view_needed (seen);
2350	}
2351	break;
2352
2353	case NOTE_INSN_BEGIN_STMT:
2354	gcc_checking_assert (cfun->debug_nonbind_markers);
2355	if (!DECL_IGNORED_P (current_function_decl)
2356	&& notice_source_line (insn, NULL))
2357	{
2358	output_source_line:
2359	(*debug_hooks->source_line) (last_linenum, last_columnnum,
2360	last_filename, last_discriminator,
2361	true);
2362	clear_next_view_needed (seen);
2363	}
2364	break;
2365
2366	case NOTE_INSN_INLINE_ENTRY:
2367	gcc_checking_assert (cfun->debug_nonbind_markers);
2368	if (!DECL_IGNORED_P (current_function_decl)
2369	&& notice_source_line (insn, NULL))
2370	{
2371	(*debug_hooks->inline_entry) (LOCATION_BLOCK
2372	(NOTE_MARKER_LOCATION (insn)));
2373	goto output_source_line;
2374	}
2375	break;
2376
2377	default:
2378	gcc_unreachable ();
2379	break;
2380	}
2381	break;
2382
2383	case BARRIER:
2384	break;
2385
2386	case CODE_LABEL:
2387	/* The target port might emit labels in the output function for
2388	some insn, e.g. sh.cc output_branchy_insn. */
2389	if (CODE_LABEL_NUMBER (insn) <= max_labelno)
2390	{
2391	align_flags alignment = LABEL_TO_ALIGNMENT (insn);
2392	if (alignment.levels[0].log && NEXT_INSN (insn))
2393	{
2394	#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
2395	/* Output both primary and secondary alignment. */
2396	ASM_OUTPUT_MAX_SKIP_ALIGN (file, alignment.levels[0].log,
2397	alignment.levels[0].maxskip);
2398	ASM_OUTPUT_MAX_SKIP_ALIGN (file, alignment.levels[1].log,
2399	alignment.levels[1].maxskip);
2400	#else
2401	#ifdef ASM_OUTPUT_ALIGN_WITH_NOP
2402	ASM_OUTPUT_ALIGN_WITH_NOP (file, alignment.levels[0].log);
2403	#else
2404	ASM_OUTPUT_ALIGN (file, alignment.levels[0].log);
2405	#endif
2406	#endif
2407	}
2408	}
2409	CC_STATUS_INIT;
2410
2411	if (!DECL_IGNORED_P (current_function_decl) && LABEL_NAME (insn))
2412	debug_hooks->label (as_a <rtx_code_label *> (p: insn));
2413
2414	app_disable ();
2415
2416	/* If this label is followed by a jump-table, make sure we put
2417	the label in the read-only section. Also possibly write the
2418	label and jump table together. */
2419	table = jump_table_for_label (label: as_a <rtx_code_label *> (p: insn));
2420	if (table)
2421	{
2422	#if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2423	/* In this case, the case vector is being moved by the
2424	target, so don't output the label at all. Leave that
2425	to the back end macros. */
2426	#else
2427	if (! JUMP_TABLES_IN_TEXT_SECTION)
2428	{
2429	int log_align;
2430
2431	switch_to_section (targetm.asm_out.function_rodata_section
2432	(current_function_decl,
2433	jumptable_relocatable ()));
2434
2435	#ifdef ADDR_VEC_ALIGN
2436	log_align = ADDR_VEC_ALIGN (table);
2437	#else
2438	log_align = exact_log2 (BIGGEST_ALIGNMENT / BITS_PER_UNIT);
2439	#endif
2440	ASM_OUTPUT_ALIGN (file, log_align);
2441	}
2442	else
2443	switch_to_section (current_function_section ());
2444
2445	#ifdef ASM_OUTPUT_CASE_LABEL
2446	ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn), table);
2447	#else
2448	targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (insn));
2449	#endif
2450	#endif
2451	break;
2452	}
2453	if (LABEL_ALT_ENTRY_P (insn))
2454	output_alternate_entry_point (file, insn);
2455	else
2456	targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (insn));
2457	break;
2458
2459	default:
2460	{
2461	rtx body = PATTERN (insn);
2462	int insn_code_number;
2463	const char *templ;
2464	bool is_stmt, *is_stmt_p;
2465
2466	if (MAY_HAVE_DEBUG_MARKER_INSNS && cfun->debug_nonbind_markers)
2467	{
2468	is_stmt = false;
2469	is_stmt_p = NULL;
2470	}
2471	else
2472	is_stmt_p = &is_stmt;
2473
2474	/* Reset this early so it is correct for ASM statements. */
2475	current_insn_predicate = NULL_RTX;
2476
2477	/* An INSN, JUMP_INSN or CALL_INSN.
2478	First check for special kinds that recog doesn't recognize. */
2479
2480	if (GET_CODE (body) == USE /* These are just declarations. */
2481	|| GET_CODE (body) == CLOBBER)
2482	break;
2483
2484	/* Detect insns that are really jump-tables
2485	and output them as such. */
2486
2487	if (JUMP_TABLE_DATA_P (insn))
2488	{
2489	#if !(defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC))
2490	int vlen, idx;
2491	#endif
2492
2493	if (! JUMP_TABLES_IN_TEXT_SECTION)
2494	switch_to_section (targetm.asm_out.function_rodata_section
2495	(current_function_decl,
2496	jumptable_relocatable ()));
2497	else
2498	switch_to_section (current_function_section ());
2499
2500	app_disable ();
2501
2502	#if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2503	if (GET_CODE (body) == ADDR_VEC)
2504	{
2505	#ifdef ASM_OUTPUT_ADDR_VEC
2506	ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn), body);
2507	#else
2508	gcc_unreachable ();
2509	#endif
2510	}
2511	else
2512	{
2513	#ifdef ASM_OUTPUT_ADDR_DIFF_VEC
2514	ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn), body);
2515	#else
2516	gcc_unreachable ();
2517	#endif
2518	}
2519	#else
2520	vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC);
2521	for (idx = 0; idx < vlen; idx++)
2522	{
2523	if (GET_CODE (body) == ADDR_VEC)
2524	{
2525	#ifdef ASM_OUTPUT_ADDR_VEC_ELT
2526	ASM_OUTPUT_ADDR_VEC_ELT
2527	(file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
2528	#else
2529	gcc_unreachable ();
2530	#endif
2531	}
2532	else
2533	{
2534	#ifdef ASM_OUTPUT_ADDR_DIFF_ELT
2535	ASM_OUTPUT_ADDR_DIFF_ELT
2536	(file,
2537	body,
2538	CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
2539	CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
2540	#else
2541	gcc_unreachable ();
2542	#endif
2543	}
2544	}
2545	#ifdef ASM_OUTPUT_CASE_END
2546	ASM_OUTPUT_CASE_END (file,
2547	CODE_LABEL_NUMBER (PREV_INSN (insn)),
2548	insn);
2549	#endif
2550	#endif
2551
2552	switch_to_section (current_function_section ());
2553
2554	if (debug_variable_location_views
2555	&& !DECL_IGNORED_P (current_function_decl))
2556	debug_hooks->var_location (insn);
2557
2558	break;
2559	}
2560	/* Output this line note if it is the first or the last line
2561	note in a row. */
2562	if (!DECL_IGNORED_P (current_function_decl)
2563	&& notice_source_line (insn, is_stmt_p))
2564	{
2565	if (flag_verbose_asm)
2566	asm_show_source (filename: last_filename, linenum: last_linenum);
2567	(*debug_hooks->source_line) (last_linenum, last_columnnum,
2568	last_filename, last_discriminator,
2569	is_stmt);
2570	clear_next_view_needed (seen);
2571	}
2572	else
2573	maybe_output_next_view (seen);
2574
2575	gcc_checking_assert (!DEBUG_INSN_P (insn));
2576
2577	if (GET_CODE (body) == PARALLEL
2578	&& GET_CODE (XVECEXP (body, 0, 0)) == ASM_INPUT)
2579	body = XVECEXP (body, 0, 0);
2580
2581	if (GET_CODE (body) == ASM_INPUT)
2582	{
2583	const char *string = XSTR (body, 0);
2584
2585	/* There's no telling what that did to the condition codes. */
2586	CC_STATUS_INIT;
2587
2588	if (string[0])
2589	{
2590	expanded_location loc;
2591
2592	app_enable ();
2593	loc = expand_location (ASM_INPUT_SOURCE_LOCATION (body));
2594	if (*loc.file && loc.line)
2595	fprintf (stream: asm_out_file, format: "%s %i \"%s\" 1\n",
2596	ASM_COMMENT_START, loc.line, loc.file);
2597	fprintf (stream: asm_out_file, format: "\t%s\n", string);
2598	#if HAVE_AS_LINE_ZERO
2599	if (*loc.file && loc.line)
2600	fprintf (stream: asm_out_file, format: "%s 0 \"\" 2\n", ASM_COMMENT_START);
2601	#endif
2602	}
2603	break;
2604	}
2605
2606	/* Detect `asm' construct with operands. */
2607	if (asm_noperands (body) >= 0)
2608	{
2609	unsigned int noperands = asm_noperands (body);
2610	rtx *ops = XALLOCAVEC (rtx, noperands);
2611	const char *string;
2612	location_t loc;
2613	expanded_location expanded;
2614
2615	/* There's no telling what that did to the condition codes. */
2616	CC_STATUS_INIT;
2617
2618	/* Get out the operand values. */
2619	string = decode_asm_operands (body, ops, NULL, NULL, NULL, &loc);
2620	/* Inhibit dying on what would otherwise be compiler bugs. */
2621	insn_noperands = noperands;
2622	this_is_asm_operands = insn;
2623	expanded = expand_location (loc);
2624
2625	#ifdef FINAL_PRESCAN_INSN
2626	FINAL_PRESCAN_INSN (insn, ops, insn_noperands);
2627	#endif
2628
2629	/* Output the insn using them. */
2630	if (string[0])
2631	{
2632	app_enable ();
2633	if (expanded.file && expanded.line)
2634	fprintf (stream: asm_out_file, format: "%s %i \"%s\" 1\n",
2635	ASM_COMMENT_START, expanded.line, expanded.file);
2636	output_asm_insn (string, ops);
2637	#if HAVE_AS_LINE_ZERO
2638	if (expanded.file && expanded.line)
2639	fprintf (stream: asm_out_file, format: "%s 0 \"\" 2\n", ASM_COMMENT_START);
2640	#endif
2641	}
2642
2643	if (targetm.asm_out.final_postscan_insn)
2644	targetm.asm_out.final_postscan_insn (file, insn, ops,
2645	insn_noperands);
2646
2647	this_is_asm_operands = 0;
2648	break;
2649	}
2650
2651	app_disable ();
2652
2653	if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (p: body))
2654	{
2655	/* A delayed-branch sequence */
2656	int i;
2657
2658	final_sequence = seq;
2659
2660	/* The first insn in this SEQUENCE might be a JUMP_INSN that will
2661	force the restoration of a comparison that was previously
2662	thought unnecessary. If that happens, cancel this sequence
2663	and cause that insn to be restored. */
2664
2665	next = final_scan_insn (seq->insn (index: 0), file, 0, 1, seen);
2666	if (next != seq->insn (index: 1))
2667	{
2668	final_sequence = 0;
2669	return next;
2670	}
2671
2672	for (i = 1; i < seq->len (); i++)
2673	{
2674	rtx_insn *insn = seq->insn (index: i);
2675	rtx_insn *next = NEXT_INSN (insn);
2676	/* We loop in case any instruction in a delay slot gets
2677	split. */
2678	do
2679	insn = final_scan_insn (insn, file, 0, 1, seen);
2680	while (insn != next);
2681	}
2682	#ifdef DBR_OUTPUT_SEQEND
2683	DBR_OUTPUT_SEQEND (file);
2684	#endif
2685	final_sequence = 0;
2686
2687	/* If the insn requiring the delay slot was a CALL_INSN, the
2688	insns in the delay slot are actually executed before the
2689	called function. Hence we don't preserve any CC-setting
2690	actions in these insns and the CC must be marked as being
2691	clobbered by the function. */
2692	if (CALL_P (seq->insn (0)))
2693	{
2694	CC_STATUS_INIT;
2695	}
2696	break;
2697	}
2698
2699	/* We have a real machine instruction as rtl. */
2700
2701	body = PATTERN (insn);
2702
2703	/* Do machine-specific peephole optimizations if desired. */
2704
2705	if (HAVE_peephole && optimize_p && !flag_no_peephole && !nopeepholes)
2706	{
2707	rtx_insn *next = peephole (insn);
2708	/* When peepholing, if there were notes within the peephole,
2709	emit them before the peephole. */
2710	if (next != 0 && next != NEXT_INSN (insn))
2711	{
2712	rtx_insn *note, *prev = PREV_INSN (insn);
2713
2714	for (note = NEXT_INSN (insn); note != next;
2715	note = NEXT_INSN (insn: note))
2716	final_scan_insn (note, file, optimize_p, nopeepholes, seen);
2717
2718	/* Put the notes in the proper position for a later
2719	rescan. For example, the SH target can do this
2720	when generating a far jump in a delayed branch
2721	sequence. */
2722	note = NEXT_INSN (insn);
2723	SET_PREV_INSN (note) = prev;
2724	SET_NEXT_INSN (prev) = note;
2725	SET_NEXT_INSN (PREV_INSN (insn: next)) = insn;
2726	SET_PREV_INSN (insn) = PREV_INSN (insn: next);
2727	SET_NEXT_INSN (insn) = next;
2728	SET_PREV_INSN (next) = insn;
2729	}
2730
2731	/* PEEPHOLE might have changed this. */
2732	body = PATTERN (insn);
2733	}
2734
2735	/* Try to recognize the instruction.
2736	If successful, verify that the operands satisfy the
2737	constraints for the instruction. Crash if they don't,
2738	since `reload' should have changed them so that they do. */
2739
2740	insn_code_number = recog_memoized (insn);
2741	cleanup_subreg_operands (insn);
2742
2743	/* Dump the insn in the assembly for debugging (-dAP).
2744	If the final dump is requested as slim RTL, dump slim
2745	RTL to the assembly file also. */
2746	if (flag_dump_rtl_in_asm)
2747	{
2748	print_rtx_head = ASM_COMMENT_START;
2749	if (! (dump_flags & TDF_SLIM))
2750	print_rtl_single (asm_out_file, insn);
2751	else
2752	dump_insn_slim (asm_out_file, insn);
2753	print_rtx_head = "";
2754	}
2755
2756	if (! constrain_operands_cached (insn, 1))
2757	fatal_insn_not_found (insn);
2758
2759	/* Some target machines need to prescan each insn before
2760	it is output. */
2761
2762	#ifdef FINAL_PRESCAN_INSN
2763	FINAL_PRESCAN_INSN (insn, recog_data.operand, recog_data.n_operands);
2764	#endif
2765
2766	if (targetm.have_conditional_execution ()
2767	&& GET_CODE (PATTERN (insn)) == COND_EXEC)
2768	current_insn_predicate = COND_EXEC_TEST (PATTERN (insn));
2769
2770	current_output_insn = debug_insn = insn;
2771
2772	/* Find the proper template for this insn. */
2773	templ = get_insn_template (code: insn_code_number, insn);
2774
2775	/* If the C code returns 0, it means that it is a jump insn
2776	which follows a deleted test insn, and that test insn
2777	needs to be reinserted. */
2778	if (templ == 0)
2779	{
2780	rtx_insn *prev;
2781
2782	gcc_assert (prev_nonnote_insn (insn) == last_ignored_compare);
2783
2784	/* We have already processed the notes between the setter and
2785	the user. Make sure we don't process them again, this is
2786	particularly important if one of the notes is a block
2787	scope note or an EH note. */
2788	for (prev = insn;
2789	prev != last_ignored_compare;
2790	prev = PREV_INSN (insn: prev))
2791	{
2792	if (NOTE_P (prev))
2793	delete_insn (prev); /* Use delete_note. */
2794	}
2795
2796	return prev;
2797	}
2798
2799	/* If the template is the string "#", it means that this insn must
2800	be split. */
2801	if (templ[0] == '#' && templ[1] == '\0')
2802	{
2803	rtx_insn *new_rtx = try_split (body, insn, 0);
2804
2805	/* If we didn't split the insn, go away. */
2806	if (new_rtx == insn && PATTERN (insn: new_rtx) == body)
2807	fatal_insn ("could not split insn", insn);
2808
2809	/* If we have a length attribute, this instruction should have
2810	been split in shorten_branches, to ensure that we would have
2811	valid length info for the splitees. */
2812	gcc_assert (!HAVE_ATTR_length);
2813
2814	return new_rtx;
2815	}
2816
2817	/* ??? This will put the directives in the wrong place if
2818	get_insn_template outputs assembly directly. However calling it
2819	before get_insn_template breaks if the insns is split. */
2820	if (targetm.asm_out.unwind_emit_before_insn
2821	&& targetm.asm_out.unwind_emit)
2822	targetm.asm_out.unwind_emit (asm_out_file, insn);
2823
2824	rtx_call_insn *call_insn = dyn_cast <rtx_call_insn *> (p: insn);
2825	if (call_insn != NULL)
2826	{
2827	rtx x = call_from_call_insn (insn: call_insn);
2828	x = XEXP (x, 0);
2829	if (x && MEM_P (x) && GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
2830	{
2831	tree t;
2832	x = XEXP (x, 0);
2833	t = SYMBOL_REF_DECL (x);
2834	if (t)
2835	assemble_external (t);
2836	}
2837	}
2838
2839	/* Output assembler code from the template. */
2840	output_asm_insn (templ, recog_data.operand);
2841
2842	/* Some target machines need to postscan each insn after
2843	it is output. */
2844	if (targetm.asm_out.final_postscan_insn)
2845	targetm.asm_out.final_postscan_insn (file, insn, recog_data.operand,
2846	recog_data.n_operands);
2847
2848	if (!targetm.asm_out.unwind_emit_before_insn
2849	&& targetm.asm_out.unwind_emit)
2850	targetm.asm_out.unwind_emit (asm_out_file, insn);
2851
2852	/* Let the debug info back-end know about this call. We do this only
2853	after the instruction has been emitted because labels that may be
2854	created to reference the call instruction must appear after it. */
2855	if ((debug_variable_location_views || call_insn != NULL)
2856	&& !DECL_IGNORED_P (current_function_decl))
2857	debug_hooks->var_location (insn);
2858
2859	current_output_insn = debug_insn = 0;
2860	}
2861	}
2862	return NEXT_INSN (insn);
2863	}
2864
2865	/* This is a wrapper around final_scan_insn_1 that allows ports to
2866	call it recursively without a known value for SEEN. The value is
2867	saved at the outermost call, and recovered for recursive calls.
2868	Recursive calls MUST pass NULL, or the same pointer if they can
2869	otherwise get to it. */
2870
2871	rtx_insn *
2872	final_scan_insn (rtx_insn *insn, FILE *file, int optimize_p,
2873	int nopeepholes, int *seen)
2874	{
2875	static int *enclosing_seen;
2876	static int recursion_counter;
2877
2878	gcc_assert (seen || recursion_counter);
2879	gcc_assert (!recursion_counter || !seen || seen == enclosing_seen);
2880
2881	if (!recursion_counter++)
2882	enclosing_seen = seen;
2883	else if (!seen)
2884	seen = enclosing_seen;
2885
2886	rtx_insn *ret = final_scan_insn_1 (insn, file, optimize_p, nopeepholes, seen);
2887
2888	if (!--recursion_counter)
2889	enclosing_seen = NULL;
2890
2891	return ret;
2892	}
2893
2894
2895
2896	/* Map DECLs to instance discriminators. This is allocated and
2897	defined in ada/gcc-interfaces/trans.cc, when compiling with -gnateS.
2898	Mappings from this table are saved and restored for LTO, so
2899	link-time compilation will have this map set, at least in
2900	partitions containing at least one DECL with an associated instance
2901	discriminator. */
2902
2903	decl_to_instance_map_t *decl_to_instance_map;
2904
2905	/* Return the instance number assigned to DECL. */
2906
2907	static inline int
2908	map_decl_to_instance (const_tree decl)
2909	{
2910	int *inst;
2911
2912	if (!decl_to_instance_map || !decl || !DECL_P (decl))
2913	return 0;
2914
2915	inst = decl_to_instance_map->get (k: decl);
2916
2917	if (!inst)
2918	return 0;
2919
2920	return *inst;
2921	}
2922
2923	/* Set DISCRIMINATOR to the appropriate value, possibly derived from LOC. */
2924
2925	static inline int
2926	compute_discriminator (location_t loc)
2927	{
2928	int discriminator;
2929
2930	if (!decl_to_instance_map)
2931	discriminator = get_discriminator_from_loc (loc);
2932	else
2933	{
2934	tree block = LOCATION_BLOCK (loc);
2935
2936	while (block && TREE_CODE (block) == BLOCK
2937	&& !inlined_function_outer_scope_p (block))
2938	block = BLOCK_SUPERCONTEXT (block);
2939
2940	tree decl;
2941
2942	if (!block)
2943	decl = current_function_decl;
2944	else if (DECL_P (block))
2945	decl = block;
2946	else
2947	decl = block_ultimate_origin (block);
2948
2949	discriminator = map_decl_to_instance (decl);
2950	}
2951
2952	return discriminator;
2953	}
2954
2955	/* Return discriminator of the statement that produced this insn. */
2956	int
2957	insn_discriminator (const rtx_insn *insn)
2958	{
2959	return compute_discriminator (loc: INSN_LOCATION (insn));
2960	}
2961
2962	/* Return whether a source line note needs to be emitted before INSN.
2963	Sets IS_STMT to TRUE if the line should be marked as a possible
2964	breakpoint location. */
2965
2966	static bool
2967	notice_source_line (rtx_insn *insn, bool *is_stmt)
2968	{
2969	const char *filename;
2970	int linenum, columnnum;
2971	int discriminator;
2972
2973	if (NOTE_MARKER_P (insn))
2974	{
2975	location_t loc = NOTE_MARKER_LOCATION (insn);
2976	expanded_location xloc = expand_location (loc);
2977	if (xloc.line == 0
2978	&& (LOCATION_LOCUS (loc) == UNKNOWN_LOCATION
2979	|| LOCATION_LOCUS (loc) == BUILTINS_LOCATION))
2980	return false;
2981
2982	filename = xloc.file;
2983	linenum = xloc.line;
2984	columnnum = xloc.column;
2985	discriminator = compute_discriminator (loc);
2986	force_source_line = true;
2987	}
2988	else if (override_filename)
2989	{
2990	filename = override_filename;
2991	linenum = override_linenum;
2992	columnnum = override_columnnum;
2993	discriminator = override_discriminator;
2994	}
2995	else if (INSN_HAS_LOCATION (insn))
2996	{
2997	expanded_location xloc = insn_location (insn);
2998	filename = xloc.file;
2999	linenum = xloc.line;
3000	columnnum = xloc.column;
3001	discriminator = insn_discriminator (insn);
3002	}
3003	else
3004	{
3005	filename = NULL;
3006	linenum = 0;
3007	columnnum = 0;
3008	discriminator = 0;
3009	}
3010
3011	if (filename == NULL)
3012	return false;
3013
3014	if (force_source_line
3015	|| filename != last_filename
3016	|| last_linenum != linenum
3017	|| (debug_column_info && last_columnnum != columnnum))
3018	{
3019	force_source_line = false;
3020	last_filename = filename;
3021	last_linenum = linenum;
3022	last_columnnum = columnnum;
3023	last_discriminator = discriminator;
3024	if (is_stmt)
3025	*is_stmt = true;
3026	high_block_linenum = MAX (last_linenum, high_block_linenum);
3027	high_function_linenum = MAX (last_linenum, high_function_linenum);
3028	return true;
3029	}
3030
3031	if (SUPPORTS_DISCRIMINATOR && last_discriminator != discriminator)
3032	{
3033	/* If the discriminator changed, but the line number did not,
3034	output the line table entry with is_stmt false so the
3035	debugger does not treat this as a breakpoint location. */
3036	last_discriminator = discriminator;
3037	if (is_stmt)
3038	*is_stmt = false;
3039	return true;
3040	}
3041
3042	return false;
3043	}
3044
3045	/* For each operand in INSN, simplify (subreg (reg)) so that it refers
3046	directly to the desired hard register. */
3047
3048	void
3049	cleanup_subreg_operands (rtx_insn *insn)
3050	{
3051	int i;
3052	bool changed = false;
3053	extract_insn_cached (insn);
3054	for (i = 0; i < recog_data.n_operands; i++)
3055	{
3056	/* The following test cannot use recog_data.operand when testing
3057	for a SUBREG: the underlying object might have been changed
3058	already if we are inside a match_operator expression that
3059	matches the else clause. Instead we test the underlying
3060	expression directly. */
3061	if (GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
3062	{
3063	recog_data.operand[i] = alter_subreg (recog_data.operand_loc[i], true);
3064	changed = true;
3065	}
3066	else if (GET_CODE (recog_data.operand[i]) == PLUS
3067	|| GET_CODE (recog_data.operand[i]) == MULT
3068	|| MEM_P (recog_data.operand[i]))
3069	recog_data.operand[i] = walk_alter_subreg (recog_data.operand_loc[i], &changed);
3070	}
3071
3072	for (i = 0; i < recog_data.n_dups; i++)
3073	{
3074	if (GET_CODE (*recog_data.dup_loc[i]) == SUBREG)
3075	{
3076	*recog_data.dup_loc[i] = alter_subreg (recog_data.dup_loc[i], true);
3077	changed = true;
3078	}
3079	else if (GET_CODE (*recog_data.dup_loc[i]) == PLUS
3080	|| GET_CODE (*recog_data.dup_loc[i]) == MULT
3081	|| MEM_P (*recog_data.dup_loc[i]))
3082	*recog_data.dup_loc[i] = walk_alter_subreg (recog_data.dup_loc[i], &changed);
3083	}
3084	if (changed)
3085	df_insn_rescan (insn);
3086	}
3087
3088	/* If X is a SUBREG, try to replace it with a REG or a MEM, based on
3089	the thing it is a subreg of. Do it anyway if FINAL_P. */
3090
3091	rtx
3092	alter_subreg (rtx *xp, bool final_p)
3093	{
3094	rtx x = *xp;
3095	rtx y = SUBREG_REG (x);
3096
3097	/* simplify_subreg does not remove subreg from volatile references.
3098	We are required to. */
3099	if (MEM_P (y))
3100	{
3101	poly_int64 offset = SUBREG_BYTE (x);
3102
3103	/* For paradoxical subregs on big-endian machines, SUBREG_BYTE
3104	contains 0 instead of the proper offset. See simplify_subreg. */
3105	if (paradoxical_subreg_p (x))
3106	offset = byte_lowpart_offset (GET_MODE (x), GET_MODE (y));
3107
3108	if (final_p)
3109	*xp = adjust_address (y, GET_MODE (x), offset);
3110	else
3111	*xp = adjust_address_nv (y, GET_MODE (x), offset);
3112	}
3113	else if (REG_P (y) && HARD_REGISTER_P (y))
3114	{
3115	rtx new_rtx = simplify_subreg (GET_MODE (x), op: y, GET_MODE (y),
3116	SUBREG_BYTE (x));
3117
3118	if (new_rtx != 0)
3119	*xp = new_rtx;
3120	else if (final_p && REG_P (y))
3121	{
3122	/* Simplify_subreg can't handle some REG cases, but we have to. */
3123	unsigned int regno;
3124	poly_int64 offset;
3125
3126	regno = subreg_regno (x);
3127	if (subreg_lowpart_p (x))
3128	offset = byte_lowpart_offset (GET_MODE (x), GET_MODE (y));
3129	else
3130	offset = SUBREG_BYTE (x);
3131	*xp = gen_rtx_REG_offset (y, GET_MODE (x), regno, offset);
3132	}
3133	}
3134
3135	return *xp;
3136	}
3137
3138	/* Do alter_subreg on all the SUBREGs contained in X. */
3139
3140	static rtx
3141	walk_alter_subreg (rtx *xp, bool *changed)
3142	{
3143	rtx x = *xp;
3144	switch (GET_CODE (x))
3145	{
3146	case PLUS:
3147	case MULT:
3148	case AND:
3149	XEXP (x, 0) = walk_alter_subreg (xp: &XEXP (x, 0), changed);
3150	XEXP (x, 1) = walk_alter_subreg (xp: &XEXP (x, 1), changed);
3151	break;
3152
3153	case MEM:
3154	case ZERO_EXTEND:
3155	XEXP (x, 0) = walk_alter_subreg (xp: &XEXP (x, 0), changed);
3156	break;
3157
3158	case SUBREG:
3159	*changed = true;
3160	return alter_subreg (xp, final_p: true);
3161
3162	default:
3163	break;
3164	}
3165
3166	return *xp;
3167	}
3168
3169	/* Report inconsistency between the assembler template and the operands.
3170	In an `asm', it's the user's fault; otherwise, the compiler's fault. */
3171
3172	void
3173	output_operand_lossage (const char *cmsgid, ...)
3174	{
3175	char *fmt_string;
3176	char *new_message;
3177	const char *pfx_str;
3178	va_list ap;
3179
3180	va_start (ap, cmsgid);
3181
3182	pfx_str = this_is_asm_operands ? _("invalid 'asm': ") : "output_operand: ";
3183	fmt_string = xasprintf ("%s%s", pfx_str, _(cmsgid));
3184	new_message = xvasprintf (fmt_string, ap);
3185
3186	if (this_is_asm_operands)
3187	error_for_asm (this_is_asm_operands, "%s", new_message);
3188	else
3189	internal_error ("%s", new_message);
3190
3191	free (ptr: fmt_string);
3192	free (ptr: new_message);
3193	va_end (ap);
3194	}
3195
3196	/* Output of assembler code from a template, and its subroutines. */
3197
3198	/* Annotate the assembly with a comment describing the pattern and
3199	alternative used. */
3200
3201	static void
3202	output_asm_name (void)
3203	{
3204	if (debug_insn)
3205	{
3206	fprintf (stream: asm_out_file, format: "\t%s %d\t",
3207	ASM_COMMENT_START, INSN_UID (insn: debug_insn));
3208
3209	fprintf (stream: asm_out_file, format: "[c=%d",
3210	insn_cost (debug_insn, optimize_insn_for_speed_p ()));
3211	if (HAVE_ATTR_length)
3212	fprintf (stream: asm_out_file, format: " l=%d",
3213	get_attr_length (insn: debug_insn));
3214	fprintf (stream: asm_out_file, format: "] ");
3215
3216	int num = INSN_CODE (debug_insn);
3217	fprintf (stream: asm_out_file, format: "%s", insn_data[num].name);
3218	if (insn_data[num].n_alternatives > 1)
3219	fprintf (stream: asm_out_file, format: "/%d", which_alternative);
3220
3221	/* Clear this so only the first assembler insn
3222	of any rtl insn will get the special comment for -dp. */
3223	debug_insn = 0;
3224	}
3225	}
3226
3227	/* If OP is a REG or MEM and we can find a MEM_EXPR corresponding to it
3228	or its address, return that expr . Set *PADDRESSP to 1 if the expr
3229	corresponds to the address of the object and 0 if to the object. */
3230
3231	static tree
3232	get_mem_expr_from_op (rtx op, int *paddressp)
3233	{
3234	tree expr;
3235	int inner_addressp;
3236
3237	*paddressp = 0;
3238
3239	if (REG_P (op))
3240	return REG_EXPR (op);
3241	else if (!MEM_P (op))
3242	return 0;
3243
3244	if (MEM_EXPR (op) != 0)
3245	return MEM_EXPR (op);
3246
3247	/* Otherwise we have an address, so indicate it and look at the address. */
3248	*paddressp = 1;
3249	op = XEXP (op, 0);
3250
3251	/* First check if we have a decl for the address, then look at the right side
3252	if it is a PLUS. Otherwise, strip off arithmetic and keep looking.
3253	But don't allow the address to itself be indirect. */
3254	if ((expr = get_mem_expr_from_op (op, paddressp: &inner_addressp)) && ! inner_addressp)
3255	return expr;
3256	else if (GET_CODE (op) == PLUS
3257	&& (expr = get_mem_expr_from_op (XEXP (op, 1), paddressp: &inner_addressp)))
3258	return expr;
3259
3260	while (UNARY_P (op)
3261	|| GET_RTX_CLASS (GET_CODE (op)) == RTX_BIN_ARITH)
3262	op = XEXP (op, 0);
3263
3264	expr = get_mem_expr_from_op (op, paddressp: &inner_addressp);
3265	return inner_addressp ? 0 : expr;
3266	}
3267
3268	/* Output operand names for assembler instructions. OPERANDS is the
3269	operand vector, OPORDER is the order to write the operands, and NOPS
3270	is the number of operands to write. */
3271
3272	static void
3273	output_asm_operand_names (rtx *operands, int *oporder, int nops)
3274	{
3275	int wrote = 0;
3276	int i;
3277
3278	for (i = 0; i < nops; i++)
3279	{
3280	int addressp;
3281	rtx op = operands[oporder[i]];
3282	tree expr = get_mem_expr_from_op (op, paddressp: &addressp);
3283
3284	fprintf (stream: asm_out_file, format: "%c%s",
3285	wrote ? ',' : '\t', wrote ? "" : ASM_COMMENT_START);
3286	wrote = 1;
3287	if (expr)
3288	{
3289	fprintf (stream: asm_out_file, format: "%s",
3290	addressp ? "*" : "");
3291	print_mem_expr (asm_out_file, expr);
3292	wrote = 1;
3293	}
3294	else if (REG_P (op) && ORIGINAL_REGNO (op)
3295	&& ORIGINAL_REGNO (op) != REGNO (op))
3296	fprintf (stream: asm_out_file, format: " tmp%i", ORIGINAL_REGNO (op));
3297	}
3298	}
3299
3300	#ifdef ASSEMBLER_DIALECT
3301	/* Helper function to parse assembler dialects in the asm string.
3302	This is called from output_asm_insn and asm_fprintf. */
3303	static const char *
3304	do_assembler_dialects (const char *p, int *dialect)
3305	{
3306	char c = *(p - 1);
3307
3308	switch (c)
3309	{
3310	case '{':
3311	{
3312	int i;
3313
3314	if (*dialect)
3315	output_operand_lossage (cmsgid: "nested assembly dialect alternatives");
3316	else
3317	*dialect = 1;
3318
3319	/* If we want the first dialect, do nothing. Otherwise, skip
3320	DIALECT_NUMBER of strings ending with '|'. */
3321	for (i = 0; i < dialect_number; i++)
3322	{
3323	while (*p && *p != '}')
3324	{
3325	if (*p == '|')
3326	{
3327	p++;
3328	break;
3329	}
3330
3331	/* Skip over any character after a percent sign. */
3332	if (*p == '%')
3333	p++;
3334	if (*p)
3335	p++;
3336	}
3337
3338	if (*p == '}')
3339	break;
3340	}
3341
3342	if (*p == '\0')
3343	output_operand_lossage (cmsgid: "unterminated assembly dialect alternative");
3344	}
3345	break;
3346
3347	case '|':
3348	if (*dialect)
3349	{
3350	/* Skip to close brace. */
3351	do
3352	{
3353	if (*p == '\0')
3354	{
3355	output_operand_lossage (cmsgid: "unterminated assembly dialect alternative");
3356	break;
3357	}
3358
3359	/* Skip over any character after a percent sign. */
3360	if (*p == '%' && p[1])
3361	{
3362	p += 2;
3363	continue;
3364	}
3365
3366	if (*p++ == '}')
3367	break;
3368	}
3369	while (1);
3370
3371	*dialect = 0;
3372	}
3373	else
3374	putc (c: c, stream: asm_out_file);
3375	break;
3376
3377	case '}':
3378	if (! *dialect)
3379	putc (c: c, stream: asm_out_file);
3380	*dialect = 0;
3381	break;
3382	default:
3383	gcc_unreachable ();
3384	}
3385
3386	return p;
3387	}
3388	#endif
3389
3390	/* Output text from TEMPLATE to the assembler output file,
3391	obeying %-directions to substitute operands taken from
3392	the vector OPERANDS.
3393
3394	%N (for N a digit) means print operand N in usual manner.
3395	%lN means require operand N to be a CODE_LABEL or LABEL_REF
3396	and print the label name with no punctuation.
3397	%cN means require operand N to be a constant
3398	and print the constant expression with no punctuation.
3399	%aN means expect operand N to be a memory address
3400	(not a memory reference!) and print a reference
3401	to that address.
3402	%nN means expect operand N to be a constant
3403	and print a constant expression for minus the value
3404	of the operand, with no other punctuation. */
3405
3406	void
3407	output_asm_insn (const char *templ, rtx *operands)
3408	{
3409	const char *p;
3410	int c;
3411	#ifdef ASSEMBLER_DIALECT
3412	int dialect = 0;
3413	#endif
3414	int oporder[MAX_RECOG_OPERANDS];
3415	char opoutput[MAX_RECOG_OPERANDS];
3416	int ops = 0;
3417
3418	/* An insn may return a null string template
3419	in a case where no assembler code is needed. */
3420	if (*templ == 0)
3421	return;
3422
3423	memset (s: opoutput, c: 0, n: sizeof opoutput);
3424	p = templ;
3425	putc (c: '\t', stream: asm_out_file);
3426
3427	#ifdef ASM_OUTPUT_OPCODE
3428	ASM_OUTPUT_OPCODE (asm_out_file, p);
3429	#endif
3430
3431	while ((c = *p++))
3432	switch (c)
3433	{
3434	case '\n':
3435	if (flag_verbose_asm)
3436	output_asm_operand_names (operands, oporder, nops: ops);
3437	if (flag_print_asm_name)
3438	output_asm_name ();
3439
3440	ops = 0;
3441	memset (s: opoutput, c: 0, n: sizeof opoutput);
3442
3443	putc (c: c, stream: asm_out_file);
3444	#ifdef ASM_OUTPUT_OPCODE
3445	while ((c = *p) == '\t')
3446	{
3447	putc (c: c, stream: asm_out_file);
3448	p++;
3449	}
3450	ASM_OUTPUT_OPCODE (asm_out_file, p);
3451	#endif
3452	break;
3453
3454	#ifdef ASSEMBLER_DIALECT
3455	case '{':
3456	case '}':
3457	case '|':
3458	p = do_assembler_dialects (p, dialect: &dialect);
3459	break;
3460	#endif
3461
3462	case '%':
3463	/* %% outputs a single %. %{, %} and %| print {, } and | respectively
3464	if ASSEMBLER_DIALECT defined and these characters have a special
3465	meaning as dialect delimiters.*/
3466	if (*p == '%'
3467	#ifdef ASSEMBLER_DIALECT
3468	|| *p == '{' || *p == '}' || *p == '|'
3469	#endif
3470	)
3471	{
3472	putc (c: *p, stream: asm_out_file);
3473	p++;
3474	}
3475	/* %= outputs a number which is unique to each insn in the entire
3476	compilation. This is useful for making local labels that are
3477	referred to more than once in a given insn. */
3478	else if (*p == '=')
3479	{
3480	p++;
3481	fprintf (stream: asm_out_file, format: "%d", insn_counter);
3482	}
3483	/* % followed by a letter and some digits
3484	outputs an operand in a special way depending on the letter.
3485	Letters `acln' are implemented directly.
3486	Other letters are passed to `output_operand' so that
3487	the TARGET_PRINT_OPERAND hook can define them. */
3488	else if (ISALPHA (*p))
3489	{
3490	int letter = *p++;
3491	unsigned long opnum;
3492	char *endptr;
3493
3494	opnum = strtoul (nptr: p, endptr: &endptr, base: 10);
3495
3496	if (endptr == p)
3497	output_operand_lossage (cmsgid: "operand number missing "
3498	"after %%-letter");
3499	else if (this_is_asm_operands && opnum >= insn_noperands)
3500	output_operand_lossage (cmsgid: "operand number out of range");
3501	else if (letter == 'l')
3502	output_asm_label (operands[opnum]);
3503	else if (letter == 'a')
3504	output_address (VOIDmode, operands[opnum]);
3505	else if (letter == 'c')
3506	{
3507	if (CONSTANT_ADDRESS_P (operands[opnum]))
3508	output_addr_const (asm_out_file, operands[opnum]);
3509	else
3510	output_operand (operands[opnum], 'c');
3511	}
3512	else if (letter == 'n')
3513	{
3514	if (CONST_INT_P (operands[opnum]))
3515	fprintf (stream: asm_out_file, HOST_WIDE_INT_PRINT_DEC,
3516	- INTVAL (operands[opnum]));
3517	else
3518	{
3519	putc (c: '-', stream: asm_out_file);
3520	output_addr_const (asm_out_file, operands[opnum]);
3521	}
3522	}
3523	else
3524	output_operand (operands[opnum], letter);
3525
3526	if (!opoutput[opnum])
3527	oporder[ops++] = opnum;
3528	opoutput[opnum] = 1;
3529
3530	p = endptr;
3531	c = *p;
3532	}
3533	/* % followed by a digit outputs an operand the default way. */
3534	else if (ISDIGIT (*p))
3535	{
3536	unsigned long opnum;
3537	char *endptr;
3538
3539	opnum = strtoul (nptr: p, endptr: &endptr, base: 10);
3540	if (this_is_asm_operands && opnum >= insn_noperands)
3541	output_operand_lossage (cmsgid: "operand number out of range");
3542	else
3543	output_operand (operands[opnum], 0);
3544
3545	if (!opoutput[opnum])
3546	oporder[ops++] = opnum;
3547	opoutput[opnum] = 1;
3548
3549	p = endptr;
3550	c = *p;
3551	}
3552	/* % followed by punctuation: output something for that
3553	punctuation character alone, with no operand. The
3554	TARGET_PRINT_OPERAND hook decides what is actually done. */
3555	else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned char) *p))
3556	output_operand (NULL_RTX, *p++);
3557	else
3558	output_operand_lossage (cmsgid: "invalid %%-code");
3559	break;
3560
3561	default:
3562	putc (c: c, stream: asm_out_file);
3563	}
3564
3565	/* Try to keep the asm a bit more readable. */
3566	if ((flag_verbose_asm || flag_print_asm_name) && strlen (s: templ) < 9)
3567	putc (c: '\t', stream: asm_out_file);
3568
3569	/* Write out the variable names for operands, if we know them. */
3570	if (flag_verbose_asm)
3571	output_asm_operand_names (operands, oporder, nops: ops);
3572	if (flag_print_asm_name)
3573	output_asm_name ();
3574
3575	putc (c: '\n', stream: asm_out_file);
3576	}
3577
3578	/* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */
3579
3580	void
3581	output_asm_label (rtx x)
3582	{
3583	char buf[256];
3584
3585	if (GET_CODE (x) == LABEL_REF)
3586	x = label_ref_label (ref: x);
3587	if (LABEL_P (x)
3588	|| (NOTE_P (x)
3589	&& NOTE_KIND (x) == NOTE_INSN_DELETED_LABEL))
3590	ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
3591	else
3592	output_operand_lossage (cmsgid: "'%%l' operand isn't a label");
3593
3594	assemble_name (asm_out_file, buf);
3595	}
3596
3597	/* Marks SYMBOL_REFs in x as referenced through use of assemble_external. */
3598
3599	void
3600	mark_symbol_refs_as_used (rtx x)
3601	{
3602	subrtx_iterator::array_type array;
3603	FOR_EACH_SUBRTX (iter, array, x, ALL)
3604	{
3605	const_rtx x = *iter;
3606	if (GET_CODE (x) == SYMBOL_REF)
3607	if (tree t = SYMBOL_REF_DECL (x))
3608	assemble_external (t);
3609	}
3610	}
3611
3612	/* Print operand X using machine-dependent assembler syntax.
3613	CODE is a non-digit that preceded the operand-number in the % spec,
3614	such as 'z' if the spec was `%z3'. CODE is 0 if there was no char
3615	between the % and the digits.
3616	When CODE is a non-letter, X is 0.
3617
3618	The meanings of the letters are machine-dependent and controlled
3619	by TARGET_PRINT_OPERAND. */
3620
3621	void
3622	output_operand (rtx x, int code ATTRIBUTE_UNUSED)
3623	{
3624	if (x && GET_CODE (x) == SUBREG)
3625	x = alter_subreg (xp: &x, final_p: true);
3626
3627	/* X must not be a pseudo reg. */
3628	if (!targetm.no_register_allocation)
3629	gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
3630
3631	targetm.asm_out.print_operand (asm_out_file, x, code);
3632
3633	if (x == NULL_RTX)
3634	return;
3635
3636	mark_symbol_refs_as_used (x);
3637	}
3638
3639	/* Print a memory reference operand for address X using
3640	machine-dependent assembler syntax. */
3641
3642	void
3643	output_address (machine_mode mode, rtx x)
3644	{
3645	bool changed = false;
3646	walk_alter_subreg (xp: &x, changed: &changed);
3647	targetm.asm_out.print_operand_address (asm_out_file, mode, x);
3648	}
3649
3650	/* Print an integer constant expression in assembler syntax.
3651	Addition and subtraction are the only arithmetic
3652	that may appear in these expressions. */
3653
3654	void
3655	output_addr_const (FILE *file, rtx x)
3656	{
3657	char buf[256];
3658
3659	restart:
3660	switch (GET_CODE (x))
3661	{
3662	case PC:
3663	putc (c: '.', stream: file);
3664	break;
3665
3666	case SYMBOL_REF:
3667	if (SYMBOL_REF_DECL (x))
3668	assemble_external (SYMBOL_REF_DECL (x));
3669	#ifdef ASM_OUTPUT_SYMBOL_REF
3670	ASM_OUTPUT_SYMBOL_REF (file, x);
3671	#else
3672	assemble_name (file, XSTR (x, 0));
3673	#endif
3674	break;
3675
3676	case LABEL_REF:
3677	x = label_ref_label (ref: x);
3678	/* Fall through. */
3679	case CODE_LABEL:
3680	ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
3681	#ifdef ASM_OUTPUT_LABEL_REF
3682	ASM_OUTPUT_LABEL_REF (file, buf);
3683	#else
3684	assemble_name (file, buf);
3685	#endif
3686	break;
3687
3688	case CONST_INT:
3689	fprintf (stream: file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
3690	break;
3691
3692	case CONST:
3693	/* This used to output parentheses around the expression,
3694	but that does not work on the 386 (either ATT or BSD assembler). */
3695	output_addr_const (file, XEXP (x, 0));
3696	break;
3697
3698	case CONST_WIDE_INT:
3699	/* We do not know the mode here so we have to use a round about
3700	way to build a wide-int to get it printed properly. */
3701	{
3702	wide_int w = wide_int::from_array (val: &CONST_WIDE_INT_ELT (x, 0),
3703	CONST_WIDE_INT_NUNITS (x),
3704	CONST_WIDE_INT_NUNITS (x)
3705	* HOST_BITS_PER_WIDE_INT,
3706	need_canon_p: false);
3707	print_decs (wi: w, file);
3708	}
3709	break;
3710
3711	case CONST_DOUBLE:
3712	if (CONST_DOUBLE_AS_INT_P (x))
3713	{
3714	/* We can use %d if the number is one word and positive. */
3715	if (CONST_DOUBLE_HIGH (x))
3716	fprintf (stream: file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3717	(unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x),
3718	(unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x));
3719	else if (CONST_DOUBLE_LOW (x) < 0)
3720	fprintf (stream: file, HOST_WIDE_INT_PRINT_HEX,
3721	(unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x));
3722	else
3723	fprintf (stream: file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
3724	}
3725	else
3726	/* We can't handle floating point constants;
3727	PRINT_OPERAND must handle them. */
3728	output_operand_lossage (cmsgid: "floating constant misused");
3729	break;
3730
3731	case CONST_FIXED:
3732	fprintf (stream: file, HOST_WIDE_INT_PRINT_DEC, CONST_FIXED_VALUE_LOW (x));
3733	break;
3734
3735	case PLUS:
3736	/* Some assemblers need integer constants to appear last (eg masm). */
3737	if (CONST_INT_P (XEXP (x, 0)))
3738	{
3739	output_addr_const (file, XEXP (x, 1));
3740	if (INTVAL (XEXP (x, 0)) >= 0)
3741	fprintf (stream: file, format: "+");
3742	output_addr_const (file, XEXP (x, 0));
3743	}
3744	else
3745	{
3746	output_addr_const (file, XEXP (x, 0));
3747	if (!CONST_INT_P (XEXP (x, 1))
3748	|| INTVAL (XEXP (x, 1)) >= 0)
3749	fprintf (stream: file, format: "+");
3750	output_addr_const (file, XEXP (x, 1));
3751	}
3752	break;
3753
3754	case MINUS:
3755	/* Avoid outputting things like x-x or x+5-x,
3756	since some assemblers can't handle that. */
3757	x = simplify_subtraction (x);
3758	if (GET_CODE (x) != MINUS)
3759	goto restart;
3760
3761	output_addr_const (file, XEXP (x, 0));
3762	fprintf (stream: file, format: "-");
3763	if ((CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) >= 0)
3764	|| GET_CODE (XEXP (x, 1)) == PC
3765	|| GET_CODE (XEXP (x, 1)) == SYMBOL_REF)
3766	output_addr_const (file, XEXP (x, 1));
3767	else
3768	{
3769	fputs (s: targetm.asm_out.open_paren, stream: file);
3770	output_addr_const (file, XEXP (x, 1));
3771	fputs (s: targetm.asm_out.close_paren, stream: file);
3772	}
3773	break;
3774
3775	case ZERO_EXTEND:
3776	case SIGN_EXTEND:
3777	case SUBREG:
3778	case TRUNCATE:
3779	output_addr_const (file, XEXP (x, 0));
3780	break;
3781
3782	default:
3783	if (targetm.asm_out.output_addr_const_extra (file, x))
3784	break;
3785
3786	output_operand_lossage (cmsgid: "invalid expression as operand");
3787	}
3788	}
3789
3790	/* Output a quoted string. */
3791
3792	void
3793	output_quoted_string (FILE *asm_file, const char *string)
3794	{
3795	#ifdef OUTPUT_QUOTED_STRING
3796	OUTPUT_QUOTED_STRING (asm_file, string);
3797	#else
3798	char c;
3799
3800	putc (c: '\"', stream: asm_file);
3801	while ((c = *string++) != 0)
3802	{
3803	if (ISPRINT (c))
3804	{
3805	if (c == '\"' || c == '\\')
3806	putc (c: '\\', stream: asm_file);
3807	putc (c: c, stream: asm_file);
3808	}
3809	else
3810	fprintf (stream: asm_file, format: "\\%03o", (unsigned char) c);
3811	}
3812	putc (c: '\"', stream: asm_file);
3813	#endif
3814	}
3815
3816	/* Write a HOST_WIDE_INT number in hex form 0x1234, fast. */
3817
3818	void
3819	fprint_whex (FILE *f, unsigned HOST_WIDE_INT value)
3820	{
3821	char buf[2 + CHAR_BIT * sizeof (value) / 4];
3822	if (value == 0)
3823	putc (c: '0', stream: f);
3824	else
3825	{
3826	char *p = buf + sizeof (buf);
3827	do
3828	*--p = "0123456789abcdef"[value % 16];
3829	while ((value /= 16) != 0);
3830	*--p = 'x';
3831	*--p = '0';
3832	fwrite (ptr: p, size: 1, n: buf + sizeof (buf) - p, s: f);
3833	}
3834	}
3835
3836	/* Internal function that prints an unsigned long in decimal in reverse.
3837	The output string IS NOT null-terminated. */
3838
3839	static int
3840	sprint_ul_rev (char *s, unsigned long value)
3841	{
3842	int i = 0;
3843	do
3844	{
3845	s[i] = "0123456789"[value % 10];
3846	value /= 10;
3847	i++;
3848	/* alternate version, without modulo */
3849	/* oldval = value; */
3850	/* value /= 10; */
3851	/* s[i] = "0123456789" [oldval - 10*value]; */
3852	/* i++ */
3853	}
3854	while (value != 0);
3855	return i;
3856	}
3857
3858	/* Write an unsigned long as decimal to a file, fast. */
3859
3860	void
3861	fprint_ul (FILE *f, unsigned long value)
3862	{
3863	/* python says: len(str(2**64)) == 20 */
3864	char s[20];
3865	int i;
3866
3867	i = sprint_ul_rev (s, value);
3868
3869	/* It's probably too small to bother with string reversal and fputs. */
3870	do
3871	{
3872	i--;
3873	putc (c: s[i], stream: f);
3874	}
3875	while (i != 0);
3876	}
3877
3878	/* Write an unsigned long as decimal to a string, fast.
3879	s must be wide enough to not overflow, at least 21 chars.
3880	Returns the length of the string (without terminating '\0'). */
3881
3882	int
3883	sprint_ul (char *s, unsigned long value)
3884	{
3885	int len = sprint_ul_rev (s, value);
3886	s[len] = '\0';
3887
3888	std::reverse (first: s, last: s + len);
3889	return len;
3890	}
3891
3892	/* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
3893	%R prints the value of REGISTER_PREFIX.
3894	%L prints the value of LOCAL_LABEL_PREFIX.
3895	%U prints the value of USER_LABEL_PREFIX.
3896	%I prints the value of IMMEDIATE_PREFIX.
3897	%O runs ASM_OUTPUT_OPCODE to transform what follows in the string.
3898	Also supported are %d, %i, %u, %x, %X, %o, %c, %s and %%.
3899
3900	We handle alternate assembler dialects here, just like output_asm_insn. */
3901
3902	void
3903	asm_fprintf (FILE *file, const char *p, ...)
3904	{
3905	char buf[10];
3906	char *q, c;
3907	#ifdef ASSEMBLER_DIALECT
3908	int dialect = 0;
3909	#endif
3910	va_list argptr;
3911
3912	va_start (argptr, p);
3913
3914	buf[0] = '%';
3915
3916	while ((c = *p++))
3917	switch (c)
3918	{
3919	#ifdef ASSEMBLER_DIALECT
3920	case '{':
3921	case '}':
3922	case '|':
3923	p = do_assembler_dialects (p, dialect: &dialect);
3924	break;
3925	#endif
3926
3927	case '%':
3928	c = *p++;
3929	q = &buf[1];
3930	while (strchr (s: "-+ #0", c: c))
3931	{
3932	*q++ = c;
3933	c = *p++;
3934	}
3935	while (ISDIGIT (c) || c == '.')
3936	{
3937	*q++ = c;
3938	c = *p++;
3939	}
3940	switch (c)
3941	{
3942	case '%':
3943	putc (c: '%', stream: file);
3944	break;
3945
3946	case 'd': case 'i': case 'u':
3947	case 'x': case 'X': case 'o':
3948	case 'c':
3949	*q++ = c;
3950	*q = 0;
3951	fprintf (stream: file, format: buf, va_arg (argptr, int));
3952	break;
3953
3954	case 'w':
3955	/* This is a prefix to the 'd', 'i', 'u', 'x', 'X', and
3956	'o' cases, but we do not check for those cases. It
3957	means that the value is a HOST_WIDE_INT, which may be
3958	either `long' or `long long'. */
3959	memcpy (dest: q, HOST_WIDE_INT_PRINT, n: strlen (HOST_WIDE_INT_PRINT));
3960	q += strlen (HOST_WIDE_INT_PRINT);
3961	*q++ = *p++;
3962	*q = 0;
3963	fprintf (stream: file, format: buf, va_arg (argptr, HOST_WIDE_INT));
3964	break;
3965
3966	case 'l':
3967	*q++ = c;
3968	#ifdef HAVE_LONG_LONG
3969	if (*p == 'l')
3970	{
3971	*q++ = *p++;
3972	*q++ = *p++;
3973	*q = 0;
3974	fprintf (stream: file, format: buf, va_arg (argptr, long long));
3975	}
3976	else
3977	#endif
3978	{
3979	*q++ = *p++;
3980	*q = 0;
3981	fprintf (stream: file, format: buf, va_arg (argptr, long));
3982	}
3983
3984	break;
3985
3986	case 's':
3987	*q++ = c;
3988	*q = 0;
3989	fprintf (stream: file, format: buf, va_arg (argptr, char *));
3990	break;
3991
3992	case 'O':
3993	#ifdef ASM_OUTPUT_OPCODE
3994	ASM_OUTPUT_OPCODE (asm_out_file, p);
3995	#endif
3996	break;
3997
3998	case 'R':
3999	#ifdef REGISTER_PREFIX
4000	fprintf (file, "%s", REGISTER_PREFIX);
4001	#endif
4002	break;
4003
4004	case 'I':
4005	#ifdef IMMEDIATE_PREFIX
4006	fprintf (file, "%s", IMMEDIATE_PREFIX);
4007	#endif
4008	break;
4009
4010	case 'L':
4011	#ifdef LOCAL_LABEL_PREFIX
4012	fprintf (stream: file, format: "%s", LOCAL_LABEL_PREFIX);
4013	#endif
4014	break;
4015
4016	case 'U':
4017	fputs (s: user_label_prefix, stream: file);
4018	break;
4019
4020	#ifdef ASM_FPRINTF_EXTENSIONS
4021	/* Uppercase letters are reserved for general use by asm_fprintf
4022	and so are not available to target specific code. In order to
4023	prevent the ASM_FPRINTF_EXTENSIONS macro from using them then,
4024	they are defined here. As they get turned into real extensions
4025	to asm_fprintf they should be removed from this list. */
4026	case 'A': case 'B': case 'C': case 'D': case 'E':
4027	case 'F': case 'G': case 'H': case 'J': case 'K':
4028	case 'M': case 'N': case 'P': case 'Q': case 'S':
4029	case 'T': case 'V': case 'W': case 'Y': case 'Z':
4030	break;
4031
4032	ASM_FPRINTF_EXTENSIONS (file, argptr, p)
4033	#endif
4034	default:
4035	gcc_unreachable ();
4036	}
4037	break;
4038
4039	default:
4040	putc (c: c, stream: file);
4041	}
4042	va_end (argptr);
4043	}
4044
4045	/* Return true if this function has no function calls. */
4046
4047	bool
4048	leaf_function_p (void)
4049	{
4050	rtx_insn *insn;
4051
4052	/* Ensure we walk the entire function body. */
4053	gcc_assert (!in_sequence_p ());
4054
4055	/* Some back-ends (e.g. s390) want leaf functions to stay leaf
4056	functions even if they call mcount. */
4057	if (crtl->profile && !targetm.keep_leaf_when_profiled ())
4058	return false;
4059
4060	for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4061	{
4062	if (CALL_P (insn)
4063	&& ! SIBLING_CALL_P (insn)
4064	&& ! FAKE_CALL_P (insn))
4065	return false;
4066	if (NONJUMP_INSN_P (insn)
4067	&& GET_CODE (PATTERN (insn)) == SEQUENCE
4068	&& CALL_P (XVECEXP (PATTERN (insn), 0, 0))
4069	&& ! SIBLING_CALL_P (XVECEXP (PATTERN (insn), 0, 0)))
4070	return false;
4071	}
4072
4073	return true;
4074	}
4075
4076	/* Return true if branch is a forward branch.
4077	Uses insn_shuid array, so it works only in the final pass. May be used by
4078	output templates to customary add branch prediction hints.
4079	*/
4080	bool
4081	final_forward_branch_p (rtx_insn *insn)
4082	{
4083	int insn_id, label_id;
4084
4085	gcc_assert (uid_shuid);
4086	insn_id = INSN_SHUID (insn);
4087	label_id = INSN_SHUID (JUMP_LABEL (insn));
4088	/* We've hit some insns that does not have id information available. */
4089	gcc_assert (insn_id && label_id);
4090	return insn_id < label_id;
4091	}
4092
4093	/* On some machines, a function with no call insns
4094	can run faster if it doesn't create its own register window.
4095	When output, the leaf function should use only the "output"
4096	registers. Ordinarily, the function would be compiled to use
4097	the "input" registers to find its arguments; it is a candidate
4098	for leaf treatment if it uses only the "input" registers.
4099	Leaf function treatment means renumbering so the function
4100	uses the "output" registers instead. */
4101
4102	#ifdef LEAF_REGISTERS
4103
4104	/* Return bool if this function uses only the registers that can be
4105	safely renumbered. */
4106
4107	bool
4108	only_leaf_regs_used (void)
4109	{
4110	int i;
4111	const char *const permitted_reg_in_leaf_functions = LEAF_REGISTERS;
4112
4113	for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4114	if ((df_regs_ever_live_p (i) || global_regs[i])
4115	&& ! permitted_reg_in_leaf_functions[i])
4116	return false;
4117
4118	if (crtl->uses_pic_offset_table
4119	&& pic_offset_table_rtx != 0
4120	&& REG_P (pic_offset_table_rtx)
4121	&& ! permitted_reg_in_leaf_functions[REGNO (pic_offset_table_rtx)])
4122	return false;
4123
4124	return true;
4125	}
4126
4127	/* Scan all instructions and renumber all registers into those
4128	available in leaf functions. */
4129
4130	static void
4131	leaf_renumber_regs (rtx_insn *first)
4132	{
4133	rtx_insn *insn;
4134
4135	/* Renumber only the actual patterns.
4136	The reg-notes can contain frame pointer refs,
4137	and renumbering them could crash, and should not be needed. */
4138	for (insn = first; insn; insn = NEXT_INSN (insn))
4139	if (INSN_P (insn))
4140	leaf_renumber_regs_insn (PATTERN (insn));
4141	}
4142
4143	/* Scan IN_RTX and its subexpressions, and renumber all regs into those
4144	available in leaf functions. */
4145
4146	void
4147	leaf_renumber_regs_insn (rtx in_rtx)
4148	{
4149	int i, j;
4150	const char *format_ptr;
4151
4152	if (in_rtx == 0)
4153	return;
4154
4155	/* Renumber all input-registers into output-registers.
4156	renumbered_regs would be 1 for an output-register;
4157	they */
4158
4159	if (REG_P (in_rtx))
4160	{
4161	int newreg;
4162
4163	/* Don't renumber the same reg twice. */
4164	if (in_rtx->used)
4165	return;
4166
4167	newreg = REGNO (in_rtx);
4168	/* Don't try to renumber pseudo regs. It is possible for a pseudo reg
4169	to reach here as part of a REG_NOTE. */
4170	if (newreg >= FIRST_PSEUDO_REGISTER)
4171	{
4172	in_rtx->used = 1;
4173	return;
4174	}
4175	newreg = LEAF_REG_REMAP (newreg);
4176	gcc_assert (newreg >= 0);
4177	df_set_regs_ever_live (REGNO (in_rtx), false);
4178	df_set_regs_ever_live (newreg, true);
4179	SET_REGNO (in_rtx, newreg);
4180	in_rtx->used = 1;
4181	return;
4182	}
4183
4184	if (INSN_P (in_rtx))
4185	{
4186	/* Inside a SEQUENCE, we find insns.
4187	Renumber just the patterns of these insns,
4188	just as we do for the top-level insns. */
4189	leaf_renumber_regs_insn (PATTERN (in_rtx));
4190	return;
4191	}
4192
4193	format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
4194
4195	for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
4196	switch (*format_ptr++)
4197	{
4198	case 'e':
4199	leaf_renumber_regs_insn (XEXP (in_rtx, i));
4200	break;
4201
4202	case 'E':
4203	if (XVEC (in_rtx, i) != NULL)
4204	for (j = 0; j < XVECLEN (in_rtx, i); j++)
4205	leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));
4206	break;
4207
4208	case 'S':
4209	case 's':
4210	case '0':
4211	case 'i':
4212	case 'w':
4213	case 'p':
4214	case 'n':
4215	case 'u':
4216	break;
4217
4218	default:
4219	gcc_unreachable ();
4220	}
4221	}
4222	#endif
4223
4224	/* Turn the RTL into assembly. */
4225	static unsigned int
4226	rest_of_handle_final (void)
4227	{
4228	const char *fnname = get_fnname_from_decl (current_function_decl);
4229
4230	/* Turn debug markers into notes if the var-tracking pass has not
4231	been invoked. */
4232	if (!flag_var_tracking && MAY_HAVE_DEBUG_MARKER_INSNS)
4233	delete_vta_debug_insns (false);
4234
4235	assemble_start_function (current_function_decl, fnname);
4236	rtx_insn *first = get_insns ();
4237	int seen = 0;
4238	final_start_function_1 (firstp: &first, file: asm_out_file, seen: &seen, optimize);
4239	final_1 (first, file: asm_out_file, seen, optimize);
4240	if (flag_ipa_ra
4241	&& !lookup_attribute (attr_name: "noipa", DECL_ATTRIBUTES (current_function_decl))
4242	/* Functions with naked attributes are supported only with basic asm
4243	statements in the body, thus for supported use cases the information
4244	on clobbered registers is not available. */
4245	&& !lookup_attribute (attr_name: "naked", DECL_ATTRIBUTES (current_function_decl)))
4246	collect_fn_hard_reg_usage ();
4247	final_end_function ();
4248
4249	/* The IA-64 ".handlerdata" directive must be issued before the ".endp"
4250	directive that closes the procedure descriptor. Similarly, for x64 SEH.
4251	Otherwise it's not strictly necessary, but it doesn't hurt either. */
4252	output_function_exception_table (crtl->has_bb_partition ? 1 : 0);
4253
4254	assemble_end_function (current_function_decl, fnname);
4255
4256	/* Free up reg info memory. */
4257	free_reg_info ();
4258
4259	if (! quiet_flag)
4260	fflush (stream: asm_out_file);
4261
4262	/* Note that for those inline functions where we don't initially
4263	know for certain that we will be generating an out-of-line copy,
4264	the first invocation of this routine (rest_of_compilation) will
4265	skip over this code by doing a `goto exit_rest_of_compilation;'.
4266	Later on, wrapup_global_declarations will (indirectly) call
4267	rest_of_compilation again for those inline functions that need
4268	to have out-of-line copies generated. During that call, we
4269	*will* be routed past here. */
4270
4271	timevar_push (tv: TV_SYMOUT);
4272	if (!DECL_IGNORED_P (current_function_decl))
4273	debug_hooks->function_decl (current_function_decl);
4274	timevar_pop (tv: TV_SYMOUT);
4275
4276	/* Release the blocks that are linked to DECL_INITIAL() to free the memory. */
4277	DECL_INITIAL (current_function_decl) = error_mark_node;
4278
4279	if (DECL_STATIC_CONSTRUCTOR (current_function_decl)
4280	&& targetm.have_ctors_dtors)
4281	targetm.asm_out.constructor (XEXP (DECL_RTL (current_function_decl), 0),
4282	decl_init_priority_lookup
4283	(current_function_decl));
4284	if (DECL_STATIC_DESTRUCTOR (current_function_decl)
4285	&& targetm.have_ctors_dtors)
4286	targetm.asm_out.destructor (XEXP (DECL_RTL (current_function_decl), 0),
4287	decl_fini_priority_lookup
4288	(current_function_decl));
4289	return 0;
4290	}
4291
4292	namespace {
4293
4294	const pass_data pass_data_final =
4295	{
4296	.type: RTL_PASS, /* type */
4297	.name: "final", /* name */
4298	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
4299	.tv_id: TV_FINAL, /* tv_id */
4300	.properties_required: 0, /* properties_required */
4301	.properties_provided: 0, /* properties_provided */
4302	.properties_destroyed: 0, /* properties_destroyed */
4303	.todo_flags_start: 0, /* todo_flags_start */
4304	.todo_flags_finish: 0, /* todo_flags_finish */
4305	};
4306
4307	class pass_final : public rtl_opt_pass
4308	{
4309	public:
4310	pass_final (gcc::context *ctxt)
4311	: rtl_opt_pass (pass_data_final, ctxt)
4312	{}
4313
4314	/* opt_pass methods: */
4315	unsigned int execute (function *) final override
4316	{
4317	return rest_of_handle_final ();
4318	}
4319
4320	}; // class pass_final
4321
4322	} // anon namespace
4323
4324	rtl_opt_pass *
4325	make_pass_final (gcc::context *ctxt)
4326	{
4327	return new pass_final (ctxt);
4328	}
4329
4330
4331	static unsigned int
4332	rest_of_handle_shorten_branches (void)
4333	{
4334	/* Shorten branches. */
4335	shorten_branches (first: get_insns ());
4336	return 0;
4337	}
4338
4339	namespace {
4340
4341	const pass_data pass_data_shorten_branches =
4342	{
4343	.type: RTL_PASS, /* type */
4344	.name: "shorten", /* name */
4345	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
4346	.tv_id: TV_SHORTEN_BRANCH, /* tv_id */
4347	.properties_required: 0, /* properties_required */
4348	.properties_provided: 0, /* properties_provided */
4349	.properties_destroyed: 0, /* properties_destroyed */
4350	.todo_flags_start: 0, /* todo_flags_start */
4351	.todo_flags_finish: 0, /* todo_flags_finish */
4352	};
4353
4354	class pass_shorten_branches : public rtl_opt_pass
4355	{
4356	public:
4357	pass_shorten_branches (gcc::context *ctxt)
4358	: rtl_opt_pass (pass_data_shorten_branches, ctxt)
4359	{}
4360
4361	/* opt_pass methods: */
4362	unsigned int execute (function *) final override
4363	{
4364	return rest_of_handle_shorten_branches ();
4365	}
4366
4367	}; // class pass_shorten_branches
4368
4369	} // anon namespace
4370
4371	rtl_opt_pass *
4372	make_pass_shorten_branches (gcc::context *ctxt)
4373	{
4374	return new pass_shorten_branches (ctxt);
4375	}
4376
4377
4378	static unsigned int
4379	rest_of_clean_state (void)
4380	{
4381	rtx_insn *insn, *next;
4382	FILE *final_output = NULL;
4383	int save_unnumbered = flag_dump_unnumbered;
4384	int save_noaddr = flag_dump_noaddr;
4385
4386	if (flag_dump_final_insns)
4387	{
4388	final_output = fopen (flag_dump_final_insns, modes: "a");
4389	if (!final_output)
4390	{
4391	error ("could not open final insn dump file %qs: %m",
4392	flag_dump_final_insns);
4393	flag_dump_final_insns = NULL;
4394	}
4395	else
4396	{
4397	flag_dump_noaddr = flag_dump_unnumbered = 1;
4398	if (flag_compare_debug_opt || flag_compare_debug)
4399	dump_flags |= TDF_NOUID | TDF_COMPARE_DEBUG;
4400	dump_function_header (final_output, current_function_decl,
4401	dump_flags);
4402	final_insns_dump_p = true;
4403
4404	for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4405	if (LABEL_P (insn))
4406	INSN_UID (insn) = CODE_LABEL_NUMBER (insn);
4407	else
4408	{
4409	if (NOTE_P (insn))
4410	set_block_for_insn (insn, NULL);
4411	INSN_UID (insn) = 0;
4412	}
4413	}
4414	}
4415
4416	/* It is very important to decompose the RTL instruction chain here:
4417	debug information keeps pointing into CODE_LABEL insns inside the function
4418	body. If these remain pointing to the other insns, we end up preserving
4419	whole RTL chain and attached detailed debug info in memory. */
4420	for (insn = get_insns (); insn; insn = next)
4421	{
4422	next = NEXT_INSN (insn);
4423	SET_NEXT_INSN (insn) = NULL;
4424	SET_PREV_INSN (insn) = NULL;
4425
4426	rtx_insn *call_insn = insn;
4427	if (NONJUMP_INSN_P (call_insn)
4428	&& GET_CODE (PATTERN (call_insn)) == SEQUENCE)
4429	{
4430	rtx_sequence *seq = as_a <rtx_sequence *> (p: PATTERN (insn: call_insn));
4431	call_insn = seq->insn (index: 0);
4432	}
4433	if (CALL_P (call_insn))
4434	{
4435	rtx note
4436	= find_reg_note (call_insn, REG_CALL_ARG_LOCATION, NULL_RTX);
4437	if (note)
4438	remove_note (call_insn, note);
4439	}
4440
4441	if (final_output
4442	&& (!NOTE_P (insn)
4443	|| (NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION
4444	&& NOTE_KIND (insn) != NOTE_INSN_BEGIN_STMT
4445	&& NOTE_KIND (insn) != NOTE_INSN_INLINE_ENTRY
4446	&& NOTE_KIND (insn) != NOTE_INSN_BLOCK_BEG
4447	&& NOTE_KIND (insn) != NOTE_INSN_BLOCK_END
4448	&& NOTE_KIND (insn) != NOTE_INSN_DELETED_DEBUG_LABEL)))
4449	print_rtl_single (final_output, insn);
4450	}
4451
4452	if (final_output)
4453	{
4454	flag_dump_noaddr = save_noaddr;
4455	flag_dump_unnumbered = save_unnumbered;
4456	final_insns_dump_p = false;
4457
4458	if (fclose (stream: final_output))
4459	{
4460	error ("could not close final insn dump file %qs: %m",
4461	flag_dump_final_insns);
4462	flag_dump_final_insns = NULL;
4463	}
4464	}
4465
4466	flag_rerun_cse_after_global_opts = 0;
4467	reload_completed = 0;
4468	epilogue_completed = 0;
4469	#ifdef STACK_REGS
4470	regstack_completed = 0;
4471	#endif
4472
4473	/* Clear out the insn_length contents now that they are no
4474	longer valid. */
4475	init_insn_lengths ();
4476
4477	/* Show no temporary slots allocated. */
4478	init_temp_slots ();
4479
4480	free_bb_for_insn ();
4481
4482	if (cfun->gimple_df)
4483	delete_tree_ssa (cfun);
4484
4485	/* We can reduce stack alignment on call site only when we are sure that
4486	the function body just produced will be actually used in the final
4487	executable. */
4488	if (flag_ipa_stack_alignment
4489	&& decl_binds_to_current_def_p (current_function_decl))
4490	{
4491	unsigned int pref = crtl->preferred_stack_boundary;
4492	if (crtl->stack_alignment_needed > crtl->preferred_stack_boundary)
4493	pref = crtl->stack_alignment_needed;
4494	cgraph_node::rtl_info (current_function_decl)
4495	->preferred_incoming_stack_boundary = pref;
4496	}
4497
4498	/* Make sure volatile mem refs aren't considered valid operands for
4499	arithmetic insns. We must call this here if this is a nested inline
4500	function, since the above code leaves us in the init_recog state,
4501	and the function context push/pop code does not save/restore volatile_ok.
4502
4503	??? Maybe it isn't necessary for expand_start_function to call this
4504	anymore if we do it here? */
4505
4506	init_recog_no_volatile ();
4507
4508	/* We're done with this function. Free up memory if we can. */
4509	free_after_parsing (cfun);
4510	free_after_compilation (cfun);
4511	return 0;
4512	}
4513
4514	namespace {
4515
4516	const pass_data pass_data_clean_state =
4517	{
4518	.type: RTL_PASS, /* type */
4519	.name: "*clean_state", /* name */
4520	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
4521	.tv_id: TV_FINAL, /* tv_id */
4522	.properties_required: 0, /* properties_required */
4523	.properties_provided: 0, /* properties_provided */
4524	PROP_rtl, /* properties_destroyed */
4525	.todo_flags_start: 0, /* todo_flags_start */
4526	.todo_flags_finish: 0, /* todo_flags_finish */
4527	};
4528
4529	class pass_clean_state : public rtl_opt_pass
4530	{
4531	public:
4532	pass_clean_state (gcc::context *ctxt)
4533	: rtl_opt_pass (pass_data_clean_state, ctxt)
4534	{}
4535
4536	/* opt_pass methods: */
4537	unsigned int execute (function *) final override
4538	{
4539	return rest_of_clean_state ();
4540	}
4541
4542	}; // class pass_clean_state
4543
4544	} // anon namespace
4545
4546	rtl_opt_pass *
4547	make_pass_clean_state (gcc::context *ctxt)
4548	{
4549	return new pass_clean_state (ctxt);
4550	}
4551
4552	/* Return true if INSN is a call to the current function. */
4553
4554	static bool
4555	self_recursive_call_p (rtx_insn *insn)
4556	{
4557	tree fndecl = get_call_fndecl (insn);
4558	return (fndecl == current_function_decl
4559	&& decl_binds_to_current_def_p (fndecl));
4560	}
4561
4562	/* Collect hard register usage for the current function. */
4563
4564	static void
4565	collect_fn_hard_reg_usage (void)
4566	{
4567	rtx_insn *insn;
4568	#ifdef STACK_REGS
4569	int i;
4570	#endif
4571	struct cgraph_rtl_info *node;
4572	HARD_REG_SET function_used_regs;
4573
4574	/* ??? To be removed when all the ports have been fixed. */
4575	if (!targetm.call_fusage_contains_non_callee_clobbers)
4576	return;
4577
4578	/* Be conservative - mark fixed and global registers as used. */
4579	function_used_regs = fixed_reg_set;
4580
4581	#ifdef STACK_REGS
4582	/* Handle STACK_REGS conservatively, since the df-framework does not
4583	provide accurate information for them. */
4584
4585	for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
4586	SET_HARD_REG_BIT (set&: function_used_regs, bit: i);
4587	#endif
4588
4589	for (insn = get_insns (); insn != NULL_RTX; insn = next_insn (insn))
4590	{
4591	HARD_REG_SET insn_used_regs;
4592
4593	if (!NONDEBUG_INSN_P (insn))
4594	continue;
4595
4596	if (CALL_P (insn)
4597	&& !self_recursive_call_p (insn))
4598	function_used_regs
4599	|= insn_callee_abi (insn).full_and_partial_reg_clobbers ();
4600
4601	find_all_hard_reg_sets (insn, &insn_used_regs, false);
4602	function_used_regs |= insn_used_regs;
4603
4604	if (hard_reg_set_subset_p (crtl->abi->full_and_partial_reg_clobbers (),
4605	y: function_used_regs))
4606	return;
4607	}
4608
4609	/* Mask out fully-saved registers, so that they don't affect equality
4610	comparisons between function_abis. */
4611	function_used_regs &= crtl->abi->full_and_partial_reg_clobbers ();
4612
4613	node = cgraph_node::rtl_info (current_function_decl);
4614	gcc_assert (node != NULL);
4615
4616	node->function_used_regs = function_used_regs;
4617	}
4618