1	/* Expands front end tree to back end RTL for GCC.
2	Copyright (C) 1987-2023 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 file handles the generation of rtl code from tree structure
21	at the level of the function as a whole.
22	It creates the rtl expressions for parameters and auto variables
23	and has full responsibility for allocating stack slots.
24
25	`expand_function_start' is called at the beginning of a function,
26	before the function body is parsed, and `expand_function_end' is
27	called after parsing the body.
28
29	Call `assign_stack_local' to allocate a stack slot for a local variable.
30	This is usually done during the RTL generation for the function body,
31	but it can also be done in the reload pass when a pseudo-register does
32	not get a hard register. */
33
34	#include "config.h"
35	#include "system.h"
36	#include "coretypes.h"
37	#include "backend.h"
38	#include "target.h"
39	#include "rtl.h"
40	#include "tree.h"
41	#include "gimple-expr.h"
42	#include "cfghooks.h"
43	#include "df.h"
44	#include "memmodel.h"
45	#include "tm_p.h"
46	#include "stringpool.h"
47	#include "expmed.h"
48	#include "optabs.h"
49	#include "opts.h"
50	#include "regs.h"
51	#include "emit-rtl.h"
52	#include "recog.h"
53	#include "rtl-error.h"
54	#include "hard-reg-set.h"
55	#include "alias.h"
56	#include "fold-const.h"
57	#include "stor-layout.h"
58	#include "varasm.h"
59	#include "except.h"
60	#include "dojump.h"
61	#include "explow.h"
62	#include "calls.h"
63	#include "expr.h"
64	#include "optabs-tree.h"
65	#include "output.h"
66	#include "langhooks.h"
67	#include "common/common-target.h"
68	#include "gimplify.h"
69	#include "tree-pass.h"
70	#include "cfgrtl.h"
71	#include "cfganal.h"
72	#include "cfgbuild.h"
73	#include "cfgcleanup.h"
74	#include "cfgexpand.h"
75	#include "shrink-wrap.h"
76	#include "toplev.h"
77	#include "rtl-iter.h"
78	#include "tree-dfa.h"
79	#include "tree-ssa.h"
80	#include "stringpool.h"
81	#include "attribs.h"
82	#include "gimple.h"
83	#include "options.h"
84	#include "function-abi.h"
85	#include "value-range.h"
86	#include "gimple-range.h"
87
88	/* So we can assign to cfun in this file. */
89	#undef cfun
90
91	#ifndef STACK_ALIGNMENT_NEEDED
92	#define STACK_ALIGNMENT_NEEDED 1
93	#endif
94
95	#define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
96
97	/* Round a value to the lowest integer less than it that is a multiple of
98	the required alignment. Avoid using division in case the value is
99	negative. Assume the alignment is a power of two. */
100	#define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
101
102	/* Similar, but round to the next highest integer that meets the
103	alignment. */
104	#define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
105
106	/* Nonzero once virtual register instantiation has been done.
107	assign_stack_local uses frame_pointer_rtx when this is nonzero.
108	calls.cc:emit_library_call_value_1 uses it to set up
109	post-instantiation libcalls. */
110	int virtuals_instantiated;
111
112	/* Assign unique numbers to labels generated for profiling, debugging, etc. */
113	static GTY(()) int funcdef_no;
114
115	/* These variables hold pointers to functions to create and destroy
116	target specific, per-function data structures. */
117	struct machine_function * (*init_machine_status) (void);
118
119	/* The currently compiled function. */
120	struct function *cfun = 0;
121
122	/* These hashes record the prologue and epilogue insns. */
123
124	struct insn_cache_hasher : ggc_cache_ptr_hash<rtx_def>
125	{
126	static hashval_t hash (rtx x) { return htab_hash_pointer (x); }
127	static bool equal (rtx a, rtx b) { return a == b; }
128	};
129
130	static GTY((cache))
131	hash_table<insn_cache_hasher> *prologue_insn_hash;
132	static GTY((cache))
133	hash_table<insn_cache_hasher> *epilogue_insn_hash;
134
135
136	hash_table<used_type_hasher> *types_used_by_vars_hash = NULL;
137	vec<tree, va_gc> *types_used_by_cur_var_decl;
138
139	/* Forward declarations. */
140
141	static class temp_slot *find_temp_slot_from_address (rtx);
142	static void pad_to_arg_alignment (struct args_size *, int, struct args_size *);
143	static void pad_below (struct args_size *, machine_mode, tree);
144	static void reorder_blocks_1 (rtx_insn *, tree, vec<tree> *);
145	static int all_blocks (tree, tree *);
146	static tree *get_block_vector (tree, int *);
147	extern tree debug_find_var_in_block_tree (tree, tree);
148	/* We always define `record_insns' even if it's not used so that we
149	can always export `prologue_epilogue_contains'. */
150	static void record_insns (rtx_insn *, rtx, hash_table<insn_cache_hasher> **)
151	ATTRIBUTE_UNUSED;
152	static bool contains (const rtx_insn *, hash_table<insn_cache_hasher> *);
153	static void prepare_function_start (void);
154	static void do_clobber_return_reg (rtx, void *);
155	static void do_use_return_reg (rtx, void *);
156
157
158	/* Stack of nested functions. */
159	/* Keep track of the cfun stack. */
160
161	static vec<function *> function_context_stack;
162
163	/* Save the current context for compilation of a nested function.
164	This is called from language-specific code. */
165
166	void
167	push_function_context (void)
168	{
169	if (cfun == 0)
170	allocate_struct_function (NULL, false);
171
172	function_context_stack.safe_push (obj: cfun);
173	set_cfun (NULL);
174	}
175
176	/* Restore the last saved context, at the end of a nested function.
177	This function is called from language-specific code. */
178
179	void
180	pop_function_context (void)
181	{
182	struct function *p = function_context_stack.pop ();
183	set_cfun (new_cfun: p);
184	current_function_decl = p->decl;
185
186	/* Reset variables that have known state during rtx generation. */
187	virtuals_instantiated = 0;
188	generating_concat_p = 1;
189	}
190
191	/* Clear out all parts of the state in F that can safely be discarded
192	after the function has been parsed, but not compiled, to let
193	garbage collection reclaim the memory. */
194
195	void
196	free_after_parsing (struct function *f)
197	{
198	f->language = 0;
199	}
200
201	/* Clear out all parts of the state in F that can safely be discarded
202	after the function has been compiled, to let garbage collection
203	reclaim the memory. */
204
205	void
206	free_after_compilation (struct function *f)
207	{
208	prologue_insn_hash = NULL;
209	epilogue_insn_hash = NULL;
210
211	free (crtl->emit.regno_pointer_align);
212
213	memset (crtl, c: 0, n: sizeof (struct rtl_data));
214	f->eh = NULL;
215	f->machine = NULL;
216	f->cfg = NULL;
217	f->curr_properties &= ~PROP_cfg;
218
219	regno_reg_rtx = NULL;
220	}
221
222	/* Return size needed for stack frame based on slots so far allocated.
223	This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
224	the caller may have to do that. */
225
226	poly_int64
227	get_frame_size (void)
228	{
229	if (FRAME_GROWS_DOWNWARD)
230	return -frame_offset;
231	else
232	return frame_offset;
233	}
234
235	/* Issue an error message and return TRUE if frame OFFSET overflows in
236	the signed target pointer arithmetics for function FUNC. Otherwise
237	return FALSE. */
238
239	bool
240	frame_offset_overflow (poly_int64 offset, tree func)
241	{
242	poly_uint64 size = FRAME_GROWS_DOWNWARD ? -offset : offset;
243	unsigned HOST_WIDE_INT limit
244	= ((HOST_WIDE_INT_1U << (GET_MODE_BITSIZE (Pmode) - 1))
245	/* Leave room for the fixed part of the frame. */
246	- 64 * UNITS_PER_WORD);
247
248	if (!coeffs_in_range_p (a: size, b: 0U, c: limit))
249	{
250	unsigned HOST_WIDE_INT hwisize;
251	if (size.is_constant (const_value: &hwisize))
252	error_at (DECL_SOURCE_LOCATION (func),
253	"total size of local objects %wu exceeds maximum %wu",
254	hwisize, limit);
255	else
256	error_at (DECL_SOURCE_LOCATION (func),
257	"total size of local objects exceeds maximum %wu",
258	limit);
259	return true;
260	}
261
262	return false;
263	}
264
265	/* Return the minimum spill slot alignment for a register of mode MODE. */
266
267	unsigned int
268	spill_slot_alignment (machine_mode mode ATTRIBUTE_UNUSED)
269	{
270	return STACK_SLOT_ALIGNMENT (NULL_TREE, mode, GET_MODE_ALIGNMENT (mode));
271	}
272
273	/* Return stack slot alignment in bits for TYPE and MODE. */
274
275	static unsigned int
276	get_stack_local_alignment (tree type, machine_mode mode)
277	{
278	unsigned int alignment;
279
280	if (mode == BLKmode)
281	alignment = BIGGEST_ALIGNMENT;
282	else
283	alignment = GET_MODE_ALIGNMENT (mode);
284
285	/* Allow the frond-end to (possibly) increase the alignment of this
286	stack slot. */
287	if (! type)
288	type = lang_hooks.types.type_for_mode (mode, 0);
289
290	return STACK_SLOT_ALIGNMENT (type, mode, alignment);
291	}
292
293	/* Determine whether it is possible to fit a stack slot of size SIZE and
294	alignment ALIGNMENT into an area in the stack frame that starts at
295	frame offset START and has a length of LENGTH. If so, store the frame
296	offset to be used for the stack slot in *POFFSET and return true;
297	return false otherwise. This function will extend the frame size when
298	given a start/length pair that lies at the end of the frame. */
299
300	static bool
301	try_fit_stack_local (poly_int64 start, poly_int64 length,
302	poly_int64 size, unsigned int alignment,
303	poly_int64 *poffset)
304	{
305	poly_int64 this_frame_offset;
306	int frame_off, frame_alignment, frame_phase;
307
308	/* Calculate how many bytes the start of local variables is off from
309	stack alignment. */
310	frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
311	frame_off = targetm.starting_frame_offset () % frame_alignment;
312	frame_phase = frame_off ? frame_alignment - frame_off : 0;
313
314	/* Round the frame offset to the specified alignment. */
315
316	if (FRAME_GROWS_DOWNWARD)
317	this_frame_offset
318	= (aligned_lower_bound (value: start + length - size - frame_phase, align: alignment)
319	+ frame_phase);
320	else
321	this_frame_offset
322	= aligned_upper_bound (value: start - frame_phase, align: alignment) + frame_phase;
323
324	/* See if it fits. If this space is at the edge of the frame,
325	consider extending the frame to make it fit. Our caller relies on
326	this when allocating a new slot. */
327	if (maybe_lt (a: this_frame_offset, b: start))
328	{
329	if (known_eq (frame_offset, start))
330	frame_offset = this_frame_offset;
331	else
332	return false;
333	}
334	else if (maybe_gt (this_frame_offset + size, start + length))
335	{
336	if (known_eq (frame_offset, start + length))
337	frame_offset = this_frame_offset + size;
338	else
339	return false;
340	}
341
342	*poffset = this_frame_offset;
343	return true;
344	}
345
346	/* Create a new frame_space structure describing free space in the stack
347	frame beginning at START and ending at END, and chain it into the
348	function's frame_space_list. */
349
350	static void
351	add_frame_space (poly_int64 start, poly_int64 end)
352	{
353	class frame_space *space = ggc_alloc<frame_space> ();
354	space->next = crtl->frame_space_list;
355	crtl->frame_space_list = space;
356	space->start = start;
357	space->length = end - start;
358	}
359
360	/* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
361	with machine mode MODE.
362
363	ALIGN controls the amount of alignment for the address of the slot:
364	0 means according to MODE,
365	-1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
366	-2 means use BITS_PER_UNIT,
367	positive specifies alignment boundary in bits.
368
369	KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce
370	alignment and ASLK_RECORD_PAD bit set if we should remember
371	extra space we allocated for alignment purposes. When we are
372	called from assign_stack_temp_for_type, it is not set so we don't
373	track the same stack slot in two independent lists.
374
375	We do not round to stack_boundary here. */
376
377	rtx
378	assign_stack_local_1 (machine_mode mode, poly_int64 size,
379	int align, int kind)
380	{
381	rtx x, addr;
382	poly_int64 bigend_correction = 0;
383	poly_int64 slot_offset = 0, old_frame_offset;
384	unsigned int alignment, alignment_in_bits;
385
386	if (align == 0)
387	{
388	alignment = get_stack_local_alignment (NULL, mode);
389	alignment /= BITS_PER_UNIT;
390	}
391	else if (align == -1)
392	{
393	alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
394	size = aligned_upper_bound (value: size, align: alignment);
395	}
396	else if (align == -2)
397	alignment = 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
398	else
399	alignment = align / BITS_PER_UNIT;
400
401	alignment_in_bits = alignment * BITS_PER_UNIT;
402
403	/* Ignore alignment if it exceeds MAX_SUPPORTED_STACK_ALIGNMENT. */
404	if (alignment_in_bits > MAX_SUPPORTED_STACK_ALIGNMENT)
405	{
406	alignment_in_bits = MAX_SUPPORTED_STACK_ALIGNMENT;
407	alignment = MAX_SUPPORTED_STACK_ALIGNMENT / BITS_PER_UNIT;
408	}
409
410	if (SUPPORTS_STACK_ALIGNMENT)
411	{
412	if (crtl->stack_alignment_estimated < alignment_in_bits)
413	{
414	if (!crtl->stack_realign_processed)
415	crtl->stack_alignment_estimated = alignment_in_bits;
416	else
417	{
418	/* If stack is realigned and stack alignment value
419	hasn't been finalized, it is OK not to increase
420	stack_alignment_estimated. The bigger alignment
421	requirement is recorded in stack_alignment_needed
422	below. */
423	gcc_assert (!crtl->stack_realign_finalized);
424	if (!crtl->stack_realign_needed)
425	{
426	/* It is OK to reduce the alignment as long as the
427	requested size is 0 or the estimated stack
428	alignment >= mode alignment. */
429	gcc_assert ((kind & ASLK_REDUCE_ALIGN)
430	|| known_eq (size, 0)
431	|| (crtl->stack_alignment_estimated
432	>= GET_MODE_ALIGNMENT (mode)));
433	alignment_in_bits = crtl->stack_alignment_estimated;
434	alignment = alignment_in_bits / BITS_PER_UNIT;
435	}
436	}
437	}
438	}
439
440	if (crtl->stack_alignment_needed < alignment_in_bits)
441	crtl->stack_alignment_needed = alignment_in_bits;
442	if (crtl->max_used_stack_slot_alignment < alignment_in_bits)
443	crtl->max_used_stack_slot_alignment = alignment_in_bits;
444
445	if (mode != BLKmode || maybe_ne (a: size, b: 0))
446	{
447	if (kind & ASLK_RECORD_PAD)
448	{
449	class frame_space **psp;
450
451	for (psp = &crtl->frame_space_list; *psp; psp = &(*psp)->next)
452	{
453	class frame_space *space = *psp;
454	if (!try_fit_stack_local (start: space->start, length: space->length, size,
455	alignment, poffset: &slot_offset))
456	continue;
457	*psp = space->next;
458	if (known_gt (slot_offset, space->start))
459	add_frame_space (start: space->start, end: slot_offset);
460	if (known_lt (slot_offset + size, space->start + space->length))
461	add_frame_space (start: slot_offset + size,
462	end: space->start + space->length);
463	goto found_space;
464	}
465	}
466	}
467	else if (!STACK_ALIGNMENT_NEEDED)
468	{
469	slot_offset = frame_offset;
470	goto found_space;
471	}
472
473	old_frame_offset = frame_offset;
474
475	if (FRAME_GROWS_DOWNWARD)
476	{
477	frame_offset -= size;
478	try_fit_stack_local (frame_offset, length: size, size, alignment, poffset: &slot_offset);
479
480	if (kind & ASLK_RECORD_PAD)
481	{
482	if (known_gt (slot_offset, frame_offset))
483	add_frame_space (frame_offset, end: slot_offset);
484	if (known_lt (slot_offset + size, old_frame_offset))
485	add_frame_space (start: slot_offset + size, end: old_frame_offset);
486	}
487	}
488	else
489	{
490	frame_offset += size;
491	try_fit_stack_local (start: old_frame_offset, length: size, size, alignment, poffset: &slot_offset);
492
493	if (kind & ASLK_RECORD_PAD)
494	{
495	if (known_gt (slot_offset, old_frame_offset))
496	add_frame_space (start: old_frame_offset, end: slot_offset);
497	if (known_lt (slot_offset + size, frame_offset))
498	add_frame_space (start: slot_offset + size, frame_offset);
499	}
500	}
501
502	found_space:
503	/* On a big-endian machine, if we are allocating more space than we will use,
504	use the least significant bytes of those that are allocated. */
505	if (mode != BLKmode)
506	{
507	/* The slot size can sometimes be smaller than the mode size;
508	e.g. the rs6000 port allocates slots with a vector mode
509	that have the size of only one element. However, the slot
510	size must always be ordered wrt to the mode size, in the
511	same way as for a subreg. */
512	gcc_checking_assert (ordered_p (GET_MODE_SIZE (mode), size));
513	if (BYTES_BIG_ENDIAN && maybe_lt (a: GET_MODE_SIZE (mode), b: size))
514	bigend_correction = size - GET_MODE_SIZE (mode);
515	}
516
517	/* If we have already instantiated virtual registers, return the actual
518	address relative to the frame pointer. */
519	if (virtuals_instantiated)
520	addr = plus_constant (Pmode, frame_pointer_rtx,
521	trunc_int_for_mode
522	(slot_offset + bigend_correction
523	+ targetm.starting_frame_offset (), Pmode));
524	else
525	addr = plus_constant (Pmode, virtual_stack_vars_rtx,
526	trunc_int_for_mode
527	(slot_offset + bigend_correction,
528	Pmode));
529
530	x = gen_rtx_MEM (mode, addr);
531	set_mem_align (x, alignment_in_bits);
532	MEM_NOTRAP_P (x) = 1;
533
534	vec_safe_push (stack_slot_list, obj: x);
535
536	if (frame_offset_overflow (frame_offset, func: current_function_decl))
537	frame_offset = 0;
538
539	return x;
540	}
541
542	/* Wrap up assign_stack_local_1 with last parameter as false. */
543
544	rtx
545	assign_stack_local (machine_mode mode, poly_int64 size, int align)
546	{
547	return assign_stack_local_1 (mode, size, align, ASLK_RECORD_PAD);
548	}
549
550	/* In order to evaluate some expressions, such as function calls returning
551	structures in memory, we need to temporarily allocate stack locations.
552	We record each allocated temporary in the following structure.
553
554	Associated with each temporary slot is a nesting level. When we pop up
555	one level, all temporaries associated with the previous level are freed.
556	Normally, all temporaries are freed after the execution of the statement
557	in which they were created. However, if we are inside a ({...}) grouping,
558	the result may be in a temporary and hence must be preserved. If the
559	result could be in a temporary, we preserve it if we can determine which
560	one it is in. If we cannot determine which temporary may contain the
561	result, all temporaries are preserved. A temporary is preserved by
562	pretending it was allocated at the previous nesting level. */
563
564	class GTY(()) temp_slot {
565	public:
566	/* Points to next temporary slot. */
567	class temp_slot *next;
568	/* Points to previous temporary slot. */
569	class temp_slot *prev;
570	/* The rtx to used to reference the slot. */
571	rtx slot;
572	/* The size, in units, of the slot. */
573	poly_int64 size;
574	/* The type of the object in the slot, or zero if it doesn't correspond
575	to a type. We use this to determine whether a slot can be reused.
576	It can be reused if objects of the type of the new slot will always
577	conflict with objects of the type of the old slot. */
578	tree type;
579	/* The alignment (in bits) of the slot. */
580	unsigned int align;
581	/* True if this temporary is currently in use. */
582	bool in_use;
583	/* Nesting level at which this slot is being used. */
584	int level;
585	/* The offset of the slot from the frame_pointer, including extra space
586	for alignment. This info is for combine_temp_slots. */
587	poly_int64 base_offset;
588	/* The size of the slot, including extra space for alignment. This
589	info is for combine_temp_slots. */
590	poly_int64 full_size;
591	};
592
593	/* Entry for the below hash table. */
594	struct GTY((for_user)) temp_slot_address_entry {
595	hashval_t hash;
596	rtx address;
597	class temp_slot *temp_slot;
598	};
599
600	struct temp_address_hasher : ggc_ptr_hash<temp_slot_address_entry>
601	{
602	static hashval_t hash (temp_slot_address_entry *);
603	static bool equal (temp_slot_address_entry *, temp_slot_address_entry *);
604	};
605
606	/* A table of addresses that represent a stack slot. The table is a mapping
607	from address RTXen to a temp slot. */
608	static GTY(()) hash_table<temp_address_hasher> *temp_slot_address_table;
609	static size_t n_temp_slots_in_use;
610
611	/* Removes temporary slot TEMP from LIST. */
612
613	static void
614	cut_slot_from_list (class temp_slot *temp, class temp_slot **list)
615	{
616	if (temp->next)
617	temp->next->prev = temp->prev;
618	if (temp->prev)
619	temp->prev->next = temp->next;
620	else
621	*list = temp->next;
622
623	temp->prev = temp->next = NULL;
624	}
625
626	/* Inserts temporary slot TEMP to LIST. */
627
628	static void
629	insert_slot_to_list (class temp_slot *temp, class temp_slot **list)
630	{
631	temp->next = *list;
632	if (*list)
633	(*list)->prev = temp;
634	temp->prev = NULL;
635	*list = temp;
636	}
637
638	/* Returns the list of used temp slots at LEVEL. */
639
640	static class temp_slot **
641	temp_slots_at_level (int level)
642	{
643	if (level >= (int) vec_safe_length (used_temp_slots))
644	vec_safe_grow_cleared (used_temp_slots, len: level + 1, exact: true);
645
646	return &(*used_temp_slots)[level];
647	}
648
649	/* Returns the maximal temporary slot level. */
650
651	static int
652	max_slot_level (void)
653	{
654	if (!used_temp_slots)
655	return -1;
656
657	return used_temp_slots->length () - 1;
658	}
659
660	/* Moves temporary slot TEMP to LEVEL. */
661
662	static void
663	move_slot_to_level (class temp_slot *temp, int level)
664	{
665	cut_slot_from_list (temp, list: temp_slots_at_level (level: temp->level));
666	insert_slot_to_list (temp, list: temp_slots_at_level (level));
667	temp->level = level;
668	}
669
670	/* Make temporary slot TEMP available. */
671
672	static void
673	make_slot_available (class temp_slot *temp)
674	{
675	cut_slot_from_list (temp, list: temp_slots_at_level (level: temp->level));
676	insert_slot_to_list (temp, list: &avail_temp_slots);
677	temp->in_use = false;
678	temp->level = -1;
679	n_temp_slots_in_use--;
680	}
681
682	/* Compute the hash value for an address -> temp slot mapping.
683	The value is cached on the mapping entry. */
684	static hashval_t
685	temp_slot_address_compute_hash (struct temp_slot_address_entry *t)
686	{
687	int do_not_record = 0;
688	return hash_rtx (t->address, GET_MODE (t->address),
689	&do_not_record, NULL, false);
690	}
691
692	/* Return the hash value for an address -> temp slot mapping. */
693	hashval_t
694	temp_address_hasher::hash (temp_slot_address_entry *t)
695	{
696	return t->hash;
697	}
698
699	/* Compare two address -> temp slot mapping entries. */
700	bool
701	temp_address_hasher::equal (temp_slot_address_entry *t1,
702	temp_slot_address_entry *t2)
703	{
704	return exp_equiv_p (t1->address, t2->address, 0, true);
705	}
706
707	/* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping. */
708	static void
709	insert_temp_slot_address (rtx address, class temp_slot *temp_slot)
710	{
711	struct temp_slot_address_entry *t = ggc_alloc<temp_slot_address_entry> ();
712	t->address = copy_rtx (address);
713	t->temp_slot = temp_slot;
714	t->hash = temp_slot_address_compute_hash (t);
715	*temp_slot_address_table->find_slot_with_hash (comparable: t, hash: t->hash, insert: INSERT) = t;
716	}
717
718	/* Remove an address -> temp slot mapping entry if the temp slot is
719	not in use anymore. Callback for remove_unused_temp_slot_addresses. */
720	int
721	remove_unused_temp_slot_addresses_1 (temp_slot_address_entry **slot, void *)
722	{
723	const struct temp_slot_address_entry *t = *slot;
724	if (! t->temp_slot->in_use)
725	temp_slot_address_table->clear_slot (slot);
726	return 1;
727	}
728
729	/* Remove all mappings of addresses to unused temp slots. */
730	static void
731	remove_unused_temp_slot_addresses (void)
732	{
733	/* Use quicker clearing if there aren't any active temp slots. */
734	if (n_temp_slots_in_use)
735	temp_slot_address_table->traverse
736	<void *, remove_unused_temp_slot_addresses_1> (NULL);
737	else
738	temp_slot_address_table->empty ();
739	}
740
741	/* Find the temp slot corresponding to the object at address X. */
742
743	static class temp_slot *
744	find_temp_slot_from_address (rtx x)
745	{
746	class temp_slot *p;
747	struct temp_slot_address_entry tmp, *t;
748
749	/* First try the easy way:
750	See if X exists in the address -> temp slot mapping. */
751	tmp.address = x;
752	tmp.temp_slot = NULL;
753	tmp.hash = temp_slot_address_compute_hash (t: &tmp);
754	t = temp_slot_address_table->find_with_hash (comparable: &tmp, hash: tmp.hash);
755	if (t)
756	return t->temp_slot;
757
758	/* If we have a sum involving a register, see if it points to a temp
759	slot. */
760	if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 0))
761	&& (p = find_temp_slot_from_address (XEXP (x, 0))) != 0)
762	return p;
763	else if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 1))
764	&& (p = find_temp_slot_from_address (XEXP (x, 1))) != 0)
765	return p;
766
767	/* Last resort: Address is a virtual stack var address. */
768	poly_int64 offset;
769	if (strip_offset (x, &offset) == virtual_stack_vars_rtx)
770	{
771	int i;
772	for (i = max_slot_level (); i >= 0; i--)
773	for (p = *temp_slots_at_level (level: i); p; p = p->next)
774	if (known_in_range_p (val: offset, pos: p->base_offset, size: p->full_size))
775	return p;
776	}
777
778	return NULL;
779	}
780
781	/* Allocate a temporary stack slot and record it for possible later
782	reuse.
783
784	MODE is the machine mode to be given to the returned rtx.
785
786	SIZE is the size in units of the space required. We do no rounding here
787	since assign_stack_local will do any required rounding.
788
789	TYPE is the type that will be used for the stack slot. */
790
791	rtx
792	assign_stack_temp_for_type (machine_mode mode, poly_int64 size, tree type)
793	{
794	unsigned int align;
795	class temp_slot *p, *best_p = 0, *selected = NULL, **pp;
796	rtx slot;
797
798	gcc_assert (known_size_p (size));
799
800	align = get_stack_local_alignment (type, mode);
801
802	/* Try to find an available, already-allocated temporary of the proper
803	mode which meets the size and alignment requirements. Choose the
804	smallest one with the closest alignment.
805
806	If assign_stack_temp is called outside of the tree->rtl expansion,
807	we cannot reuse the stack slots (that may still refer to
808	VIRTUAL_STACK_VARS_REGNUM). */
809	if (!virtuals_instantiated)
810	{
811	for (p = avail_temp_slots; p; p = p->next)
812	{
813	if (p->align >= align
814	&& known_ge (p->size, size)
815	&& GET_MODE (p->slot) == mode
816	&& objects_must_conflict_p (p->type, type)
817	&& (best_p == 0
818	|| (known_eq (best_p->size, p->size)
819	? best_p->align > p->align
820	: known_ge (best_p->size, p->size))))
821	{
822	if (p->align == align && known_eq (p->size, size))
823	{
824	selected = p;
825	cut_slot_from_list (temp: selected, list: &avail_temp_slots);
826	best_p = 0;
827	break;
828	}
829	best_p = p;
830	}
831	}
832	}
833
834	/* Make our best, if any, the one to use. */
835	if (best_p)
836	{
837	selected = best_p;
838	cut_slot_from_list (temp: selected, list: &avail_temp_slots);
839
840	/* If there are enough aligned bytes left over, make them into a new
841	temp_slot so that the extra bytes don't get wasted. Do this only
842	for BLKmode slots, so that we can be sure of the alignment. */
843	if (GET_MODE (best_p->slot) == BLKmode)
844	{
845	int alignment = best_p->align / BITS_PER_UNIT;
846	poly_int64 rounded_size = aligned_upper_bound (value: size, align: alignment);
847
848	if (known_ge (best_p->size - rounded_size, alignment))
849	{
850	p = ggc_alloc<temp_slot> ();
851	p->in_use = false;
852	p->size = best_p->size - rounded_size;
853	p->base_offset = best_p->base_offset + rounded_size;
854	p->full_size = best_p->full_size - rounded_size;
855	p->slot = adjust_address_nv (best_p->slot, BLKmode, rounded_size);
856	p->align = best_p->align;
857	p->type = best_p->type;
858	insert_slot_to_list (temp: p, list: &avail_temp_slots);
859
860	vec_safe_push (stack_slot_list, obj: p->slot);
861
862	best_p->size = rounded_size;
863	best_p->full_size = rounded_size;
864	}
865	}
866	}
867
868	/* If we still didn't find one, make a new temporary. */
869	if (selected == 0)
870	{
871	poly_int64 frame_offset_old = frame_offset;
872
873	p = ggc_alloc<temp_slot> ();
874
875	/* We are passing an explicit alignment request to assign_stack_local.
876	One side effect of that is assign_stack_local will not round SIZE
877	to ensure the frame offset remains suitably aligned.
878
879	So for requests which depended on the rounding of SIZE, we go ahead
880	and round it now. We also make sure ALIGNMENT is at least
881	BIGGEST_ALIGNMENT. */
882	gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT);
883	p->slot = assign_stack_local_1 (mode,
884	size: (mode == BLKmode
885	? aligned_upper_bound (value: size,
886	align: (int) align
887	/ BITS_PER_UNIT)
888	: size),
889	align, kind: 0);
890
891	p->align = align;
892
893	/* The following slot size computation is necessary because we don't
894	know the actual size of the temporary slot until assign_stack_local
895	has performed all the frame alignment and size rounding for the
896	requested temporary. Note that extra space added for alignment
897	can be either above or below this stack slot depending on which
898	way the frame grows. We include the extra space if and only if it
899	is above this slot. */
900	if (FRAME_GROWS_DOWNWARD)
901	p->size = frame_offset_old - frame_offset;
902	else
903	p->size = size;
904
905	/* Now define the fields used by combine_temp_slots. */
906	if (FRAME_GROWS_DOWNWARD)
907	{
908	p->base_offset = frame_offset;
909	p->full_size = frame_offset_old - frame_offset;
910	}
911	else
912	{
913	p->base_offset = frame_offset_old;
914	p->full_size = frame_offset - frame_offset_old;
915	}
916
917	selected = p;
918	}
919
920	p = selected;
921	p->in_use = true;
922	p->type = type;
923	p->level = temp_slot_level;
924	n_temp_slots_in_use++;
925
926	pp = temp_slots_at_level (level: p->level);
927	insert_slot_to_list (temp: p, list: pp);
928	insert_temp_slot_address (XEXP (p->slot, 0), temp_slot: p);
929
930	/* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */
931	slot = gen_rtx_MEM (mode, XEXP (p->slot, 0));
932	vec_safe_push (stack_slot_list, obj: slot);
933
934	/* If we know the alias set for the memory that will be used, use
935	it. If there's no TYPE, then we don't know anything about the
936	alias set for the memory. */
937	set_mem_alias_set (slot, type ? get_alias_set (type) : 0);
938	set_mem_align (slot, align);
939
940	/* If a type is specified, set the relevant flags. */
941	if (type != 0)
942	MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type);
943	MEM_NOTRAP_P (slot) = 1;
944
945	return slot;
946	}
947
948	/* Allocate a temporary stack slot and record it for possible later
949	reuse. First two arguments are same as in preceding function. */
950
951	rtx
952	assign_stack_temp (machine_mode mode, poly_int64 size)
953	{
954	return assign_stack_temp_for_type (mode, size, NULL_TREE);
955	}
956
957	/* Assign a temporary.
958	If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
959	and so that should be used in error messages. In either case, we
960	allocate of the given type.
961	MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
962	it is 0 if a register is OK.
963	DONT_PROMOTE is 1 if we should not promote values in register
964	to wider modes. */
965
966	rtx
967	assign_temp (tree type_or_decl, int memory_required,
968	int dont_promote ATTRIBUTE_UNUSED)
969	{
970	tree type, decl;
971	machine_mode mode;
972	#ifdef PROMOTE_MODE
973	int unsignedp;
974	#endif
975
976	if (DECL_P (type_or_decl))
977	decl = type_or_decl, type = TREE_TYPE (decl);
978	else
979	decl = NULL, type = type_or_decl;
980
981	mode = TYPE_MODE (type);
982	#ifdef PROMOTE_MODE
983	unsignedp = TYPE_UNSIGNED (type);
984	#endif
985
986	/* Allocating temporaries of TREE_ADDRESSABLE type must be done in the front
987	end. See also create_tmp_var for the gimplification-time check. */
988	gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
989
990	if (mode == BLKmode || memory_required)
991	{
992	poly_int64 size;
993	rtx tmp;
994
995	/* Unfortunately, we don't yet know how to allocate variable-sized
996	temporaries. However, sometimes we can find a fixed upper limit on
997	the size, so try that instead. */
998	if (!poly_int_tree_p (TYPE_SIZE_UNIT (type), value: &size))
999	size = max_int_size_in_bytes (type);
1000
1001	/* Zero sized arrays are a GNU C extension. Set size to 1 to avoid
1002	problems with allocating the stack space. */
1003	if (known_eq (size, 0))
1004	size = 1;
1005
1006	/* The size of the temporary may be too large to fit into an integer. */
1007	/* ??? Not sure this should happen except for user silliness, so limit
1008	this to things that aren't compiler-generated temporaries. The
1009	rest of the time we'll die in assign_stack_temp_for_type. */
1010	if (decl
1011	&& !known_size_p (a: size)
1012	&& TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST)
1013	{
1014	error ("size of variable %q+D is too large", decl);
1015	size = 1;
1016	}
1017
1018	tmp = assign_stack_temp_for_type (mode, size, type);
1019	return tmp;
1020	}
1021
1022	#ifdef PROMOTE_MODE
1023	if (! dont_promote)
1024	mode = promote_mode (type, mode, &unsignedp);
1025	#endif
1026
1027	return gen_reg_rtx (mode);
1028	}
1029
1030	/* Combine temporary stack slots which are adjacent on the stack.
1031
1032	This allows for better use of already allocated stack space. This is only
1033	done for BLKmode slots because we can be sure that we won't have alignment
1034	problems in this case. */
1035
1036	static void
1037	combine_temp_slots (void)
1038	{
1039	class temp_slot *p, *q, *next, *next_q;
1040	int num_slots;
1041
1042	/* We can't combine slots, because the information about which slot
1043	is in which alias set will be lost. */
1044	if (flag_strict_aliasing)
1045	return;
1046
1047	/* If there are a lot of temp slots, don't do anything unless
1048	high levels of optimization. */
1049	if (! flag_expensive_optimizations)
1050	for (p = avail_temp_slots, num_slots = 0; p; p = p->next, num_slots++)
1051	if (num_slots > 100 || (num_slots > 10 && optimize == 0))
1052	return;
1053
1054	for (p = avail_temp_slots; p; p = next)
1055	{
1056	int delete_p = 0;
1057
1058	next = p->next;
1059
1060	if (GET_MODE (p->slot) != BLKmode)
1061	continue;
1062
1063	for (q = p->next; q; q = next_q)
1064	{
1065	int delete_q = 0;
1066
1067	next_q = q->next;
1068
1069	if (GET_MODE (q->slot) != BLKmode)
1070	continue;
1071
1072	if (known_eq (p->base_offset + p->full_size, q->base_offset))
1073	{
1074	/* Q comes after P; combine Q into P. */
1075	p->size += q->size;
1076	p->full_size += q->full_size;
1077	delete_q = 1;
1078	}
1079	else if (known_eq (q->base_offset + q->full_size, p->base_offset))
1080	{
1081	/* P comes after Q; combine P into Q. */
1082	q->size += p->size;
1083	q->full_size += p->full_size;
1084	delete_p = 1;
1085	break;
1086	}
1087	if (delete_q)
1088	cut_slot_from_list (temp: q, list: &avail_temp_slots);
1089	}
1090
1091	/* Either delete P or advance past it. */
1092	if (delete_p)
1093	cut_slot_from_list (temp: p, list: &avail_temp_slots);
1094	}
1095	}
1096
1097	/* Indicate that NEW_RTX is an alternate way of referring to the temp
1098	slot that previously was known by OLD_RTX. */
1099
1100	void
1101	update_temp_slot_address (rtx old_rtx, rtx new_rtx)
1102	{
1103	class temp_slot *p;
1104
1105	if (rtx_equal_p (old_rtx, new_rtx))
1106	return;
1107
1108	p = find_temp_slot_from_address (x: old_rtx);
1109
1110	/* If we didn't find one, see if both OLD_RTX is a PLUS. If so, and
1111	NEW_RTX is a register, see if one operand of the PLUS is a
1112	temporary location. If so, NEW_RTX points into it. Otherwise,
1113	if both OLD_RTX and NEW_RTX are a PLUS and if there is a register
1114	in common between them. If so, try a recursive call on those
1115	values. */
1116	if (p == 0)
1117	{
1118	if (GET_CODE (old_rtx) != PLUS)
1119	return;
1120
1121	if (REG_P (new_rtx))
1122	{
1123	update_temp_slot_address (XEXP (old_rtx, 0), new_rtx);
1124	update_temp_slot_address (XEXP (old_rtx, 1), new_rtx);
1125	return;
1126	}
1127	else if (GET_CODE (new_rtx) != PLUS)
1128	return;
1129
1130	if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 0)))
1131	update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 1));
1132	else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 0)))
1133	update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 1));
1134	else if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 1)))
1135	update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 0));
1136	else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 1)))
1137	update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 0));
1138
1139	return;
1140	}
1141
1142	/* Otherwise add an alias for the temp's address. */
1143	insert_temp_slot_address (address: new_rtx, temp_slot: p);
1144	}
1145
1146	/* If X could be a reference to a temporary slot, mark that slot as
1147	belonging to the to one level higher than the current level. If X
1148	matched one of our slots, just mark that one. Otherwise, we can't
1149	easily predict which it is, so upgrade all of them.
1150
1151	This is called when an ({...}) construct occurs and a statement
1152	returns a value in memory. */
1153
1154	void
1155	preserve_temp_slots (rtx x)
1156	{
1157	class temp_slot *p = 0, *next;
1158
1159	if (x == 0)
1160	return;
1161
1162	/* If X is a register that is being used as a pointer, see if we have
1163	a temporary slot we know it points to. */
1164	if (REG_P (x) && REG_POINTER (x))
1165	p = find_temp_slot_from_address (x);
1166
1167	/* If X is not in memory or is at a constant address, it cannot be in
1168	a temporary slot. */
1169	if (p == 0 && (!MEM_P (x) || CONSTANT_P (XEXP (x, 0))))
1170	return;
1171
1172	/* First see if we can find a match. */
1173	if (p == 0)
1174	p = find_temp_slot_from_address (XEXP (x, 0));
1175
1176	if (p != 0)
1177	{
1178	if (p->level == temp_slot_level)
1179	move_slot_to_level (temp: p, temp_slot_level - 1);
1180	return;
1181	}
1182
1183	/* Otherwise, preserve all non-kept slots at this level. */
1184	for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1185	{
1186	next = p->next;
1187	move_slot_to_level (temp: p, temp_slot_level - 1);
1188	}
1189	}
1190
1191	/* Free all temporaries used so far. This is normally called at the
1192	end of generating code for a statement. */
1193
1194	void
1195	free_temp_slots (void)
1196	{
1197	class temp_slot *p, *next;
1198	bool some_available = false;
1199
1200	for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
1201	{
1202	next = p->next;
1203	make_slot_available (temp: p);
1204	some_available = true;
1205	}
1206
1207	if (some_available)
1208	{
1209	remove_unused_temp_slot_addresses ();
1210	combine_temp_slots ();
1211	}
1212	}
1213
1214	/* Push deeper into the nesting level for stack temporaries. */
1215
1216	void
1217	push_temp_slots (void)
1218	{
1219	temp_slot_level++;
1220	}
1221
1222	/* Pop a temporary nesting level. All slots in use in the current level
1223	are freed. */
1224
1225	void
1226	pop_temp_slots (void)
1227	{
1228	free_temp_slots ();
1229	temp_slot_level--;
1230	}
1231
1232	/* Initialize temporary slots. */
1233
1234	void
1235	init_temp_slots (void)
1236	{
1237	/* We have not allocated any temporaries yet. */
1238	avail_temp_slots = 0;
1239	vec_alloc (used_temp_slots, nelems: 0);
1240	temp_slot_level = 0;
1241	n_temp_slots_in_use = 0;
1242
1243	/* Set up the table to map addresses to temp slots. */
1244	if (! temp_slot_address_table)
1245	temp_slot_address_table = hash_table<temp_address_hasher>::create_ggc (n: 32);
1246	else
1247	temp_slot_address_table->empty ();
1248	}
1249
1250	/* Functions and data structures to keep track of the values hard regs
1251	had at the start of the function. */
1252
1253	/* Private type used by get_hard_reg_initial_reg, get_hard_reg_initial_val,
1254	and has_hard_reg_initial_val.. */
1255	struct GTY(()) initial_value_pair {
1256	rtx hard_reg;
1257	rtx pseudo;
1258	};
1259	/* ??? This could be a VEC but there is currently no way to define an
1260	opaque VEC type. This could be worked around by defining struct
1261	initial_value_pair in function.h. */
1262	struct GTY(()) initial_value_struct {
1263	int num_entries;
1264	int max_entries;
1265	initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
1266	};
1267
1268	/* If a pseudo represents an initial hard reg (or expression), return
1269	it, else return NULL_RTX. */
1270
1271	rtx
1272	get_hard_reg_initial_reg (rtx reg)
1273	{
1274	struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
1275	int i;
1276
1277	if (ivs == 0)
1278	return NULL_RTX;
1279
1280	for (i = 0; i < ivs->num_entries; i++)
1281	if (rtx_equal_p (ivs->entries[i].pseudo, reg))
1282	return ivs->entries[i].hard_reg;
1283
1284	return NULL_RTX;
1285	}
1286
1287	/* Make sure that there's a pseudo register of mode MODE that stores the
1288	initial value of hard register REGNO. Return an rtx for such a pseudo. */
1289
1290	rtx
1291	get_hard_reg_initial_val (machine_mode mode, unsigned int regno)
1292	{
1293	struct initial_value_struct *ivs;
1294	rtx rv;
1295
1296	rv = has_hard_reg_initial_val (mode, regno);
1297	if (rv)
1298	return rv;
1299
1300	ivs = crtl->hard_reg_initial_vals;
1301	if (ivs == 0)
1302	{
1303	ivs = ggc_alloc<initial_value_struct> ();
1304	ivs->num_entries = 0;
1305	ivs->max_entries = 5;
1306	ivs->entries = ggc_vec_alloc<initial_value_pair> (c: 5);
1307	crtl->hard_reg_initial_vals = ivs;
1308	}
1309
1310	if (ivs->num_entries >= ivs->max_entries)
1311	{
1312	ivs->max_entries += 5;
1313	ivs->entries = GGC_RESIZEVEC (initial_value_pair, ivs->entries,
1314	ivs->max_entries);
1315	}
1316
1317	ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);
1318	ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode);
1319
1320	return ivs->entries[ivs->num_entries++].pseudo;
1321	}
1322
1323	/* See if get_hard_reg_initial_val has been used to create a pseudo
1324	for the initial value of hard register REGNO in mode MODE. Return
1325	the associated pseudo if so, otherwise return NULL. */
1326
1327	rtx
1328	has_hard_reg_initial_val (machine_mode mode, unsigned int regno)
1329	{
1330	struct initial_value_struct *ivs;
1331	int i;
1332
1333	ivs = crtl->hard_reg_initial_vals;
1334	if (ivs != 0)
1335	for (i = 0; i < ivs->num_entries; i++)
1336	if (GET_MODE (ivs->entries[i].hard_reg) == mode
1337	&& REGNO (ivs->entries[i].hard_reg) == regno)
1338	return ivs->entries[i].pseudo;
1339
1340	return NULL_RTX;
1341	}
1342
1343	void
1344	emit_initial_value_sets (void)
1345	{
1346	struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
1347	int i;
1348	rtx_insn *seq;
1349
1350	if (ivs == 0)
1351	return;
1352
1353	start_sequence ();
1354	for (i = 0; i < ivs->num_entries; i++)
1355	emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
1356	seq = get_insns ();
1357	end_sequence ();
1358
1359	emit_insn_at_entry (seq);
1360	}
1361
1362	/* Return the hardreg-pseudoreg initial values pair entry I and
1363	TRUE if I is a valid entry, or FALSE if I is not a valid entry. */
1364	bool
1365	initial_value_entry (int i, rtx *hreg, rtx *preg)
1366	{
1367	struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
1368	if (!ivs || i >= ivs->num_entries)
1369	return false;
1370
1371	*hreg = ivs->entries[i].hard_reg;
1372	*preg = ivs->entries[i].pseudo;
1373	return true;
1374	}
1375
1376	/* These routines are responsible for converting virtual register references
1377	to the actual hard register references once RTL generation is complete.
1378
1379	The following four variables are used for communication between the
1380	routines. They contain the offsets of the virtual registers from their
1381	respective hard registers. */
1382
1383	static poly_int64 in_arg_offset;
1384	static poly_int64 var_offset;
1385	static poly_int64 dynamic_offset;
1386	static poly_int64 out_arg_offset;
1387	static poly_int64 cfa_offset;
1388
1389	/* In most machines, the stack pointer register is equivalent to the bottom
1390	of the stack. */
1391
1392	#ifndef STACK_POINTER_OFFSET
1393	#define STACK_POINTER_OFFSET 0
1394	#endif
1395
1396	#if defined (REG_PARM_STACK_SPACE) && !defined (INCOMING_REG_PARM_STACK_SPACE)
1397	#define INCOMING_REG_PARM_STACK_SPACE REG_PARM_STACK_SPACE
1398	#endif
1399
1400	/* If not defined, pick an appropriate default for the offset of dynamically
1401	allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
1402	INCOMING_REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
1403
1404	#ifndef STACK_DYNAMIC_OFFSET
1405
1406	/* The bottom of the stack points to the actual arguments. If
1407	REG_PARM_STACK_SPACE is defined, this includes the space for the register
1408	parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
1409	stack space for register parameters is not pushed by the caller, but
1410	rather part of the fixed stack areas and hence not included in
1411	`crtl->outgoing_args_size'. Nevertheless, we must allow
1412	for it when allocating stack dynamic objects. */
1413
1414	#ifdef INCOMING_REG_PARM_STACK_SPACE
1415	#define STACK_DYNAMIC_OFFSET(FNDECL) \
1416	((ACCUMULATE_OUTGOING_ARGS \
1417	? (crtl->outgoing_args_size \
1418	+ (OUTGOING_REG_PARM_STACK_SPACE ((!(FNDECL) ? NULL_TREE : TREE_TYPE (FNDECL))) ? 0 \
1419	: INCOMING_REG_PARM_STACK_SPACE (FNDECL))) \
1420	: 0) + (STACK_POINTER_OFFSET))
1421	#else
1422	#define STACK_DYNAMIC_OFFSET(FNDECL) \
1423	((ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : poly_int64 (0)) \
1424	+ (STACK_POINTER_OFFSET))
1425	#endif
1426	#endif
1427
1428
1429	/* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
1430	is a virtual register, return the equivalent hard register and set the
1431	offset indirectly through the pointer. Otherwise, return 0. */
1432
1433	static rtx
1434	instantiate_new_reg (rtx x, poly_int64 *poffset)
1435	{
1436	rtx new_rtx;
1437	poly_int64 offset;
1438
1439	if (x == virtual_incoming_args_rtx)
1440	{
1441	if (stack_realign_drap)
1442	{
1443	/* Replace virtual_incoming_args_rtx with internal arg
1444	pointer if DRAP is used to realign stack. */
1445	new_rtx = crtl->args.internal_arg_pointer;
1446	offset = 0;
1447	}
1448	else
1449	new_rtx = arg_pointer_rtx, offset = in_arg_offset;
1450	}
1451	else if (x == virtual_stack_vars_rtx)
1452	new_rtx = frame_pointer_rtx, offset = var_offset;
1453	else if (x == virtual_stack_dynamic_rtx)
1454	new_rtx = stack_pointer_rtx, offset = dynamic_offset;
1455	else if (x == virtual_outgoing_args_rtx)
1456	new_rtx = stack_pointer_rtx, offset = out_arg_offset;
1457	else if (x == virtual_cfa_rtx)
1458	{
1459	#ifdef FRAME_POINTER_CFA_OFFSET
1460	new_rtx = frame_pointer_rtx;
1461	#else
1462	new_rtx = arg_pointer_rtx;
1463	#endif
1464	offset = cfa_offset;
1465	}
1466	else if (x == virtual_preferred_stack_boundary_rtx)
1467	{
1468	new_rtx = GEN_INT (crtl->preferred_stack_boundary / BITS_PER_UNIT);
1469	offset = 0;
1470	}
1471	else
1472	return NULL_RTX;
1473
1474	*poffset = offset;
1475	return new_rtx;
1476	}
1477
1478	/* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1479	registers present inside of *LOC. The expression is simplified,
1480	as much as possible, but is not to be considered "valid" in any sense
1481	implied by the target. Return true if any change is made. */
1482
1483	static bool
1484	instantiate_virtual_regs_in_rtx (rtx *loc)
1485	{
1486	if (!*loc)
1487	return false;
1488	bool changed = false;
1489	subrtx_ptr_iterator::array_type array;
1490	FOR_EACH_SUBRTX_PTR (iter, array, loc, NONCONST)
1491	{
1492	rtx *loc = *iter;
1493	if (rtx x = *loc)
1494	{
1495	rtx new_rtx;
1496	poly_int64 offset;
1497	switch (GET_CODE (x))
1498	{
1499	case REG:
1500	new_rtx = instantiate_new_reg (x, poffset: &offset);
1501	if (new_rtx)
1502	{
1503	*loc = plus_constant (GET_MODE (x), new_rtx, offset);
1504	changed = true;
1505	}
1506	iter.skip_subrtxes ();
1507	break;
1508
1509	case PLUS:
1510	new_rtx = instantiate_new_reg (XEXP (x, 0), poffset: &offset);
1511	if (new_rtx)
1512	{
1513	XEXP (x, 0) = new_rtx;
1514	*loc = plus_constant (GET_MODE (x), x, offset, true);
1515	changed = true;
1516	iter.skip_subrtxes ();
1517	break;
1518	}
1519
1520	/* FIXME -- from old code */
1521	/* If we have (plus (subreg (virtual-reg)) (const_int)), we know
1522	we can commute the PLUS and SUBREG because pointers into the
1523	frame are well-behaved. */
1524	break;
1525
1526	default:
1527	break;
1528	}
1529	}
1530	}
1531	return changed;
1532	}
1533
1534	/* A subroutine of instantiate_virtual_regs_in_insn. Return true if X
1535	matches the predicate for insn CODE operand OPERAND. */
1536
1537	static bool
1538	safe_insn_predicate (int code, int operand, rtx x)
1539	{
1540	return code < 0 || insn_operand_matches (icode: (enum insn_code) code, opno: operand, operand: x);
1541	}
1542
1543	/* A subroutine of instantiate_virtual_regs. Instantiate any virtual
1544	registers present inside of insn. The result will be a valid insn. */
1545
1546	static void
1547	instantiate_virtual_regs_in_insn (rtx_insn *insn)
1548	{
1549	poly_int64 offset;
1550	int insn_code, i;
1551	bool any_change = false;
1552	rtx set, new_rtx, x;
1553	rtx_insn *seq;
1554
1555	/* There are some special cases to be handled first. */
1556	set = single_set (insn);
1557	if (set)
1558	{
1559	/* We're allowed to assign to a virtual register. This is interpreted
1560	to mean that the underlying register gets assigned the inverse
1561	transformation. This is used, for example, in the handling of
1562	non-local gotos. */
1563	new_rtx = instantiate_new_reg (SET_DEST (set), poffset: &offset);
1564	if (new_rtx)
1565	{
1566	start_sequence ();
1567
1568	instantiate_virtual_regs_in_rtx (loc: &SET_SRC (set));
1569	x = simplify_gen_binary (code: PLUS, GET_MODE (new_rtx), SET_SRC (set),
1570	op1: gen_int_mode (-offset, GET_MODE (new_rtx)));
1571	x = force_operand (x, new_rtx);
1572	if (x != new_rtx)
1573	emit_move_insn (new_rtx, x);
1574
1575	seq = get_insns ();
1576	end_sequence ();
1577
1578	emit_insn_before (seq, insn);
1579	delete_insn (insn);
1580	return;
1581	}
1582
1583	/* Handle a straight copy from a virtual register by generating a
1584	new add insn. The difference between this and falling through
1585	to the generic case is avoiding a new pseudo and eliminating a
1586	move insn in the initial rtl stream. */
1587	new_rtx = instantiate_new_reg (SET_SRC (set), poffset: &offset);
1588	if (new_rtx
1589	&& maybe_ne (a: offset, b: 0)
1590	&& REG_P (SET_DEST (set))
1591	&& REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER)
1592	{
1593	start_sequence ();
1594
1595	x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS, new_rtx,
1596	gen_int_mode (offset,
1597	GET_MODE (SET_DEST (set))),
1598	SET_DEST (set), 1, OPTAB_LIB_WIDEN);
1599	if (x != SET_DEST (set))
1600	emit_move_insn (SET_DEST (set), x);
1601
1602	seq = get_insns ();
1603	end_sequence ();
1604
1605	emit_insn_before (seq, insn);
1606	delete_insn (insn);
1607	return;
1608	}
1609
1610	extract_insn (insn);
1611	insn_code = INSN_CODE (insn);
1612
1613	/* Handle a plus involving a virtual register by determining if the
1614	operands remain valid if they're modified in place. */
1615	poly_int64 delta;
1616	if (GET_CODE (SET_SRC (set)) == PLUS
1617	&& recog_data.n_operands >= 3
1618	&& recog_data.operand_loc[1] == &XEXP (SET_SRC (set), 0)
1619	&& recog_data.operand_loc[2] == &XEXP (SET_SRC (set), 1)
1620	&& poly_int_rtx_p (x: recog_data.operand[2], res: &delta)
1621	&& (new_rtx = instantiate_new_reg (x: recog_data.operand[1], poffset: &offset)))
1622	{
1623	offset += delta;
1624
1625	/* If the sum is zero, then replace with a plain move. */
1626	if (known_eq (offset, 0)
1627	&& REG_P (SET_DEST (set))
1628	&& REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER)
1629	{
1630	start_sequence ();
1631	emit_move_insn (SET_DEST (set), new_rtx);
1632	seq = get_insns ();
1633	end_sequence ();
1634
1635	emit_insn_before (seq, insn);
1636	delete_insn (insn);
1637	return;
1638	}
1639
1640	x = gen_int_mode (offset, recog_data.operand_mode[2]);
1641
1642	/* Using validate_change and apply_change_group here leaves
1643	recog_data in an invalid state. Since we know exactly what
1644	we want to check, do those two by hand. */
1645	if (safe_insn_predicate (code: insn_code, operand: 1, x: new_rtx)
1646	&& safe_insn_predicate (code: insn_code, operand: 2, x))
1647	{
1648	*recog_data.operand_loc[1] = recog_data.operand[1] = new_rtx;
1649	*recog_data.operand_loc[2] = recog_data.operand[2] = x;
1650	any_change = true;
1651
1652	/* Fall through into the regular operand fixup loop in
1653	order to take care of operands other than 1 and 2. */
1654	}
1655	}
1656	}
1657	else
1658	{
1659	extract_insn (insn);
1660	insn_code = INSN_CODE (insn);
1661	}
1662
1663	/* In the general case, we expect virtual registers to appear only in
1664	operands, and then only as either bare registers or inside memories. */
1665	for (i = 0; i < recog_data.n_operands; ++i)
1666	{
1667	x = recog_data.operand[i];
1668	switch (GET_CODE (x))
1669	{
1670	case MEM:
1671	{
1672	rtx addr = XEXP (x, 0);
1673
1674	if (!instantiate_virtual_regs_in_rtx (loc: &addr))
1675	continue;
1676
1677	start_sequence ();
1678	x = replace_equiv_address (x, addr, true);
1679	/* It may happen that the address with the virtual reg
1680	was valid (e.g. based on the virtual stack reg, which might
1681	be acceptable to the predicates with all offsets), whereas
1682	the address now isn't anymore, for instance when the address
1683	is still offsetted, but the base reg isn't virtual-stack-reg
1684	anymore. Below we would do a force_reg on the whole operand,
1685	but this insn might actually only accept memory. Hence,
1686	before doing that last resort, try to reload the address into
1687	a register, so this operand stays a MEM. */
1688	if (!safe_insn_predicate (code: insn_code, operand: i, x))
1689	{
1690	addr = force_reg (GET_MODE (addr), addr);
1691	x = replace_equiv_address (x, addr, true);
1692	}
1693	seq = get_insns ();
1694	end_sequence ();
1695	if (seq)
1696	emit_insn_before (seq, insn);
1697	}
1698	break;
1699
1700	case REG:
1701	new_rtx = instantiate_new_reg (x, poffset: &offset);
1702	if (new_rtx == NULL)
1703	continue;
1704	if (known_eq (offset, 0))
1705	x = new_rtx;
1706	else
1707	{
1708	start_sequence ();
1709
1710	/* Careful, special mode predicates may have stuff in
1711	insn_data[insn_code].operand[i].mode that isn't useful
1712	to us for computing a new value. */
1713	/* ??? Recognize address_operand and/or "p" constraints
1714	to see if (plus new offset) is a valid before we put
1715	this through expand_simple_binop. */
1716	x = expand_simple_binop (GET_MODE (x), PLUS, new_rtx,
1717	gen_int_mode (offset, GET_MODE (x)),
1718	NULL_RTX, 1, OPTAB_LIB_WIDEN);
1719	seq = get_insns ();
1720	end_sequence ();
1721	emit_insn_before (seq, insn);
1722	}
1723	break;
1724
1725	case SUBREG:
1726	new_rtx = instantiate_new_reg (SUBREG_REG (x), poffset: &offset);
1727	if (new_rtx == NULL)
1728	continue;
1729	if (maybe_ne (a: offset, b: 0))
1730	{
1731	start_sequence ();
1732	new_rtx = expand_simple_binop
1733	(GET_MODE (new_rtx), PLUS, new_rtx,
1734	gen_int_mode (offset, GET_MODE (new_rtx)),
1735	NULL_RTX, 1, OPTAB_LIB_WIDEN);
1736	seq = get_insns ();
1737	end_sequence ();
1738	emit_insn_before (seq, insn);
1739	}
1740	x = simplify_gen_subreg (outermode: recog_data.operand_mode[i], op: new_rtx,
1741	GET_MODE (new_rtx), SUBREG_BYTE (x));
1742	gcc_assert (x);
1743	break;
1744
1745	default:
1746	continue;
1747	}
1748
1749	/* At this point, X contains the new value for the operand.
1750	Validate the new value vs the insn predicate. Note that
1751	asm insns will have insn_code -1 here. */
1752	if (!safe_insn_predicate (code: insn_code, operand: i, x))
1753	{
1754	start_sequence ();
1755	if (REG_P (x))
1756	{
1757	gcc_assert (REGNO (x) <= LAST_VIRTUAL_REGISTER);
1758	x = copy_to_reg (x);
1759	}
1760	else
1761	x = force_reg (insn_data[insn_code].operand[i].mode, x);
1762	seq = get_insns ();
1763	end_sequence ();
1764	if (seq)
1765	emit_insn_before (seq, insn);
1766	}
1767
1768	*recog_data.operand_loc[i] = recog_data.operand[i] = x;
1769	any_change = true;
1770	}
1771
1772	if (any_change)
1773	{
1774	/* Propagate operand changes into the duplicates. */
1775	for (i = 0; i < recog_data.n_dups; ++i)
1776	*recog_data.dup_loc[i]
1777	= copy_rtx (recog_data.operand[(unsigned)recog_data.dup_num[i]]);
1778
1779	/* Force re-recognition of the instruction for validation. */
1780	INSN_CODE (insn) = -1;
1781	}
1782
1783	if (asm_noperands (PATTERN (insn)) >= 0)
1784	{
1785	if (!check_asm_operands (PATTERN (insn)))
1786	{
1787	error_for_asm (insn, "impossible constraint in %<asm%>");
1788	/* For asm goto, instead of fixing up all the edges
1789	just clear the template and clear input and output operands
1790	and strip away clobbers. */
1791	if (JUMP_P (insn))
1792	{
1793	rtx asm_op = extract_asm_operands (PATTERN (insn));
1794	PATTERN (insn) = asm_op;
1795	PUT_MODE (x: asm_op, VOIDmode);
1796	ASM_OPERANDS_TEMPLATE (asm_op) = ggc_strdup ("");
1797	ASM_OPERANDS_OUTPUT_CONSTRAINT (asm_op) = "";
1798	ASM_OPERANDS_OUTPUT_IDX (asm_op) = 0;
1799	ASM_OPERANDS_INPUT_VEC (asm_op) = rtvec_alloc (0);
1800	ASM_OPERANDS_INPUT_CONSTRAINT_VEC (asm_op) = rtvec_alloc (0);
1801	}
1802	else
1803	delete_insn (insn);
1804	}
1805	}
1806	else
1807	{
1808	if (recog_memoized (insn) < 0)
1809	fatal_insn_not_found (insn);
1810	}
1811	}
1812
1813	/* Subroutine of instantiate_decls. Given RTL representing a decl,
1814	do any instantiation required. */
1815
1816	void
1817	instantiate_decl_rtl (rtx x)
1818	{
1819	rtx addr;
1820
1821	if (x == 0)
1822	return;
1823
1824	/* If this is a CONCAT, recurse for the pieces. */
1825	if (GET_CODE (x) == CONCAT)
1826	{
1827	instantiate_decl_rtl (XEXP (x, 0));
1828	instantiate_decl_rtl (XEXP (x, 1));
1829	return;
1830	}
1831
1832	/* If this is not a MEM, no need to do anything. Similarly if the
1833	address is a constant or a register that is not a virtual register. */
1834	if (!MEM_P (x))
1835	return;
1836
1837	addr = XEXP (x, 0);
1838	if (CONSTANT_P (addr)
1839	|| (REG_P (addr)
1840	&& !VIRTUAL_REGISTER_P (addr)))
1841	return;
1842
1843	instantiate_virtual_regs_in_rtx (loc: &XEXP (x, 0));
1844	}
1845
1846	/* Helper for instantiate_decls called via walk_tree: Process all decls
1847	in the given DECL_VALUE_EXPR. */
1848
1849	static tree
1850	instantiate_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1851	{
1852	tree t = *tp;
1853	if (! EXPR_P (t))
1854	{
1855	*walk_subtrees = 0;
1856	if (DECL_P (t))
1857	{
1858	if (DECL_RTL_SET_P (t))
1859	instantiate_decl_rtl (DECL_RTL (t));
1860	if (TREE_CODE (t) == PARM_DECL && DECL_NAMELESS (t)
1861	&& DECL_INCOMING_RTL (t))
1862	instantiate_decl_rtl (DECL_INCOMING_RTL (t));
1863	if ((VAR_P (t) || TREE_CODE (t) == RESULT_DECL)
1864	&& DECL_HAS_VALUE_EXPR_P (t))
1865	{
1866	tree v = DECL_VALUE_EXPR (t);
1867	walk_tree (&v, instantiate_expr, NULL, NULL);
1868	}
1869	}
1870	}
1871	return NULL;
1872	}
1873
1874	/* Subroutine of instantiate_decls: Process all decls in the given
1875	BLOCK node and all its subblocks. */
1876
1877	static void
1878	instantiate_decls_1 (tree let)
1879	{
1880	tree t;
1881
1882	for (t = BLOCK_VARS (let); t; t = DECL_CHAIN (t))
1883	{
1884	if (DECL_RTL_SET_P (t))
1885	instantiate_decl_rtl (DECL_RTL (t));
1886	if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
1887	{
1888	tree v = DECL_VALUE_EXPR (t);
1889	walk_tree (&v, instantiate_expr, NULL, NULL);
1890	}
1891	}
1892
1893	/* Process all subblocks. */
1894	for (t = BLOCK_SUBBLOCKS (let); t; t = BLOCK_CHAIN (t))
1895	instantiate_decls_1 (let: t);
1896	}
1897
1898	/* Scan all decls in FNDECL (both variables and parameters) and instantiate
1899	all virtual registers in their DECL_RTL's. */
1900
1901	static void
1902	instantiate_decls (tree fndecl)
1903	{
1904	tree decl;
1905	unsigned ix;
1906
1907	/* Process all parameters of the function. */
1908	for (decl = DECL_ARGUMENTS (fndecl); decl; decl = DECL_CHAIN (decl))
1909	{
1910	instantiate_decl_rtl (DECL_RTL (decl));
1911	instantiate_decl_rtl (DECL_INCOMING_RTL (decl));
1912	if (DECL_HAS_VALUE_EXPR_P (decl))
1913	{
1914	tree v = DECL_VALUE_EXPR (decl);
1915	walk_tree (&v, instantiate_expr, NULL, NULL);
1916	}
1917	}
1918
1919	if ((decl = DECL_RESULT (fndecl))
1920	&& TREE_CODE (decl) == RESULT_DECL)
1921	{
1922	if (DECL_RTL_SET_P (decl))
1923	instantiate_decl_rtl (DECL_RTL (decl));
1924	if (DECL_HAS_VALUE_EXPR_P (decl))
1925	{
1926	tree v = DECL_VALUE_EXPR (decl);
1927	walk_tree (&v, instantiate_expr, NULL, NULL);
1928	}
1929	}
1930
1931	/* Process the saved static chain if it exists. */
1932	decl = DECL_STRUCT_FUNCTION (fndecl)->static_chain_decl;
1933	if (decl && DECL_HAS_VALUE_EXPR_P (decl))
1934	instantiate_decl_rtl (DECL_RTL (DECL_VALUE_EXPR (decl)));
1935
1936	/* Now process all variables defined in the function or its subblocks. */
1937	if (DECL_INITIAL (fndecl))
1938	instantiate_decls_1 (DECL_INITIAL (fndecl));
1939
1940	FOR_EACH_LOCAL_DECL (cfun, ix, decl)
1941	if (DECL_RTL_SET_P (decl))
1942	instantiate_decl_rtl (DECL_RTL (decl));
1943	vec_free (v&: cfun->local_decls);
1944	}
1945
1946	/* Return the value of STACK_DYNAMIC_OFFSET for the current function.
1947	This is done through a function wrapper so that the macro sees a
1948	predictable set of included files. */
1949
1950	poly_int64
1951	get_stack_dynamic_offset ()
1952	{
1953	return STACK_DYNAMIC_OFFSET (current_function_decl);
1954	}
1955
1956	/* Pass through the INSNS of function FNDECL and convert virtual register
1957	references to hard register references. */
1958
1959	static void
1960	instantiate_virtual_regs (void)
1961	{
1962	rtx_insn *insn;
1963
1964	/* Compute the offsets to use for this function. */
1965	in_arg_offset = FIRST_PARM_OFFSET (current_function_decl);
1966	var_offset = targetm.starting_frame_offset ();
1967	dynamic_offset = get_stack_dynamic_offset ();
1968	out_arg_offset = STACK_POINTER_OFFSET;
1969	#ifdef FRAME_POINTER_CFA_OFFSET
1970	cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
1971	#else
1972	cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
1973	#endif
1974
1975	/* Initialize recognition, indicating that volatile is OK. */
1976	init_recog ();
1977
1978	/* Scan through all the insns, instantiating every virtual register still
1979	present. */
1980	for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1981	if (INSN_P (insn))
1982	{
1983	/* These patterns in the instruction stream can never be recognized.
1984	Fortunately, they shouldn't contain virtual registers either. */
1985	if (GET_CODE (PATTERN (insn)) == USE
1986	|| GET_CODE (PATTERN (insn)) == CLOBBER
1987	|| GET_CODE (PATTERN (insn)) == ASM_INPUT
1988	|| DEBUG_MARKER_INSN_P (insn))
1989	continue;
1990	else if (DEBUG_BIND_INSN_P (insn))
1991	instantiate_virtual_regs_in_rtx (INSN_VAR_LOCATION_PTR (insn));
1992	else
1993	instantiate_virtual_regs_in_insn (insn);
1994
1995	if (insn->deleted ())
1996	continue;
1997
1998	instantiate_virtual_regs_in_rtx (loc: &REG_NOTES (insn));
1999
2000	/* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE. */
2001	if (CALL_P (insn))
2002	instantiate_virtual_regs_in_rtx (loc: &CALL_INSN_FUNCTION_USAGE (insn));
2003	}
2004
2005	/* Instantiate the virtual registers in the DECLs for debugging purposes. */
2006	instantiate_decls (fndecl: current_function_decl);
2007
2008	targetm.instantiate_decls ();
2009
2010	/* Indicate that, from now on, assign_stack_local should use
2011	frame_pointer_rtx. */
2012	virtuals_instantiated = 1;
2013	}
2014
2015	namespace {
2016
2017	const pass_data pass_data_instantiate_virtual_regs =
2018	{
2019	.type: RTL_PASS, /* type */
2020	.name: "vregs", /* name */
2021	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
2022	.tv_id: TV_NONE, /* tv_id */
2023	.properties_required: 0, /* properties_required */
2024	.properties_provided: 0, /* properties_provided */
2025	.properties_destroyed: 0, /* properties_destroyed */
2026	.todo_flags_start: 0, /* todo_flags_start */
2027	.todo_flags_finish: 0, /* todo_flags_finish */
2028	};
2029
2030	class pass_instantiate_virtual_regs : public rtl_opt_pass
2031	{
2032	public:
2033	pass_instantiate_virtual_regs (gcc::context *ctxt)
2034	: rtl_opt_pass (pass_data_instantiate_virtual_regs, ctxt)
2035	{}
2036
2037	/* opt_pass methods: */
2038	unsigned int execute (function *) final override
2039	{
2040	instantiate_virtual_regs ();
2041	return 0;
2042	}
2043
2044	}; // class pass_instantiate_virtual_regs
2045
2046	} // anon namespace
2047
2048	rtl_opt_pass *
2049	make_pass_instantiate_virtual_regs (gcc::context *ctxt)
2050	{
2051	return new pass_instantiate_virtual_regs (ctxt);
2052	}
2053
2054
2055	/* Return true if EXP is an aggregate type (or a value with aggregate type).
2056	This means a type for which function calls must pass an address to the
2057	function or get an address back from the function.
2058	EXP may be a type node or an expression (whose type is tested). */
2059
2060	bool
2061	aggregate_value_p (const_tree exp, const_tree fntype)
2062	{
2063	const_tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp);
2064	int i, regno, nregs;
2065	rtx reg;
2066
2067	if (fntype)
2068	switch (TREE_CODE (fntype))
2069	{
2070	case CALL_EXPR:
2071	{
2072	tree fndecl = get_callee_fndecl (fntype);
2073	if (fndecl)
2074	fntype = TREE_TYPE (fndecl);
2075	else if (CALL_EXPR_FN (fntype))
2076	fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (fntype)));
2077	else
2078	/* For internal functions, assume nothing needs to be
2079	returned in memory. */
2080	return false;
2081	}
2082	break;
2083	case FUNCTION_DECL:
2084	fntype = TREE_TYPE (fntype);
2085	break;
2086	case FUNCTION_TYPE:
2087	case METHOD_TYPE:
2088	break;
2089	case IDENTIFIER_NODE:
2090	fntype = NULL_TREE;
2091	break;
2092	default:
2093	/* We don't expect other tree types here. */
2094	gcc_unreachable ();
2095	}
2096
2097	if (VOID_TYPE_P (type))
2098	return false;
2099
2100	if (error_operand_p (t: fntype))
2101	return false;
2102
2103	/* If a record should be passed the same as its first (and only) member
2104	don't pass it as an aggregate. */
2105	if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
2106	return aggregate_value_p (exp: first_field (type), fntype);
2107
2108	/* If the front end has decided that this needs to be passed by
2109	reference, do so. */
2110	if ((TREE_CODE (exp) == PARM_DECL || TREE_CODE (exp) == RESULT_DECL)
2111	&& DECL_BY_REFERENCE (exp))
2112	return true;
2113
2114	/* Function types that are TREE_ADDRESSABLE force return in memory. */
2115	if (fntype && TREE_ADDRESSABLE (fntype))
2116	return true;
2117
2118	/* Types that are TREE_ADDRESSABLE must be constructed in memory,
2119	and thus can't be returned in registers. */
2120	if (TREE_ADDRESSABLE (type))
2121	return true;
2122
2123	if (TYPE_EMPTY_P (type))
2124	return false;
2125
2126	if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type))
2127	return true;
2128
2129	if (targetm.calls.return_in_memory (type, fntype))
2130	return true;
2131
2132	/* Make sure we have suitable call-clobbered regs to return
2133	the value in; if not, we must return it in memory. */
2134	reg = hard_function_value (type, 0, fntype, 0);
2135
2136	/* If we have something other than a REG (e.g. a PARALLEL), then assume
2137	it is OK. */
2138	if (!REG_P (reg))
2139	return false;
2140
2141	/* Use the default ABI if the type of the function isn't known.
2142	The scheme for handling interoperability between different ABIs
2143	requires us to be able to tell when we're calling a function with
2144	a nondefault ABI. */
2145	const predefined_function_abi &abi = (fntype
2146	? fntype_abi (fntype)
2147	: default_function_abi);
2148	regno = REGNO (reg);
2149	nregs = hard_regno_nregs (regno, TYPE_MODE (type));
2150	for (i = 0; i < nregs; i++)
2151	if (!fixed_regs[regno + i] && !abi.clobbers_full_reg_p (regno: regno + i))
2152	return true;
2153
2154	return false;
2155	}
2156
2157	/* Return true if we should assign DECL a pseudo register; false if it
2158	should live on the local stack. */
2159
2160	bool
2161	use_register_for_decl (const_tree decl)
2162	{
2163	if (TREE_CODE (decl) == SSA_NAME)
2164	{
2165	/* We often try to use the SSA_NAME, instead of its underlying
2166	decl, to get type information and guide decisions, to avoid
2167	differences of behavior between anonymous and named
2168	variables, but in this one case we have to go for the actual
2169	variable if there is one. The main reason is that, at least
2170	at -O0, we want to place user variables on the stack, but we
2171	don't mind using pseudos for anonymous or ignored temps.
2172	Should we take the SSA_NAME, we'd conclude all SSA_NAMEs
2173	should go in pseudos, whereas their corresponding variables
2174	might have to go on the stack. So, disregarding the decl
2175	here would negatively impact debug info at -O0, enable
2176	coalescing between SSA_NAMEs that ought to get different
2177	stack/pseudo assignments, and get the incoming argument
2178	processing thoroughly confused by PARM_DECLs expected to live
2179	in stack slots but assigned to pseudos. */
2180	if (!SSA_NAME_VAR (decl))
2181	return TYPE_MODE (TREE_TYPE (decl)) != BLKmode
2182	&& !(flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl)));
2183
2184	decl = SSA_NAME_VAR (decl);
2185	}
2186
2187	/* Honor volatile. */
2188	if (TREE_SIDE_EFFECTS (decl))
2189	return false;
2190
2191	/* Honor addressability. */
2192	if (TREE_ADDRESSABLE (decl))
2193	return false;
2194
2195	/* RESULT_DECLs are a bit special in that they're assigned without
2196	regard to use_register_for_decl, but we generally only store in
2197	them. If we coalesce their SSA NAMEs, we'd better return a
2198	result that matches the assignment in expand_function_start. */
2199	if (TREE_CODE (decl) == RESULT_DECL)
2200	{
2201	/* If it's not an aggregate, we're going to use a REG or a
2202	PARALLEL containing a REG. */
2203	if (!aggregate_value_p (exp: decl, fntype: current_function_decl))
2204	return true;
2205
2206	/* If expand_function_start determines the return value, we'll
2207	use MEM if it's not by reference. */
2208	if (cfun->returns_pcc_struct
2209	|| (targetm.calls.struct_value_rtx
2210	(TREE_TYPE (current_function_decl), 1)))
2211	return DECL_BY_REFERENCE (decl);
2212
2213	/* Otherwise, we're taking an extra all.function_result_decl
2214	argument. It's set up in assign_parms_augmented_arg_list,
2215	under the (negated) conditions above, and then it's used to
2216	set up the RESULT_DECL rtl in assign_params, after looping
2217	over all parameters. Now, if the RESULT_DECL is not by
2218	reference, we'll use a MEM either way. */
2219	if (!DECL_BY_REFERENCE (decl))
2220	return false;
2221
2222	/* Otherwise, if RESULT_DECL is DECL_BY_REFERENCE, it will take
2223	the function_result_decl's assignment. Since it's a pointer,
2224	we can short-circuit a number of the tests below, and we must
2225	duplicate them because we don't have the function_result_decl
2226	to test. */
2227	if (!targetm.calls.allocate_stack_slots_for_args ())
2228	return true;
2229	/* We don't set DECL_IGNORED_P for the function_result_decl. */
2230	if (optimize)
2231	return true;
2232	if (cfun->tail_call_marked)
2233	return true;
2234	/* We don't set DECL_REGISTER for the function_result_decl. */
2235	return false;
2236	}
2237
2238	/* Only register-like things go in registers. */
2239	if (DECL_MODE (decl) == BLKmode)
2240	return false;
2241
2242	/* If -ffloat-store specified, don't put explicit float variables
2243	into registers. */
2244	/* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
2245	propagates values across these stores, and it probably shouldn't. */
2246	if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl)))
2247	return false;
2248
2249	if (!targetm.calls.allocate_stack_slots_for_args ())
2250	return true;
2251
2252	/* If we're not interested in tracking debugging information for
2253	this decl, then we can certainly put it in a register. */
2254	if (DECL_IGNORED_P (decl))
2255	return true;
2256
2257	if (optimize)
2258	return true;
2259
2260	/* Thunks force a tail call even at -O0 so we need to avoid creating a
2261	dangling reference in case the parameter is passed by reference. */
2262	if (TREE_CODE (decl) == PARM_DECL && cfun->tail_call_marked)
2263	return true;
2264
2265	if (!DECL_REGISTER (decl))
2266	return false;
2267
2268	/* When not optimizing, disregard register keyword for types that
2269	could have methods, otherwise the methods won't be callable from
2270	the debugger. */
2271	if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
2272	return false;
2273
2274	return true;
2275	}
2276
2277	/* Structures to communicate between the subroutines of assign_parms.
2278	The first holds data persistent across all parameters, the second
2279	is cleared out for each parameter. */
2280
2281	struct assign_parm_data_all
2282	{
2283	/* When INIT_CUMULATIVE_ARGS gets revamped, allocating CUMULATIVE_ARGS
2284	should become a job of the target or otherwise encapsulated. */
2285	CUMULATIVE_ARGS args_so_far_v;
2286	cumulative_args_t args_so_far;
2287	struct args_size stack_args_size;
2288	tree function_result_decl;
2289	tree orig_fnargs;
2290	rtx_insn *first_conversion_insn;
2291	rtx_insn *last_conversion_insn;
2292	HOST_WIDE_INT pretend_args_size;
2293	HOST_WIDE_INT extra_pretend_bytes;
2294	int reg_parm_stack_space;
2295	};
2296
2297	struct assign_parm_data_one
2298	{
2299	tree nominal_type;
2300	function_arg_info arg;
2301	rtx entry_parm;
2302	rtx stack_parm;
2303	machine_mode nominal_mode;
2304	machine_mode passed_mode;
2305	struct locate_and_pad_arg_data locate;
2306	int partial;
2307	};
2308
2309	/* A subroutine of assign_parms. Initialize ALL. */
2310
2311	static void
2312	assign_parms_initialize_all (struct assign_parm_data_all *all)
2313	{
2314	tree fntype ATTRIBUTE_UNUSED;
2315
2316	memset (s: all, c: 0, n: sizeof (*all));
2317
2318	fntype = TREE_TYPE (current_function_decl);
2319
2320	#ifdef INIT_CUMULATIVE_INCOMING_ARGS
2321	INIT_CUMULATIVE_INCOMING_ARGS (all->args_so_far_v, fntype, NULL_RTX);
2322	#else
2323	INIT_CUMULATIVE_ARGS (all->args_so_far_v, fntype, NULL_RTX,
2324	current_function_decl, -1);
2325	#endif
2326	all->args_so_far = pack_cumulative_args (arg: &all->args_so_far_v);
2327
2328	#ifdef INCOMING_REG_PARM_STACK_SPACE
2329	all->reg_parm_stack_space
2330	= INCOMING_REG_PARM_STACK_SPACE (current_function_decl);
2331	#endif
2332	}
2333
2334	/* If ARGS contains entries with complex types, split the entry into two
2335	entries of the component type. Return a new list of substitutions are
2336	needed, else the old list. */
2337
2338	static void
2339	split_complex_args (vec<tree> *args)
2340	{
2341	unsigned i;
2342	tree p;
2343
2344	FOR_EACH_VEC_ELT (*args, i, p)
2345	{
2346	tree type = TREE_TYPE (p);
2347	if (TREE_CODE (type) == COMPLEX_TYPE
2348	&& targetm.calls.split_complex_arg (type))
2349	{
2350	tree decl;
2351	tree subtype = TREE_TYPE (type);
2352	bool addressable = TREE_ADDRESSABLE (p);
2353
2354	/* Rewrite the PARM_DECL's type with its component. */
2355	p = copy_node (p);
2356	TREE_TYPE (p) = subtype;
2357	DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p));
2358	SET_DECL_MODE (p, VOIDmode);
2359	DECL_SIZE (p) = NULL;
2360	DECL_SIZE_UNIT (p) = NULL;
2361	/* If this arg must go in memory, put it in a pseudo here.
2362	We can't allow it to go in memory as per normal parms,
2363	because the usual place might not have the imag part
2364	adjacent to the real part. */
2365	DECL_ARTIFICIAL (p) = addressable;
2366	DECL_IGNORED_P (p) = addressable;
2367	TREE_ADDRESSABLE (p) = 0;
2368	layout_decl (p, 0);
2369	(*args)[i] = p;
2370
2371	/* Build a second synthetic decl. */
2372	decl = build_decl (EXPR_LOCATION (p),
2373	PARM_DECL, NULL_TREE, subtype);
2374	DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p);
2375	DECL_ARTIFICIAL (decl) = addressable;
2376	DECL_IGNORED_P (decl) = addressable;
2377	layout_decl (decl, 0);
2378	args->safe_insert (ix: ++i, obj: decl);
2379	}
2380	}
2381	}
2382
2383	/* A subroutine of assign_parms. Adjust the parameter list to incorporate
2384	the hidden struct return argument, and (abi willing) complex args.
2385	Return the new parameter list. */
2386
2387	static vec<tree>
2388	assign_parms_augmented_arg_list (struct assign_parm_data_all *all)
2389	{
2390	tree fndecl = current_function_decl;
2391	tree fntype = TREE_TYPE (fndecl);
2392	vec<tree> fnargs = vNULL;
2393	tree arg;
2394
2395	for (arg = DECL_ARGUMENTS (fndecl); arg; arg = DECL_CHAIN (arg))
2396	fnargs.safe_push (obj: arg);
2397
2398	all->orig_fnargs = DECL_ARGUMENTS (fndecl);
2399
2400	/* If struct value address is treated as the first argument, make it so. */
2401	if (aggregate_value_p (DECL_RESULT (fndecl), fntype: fndecl)
2402	&& ! cfun->returns_pcc_struct
2403	&& targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0)
2404	{
2405	tree type = build_pointer_type (TREE_TYPE (fntype));
2406	tree decl;
2407
2408	decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
2409	PARM_DECL, get_identifier (".result_ptr"), type);
2410	DECL_ARG_TYPE (decl) = type;
2411	DECL_ARTIFICIAL (decl) = 1;
2412	DECL_NAMELESS (decl) = 1;
2413	TREE_CONSTANT (decl) = 1;
2414	/* We don't set DECL_IGNORED_P or DECL_REGISTER here. If this
2415	changes, the end of the RESULT_DECL handling block in
2416	use_register_for_decl must be adjusted to match. */
2417
2418	DECL_CHAIN (decl) = all->orig_fnargs;
2419	all->orig_fnargs = decl;
2420	fnargs.safe_insert (ix: 0, obj: decl);
2421
2422	all->function_result_decl = decl;
2423	}
2424
2425	/* If the target wants to split complex arguments into scalars, do so. */
2426	if (targetm.calls.split_complex_arg)
2427	split_complex_args (args: &fnargs);
2428
2429	return fnargs;
2430	}
2431
2432	/* A subroutine of assign_parms. Examine PARM and pull out type and mode
2433	data for the parameter. Incorporate ABI specifics such as pass-by-
2434	reference and type promotion. */
2435
2436	static void
2437	assign_parm_find_data_types (struct assign_parm_data_all *all, tree parm,
2438	struct assign_parm_data_one *data)
2439	{
2440	int unsignedp;
2441
2442	*data = assign_parm_data_one ();
2443
2444	/* NAMED_ARG is a misnomer. We really mean 'non-variadic'. */
2445	if (!cfun->stdarg)
2446	data->arg.named = 1; /* No variadic parms. */
2447	else if (DECL_CHAIN (parm))
2448	data->arg.named = 1; /* Not the last non-variadic parm. */
2449	else if (targetm.calls.strict_argument_naming (all->args_so_far))
2450	data->arg.named = 1; /* Only variadic ones are unnamed. */
2451	else
2452	data->arg.named = 0; /* Treat as variadic. */
2453
2454	data->nominal_type = TREE_TYPE (parm);
2455	data->arg.type = DECL_ARG_TYPE (parm);
2456
2457	/* Look out for errors propagating this far. Also, if the parameter's
2458	type is void then its value doesn't matter. */
2459	if (TREE_TYPE (parm) == error_mark_node
2460	/* This can happen after weird syntax errors
2461	or if an enum type is defined among the parms. */
2462	|| TREE_CODE (parm) != PARM_DECL
2463	|| data->arg.type == NULL
2464	|| VOID_TYPE_P (data->nominal_type))
2465	{
2466	data->nominal_type = data->arg.type = void_type_node;
2467	data->nominal_mode = data->passed_mode = data->arg.mode = VOIDmode;
2468	return;
2469	}
2470
2471	/* Find mode of arg as it is passed, and mode of arg as it should be
2472	during execution of this function. */
2473	data->passed_mode = data->arg.mode = TYPE_MODE (data->arg.type);
2474	data->nominal_mode = TYPE_MODE (data->nominal_type);
2475
2476	/* If the parm is to be passed as a transparent union or record, use the
2477	type of the first field for the tests below. We have already verified
2478	that the modes are the same. */
2479	if (RECORD_OR_UNION_TYPE_P (data->arg.type)
2480	&& TYPE_TRANSPARENT_AGGR (data->arg.type))
2481	data->arg.type = TREE_TYPE (first_field (data->arg.type));
2482
2483	/* See if this arg was passed by invisible reference. */
2484	if (apply_pass_by_reference_rules (&all->args_so_far_v, data->arg))
2485	{
2486	data->nominal_type = data->arg.type;
2487	data->passed_mode = data->nominal_mode = data->arg.mode;
2488	}
2489
2490	/* Find mode as it is passed by the ABI. */
2491	unsignedp = TYPE_UNSIGNED (data->arg.type);
2492	data->arg.mode
2493	= promote_function_mode (data->arg.type, data->arg.mode, &unsignedp,
2494	TREE_TYPE (current_function_decl), 0);
2495	}
2496
2497	/* A subroutine of assign_parms. Invoke setup_incoming_varargs. */
2498
2499	static void
2500	assign_parms_setup_varargs (struct assign_parm_data_all *all,
2501	struct assign_parm_data_one *data, bool no_rtl)
2502	{
2503	int varargs_pretend_bytes = 0;
2504
2505	function_arg_info last_named_arg = data->arg;
2506	last_named_arg.named = true;
2507	targetm.calls.setup_incoming_varargs (all->args_so_far, last_named_arg,
2508	&varargs_pretend_bytes, no_rtl);
2509
2510	/* If the back-end has requested extra stack space, record how much is
2511	needed. Do not change pretend_args_size otherwise since it may be
2512	nonzero from an earlier partial argument. */
2513	if (varargs_pretend_bytes > 0)
2514	all->pretend_args_size = varargs_pretend_bytes;
2515	}
2516
2517	/* A subroutine of assign_parms. Set DATA->ENTRY_PARM corresponding to
2518	the incoming location of the current parameter. */
2519
2520	static void
2521	assign_parm_find_entry_rtl (struct assign_parm_data_all *all,
2522	struct assign_parm_data_one *data)
2523	{
2524	HOST_WIDE_INT pretend_bytes = 0;
2525	rtx entry_parm;
2526	bool in_regs;
2527
2528	if (data->arg.mode == VOIDmode)
2529	{
2530	data->entry_parm = data->stack_parm = const0_rtx;
2531	return;
2532	}
2533
2534	targetm.calls.warn_parameter_passing_abi (all->args_so_far,
2535	data->arg.type);
2536
2537	entry_parm = targetm.calls.function_incoming_arg (all->args_so_far,
2538	data->arg);
2539	if (entry_parm == 0)
2540	data->arg.mode = data->passed_mode;
2541
2542	/* Determine parm's home in the stack, in case it arrives in the stack
2543	or we should pretend it did. Compute the stack position and rtx where
2544	the argument arrives and its size.
2545
2546	There is one complexity here: If this was a parameter that would
2547	have been passed in registers, but wasn't only because it is
2548	__builtin_va_alist, we want locate_and_pad_parm to treat it as if
2549	it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
2550	In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
2551	as it was the previous time. */
2552	in_regs = (entry_parm != 0);
2553	#ifdef STACK_PARMS_IN_REG_PARM_AREA
2554	in_regs = true;
2555	#endif
2556	if (!in_regs && !data->arg.named)
2557	{
2558	if (targetm.calls.pretend_outgoing_varargs_named (all->args_so_far))
2559	{
2560	rtx tem;
2561	function_arg_info named_arg = data->arg;
2562	named_arg.named = true;
2563	tem = targetm.calls.function_incoming_arg (all->args_so_far,
2564	named_arg);
2565	in_regs = tem != NULL;
2566	}
2567	}
2568
2569	/* If this parameter was passed both in registers and in the stack, use
2570	the copy on the stack. */
2571	if (targetm.calls.must_pass_in_stack (data->arg))
2572	entry_parm = 0;
2573
2574	if (entry_parm)
2575	{
2576	int partial;
2577
2578	partial = targetm.calls.arg_partial_bytes (all->args_so_far, data->arg);
2579	data->partial = partial;
2580
2581	/* The caller might already have allocated stack space for the
2582	register parameters. */
2583	if (partial != 0 && all->reg_parm_stack_space == 0)
2584	{
2585	/* Part of this argument is passed in registers and part
2586	is passed on the stack. Ask the prologue code to extend
2587	the stack part so that we can recreate the full value.
2588
2589	PRETEND_BYTES is the size of the registers we need to store.
2590	CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
2591	stack space that the prologue should allocate.
2592
2593	Internally, gcc assumes that the argument pointer is aligned
2594	to STACK_BOUNDARY bits. This is used both for alignment
2595	optimizations (see init_emit) and to locate arguments that are
2596	aligned to more than PARM_BOUNDARY bits. We must preserve this
2597	invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
2598	a stack boundary. */
2599
2600	/* We assume at most one partial arg, and it must be the first
2601	argument on the stack. */
2602	gcc_assert (!all->extra_pretend_bytes && !all->pretend_args_size);
2603
2604	pretend_bytes = partial;
2605	all->pretend_args_size = CEIL_ROUND (pretend_bytes, STACK_BYTES);
2606
2607	/* We want to align relative to the actual stack pointer, so
2608	don't include this in the stack size until later. */
2609	all->extra_pretend_bytes = all->pretend_args_size;
2610	}
2611	}
2612
2613	locate_and_pad_parm (data->arg.mode, data->arg.type, in_regs,
2614	all->reg_parm_stack_space,
2615	entry_parm ? data->partial : 0, current_function_decl,
2616	&all->stack_args_size, &data->locate);
2617
2618	/* Update parm_stack_boundary if this parameter is passed in the
2619	stack. */
2620	if (!in_regs && crtl->parm_stack_boundary < data->locate.boundary)
2621	crtl->parm_stack_boundary = data->locate.boundary;
2622
2623	/* Adjust offsets to include the pretend args. */
2624	pretend_bytes = all->extra_pretend_bytes - pretend_bytes;
2625	data->locate.slot_offset.constant += pretend_bytes;
2626	data->locate.offset.constant += pretend_bytes;
2627
2628	data->entry_parm = entry_parm;
2629	}
2630
2631	/* A subroutine of assign_parms. If there is actually space on the stack
2632	for this parm, count it in stack_args_size and return true. */
2633
2634	static bool
2635	assign_parm_is_stack_parm (struct assign_parm_data_all *all,
2636	struct assign_parm_data_one *data)
2637	{
2638	/* Trivially true if we've no incoming register. */
2639	if (data->entry_parm == NULL)
2640	;
2641	/* Also true if we're partially in registers and partially not,
2642	since we've arranged to drop the entire argument on the stack. */
2643	else if (data->partial != 0)
2644	;
2645	/* Also true if the target says that it's passed in both registers
2646	and on the stack. */
2647	else if (GET_CODE (data->entry_parm) == PARALLEL
2648	&& XEXP (XVECEXP (data->entry_parm, 0, 0), 0) == NULL_RTX)
2649	;
2650	/* Also true if the target says that there's stack allocated for
2651	all register parameters. */
2652	else if (all->reg_parm_stack_space > 0)
2653	;
2654	/* Otherwise, no, this parameter has no ABI defined stack slot. */
2655	else
2656	return false;
2657
2658	all->stack_args_size.constant += data->locate.size.constant;
2659	if (data->locate.size.var)
2660	ADD_PARM_SIZE (all->stack_args_size, data->locate.size.var);
2661
2662	return true;
2663	}
2664
2665	/* A subroutine of assign_parms. Given that this parameter is allocated
2666	stack space by the ABI, find it. */
2667
2668	static void
2669	assign_parm_find_stack_rtl (tree parm, struct assign_parm_data_one *data)
2670	{
2671	rtx offset_rtx, stack_parm;
2672	unsigned int align, boundary;
2673
2674	/* If we're passing this arg using a reg, make its stack home the
2675	aligned stack slot. */
2676	if (data->entry_parm)
2677	offset_rtx = ARGS_SIZE_RTX (data->locate.slot_offset);
2678	else
2679	offset_rtx = ARGS_SIZE_RTX (data->locate.offset);
2680
2681	stack_parm = crtl->args.internal_arg_pointer;
2682	if (offset_rtx != const0_rtx)
2683	stack_parm = gen_rtx_PLUS (Pmode, stack_parm, offset_rtx);
2684	stack_parm = gen_rtx_MEM (data->arg.mode, stack_parm);
2685
2686	if (!data->arg.pass_by_reference)
2687	{
2688	set_mem_attributes (stack_parm, parm, 1);
2689	/* set_mem_attributes could set MEM_SIZE to the passed mode's size,
2690	while promoted mode's size is needed. */
2691	if (data->arg.mode != BLKmode
2692	&& data->arg.mode != DECL_MODE (parm))
2693	{
2694	set_mem_size (stack_parm, GET_MODE_SIZE (mode: data->arg.mode));
2695	if (MEM_EXPR (stack_parm) && MEM_OFFSET_KNOWN_P (stack_parm))
2696	{
2697	poly_int64 offset = subreg_lowpart_offset (DECL_MODE (parm),
2698	innermode: data->arg.mode);
2699	if (maybe_ne (a: offset, b: 0))
2700	set_mem_offset (stack_parm, MEM_OFFSET (stack_parm) - offset);
2701	}
2702	}
2703	}
2704
2705	boundary = data->locate.boundary;
2706	align = BITS_PER_UNIT;
2707
2708	/* If we're padding upward, we know that the alignment of the slot
2709	is TARGET_FUNCTION_ARG_BOUNDARY. If we're using slot_offset, we're
2710	intentionally forcing upward padding. Otherwise we have to come
2711	up with a guess at the alignment based on OFFSET_RTX. */
2712	poly_int64 offset;
2713	if (data->locate.where_pad == PAD_NONE || data->entry_parm)
2714	align = boundary;
2715	else if (data->locate.where_pad == PAD_UPWARD)
2716	{
2717	align = boundary;
2718	/* If the argument offset is actually more aligned than the nominal
2719	stack slot boundary, take advantage of that excess alignment.
2720	Don't make any assumptions if STACK_POINTER_OFFSET is in use. */
2721	if (poly_int_rtx_p (x: offset_rtx, res: &offset)
2722	&& known_eq (STACK_POINTER_OFFSET, 0))
2723	{
2724	unsigned int offset_align = known_alignment (a: offset) * BITS_PER_UNIT;
2725	if (offset_align == 0 || offset_align > STACK_BOUNDARY)
2726	offset_align = STACK_BOUNDARY;
2727	align = MAX (align, offset_align);
2728	}
2729	}
2730	else if (poly_int_rtx_p (x: offset_rtx, res: &offset))
2731	{
2732	align = least_bit_hwi (x: boundary);
2733	unsigned int offset_align = known_alignment (a: offset) * BITS_PER_UNIT;
2734	if (offset_align != 0)
2735	align = MIN (align, offset_align);
2736	}
2737	set_mem_align (stack_parm, align);
2738
2739	if (data->entry_parm)
2740	set_reg_attrs_for_parm (data->entry_parm, stack_parm);
2741
2742	data->stack_parm = stack_parm;
2743	}
2744
2745	/* A subroutine of assign_parms. Adjust DATA->ENTRY_RTL such that it's
2746	always valid and contiguous. */
2747
2748	static void
2749	assign_parm_adjust_entry_rtl (struct assign_parm_data_one *data)
2750	{
2751	rtx entry_parm = data->entry_parm;
2752	rtx stack_parm = data->stack_parm;
2753
2754	/* If this parm was passed part in regs and part in memory, pretend it
2755	arrived entirely in memory by pushing the register-part onto the stack.
2756	In the special case of a DImode or DFmode that is split, we could put
2757	it together in a pseudoreg directly, but for now that's not worth
2758	bothering with. */
2759	if (data->partial != 0)
2760	{
2761	/* Handle calls that pass values in multiple non-contiguous
2762	locations. The Irix 6 ABI has examples of this. */
2763	if (GET_CODE (entry_parm) == PARALLEL)
2764	emit_group_store (validize_mem (copy_rtx (stack_parm)), entry_parm,
2765	data->arg.type, int_size_in_bytes (data->arg.type));
2766	else
2767	{
2768	gcc_assert (data->partial % UNITS_PER_WORD == 0);
2769	move_block_from_reg (REGNO (entry_parm),
2770	validize_mem (copy_rtx (stack_parm)),
2771	data->partial / UNITS_PER_WORD);
2772	}
2773
2774	entry_parm = stack_parm;
2775	}
2776
2777	/* If we didn't decide this parm came in a register, by default it came
2778	on the stack. */
2779	else if (entry_parm == NULL)
2780	entry_parm = stack_parm;
2781
2782	/* When an argument is passed in multiple locations, we can't make use
2783	of this information, but we can save some copying if the whole argument
2784	is passed in a single register. */
2785	else if (GET_CODE (entry_parm) == PARALLEL
2786	&& data->nominal_mode != BLKmode
2787	&& data->passed_mode != BLKmode)
2788	{
2789	size_t i, len = XVECLEN (entry_parm, 0);
2790
2791	for (i = 0; i < len; i++)
2792	if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX
2793	&& REG_P (XEXP (XVECEXP (entry_parm, 0, i), 0))
2794	&& (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0))
2795	== data->passed_mode)
2796	&& INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0)
2797	{
2798	entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0);
2799	break;
2800	}
2801	}
2802
2803	data->entry_parm = entry_parm;
2804	}
2805
2806	/* A subroutine of assign_parms. Reconstitute any values which were
2807	passed in multiple registers and would fit in a single register. */
2808
2809	static void
2810	assign_parm_remove_parallels (struct assign_parm_data_one *data)
2811	{
2812	rtx entry_parm = data->entry_parm;
2813
2814	/* Convert the PARALLEL to a REG of the same mode as the parallel.
2815	This can be done with register operations rather than on the
2816	stack, even if we will store the reconstituted parameter on the
2817	stack later. */
2818	if (GET_CODE (entry_parm) == PARALLEL && GET_MODE (entry_parm) != BLKmode)
2819	{
2820	rtx parmreg = gen_reg_rtx (GET_MODE (entry_parm));
2821	emit_group_store (parmreg, entry_parm, data->arg.type,
2822	GET_MODE_SIZE (GET_MODE (entry_parm)));
2823	entry_parm = parmreg;
2824	}
2825
2826	data->entry_parm = entry_parm;
2827	}
2828
2829	/* A subroutine of assign_parms. Adjust DATA->STACK_RTL such that it's
2830	always valid and properly aligned. */
2831
2832	static void
2833	assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data)
2834	{
2835	rtx stack_parm = data->stack_parm;
2836
2837	/* If we can't trust the parm stack slot to be aligned enough for its
2838	ultimate type, don't use that slot after entry. We'll make another
2839	stack slot, if we need one. */
2840	if (stack_parm
2841	&& ((GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm)
2842	&& ((optab_handler (op: movmisalign_optab, mode: data->nominal_mode)
2843	!= CODE_FOR_nothing)
2844	|| targetm.slow_unaligned_access (data->nominal_mode,
2845	MEM_ALIGN (stack_parm))))
2846	|| (data->nominal_type
2847	&& TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm)
2848	&& MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY)))
2849	stack_parm = NULL;
2850
2851	/* If parm was passed in memory, and we need to convert it on entry,
2852	don't store it back in that same slot. */
2853	else if (data->entry_parm == stack_parm
2854	&& data->nominal_mode != BLKmode
2855	&& data->nominal_mode != data->passed_mode)
2856	stack_parm = NULL;
2857
2858	/* If stack protection is in effect for this function, don't leave any
2859	pointers in their passed stack slots. */
2860	else if (crtl->stack_protect_guard
2861	&& (flag_stack_protect == SPCT_FLAG_ALL
2862	|| data->arg.pass_by_reference
2863	|| POINTER_TYPE_P (data->nominal_type)))
2864	stack_parm = NULL;
2865
2866	data->stack_parm = stack_parm;
2867	}
2868
2869	/* A subroutine of assign_parms. Return true if the current parameter
2870	should be stored as a BLKmode in the current frame. */
2871
2872	static bool
2873	assign_parm_setup_block_p (struct assign_parm_data_one *data)
2874	{
2875	if (data->nominal_mode == BLKmode)
2876	return true;
2877	if (GET_MODE (data->entry_parm) == BLKmode)
2878	return true;
2879
2880	#ifdef BLOCK_REG_PADDING
2881	/* Only assign_parm_setup_block knows how to deal with register arguments
2882	that are padded at the least significant end. */
2883	if (REG_P (data->entry_parm)
2884	&& known_lt (GET_MODE_SIZE (data->arg.mode), UNITS_PER_WORD)
2885	&& (BLOCK_REG_PADDING (data->passed_mode, data->arg.type, 1)
2886	== (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
2887	return true;
2888	#endif
2889
2890	return false;
2891	}
2892
2893	/* A subroutine of assign_parms. Arrange for the parameter to be
2894	present and valid in DATA->STACK_RTL. */
2895
2896	static void
2897	assign_parm_setup_block (struct assign_parm_data_all *all,
2898	tree parm, struct assign_parm_data_one *data)
2899	{
2900	rtx entry_parm = data->entry_parm;
2901	rtx stack_parm = data->stack_parm;
2902	rtx target_reg = NULL_RTX;
2903	bool in_conversion_seq = false;
2904	HOST_WIDE_INT size;
2905	HOST_WIDE_INT size_stored;
2906
2907	if (GET_CODE (entry_parm) == PARALLEL)
2908	entry_parm = emit_group_move_into_temps (entry_parm);
2909
2910	/* If we want the parameter in a pseudo, don't use a stack slot. */
2911	if (is_gimple_reg (parm) && use_register_for_decl (decl: parm))
2912	{
2913	tree def = ssa_default_def (cfun, parm);
2914	gcc_assert (def);
2915	machine_mode mode = promote_ssa_mode (def, NULL);
2916	rtx reg = gen_reg_rtx (mode);
2917	if (GET_CODE (reg) != CONCAT)
2918	stack_parm = reg;
2919	else
2920	{
2921	target_reg = reg;
2922	/* Avoid allocating a stack slot, if there isn't one
2923	preallocated by the ABI. It might seem like we should
2924	always prefer a pseudo, but converting between
2925	floating-point and integer modes goes through the stack
2926	on various machines, so it's better to use the reserved
2927	stack slot than to risk wasting it and allocating more
2928	for the conversion. */
2929	if (stack_parm == NULL_RTX)
2930	{
2931	int save = generating_concat_p;
2932	generating_concat_p = 0;
2933	stack_parm = gen_reg_rtx (mode);
2934	generating_concat_p = save;
2935	}
2936	}
2937	data->stack_parm = NULL;
2938	}
2939
2940	size = int_size_in_bytes (data->arg.type);
2941	size_stored = CEIL_ROUND (size, UNITS_PER_WORD);
2942	if (stack_parm == 0)
2943	{
2944	HOST_WIDE_INT parm_align
2945	= (STRICT_ALIGNMENT
2946	? MAX (DECL_ALIGN (parm), BITS_PER_WORD) : DECL_ALIGN (parm));
2947
2948	SET_DECL_ALIGN (parm, parm_align);
2949	if (DECL_ALIGN (parm) > MAX_SUPPORTED_STACK_ALIGNMENT)
2950	{
2951	rtx allocsize = gen_int_mode (size_stored, Pmode);
2952	get_dynamic_stack_size (&allocsize, 0, DECL_ALIGN (parm), NULL);
2953	stack_parm = assign_stack_local (BLKmode, UINTVAL (allocsize),
2954	MAX_SUPPORTED_STACK_ALIGNMENT);
2955	rtx addr = align_dynamic_address (XEXP (stack_parm, 0),
2956	DECL_ALIGN (parm));
2957	mark_reg_pointer (addr, DECL_ALIGN (parm));
2958	stack_parm = gen_rtx_MEM (GET_MODE (stack_parm), addr);
2959	MEM_NOTRAP_P (stack_parm) = 1;
2960	}
2961	else
2962	stack_parm = assign_stack_local (BLKmode, size: size_stored,
2963	DECL_ALIGN (parm));
2964	if (known_eq (GET_MODE_SIZE (GET_MODE (entry_parm)), size))
2965	PUT_MODE (x: stack_parm, GET_MODE (entry_parm));
2966	set_mem_attributes (stack_parm, parm, 1);
2967	}
2968
2969	/* If a BLKmode arrives in registers, copy it to a stack slot. Handle
2970	calls that pass values in multiple non-contiguous locations. */
2971	if (REG_P (entry_parm) || GET_CODE (entry_parm) == PARALLEL)
2972	{
2973	rtx mem;
2974
2975	/* Note that we will be storing an integral number of words.
2976	So we have to be careful to ensure that we allocate an
2977	integral number of words. We do this above when we call
2978	assign_stack_local if space was not allocated in the argument
2979	list. If it was, this will not work if PARM_BOUNDARY is not
2980	a multiple of BITS_PER_WORD. It isn't clear how to fix this
2981	if it becomes a problem. Exception is when BLKmode arrives
2982	with arguments not conforming to word_mode. */
2983
2984	if (data->stack_parm == 0)
2985	;
2986	else if (GET_CODE (entry_parm) == PARALLEL)
2987	;
2988	else
2989	gcc_assert (!size || !(PARM_BOUNDARY % BITS_PER_WORD));
2990
2991	mem = validize_mem (copy_rtx (stack_parm));
2992
2993	/* Handle values in multiple non-contiguous locations. */
2994	if (GET_CODE (entry_parm) == PARALLEL && !MEM_P (mem))
2995	emit_group_store (mem, entry_parm, data->arg.type, size);
2996	else if (GET_CODE (entry_parm) == PARALLEL)
2997	{
2998	push_to_sequence2 (all->first_conversion_insn,
2999	all->last_conversion_insn);
3000	emit_group_store (mem, entry_parm, data->arg.type, size);
3001	all->first_conversion_insn = get_insns ();
3002	all->last_conversion_insn = get_last_insn ();
3003	end_sequence ();
3004	in_conversion_seq = true;
3005	}
3006
3007	else if (size == 0)
3008	;
3009
3010	/* If SIZE is that of a mode no bigger than a word, just use
3011	that mode's store operation. */
3012	else if (size <= UNITS_PER_WORD)
3013	{
3014	unsigned int bits = size * BITS_PER_UNIT;
3015	machine_mode mode = int_mode_for_size (size: bits, limit: 0).else_blk ();
3016
3017	if (mode != BLKmode
3018	#ifdef BLOCK_REG_PADDING
3019	&& (size == UNITS_PER_WORD
3020	|| (BLOCK_REG_PADDING (mode, data->arg.type, 1)
3021	!= (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
3022	#endif
3023	)
3024	{
3025	rtx reg;
3026
3027	/* We are really truncating a word_mode value containing
3028	SIZE bytes into a value of mode MODE. If such an
3029	operation requires no actual instructions, we can refer
3030	to the value directly in mode MODE, otherwise we must
3031	start with the register in word_mode and explicitly
3032	convert it. */
3033	if (mode == word_mode
3034	|| TRULY_NOOP_TRUNCATION_MODES_P (mode, word_mode))
3035	reg = gen_rtx_REG (mode, REGNO (entry_parm));
3036	else
3037	{
3038	reg = gen_rtx_REG (word_mode, REGNO (entry_parm));
3039	reg = convert_to_mode (mode, copy_to_reg (reg), 1);
3040	}
3041
3042	/* We use adjust_address to get a new MEM with the mode
3043	changed. adjust_address is better than change_address
3044	for this purpose because adjust_address does not lose
3045	the MEM_EXPR associated with the MEM.
3046
3047	If the MEM_EXPR is lost, then optimizations like DSE
3048	assume the MEM escapes and thus is not subject to DSE. */
3049	emit_move_insn (adjust_address (mem, mode, 0), reg);
3050	}
3051
3052	#ifdef BLOCK_REG_PADDING
3053	/* Storing the register in memory as a full word, as
3054	move_block_from_reg below would do, and then using the
3055	MEM in a smaller mode, has the effect of shifting right
3056	if BYTES_BIG_ENDIAN. If we're bypassing memory, the
3057	shifting must be explicit. */
3058	else if (!MEM_P (mem))
3059	{
3060	rtx x;
3061
3062	/* If the assert below fails, we should have taken the
3063	mode != BLKmode path above, unless we have downward
3064	padding of smaller-than-word arguments on a machine
3065	with little-endian bytes, which would likely require
3066	additional changes to work correctly. */
3067	gcc_checking_assert (BYTES_BIG_ENDIAN
3068	&& (BLOCK_REG_PADDING (mode,
3069	data->arg.type, 1)
3070	== PAD_UPWARD));
3071
3072	int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
3073
3074	x = gen_rtx_REG (word_mode, REGNO (entry_parm));
3075	x = expand_shift (RSHIFT_EXPR, word_mode, x, by,
3076	NULL_RTX, 1);
3077	x = force_reg (word_mode, x);
3078	x = gen_lowpart_SUBREG (GET_MODE (mem), x);
3079
3080	emit_move_insn (mem, x);
3081	}
3082	#endif
3083
3084	/* Blocks smaller than a word on a BYTES_BIG_ENDIAN
3085	machine must be aligned to the left before storing
3086	to memory. Note that the previous test doesn't
3087	handle all cases (e.g. SIZE == 3). */
3088	else if (size != UNITS_PER_WORD
3089	#ifdef BLOCK_REG_PADDING
3090	&& (BLOCK_REG_PADDING (mode, data->arg.type, 1)
3091	== PAD_DOWNWARD)
3092	#else
3093	&& BYTES_BIG_ENDIAN
3094	#endif
3095	)
3096	{
3097	rtx tem, x;
3098	int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
3099	rtx reg = gen_rtx_REG (word_mode, REGNO (entry_parm));
3100
3101	x = expand_shift (LSHIFT_EXPR, word_mode, reg, by, NULL_RTX, 1);
3102	tem = change_address (mem, word_mode, 0);
3103	emit_move_insn (tem, x);
3104	}
3105	else
3106	move_block_from_reg (REGNO (entry_parm), mem,
3107	size_stored / UNITS_PER_WORD);
3108	}
3109	else if (!MEM_P (mem))
3110	{
3111	gcc_checking_assert (size > UNITS_PER_WORD);
3112	#ifdef BLOCK_REG_PADDING
3113	gcc_checking_assert (BLOCK_REG_PADDING (GET_MODE (mem),
3114	data->arg.type, 0)
3115	== PAD_UPWARD);
3116	#endif
3117	emit_move_insn (mem, entry_parm);
3118	}
3119	else
3120	move_block_from_reg (REGNO (entry_parm), mem,
3121	size_stored / UNITS_PER_WORD);
3122	}
3123	else if (data->stack_parm == 0 && !TYPE_EMPTY_P (data->arg.type))
3124	{
3125	push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
3126	emit_block_move (stack_parm, data->entry_parm, GEN_INT (size),
3127	BLOCK_OP_NORMAL);
3128	all->first_conversion_insn = get_insns ();
3129	all->last_conversion_insn = get_last_insn ();
3130	end_sequence ();
3131	in_conversion_seq = true;
3132	}
3133
3134	if (target_reg)
3135	{
3136	if (!in_conversion_seq)
3137	emit_move_insn (target_reg, stack_parm);
3138	else
3139	{
3140	push_to_sequence2 (all->first_conversion_insn,
3141	all->last_conversion_insn);
3142	emit_move_insn (target_reg, stack_parm);
3143	all->first_conversion_insn = get_insns ();
3144	all->last_conversion_insn = get_last_insn ();
3145	end_sequence ();
3146	}
3147	stack_parm = target_reg;
3148	}
3149
3150	data->stack_parm = stack_parm;
3151	set_parm_rtl (parm, stack_parm);
3152	}
3153
3154	/* A subroutine of assign_parms. Allocate a pseudo to hold the current
3155	parameter. Get it there. Perform all ABI specified conversions. */
3156
3157	static void
3158	assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
3159	struct assign_parm_data_one *data)
3160	{
3161	rtx parmreg, validated_mem;
3162	rtx equiv_stack_parm;
3163	machine_mode promoted_nominal_mode;
3164	int unsignedp = TYPE_UNSIGNED (TREE_TYPE (parm));
3165	bool did_conversion = false;
3166	bool need_conversion, moved;
3167	enum insn_code icode;
3168	rtx rtl;
3169
3170	/* Store the parm in a pseudoregister during the function, but we may
3171	need to do it in a wider mode. Using 2 here makes the result
3172	consistent with promote_decl_mode and thus expand_expr_real_1. */
3173	promoted_nominal_mode
3174	= promote_function_mode (data->nominal_type, data->nominal_mode, &unsignedp,
3175	TREE_TYPE (current_function_decl), 2);
3176
3177	parmreg = gen_reg_rtx (promoted_nominal_mode);
3178	if (!DECL_ARTIFICIAL (parm))
3179	mark_user_reg (parmreg);
3180
3181	/* If this was an item that we received a pointer to,
3182	set rtl appropriately. */
3183	if (data->arg.pass_by_reference)
3184	{
3185	rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data->arg.type)), parmreg);
3186	set_mem_attributes (rtl, parm, 1);
3187	}
3188	else
3189	rtl = parmreg;
3190
3191	assign_parm_remove_parallels (data);
3192
3193	/* Copy the value into the register, thus bridging between
3194	assign_parm_find_data_types and expand_expr_real_1. */
3195
3196	equiv_stack_parm = data->stack_parm;
3197	validated_mem = validize_mem (copy_rtx (data->entry_parm));
3198
3199	need_conversion = (data->nominal_mode != data->passed_mode
3200	|| promoted_nominal_mode != data->arg.mode);
3201	moved = false;
3202
3203	if (need_conversion
3204	&& GET_MODE_CLASS (data->nominal_mode) == MODE_INT
3205	&& data->nominal_mode == data->passed_mode
3206	&& data->nominal_mode == GET_MODE (data->entry_parm))
3207	{
3208	/* ENTRY_PARM has been converted to PROMOTED_MODE, its
3209	mode, by the caller. We now have to convert it to
3210	NOMINAL_MODE, if different. However, PARMREG may be in
3211	a different mode than NOMINAL_MODE if it is being stored
3212	promoted.
3213
3214	If ENTRY_PARM is a hard register, it might be in a register
3215	not valid for operating in its mode (e.g., an odd-numbered
3216	register for a DFmode). In that case, moves are the only
3217	thing valid, so we can't do a convert from there. This
3218	occurs when the calling sequence allow such misaligned
3219	usages.
3220
3221	In addition, the conversion may involve a call, which could
3222	clobber parameters which haven't been copied to pseudo
3223	registers yet.
3224
3225	First, we try to emit an insn which performs the necessary
3226	conversion. We verify that this insn does not clobber any
3227	hard registers. */
3228
3229	rtx op0, op1;
3230
3231	icode = can_extend_p (promoted_nominal_mode, data->passed_mode,
3232	unsignedp);
3233
3234	op0 = parmreg;
3235	op1 = validated_mem;
3236	if (icode != CODE_FOR_nothing
3237	&& insn_operand_matches (icode, opno: 0, operand: op0)
3238	&& insn_operand_matches (icode, opno: 1, operand: op1))
3239	{
3240	enum rtx_code code = unsignedp ? ZERO_EXTEND : SIGN_EXTEND;
3241	rtx_insn *insn, *insns;
3242	rtx t = op1;
3243	HARD_REG_SET hardregs;
3244
3245	start_sequence ();
3246	/* If op1 is a hard register that is likely spilled, first
3247	force it into a pseudo, otherwise combiner might extend
3248	its lifetime too much. */
3249	if (GET_CODE (t) == SUBREG)
3250	t = SUBREG_REG (t);
3251	if (REG_P (t)
3252	&& HARD_REGISTER_P (t)
3253	&& ! TEST_HARD_REG_BIT (fixed_reg_set, REGNO (t))
3254	&& targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (t))))
3255	{
3256	t = gen_reg_rtx (GET_MODE (op1));
3257	emit_move_insn (t, op1);
3258	}
3259	else
3260	t = op1;
3261	rtx_insn *pat = gen_extend_insn (op0, t, promoted_nominal_mode,
3262	data->passed_mode, unsignedp);
3263	emit_insn (pat);
3264	insns = get_insns ();
3265
3266	moved = true;
3267	CLEAR_HARD_REG_SET (set&: hardregs);
3268	for (insn = insns; insn && moved; insn = NEXT_INSN (insn))
3269	{
3270	if (INSN_P (insn))
3271	note_stores (insn, record_hard_reg_sets, &hardregs);
3272	if (!hard_reg_set_empty_p (x: hardregs))
3273	moved = false;
3274	}
3275
3276	end_sequence ();
3277
3278	if (moved)
3279	{
3280	emit_insn (insns);
3281	if (equiv_stack_parm != NULL_RTX)
3282	equiv_stack_parm = gen_rtx_fmt_e (code, GET_MODE (parmreg),
3283	equiv_stack_parm);
3284	}
3285	}
3286	}
3287
3288	if (moved)
3289	/* Nothing to do. */
3290	;
3291	else if (need_conversion)
3292	{
3293	/* We did not have an insn to convert directly, or the sequence
3294	generated appeared unsafe. We must first copy the parm to a
3295	pseudo reg, and save the conversion until after all
3296	parameters have been moved. */
3297
3298	int save_tree_used;
3299	rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm));
3300
3301	emit_move_insn (tempreg, validated_mem);
3302
3303	push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
3304	tempreg = convert_to_mode (data->nominal_mode, tempreg, unsignedp);
3305
3306	if (partial_subreg_p (x: tempreg)
3307	&& GET_MODE (tempreg) == data->nominal_mode
3308	&& REG_P (SUBREG_REG (tempreg))
3309	&& data->nominal_mode == data->passed_mode
3310	&& GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (data->entry_parm))
3311	{
3312	/* The argument is already sign/zero extended, so note it
3313	into the subreg. */
3314	SUBREG_PROMOTED_VAR_P (tempreg) = 1;
3315	SUBREG_PROMOTED_SET (tempreg, unsignedp);
3316	}
3317
3318	/* TREE_USED gets set erroneously during expand_assignment. */
3319	save_tree_used = TREE_USED (parm);
3320	SET_DECL_RTL (parm, rtl);
3321	expand_assignment (parm, make_tree (data->nominal_type, tempreg), false);
3322	SET_DECL_RTL (parm, NULL_RTX);
3323	TREE_USED (parm) = save_tree_used;
3324	all->first_conversion_insn = get_insns ();
3325	all->last_conversion_insn = get_last_insn ();
3326	end_sequence ();
3327
3328	did_conversion = true;
3329	}
3330	else if (MEM_P (data->entry_parm)
3331	&& GET_MODE_ALIGNMENT (promoted_nominal_mode)
3332	> MEM_ALIGN (data->entry_parm)
3333	&& (((icode = optab_handler (op: movmisalign_optab,
3334	mode: promoted_nominal_mode))
3335	!= CODE_FOR_nothing)
3336	|| targetm.slow_unaligned_access (promoted_nominal_mode,
3337	MEM_ALIGN (data->entry_parm))))
3338	{
3339	if (icode != CODE_FOR_nothing)
3340	emit_insn (GEN_FCN (icode) (parmreg, validated_mem));
3341	else
3342	rtl = parmreg = extract_bit_field (validated_mem,
3343	GET_MODE_BITSIZE (mode: promoted_nominal_mode), 0,
3344	unsignedp, parmreg,
3345	promoted_nominal_mode, VOIDmode, false, NULL);
3346	}
3347	else
3348	emit_move_insn (parmreg, validated_mem);
3349
3350	/* If we were passed a pointer but the actual value can live in a register,
3351	retrieve it and use it directly. Note that we cannot use nominal_mode,
3352	because it will have been set to Pmode above, we must use the actual mode
3353	of the parameter instead. */
3354	if (data->arg.pass_by_reference && TYPE_MODE (TREE_TYPE (parm)) != BLKmode)
3355	{
3356	/* Use a stack slot for debugging purposes if possible. */
3357	if (use_register_for_decl (decl: parm))
3358	{
3359	parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
3360	mark_user_reg (parmreg);
3361	}
3362	else
3363	{
3364	int align = STACK_SLOT_ALIGNMENT (TREE_TYPE (parm),
3365	TYPE_MODE (TREE_TYPE (parm)),
3366	TYPE_ALIGN (TREE_TYPE (parm)));
3367	parmreg
3368	= assign_stack_local (TYPE_MODE (TREE_TYPE (parm)),
3369	size: GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parm))),
3370	align);
3371	set_mem_attributes (parmreg, parm, 1);
3372	}
3373
3374	/* We need to preserve an address based on VIRTUAL_STACK_VARS_REGNUM for
3375	the debug info in case it is not legitimate. */
3376	if (GET_MODE (parmreg) != GET_MODE (rtl))
3377	{
3378	rtx tempreg = gen_reg_rtx (GET_MODE (rtl));
3379	int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm));
3380
3381	push_to_sequence2 (all->first_conversion_insn,
3382	all->last_conversion_insn);
3383	emit_move_insn (tempreg, rtl);
3384	tempreg = convert_to_mode (GET_MODE (parmreg), tempreg, unsigned_p);
3385	emit_move_insn (MEM_P (parmreg) ? copy_rtx (parmreg) : parmreg,
3386	tempreg);
3387	all->first_conversion_insn = get_insns ();
3388	all->last_conversion_insn = get_last_insn ();
3389	end_sequence ();
3390
3391	did_conversion = true;
3392	}
3393	else
3394	emit_move_insn (MEM_P (parmreg) ? copy_rtx (parmreg) : parmreg, rtl);
3395
3396	rtl = parmreg;
3397
3398	/* STACK_PARM is the pointer, not the parm, and PARMREG is
3399	now the parm. */
3400	data->stack_parm = NULL;
3401	}
3402
3403	set_parm_rtl (parm, rtl);
3404
3405	/* Mark the register as eliminable if we did no conversion and it was
3406	copied from memory at a fixed offset, and the arg pointer was not
3407	copied to a pseudo-reg. If the arg pointer is a pseudo reg or the
3408	offset formed an invalid address, such memory-equivalences as we
3409	make here would screw up life analysis for it. */
3410	if (data->nominal_mode == data->passed_mode
3411	&& !did_conversion
3412	&& data->stack_parm != 0
3413	&& MEM_P (data->stack_parm)
3414	&& data->locate.offset.var == 0
3415	&& reg_mentioned_p (virtual_incoming_args_rtx,
3416	XEXP (data->stack_parm, 0)))
3417	{
3418	rtx_insn *linsn = get_last_insn ();
3419	rtx_insn *sinsn;
3420	rtx set;
3421
3422	/* Mark complex types separately. */
3423	if (GET_CODE (parmreg) == CONCAT)
3424	{
3425	scalar_mode submode = GET_MODE_INNER (GET_MODE (parmreg));
3426	int regnor = REGNO (XEXP (parmreg, 0));
3427	int regnoi = REGNO (XEXP (parmreg, 1));
3428	rtx stackr = adjust_address_nv (data->stack_parm, submode, 0);
3429	rtx stacki = adjust_address_nv (data->stack_parm, submode,
3430	GET_MODE_SIZE (submode));
3431
3432	/* Scan backwards for the set of the real and
3433	imaginary parts. */
3434	for (sinsn = linsn; sinsn != 0;
3435	sinsn = prev_nonnote_insn (sinsn))
3436	{
3437	set = single_set (insn: sinsn);
3438	if (set == 0)
3439	continue;
3440
3441	if (SET_DEST (set) == regno_reg_rtx [regnoi])
3442	set_unique_reg_note (sinsn, REG_EQUIV, stacki);
3443	else if (SET_DEST (set) == regno_reg_rtx [regnor])
3444	set_unique_reg_note (sinsn, REG_EQUIV, stackr);
3445	}
3446	}
3447	else
3448	set_dst_reg_note (linsn, REG_EQUIV, equiv_stack_parm, parmreg);
3449	}
3450
3451	/* For pointer data type, suggest pointer register. */
3452	if (POINTER_TYPE_P (TREE_TYPE (parm)))
3453	mark_reg_pointer (parmreg,
3454	TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
3455	}
3456
3457	/* A subroutine of assign_parms. Allocate stack space to hold the current
3458	parameter. Get it there. Perform all ABI specified conversions. */
3459
3460	static void
3461	assign_parm_setup_stack (struct assign_parm_data_all *all, tree parm,
3462	struct assign_parm_data_one *data)
3463	{
3464	/* Value must be stored in the stack slot STACK_PARM during function
3465	execution. */
3466	bool to_conversion = false;
3467
3468	assign_parm_remove_parallels (data);
3469
3470	if (data->arg.mode != data->nominal_mode)
3471	{
3472	/* Conversion is required. */
3473	rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm));
3474
3475	emit_move_insn (tempreg, validize_mem (copy_rtx (data->entry_parm)));
3476
3477	/* Some ABIs require scalar floating point modes to be passed
3478	in a wider scalar integer mode. We need to explicitly
3479	truncate to an integer mode of the correct precision before
3480	using a SUBREG to reinterpret as a floating point value. */
3481	if (SCALAR_FLOAT_MODE_P (data->nominal_mode)
3482	&& SCALAR_INT_MODE_P (data->arg.mode)
3483	&& known_lt (GET_MODE_SIZE (data->nominal_mode),
3484	GET_MODE_SIZE (data->arg.mode)))
3485	tempreg = convert_wider_int_to_float (mode: data->nominal_mode,
3486	imode: data->arg.mode, x: tempreg);
3487
3488	push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
3489	to_conversion = true;
3490
3491	data->entry_parm = convert_to_mode (data->nominal_mode, tempreg,
3492	TYPE_UNSIGNED (TREE_TYPE (parm)));
3493
3494	if (data->stack_parm)
3495	{
3496	poly_int64 offset
3497	= subreg_lowpart_offset (outermode: data->nominal_mode,
3498	GET_MODE (data->stack_parm));
3499	/* ??? This may need a big-endian conversion on sparc64. */
3500	data->stack_parm
3501	= adjust_address (data->stack_parm, data->nominal_mode, 0);
3502	if (maybe_ne (a: offset, b: 0) && MEM_OFFSET_KNOWN_P (data->stack_parm))
3503	set_mem_offset (data->stack_parm,
3504	MEM_OFFSET (data->stack_parm) + offset);
3505	}
3506	}
3507
3508	if (data->entry_parm != data->stack_parm)
3509	{
3510	rtx src, dest;
3511
3512	if (data->stack_parm == 0)
3513	{
3514	int align = STACK_SLOT_ALIGNMENT (data->arg.type,
3515	GET_MODE (data->entry_parm),
3516	TYPE_ALIGN (data->arg.type));
3517	if (align < (int)GET_MODE_ALIGNMENT (GET_MODE (data->entry_parm))
3518	&& ((optab_handler (op: movmisalign_optab,
3519	GET_MODE (data->entry_parm))
3520	!= CODE_FOR_nothing)
3521	|| targetm.slow_unaligned_access (GET_MODE (data->entry_parm),
3522	align)))
3523	align = GET_MODE_ALIGNMENT (GET_MODE (data->entry_parm));
3524	data->stack_parm
3525	= assign_stack_local (GET_MODE (data->entry_parm),
3526	size: GET_MODE_SIZE (GET_MODE (data->entry_parm)),
3527	align);
3528	align = MEM_ALIGN (data->stack_parm);
3529	set_mem_attributes (data->stack_parm, parm, 1);
3530	set_mem_align (data->stack_parm, align);
3531	}
3532
3533	dest = validize_mem (copy_rtx (data->stack_parm));
3534	src = validize_mem (copy_rtx (data->entry_parm));
3535
3536	if (TYPE_EMPTY_P (data->arg.type))
3537	/* Empty types don't really need to be copied. */;
3538	else if (MEM_P (src))
3539	{
3540	/* Use a block move to handle potentially misaligned entry_parm. */
3541	if (!to_conversion)
3542	push_to_sequence2 (all->first_conversion_insn,
3543	all->last_conversion_insn);
3544	to_conversion = true;
3545
3546	emit_block_move (dest, src,
3547	GEN_INT (int_size_in_bytes (data->arg.type)),
3548	BLOCK_OP_NORMAL);
3549	}
3550	else
3551	{
3552	if (!REG_P (src))
3553	src = force_reg (GET_MODE (src), src);
3554	emit_move_insn (dest, src);
3555	}
3556	}
3557
3558	if (to_conversion)
3559	{
3560	all->first_conversion_insn = get_insns ();
3561	all->last_conversion_insn = get_last_insn ();
3562	end_sequence ();
3563	}
3564
3565	set_parm_rtl (parm, data->stack_parm);
3566	}
3567
3568	/* A subroutine of assign_parms. If the ABI splits complex arguments, then
3569	undo the frobbing that we did in assign_parms_augmented_arg_list. */
3570
3571	static void
3572	assign_parms_unsplit_complex (struct assign_parm_data_all *all,
3573	vec<tree> fnargs)
3574	{
3575	tree parm;
3576	tree orig_fnargs = all->orig_fnargs;
3577	unsigned i = 0;
3578
3579	for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm), ++i)
3580	{
3581	if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
3582	&& targetm.calls.split_complex_arg (TREE_TYPE (parm)))
3583	{
3584	rtx tmp, real, imag;
3585	scalar_mode inner = GET_MODE_INNER (DECL_MODE (parm));
3586
3587	real = DECL_RTL (fnargs[i]);
3588	imag = DECL_RTL (fnargs[i + 1]);
3589	if (inner != GET_MODE (real))
3590	{
3591	real = gen_lowpart_SUBREG (inner, real);
3592	imag = gen_lowpart_SUBREG (inner, imag);
3593	}
3594
3595	if (TREE_ADDRESSABLE (parm))
3596	{
3597	rtx rmem, imem;
3598	HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (parm));
3599	int align = STACK_SLOT_ALIGNMENT (TREE_TYPE (parm),
3600	DECL_MODE (parm),
3601	TYPE_ALIGN (TREE_TYPE (parm)));
3602
3603	/* split_complex_arg put the real and imag parts in
3604	pseudos. Move them to memory. */
3605	tmp = assign_stack_local (DECL_MODE (parm), size, align);
3606	set_mem_attributes (tmp, parm, 1);
3607	rmem = adjust_address_nv (tmp, inner, 0);
3608	imem = adjust_address_nv (tmp, inner, GET_MODE_SIZE (inner));
3609	push_to_sequence2 (all->first_conversion_insn,
3610	all->last_conversion_insn);
3611	emit_move_insn (rmem, real);
3612	emit_move_insn (imem, imag);
3613	all->first_conversion_insn = get_insns ();
3614	all->last_conversion_insn = get_last_insn ();
3615	end_sequence ();
3616	}
3617	else
3618	tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag);
3619	set_parm_rtl (parm, tmp);
3620
3621	real = DECL_INCOMING_RTL (fnargs[i]);
3622	imag = DECL_INCOMING_RTL (fnargs[i + 1]);
3623	if (inner != GET_MODE (real))
3624	{
3625	real = gen_lowpart_SUBREG (inner, real);
3626	imag = gen_lowpart_SUBREG (inner, imag);
3627	}
3628	tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag);
3629	set_decl_incoming_rtl (parm, tmp, false);
3630	i++;
3631	}
3632	}
3633	}
3634
3635	/* Assign RTL expressions to the function's parameters. This may involve
3636	copying them into registers and using those registers as the DECL_RTL. */
3637
3638	static void
3639	assign_parms (tree fndecl)
3640	{
3641	struct assign_parm_data_all all;
3642	tree parm;
3643	vec<tree> fnargs;
3644	unsigned i;
3645
3646	crtl->args.internal_arg_pointer
3647	= targetm.calls.internal_arg_pointer ();
3648
3649	assign_parms_initialize_all (all: &all);
3650	fnargs = assign_parms_augmented_arg_list (all: &all);
3651
3652	if (TYPE_NO_NAMED_ARGS_STDARG_P (TREE_TYPE (fndecl)))
3653	{
3654	struct assign_parm_data_one data = {};
3655	assign_parms_setup_varargs (all: &all, data: &data, no_rtl: false);
3656	}
3657
3658	FOR_EACH_VEC_ELT (fnargs, i, parm)
3659	{
3660	struct assign_parm_data_one data;
3661
3662	/* Extract the type of PARM; adjust it according to ABI. */
3663	assign_parm_find_data_types (all: &all, parm, data: &data);
3664
3665	/* Early out for errors and void parameters. */
3666	if (data.passed_mode == VOIDmode)
3667	{
3668	SET_DECL_RTL (parm, const0_rtx);
3669	DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
3670	continue;
3671	}
3672
3673	/* Estimate stack alignment from parameter alignment. */
3674	if (SUPPORTS_STACK_ALIGNMENT)
3675	{
3676	unsigned int align
3677	= targetm.calls.function_arg_boundary (data.arg.mode,
3678	data.arg.type);
3679	align = MINIMUM_ALIGNMENT (data.arg.type, data.arg.mode, align);
3680	if (TYPE_ALIGN (data.nominal_type) > align)
3681	align = MINIMUM_ALIGNMENT (data.nominal_type,
3682	TYPE_MODE (data.nominal_type),
3683	TYPE_ALIGN (data.nominal_type));
3684	if (crtl->stack_alignment_estimated < align)
3685	{
3686	gcc_assert (!crtl->stack_realign_processed);
3687	crtl->stack_alignment_estimated = align;
3688	}
3689	}
3690
3691	/* Find out where the parameter arrives in this function. */
3692	assign_parm_find_entry_rtl (all: &all, data: &data);
3693
3694	/* Find out where stack space for this parameter might be. */
3695	if (assign_parm_is_stack_parm (all: &all, data: &data))
3696	{
3697	assign_parm_find_stack_rtl (parm, data: &data);
3698	assign_parm_adjust_entry_rtl (data: &data);
3699	/* For arguments that occupy no space in the parameter
3700	passing area, have non-zero size and have address taken,
3701	force creation of a stack slot so that they have distinct
3702	address from other parameters. */
3703	if (TYPE_EMPTY_P (data.arg.type)
3704	&& TREE_ADDRESSABLE (parm)
3705	&& data.entry_parm == data.stack_parm
3706	&& MEM_P (data.entry_parm)
3707	&& int_size_in_bytes (data.arg.type))
3708	data.stack_parm = NULL_RTX;
3709	}
3710	/* Record permanently how this parm was passed. */
3711	if (data.arg.pass_by_reference)
3712	{
3713	rtx incoming_rtl
3714	= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data.arg.type)),
3715	data.entry_parm);
3716	set_decl_incoming_rtl (parm, incoming_rtl, true);
3717	}
3718	else
3719	set_decl_incoming_rtl (parm, data.entry_parm, false);
3720
3721	assign_parm_adjust_stack_rtl (data: &data);
3722
3723	if (assign_parm_setup_block_p (data: &data))
3724	assign_parm_setup_block (all: &all, parm, data: &data);
3725	else if (data.arg.pass_by_reference || use_register_for_decl (decl: parm))
3726	assign_parm_setup_reg (all: &all, parm, data: &data);
3727	else
3728	assign_parm_setup_stack (all: &all, parm, data: &data);
3729
3730	if (cfun->stdarg && !DECL_CHAIN (parm))
3731	assign_parms_setup_varargs (all: &all, data: &data, no_rtl: false);
3732
3733	/* Update info on where next arg arrives in registers. */
3734	targetm.calls.function_arg_advance (all.args_so_far, data.arg);
3735	}
3736
3737	if (targetm.calls.split_complex_arg)
3738	assign_parms_unsplit_complex (all: &all, fnargs);
3739
3740	fnargs.release ();
3741
3742	/* Output all parameter conversion instructions (possibly including calls)
3743	now that all parameters have been copied out of hard registers. */
3744	emit_insn (all.first_conversion_insn);
3745
3746	/* Estimate reload stack alignment from scalar return mode. */
3747	if (SUPPORTS_STACK_ALIGNMENT)
3748	{
3749	if (DECL_RESULT (fndecl))
3750	{
3751	tree type = TREE_TYPE (DECL_RESULT (fndecl));
3752	machine_mode mode = TYPE_MODE (type);
3753
3754	if (mode != BLKmode
3755	&& mode != VOIDmode
3756	&& !AGGREGATE_TYPE_P (type))
3757	{
3758	unsigned int align = GET_MODE_ALIGNMENT (mode);
3759	if (crtl->stack_alignment_estimated < align)
3760	{
3761	gcc_assert (!crtl->stack_realign_processed);
3762	crtl->stack_alignment_estimated = align;
3763	}
3764	}
3765	}
3766	}
3767
3768	/* If we are receiving a struct value address as the first argument, set up
3769	the RTL for the function result. As this might require code to convert
3770	the transmitted address to Pmode, we do this here to ensure that possible
3771	preliminary conversions of the address have been emitted already. */
3772	if (all.function_result_decl)
3773	{
3774	tree result = DECL_RESULT (current_function_decl);
3775	rtx addr = DECL_RTL (all.function_result_decl);
3776	rtx x;
3777
3778	if (DECL_BY_REFERENCE (result))
3779	{
3780	SET_DECL_VALUE_EXPR (result, all.function_result_decl);
3781	x = addr;
3782	}
3783	else
3784	{
3785	SET_DECL_VALUE_EXPR (result,
3786	build1 (INDIRECT_REF, TREE_TYPE (result),
3787	all.function_result_decl));
3788	addr = convert_memory_address (Pmode, addr);
3789	x = gen_rtx_MEM (DECL_MODE (result), addr);
3790	set_mem_attributes (x, result, 1);
3791	}
3792
3793	DECL_HAS_VALUE_EXPR_P (result) = 1;
3794
3795	set_parm_rtl (result, x);
3796	}
3797
3798	/* We have aligned all the args, so add space for the pretend args. */
3799	crtl->args.pretend_args_size = all.pretend_args_size;
3800	all.stack_args_size.constant += all.extra_pretend_bytes;
3801	crtl->args.size = all.stack_args_size.constant;
3802
3803	/* Adjust function incoming argument size for alignment and
3804	minimum length. */
3805
3806	crtl->args.size = upper_bound (crtl->args.size, b: all.reg_parm_stack_space);
3807	crtl->args.size = aligned_upper_bound (crtl->args.size,
3808	PARM_BOUNDARY / BITS_PER_UNIT);
3809
3810	if (ARGS_GROW_DOWNWARD)
3811	{
3812	crtl->args.arg_offset_rtx
3813	= (all.stack_args_size.var == 0
3814	? gen_int_mode (-all.stack_args_size.constant, Pmode)
3815	: expand_expr (size_diffop (all.stack_args_size.var,
3816	size_int (-all.stack_args_size.constant)),
3817	NULL_RTX, VOIDmode, modifier: EXPAND_NORMAL));
3818	}
3819	else
3820	crtl->args.arg_offset_rtx = ARGS_SIZE_RTX (all.stack_args_size);
3821
3822	/* See how many bytes, if any, of its args a function should try to pop
3823	on return. */
3824
3825	crtl->args.pops_args = targetm.calls.return_pops_args (fndecl,
3826	TREE_TYPE (fndecl),
3827	crtl->args.size);
3828
3829	/* For stdarg.h function, save info about
3830	regs and stack space used by the named args. */
3831
3832	crtl->args.info = all.args_so_far_v;
3833
3834	/* Set the rtx used for the function return value. Put this in its
3835	own variable so any optimizers that need this information don't have
3836	to include tree.h. Do this here so it gets done when an inlined
3837	function gets output. */
3838
3839	crtl->return_rtx
3840	= (DECL_RTL_SET_P (DECL_RESULT (fndecl))
3841	? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
3842
3843	/* If scalar return value was computed in a pseudo-reg, or was a named
3844	return value that got dumped to the stack, copy that to the hard
3845	return register. */
3846	if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
3847	{
3848	tree decl_result = DECL_RESULT (fndecl);
3849	rtx decl_rtl = DECL_RTL (decl_result);
3850
3851	if (REG_P (decl_rtl)
3852	? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
3853	: DECL_REGISTER (decl_result))
3854	{
3855	rtx real_decl_rtl;
3856
3857	/* Unless the psABI says not to. */
3858	if (TYPE_EMPTY_P (TREE_TYPE (decl_result)))
3859	real_decl_rtl = NULL_RTX;
3860	else
3861	{
3862	real_decl_rtl
3863	= targetm.calls.function_value (TREE_TYPE (decl_result),
3864	fndecl, true);
3865	REG_FUNCTION_VALUE_P (real_decl_rtl) = 1;
3866	}
3867	/* The delay slot scheduler assumes that crtl->return_rtx
3868	holds the hard register containing the return value, not a
3869	temporary pseudo. */
3870	crtl->return_rtx = real_decl_rtl;
3871	}
3872	}
3873	}
3874
3875	/* Gimplify the parameter list for current_function_decl. This involves
3876	evaluating SAVE_EXPRs of variable sized parameters and generating code
3877	to implement callee-copies reference parameters. Returns a sequence of
3878	statements to add to the beginning of the function. */
3879
3880	gimple_seq
3881	gimplify_parameters (gimple_seq *cleanup)
3882	{
3883	struct assign_parm_data_all all;
3884	tree parm;
3885	gimple_seq stmts = NULL;
3886	vec<tree> fnargs;
3887	unsigned i;
3888
3889	assign_parms_initialize_all (all: &all);
3890	fnargs = assign_parms_augmented_arg_list (all: &all);
3891
3892	FOR_EACH_VEC_ELT (fnargs, i, parm)
3893	{
3894	struct assign_parm_data_one data;
3895
3896	/* Extract the type of PARM; adjust it according to ABI. */
3897	assign_parm_find_data_types (all: &all, parm, data: &data);
3898
3899	/* Early out for errors and void parameters. */
3900	if (data.passed_mode == VOIDmode || DECL_SIZE (parm) == NULL)
3901	continue;
3902
3903	/* Update info on where next arg arrives in registers. */
3904	targetm.calls.function_arg_advance (all.args_so_far, data.arg);
3905
3906	/* ??? Once upon a time variable_size stuffed parameter list
3907	SAVE_EXPRs (amongst others) onto a pending sizes list. This
3908	turned out to be less than manageable in the gimple world.
3909	Now we have to hunt them down ourselves. */
3910	gimplify_type_sizes (TREE_TYPE (parm), &stmts);
3911
3912	if (TREE_CODE (DECL_SIZE_UNIT (parm)) != INTEGER_CST)
3913	{
3914	gimplify_one_sizepos (&DECL_SIZE (parm), &stmts);
3915	gimplify_one_sizepos (&DECL_SIZE_UNIT (parm), &stmts);
3916	}
3917
3918	if (data.arg.pass_by_reference)
3919	{
3920	tree type = TREE_TYPE (data.arg.type);
3921	function_arg_info orig_arg (type, data.arg.named);
3922	if (reference_callee_copied (&all.args_so_far_v, orig_arg))
3923	{
3924	tree local, t;
3925
3926	/* For constant-sized objects, this is trivial; for
3927	variable-sized objects, we have to play games. */
3928	if (TREE_CODE (DECL_SIZE_UNIT (parm)) == INTEGER_CST
3929	&& !(flag_stack_check == GENERIC_STACK_CHECK
3930	&& compare_tree_int (DECL_SIZE_UNIT (parm),
3931	STACK_CHECK_MAX_VAR_SIZE) > 0))
3932	{
3933	local = create_tmp_var (type, get_name (parm));
3934	DECL_IGNORED_P (local) = 0;
3935	/* If PARM was addressable, move that flag over
3936	to the local copy, as its address will be taken,
3937	not the PARMs. Keep the parms address taken
3938	as we'll query that flag during gimplification. */
3939	if (TREE_ADDRESSABLE (parm))
3940	TREE_ADDRESSABLE (local) = 1;
3941	if (DECL_NOT_GIMPLE_REG_P (parm))
3942	DECL_NOT_GIMPLE_REG_P (local) = 1;
3943
3944	if (!is_gimple_reg (local)
3945	&& flag_stack_reuse != SR_NONE)
3946	{
3947	tree clobber = build_clobber (type);
3948	gimple *clobber_stmt;
3949	clobber_stmt = gimple_build_assign (local, clobber);
3950	gimple_seq_add_stmt (cleanup, clobber_stmt);
3951	}
3952	}
3953	else
3954	{
3955	tree ptr_type, addr;
3956
3957	ptr_type = build_pointer_type (type);
3958	addr = create_tmp_reg (ptr_type, get_name (parm));
3959	DECL_IGNORED_P (addr) = 0;
3960	local = build_fold_indirect_ref (addr);
3961
3962	t = build_alloca_call_expr (DECL_SIZE_UNIT (parm),
3963	DECL_ALIGN (parm),
3964	max_int_size_in_bytes (type));
3965	/* The call has been built for a variable-sized object. */
3966	CALL_ALLOCA_FOR_VAR_P (t) = 1;
3967	t = fold_convert (ptr_type, t);
3968	t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
3969	gimplify_and_add (t, &stmts);
3970	}
3971
3972	gimplify_assign (local, parm, &stmts);
3973
3974	SET_DECL_VALUE_EXPR (parm, local);
3975	DECL_HAS_VALUE_EXPR_P (parm) = 1;
3976	}
3977	}
3978	}
3979
3980	fnargs.release ();
3981
3982	return stmts;
3983	}
3984
3985	/* Compute the size and offset from the start of the stacked arguments for a
3986	parm passed in mode PASSED_MODE and with type TYPE.
3987
3988	INITIAL_OFFSET_PTR points to the current offset into the stacked
3989	arguments.
3990
3991	The starting offset and size for this parm are returned in
3992	LOCATE->OFFSET and LOCATE->SIZE, respectively. When IN_REGS is
3993	nonzero, the offset is that of stack slot, which is returned in
3994	LOCATE->SLOT_OFFSET. LOCATE->ALIGNMENT_PAD is the amount of
3995	padding required from the initial offset ptr to the stack slot.
3996
3997	IN_REGS is nonzero if the argument will be passed in registers. It will
3998	never be set if REG_PARM_STACK_SPACE is not defined.
3999
4000	REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
4001	for arguments which are passed in registers.
4002
4003	FNDECL is the function in which the argument was defined.
4004
4005	There are two types of rounding that are done. The first, controlled by
4006	TARGET_FUNCTION_ARG_BOUNDARY, forces the offset from the start of the
4007	argument list to be aligned to the specific boundary (in bits). This
4008	rounding affects the initial and starting offsets, but not the argument
4009	size.
4010
4011	The second, controlled by TARGET_FUNCTION_ARG_PADDING and PARM_BOUNDARY,
4012	optionally rounds the size of the parm to PARM_BOUNDARY. The
4013	initial offset is not affected by this rounding, while the size always
4014	is and the starting offset may be. */
4015
4016	/* LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
4017	INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
4018	callers pass in the total size of args so far as
4019	INITIAL_OFFSET_PTR. LOCATE->SIZE is always positive. */
4020
4021	void
4022	locate_and_pad_parm (machine_mode passed_mode, tree type, int in_regs,
4023	int reg_parm_stack_space, int partial,
4024	tree fndecl ATTRIBUTE_UNUSED,
4025	struct args_size *initial_offset_ptr,
4026	struct locate_and_pad_arg_data *locate)
4027	{
4028	tree sizetree;
4029	pad_direction where_pad;
4030	unsigned int boundary, round_boundary;
4031	int part_size_in_regs;
4032
4033	/* If we have found a stack parm before we reach the end of the
4034	area reserved for registers, skip that area. */
4035	if (! in_regs)
4036	{
4037	if (reg_parm_stack_space > 0)
4038	{
4039	if (initial_offset_ptr->var
4040	|| !ordered_p (a: initial_offset_ptr->constant,
4041	b: reg_parm_stack_space))
4042	{
4043	initial_offset_ptr->var
4044	= size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
4045	ssize_int (reg_parm_stack_space));
4046	initial_offset_ptr->constant = 0;
4047	}
4048	else
4049	initial_offset_ptr->constant
4050	= ordered_max (a: initial_offset_ptr->constant,
4051	b: reg_parm_stack_space);
4052	}
4053	}
4054
4055	part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0);
4056
4057	sizetree = (type
4058	? arg_size_in_bytes (type)
4059	: size_int (GET_MODE_SIZE (passed_mode)));
4060	where_pad = targetm.calls.function_arg_padding (passed_mode, type);
4061	boundary = targetm.calls.function_arg_boundary (passed_mode, type);
4062	round_boundary = targetm.calls.function_arg_round_boundary (passed_mode,
4063	type);
4064	locate->where_pad = where_pad;
4065
4066	/* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT. */
4067	if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4068	boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4069
4070	locate->boundary = boundary;
4071
4072	if (SUPPORTS_STACK_ALIGNMENT)
4073	{
4074	/* stack_alignment_estimated can't change after stack has been
4075	realigned. */
4076	if (crtl->stack_alignment_estimated < boundary)
4077	{
4078	if (!crtl->stack_realign_processed)
4079	crtl->stack_alignment_estimated = boundary;
4080	else
4081	{
4082	/* If stack is realigned and stack alignment value
4083	hasn't been finalized, it is OK not to increase
4084	stack_alignment_estimated. The bigger alignment
4085	requirement is recorded in stack_alignment_needed
4086	below. */
4087	gcc_assert (!crtl->stack_realign_finalized
4088	&& crtl->stack_realign_needed);
4089	}
4090	}
4091	}
4092
4093	if (ARGS_GROW_DOWNWARD)
4094	{
4095	locate->slot_offset.constant = -initial_offset_ptr->constant;
4096	if (initial_offset_ptr->var)
4097	locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0),
4098	initial_offset_ptr->var);
4099
4100	{
4101	tree s2 = sizetree;
4102	if (where_pad != PAD_NONE
4103	&& (!tree_fits_uhwi_p (sizetree)
4104	|| (tree_to_uhwi (sizetree) * BITS_PER_UNIT) % round_boundary))
4105	s2 = round_up (s2, round_boundary / BITS_PER_UNIT);
4106	SUB_PARM_SIZE (locate->slot_offset, s2);
4107	}
4108
4109	locate->slot_offset.constant += part_size_in_regs;
4110
4111	if (!in_regs || reg_parm_stack_space > 0)
4112	pad_to_arg_alignment (&locate->slot_offset, boundary,
4113	&locate->alignment_pad);
4114
4115	locate->size.constant = (-initial_offset_ptr->constant
4116	- locate->slot_offset.constant);
4117	if (initial_offset_ptr->var)
4118	locate->size.var = size_binop (MINUS_EXPR,
4119	size_binop (MINUS_EXPR,
4120	ssize_int (0),
4121	initial_offset_ptr->var),
4122	locate->slot_offset.var);
4123
4124	/* Pad_below needs the pre-rounded size to know how much to pad
4125	below. */
4126	locate->offset = locate->slot_offset;
4127	if (where_pad == PAD_DOWNWARD)
4128	pad_below (&locate->offset, passed_mode, sizetree);
4129
4130	}
4131	else
4132	{
4133	if (!in_regs || reg_parm_stack_space > 0)
4134	pad_to_arg_alignment (initial_offset_ptr, boundary,
4135	&locate->alignment_pad);
4136	locate->slot_offset = *initial_offset_ptr;
4137
4138	#ifdef PUSH_ROUNDING
4139	if (passed_mode != BLKmode)
4140	sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
4141	#endif
4142
4143	/* Pad_below needs the pre-rounded size to know how much to pad below
4144	so this must be done before rounding up. */
4145	locate->offset = locate->slot_offset;
4146	if (where_pad == PAD_DOWNWARD)
4147	pad_below (&locate->offset, passed_mode, sizetree);
4148
4149	if (where_pad != PAD_NONE
4150	&& (!tree_fits_uhwi_p (sizetree)
4151	|| (tree_to_uhwi (sizetree) * BITS_PER_UNIT) % round_boundary))
4152	sizetree = round_up (sizetree, round_boundary / BITS_PER_UNIT);
4153
4154	ADD_PARM_SIZE (locate->size, sizetree);
4155
4156	locate->size.constant -= part_size_in_regs;
4157	}
4158
4159	locate->offset.constant
4160	+= targetm.calls.function_arg_offset (passed_mode, type);
4161	}
4162
4163	/* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
4164	BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
4165
4166	static void
4167	pad_to_arg_alignment (struct args_size *offset_ptr, int boundary,
4168	struct args_size *alignment_pad)
4169	{
4170	tree save_var = NULL_TREE;
4171	poly_int64 save_constant = 0;
4172	int boundary_in_bytes = boundary / BITS_PER_UNIT;
4173	poly_int64 sp_offset = STACK_POINTER_OFFSET;
4174
4175	#ifdef SPARC_STACK_BOUNDARY_HACK
4176	/* ??? The SPARC port may claim a STACK_BOUNDARY higher than
4177	the real alignment of %sp. However, when it does this, the
4178	alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY. */
4179	if (SPARC_STACK_BOUNDARY_HACK)
4180	sp_offset = 0;
4181	#endif
4182
4183	if (boundary > PARM_BOUNDARY)
4184	{
4185	save_var = offset_ptr->var;
4186	save_constant = offset_ptr->constant;
4187	}
4188
4189	alignment_pad->var = NULL_TREE;
4190	alignment_pad->constant = 0;
4191
4192	if (boundary > BITS_PER_UNIT)
4193	{
4194	int misalign;
4195	if (offset_ptr->var
4196	|| !known_misalignment (value: offset_ptr->constant + sp_offset,
4197	align: boundary_in_bytes, misalign: &misalign))
4198	{
4199	tree sp_offset_tree = ssize_int (sp_offset);
4200	tree offset = size_binop (PLUS_EXPR,
4201	ARGS_SIZE_TREE (*offset_ptr),
4202	sp_offset_tree);
4203	tree rounded;
4204	if (ARGS_GROW_DOWNWARD)
4205	rounded = round_down (offset, boundary / BITS_PER_UNIT);
4206	else
4207	rounded = round_up (offset, boundary / BITS_PER_UNIT);
4208
4209	offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree);
4210	/* ARGS_SIZE_TREE includes constant term. */
4211	offset_ptr->constant = 0;
4212	if (boundary > PARM_BOUNDARY)
4213	alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
4214	save_var);
4215	}
4216	else
4217	{
4218	if (ARGS_GROW_DOWNWARD)
4219	offset_ptr->constant -= misalign;
4220	else
4221	offset_ptr->constant += -misalign & (boundary_in_bytes - 1);
4222
4223	if (boundary > PARM_BOUNDARY)
4224	alignment_pad->constant = offset_ptr->constant - save_constant;
4225	}
4226	}
4227	}
4228
4229	static void
4230	pad_below (struct args_size *offset_ptr, machine_mode passed_mode, tree sizetree)
4231	{
4232	unsigned int align = PARM_BOUNDARY / BITS_PER_UNIT;
4233	int misalign;
4234	if (passed_mode != BLKmode
4235	&& known_misalignment (value: GET_MODE_SIZE (mode: passed_mode), align, misalign: &misalign))
4236	offset_ptr->constant += -misalign & (align - 1);
4237	else
4238	{
4239	if (TREE_CODE (sizetree) != INTEGER_CST
4240	|| (TREE_INT_CST_LOW (sizetree) & (align - 1)) != 0)
4241	{
4242	/* Round the size up to multiple of PARM_BOUNDARY bits. */
4243	tree s2 = round_up (sizetree, align);
4244	/* Add it in. */
4245	ADD_PARM_SIZE (*offset_ptr, s2);
4246	SUB_PARM_SIZE (*offset_ptr, sizetree);
4247	}
4248	}
4249	}
4250
4251
4252	/* True if register REGNO was alive at a place where `setjmp' was
4253	called and was set more than once or is an argument. Such regs may
4254	be clobbered by `longjmp'. */
4255
4256	static bool
4257	regno_clobbered_at_setjmp (bitmap setjmp_crosses, int regno)
4258	{
4259	/* There appear to be cases where some local vars never reach the
4260	backend but have bogus regnos. */
4261	if (regno >= max_reg_num ())
4262	return false;
4263
4264	return ((REG_N_SETS (regno) > 1
4265	|| REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR_FOR_FN (cfun)),
4266	regno))
4267	&& REGNO_REG_SET_P (setjmp_crosses, regno));
4268	}
4269
4270	/* Walk the tree of blocks describing the binding levels within a
4271	function and warn about variables the might be killed by setjmp or
4272	vfork. This is done after calling flow_analysis before register
4273	allocation since that will clobber the pseudo-regs to hard
4274	regs. */
4275
4276	static void
4277	setjmp_vars_warning (bitmap setjmp_crosses, tree block)
4278	{
4279	tree decl, sub;
4280
4281	for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
4282	{
4283	if (VAR_P (decl)
4284	&& DECL_RTL_SET_P (decl)
4285	&& REG_P (DECL_RTL (decl))
4286	&& regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl))))
4287	warning (OPT_Wclobbered, "variable %q+D might be clobbered by"
4288	" %<longjmp%> or %<vfork%>", decl);
4289	}
4290
4291	for (sub = BLOCK_SUBBLOCKS (block); sub; sub = BLOCK_CHAIN (sub))
4292	setjmp_vars_warning (setjmp_crosses, block: sub);
4293	}
4294
4295	/* Do the appropriate part of setjmp_vars_warning
4296	but for arguments instead of local variables. */
4297
4298	static void
4299	setjmp_args_warning (bitmap setjmp_crosses)
4300	{
4301	tree decl;
4302	for (decl = DECL_ARGUMENTS (current_function_decl);
4303	decl; decl = DECL_CHAIN (decl))
4304	if (DECL_RTL (decl) != 0
4305	&& REG_P (DECL_RTL (decl))
4306	&& regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl))))
4307	warning (OPT_Wclobbered,
4308	"argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
4309	decl);
4310	}
4311
4312	/* Generate warning messages for variables live across setjmp. */
4313
4314	void
4315	generate_setjmp_warnings (void)
4316	{
4317	bitmap setjmp_crosses = regstat_get_setjmp_crosses ();
4318
4319	if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS
4320	|| bitmap_empty_p (map: setjmp_crosses))
4321	return;
4322
4323	setjmp_vars_warning (setjmp_crosses, DECL_INITIAL (current_function_decl));
4324	setjmp_args_warning (setjmp_crosses);
4325	}
4326
4327
4328	/* Reverse the order of elements in the fragment chain T of blocks,
4329	and return the new head of the chain (old last element).
4330	In addition to that clear BLOCK_SAME_RANGE flags when needed
4331	and adjust BLOCK_SUPERCONTEXT from the super fragment to
4332	its super fragment origin. */
4333
4334	static tree
4335	block_fragments_nreverse (tree t)
4336	{
4337	tree prev = 0, block, next, prev_super = 0;
4338	tree super = BLOCK_SUPERCONTEXT (t);
4339	if (BLOCK_FRAGMENT_ORIGIN (super))
4340	super = BLOCK_FRAGMENT_ORIGIN (super);
4341	for (block = t; block; block = next)
4342	{
4343	next = BLOCK_FRAGMENT_CHAIN (block);
4344	BLOCK_FRAGMENT_CHAIN (block) = prev;
4345	if ((prev && !BLOCK_SAME_RANGE (prev))
4346	|| (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (block))
4347	!= prev_super))
4348	BLOCK_SAME_RANGE (block) = 0;
4349	prev_super = BLOCK_SUPERCONTEXT (block);
4350	BLOCK_SUPERCONTEXT (block) = super;
4351	prev = block;
4352	}
4353	t = BLOCK_FRAGMENT_ORIGIN (t);
4354	if (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (t))
4355	!= prev_super)
4356	BLOCK_SAME_RANGE (t) = 0;
4357	BLOCK_SUPERCONTEXT (t) = super;
4358	return prev;
4359	}
4360
4361	/* Reverse the order of elements in the chain T of blocks,
4362	and return the new head of the chain (old last element).
4363	Also do the same on subblocks and reverse the order of elements
4364	in BLOCK_FRAGMENT_CHAIN as well. */
4365
4366	static tree
4367	blocks_nreverse_all (tree t)
4368	{
4369	tree prev = 0, block, next;
4370	for (block = t; block; block = next)
4371	{
4372	next = BLOCK_CHAIN (block);
4373	BLOCK_CHAIN (block) = prev;
4374	if (BLOCK_FRAGMENT_CHAIN (block)
4375	&& BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE)
4376	{
4377	BLOCK_FRAGMENT_CHAIN (block)
4378	= block_fragments_nreverse (BLOCK_FRAGMENT_CHAIN (block));
4379	if (!BLOCK_SAME_RANGE (BLOCK_FRAGMENT_CHAIN (block)))
4380	BLOCK_SAME_RANGE (block) = 0;
4381	}
4382	BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block));
4383	prev = block;
4384	}
4385	return prev;
4386	}
4387
4388
4389	/* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
4390	and create duplicate blocks. */
4391	/* ??? Need an option to either create block fragments or to create
4392	abstract origin duplicates of a source block. It really depends
4393	on what optimization has been performed. */
4394
4395	void
4396	reorder_blocks (void)
4397	{
4398	tree block = DECL_INITIAL (current_function_decl);
4399
4400	if (block == NULL_TREE)
4401	return;
4402
4403	auto_vec<tree, 10> block_stack;
4404
4405	/* Reset the TREE_ASM_WRITTEN bit for all blocks. */
4406	clear_block_marks (block);
4407
4408	/* Prune the old trees away, so that they don't get in the way. */
4409	BLOCK_SUBBLOCKS (block) = NULL_TREE;
4410	BLOCK_CHAIN (block) = NULL_TREE;
4411
4412	/* Recreate the block tree from the note nesting. */
4413	reorder_blocks_1 (get_insns (), block, &block_stack);
4414	BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block));
4415	}
4416
4417	/* Helper function for reorder_blocks. Reset TREE_ASM_WRITTEN. */
4418
4419	void
4420	clear_block_marks (tree block)
4421	{
4422	while (block)
4423	{
4424	TREE_ASM_WRITTEN (block) = 0;
4425	clear_block_marks (BLOCK_SUBBLOCKS (block));
4426	block = BLOCK_CHAIN (block);
4427	}
4428	}
4429
4430	static void
4431	reorder_blocks_1 (rtx_insn *insns, tree current_block,
4432	vec<tree> *p_block_stack)
4433	{
4434	rtx_insn *insn;
4435	tree prev_beg = NULL_TREE, prev_end = NULL_TREE;
4436
4437	for (insn = insns; insn; insn = NEXT_INSN (insn))
4438	{
4439	if (NOTE_P (insn))
4440	{
4441	if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_BEG)
4442	{
4443	tree block = NOTE_BLOCK (insn);
4444	tree origin;
4445
4446	gcc_assert (BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE);
4447	origin = block;
4448
4449	if (prev_end)
4450	BLOCK_SAME_RANGE (prev_end) = 0;
4451	prev_end = NULL_TREE;
4452
4453	/* If we have seen this block before, that means it now
4454	spans multiple address regions. Create a new fragment. */
4455	if (TREE_ASM_WRITTEN (block))
4456	{
4457	tree new_block = copy_node (block);
4458
4459	BLOCK_SAME_RANGE (new_block) = 0;
4460	BLOCK_FRAGMENT_ORIGIN (new_block) = origin;
4461	BLOCK_FRAGMENT_CHAIN (new_block)
4462	= BLOCK_FRAGMENT_CHAIN (origin);
4463	BLOCK_FRAGMENT_CHAIN (origin) = new_block;
4464
4465	NOTE_BLOCK (insn) = new_block;
4466	block = new_block;
4467	}
4468
4469	if (prev_beg == current_block && prev_beg)
4470	BLOCK_SAME_RANGE (block) = 1;
4471
4472	prev_beg = origin;
4473
4474	BLOCK_SUBBLOCKS (block) = 0;
4475	TREE_ASM_WRITTEN (block) = 1;
4476	/* When there's only one block for the entire function,
4477	current_block == block and we mustn't do this, it
4478	will cause infinite recursion. */
4479	if (block != current_block)
4480	{
4481	tree super;
4482	if (block != origin)
4483	gcc_assert (BLOCK_SUPERCONTEXT (origin) == current_block
4484	|| BLOCK_FRAGMENT_ORIGIN (BLOCK_SUPERCONTEXT
4485	(origin))
4486	== current_block);
4487	if (p_block_stack->is_empty ())
4488	super = current_block;
4489	else
4490	{
4491	super = p_block_stack->last ();
4492	gcc_assert (super == current_block
4493	|| BLOCK_FRAGMENT_ORIGIN (super)
4494	== current_block);
4495	}
4496	BLOCK_SUPERCONTEXT (block) = super;
4497	BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
4498	BLOCK_SUBBLOCKS (current_block) = block;
4499	current_block = origin;
4500	}
4501	p_block_stack->safe_push (obj: block);
4502	}
4503	else if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_END)
4504	{
4505	NOTE_BLOCK (insn) = p_block_stack->pop ();
4506	current_block = BLOCK_SUPERCONTEXT (current_block);
4507	if (BLOCK_FRAGMENT_ORIGIN (current_block))
4508	current_block = BLOCK_FRAGMENT_ORIGIN (current_block);
4509	prev_beg = NULL_TREE;
4510	prev_end = BLOCK_SAME_RANGE (NOTE_BLOCK (insn))
4511	? NOTE_BLOCK (insn) : NULL_TREE;
4512	}
4513	}
4514	else
4515	{
4516	prev_beg = NULL_TREE;
4517	if (prev_end)
4518	BLOCK_SAME_RANGE (prev_end) = 0;
4519	prev_end = NULL_TREE;
4520	}
4521	}
4522	}
4523
4524	/* Reverse the order of elements in the chain T of blocks,
4525	and return the new head of the chain (old last element). */
4526
4527	tree
4528	blocks_nreverse (tree t)
4529	{
4530	tree prev = 0, block, next;
4531	for (block = t; block; block = next)
4532	{
4533	next = BLOCK_CHAIN (block);
4534	BLOCK_CHAIN (block) = prev;
4535	prev = block;
4536	}
4537	return prev;
4538	}
4539
4540	/* Concatenate two chains of blocks (chained through BLOCK_CHAIN)
4541	by modifying the last node in chain 1 to point to chain 2. */
4542
4543	tree
4544	block_chainon (tree op1, tree op2)
4545	{
4546	tree t1;
4547
4548	if (!op1)
4549	return op2;
4550	if (!op2)
4551	return op1;
4552
4553	for (t1 = op1; BLOCK_CHAIN (t1); t1 = BLOCK_CHAIN (t1))
4554	continue;
4555	BLOCK_CHAIN (t1) = op2;
4556
4557	#ifdef ENABLE_TREE_CHECKING
4558	{
4559	tree t2;
4560	for (t2 = op2; t2; t2 = BLOCK_CHAIN (t2))
4561	gcc_assert (t2 != t1);
4562	}
4563	#endif
4564
4565	return op1;
4566	}
4567
4568	/* Count the subblocks of the list starting with BLOCK. If VECTOR is
4569	non-NULL, list them all into VECTOR, in a depth-first preorder
4570	traversal of the block tree. Also clear TREE_ASM_WRITTEN in all
4571	blocks. */
4572
4573	static int
4574	all_blocks (tree block, tree *vector)
4575	{
4576	int n_blocks = 0;
4577
4578	while (block)
4579	{
4580	TREE_ASM_WRITTEN (block) = 0;
4581
4582	/* Record this block. */
4583	if (vector)
4584	vector[n_blocks] = block;
4585
4586	++n_blocks;
4587
4588	/* Record the subblocks, and their subblocks... */
4589	n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
4590	vector: vector ? vector + n_blocks : 0);
4591	block = BLOCK_CHAIN (block);
4592	}
4593
4594	return n_blocks;
4595	}
4596
4597	/* Return a vector containing all the blocks rooted at BLOCK. The
4598	number of elements in the vector is stored in N_BLOCKS_P. The
4599	vector is dynamically allocated; it is the caller's responsibility
4600	to call `free' on the pointer returned. */
4601
4602	static tree *
4603	get_block_vector (tree block, int *n_blocks_p)
4604	{
4605	tree *block_vector;
4606
4607	*n_blocks_p = all_blocks (block, NULL);
4608	block_vector = XNEWVEC (tree, *n_blocks_p);
4609	all_blocks (block, vector: block_vector);
4610
4611	return block_vector;
4612	}
4613
4614	static GTY(()) int next_block_index = 2;
4615
4616	/* Set BLOCK_NUMBER for all the blocks in FN. */
4617
4618	void
4619	number_blocks (tree fn)
4620	{
4621	int i;
4622	int n_blocks;
4623	tree *block_vector;
4624
4625	block_vector = get_block_vector (DECL_INITIAL (fn), n_blocks_p: &n_blocks);
4626
4627	/* The top-level BLOCK isn't numbered at all. */
4628	for (i = 1; i < n_blocks; ++i)
4629	/* We number the blocks from two. */
4630	BLOCK_NUMBER (block_vector[i]) = next_block_index++;
4631
4632	free (ptr: block_vector);
4633
4634	return;
4635	}
4636
4637	/* If VAR is present in a subblock of BLOCK, return the subblock. */
4638
4639	DEBUG_FUNCTION tree
4640	debug_find_var_in_block_tree (tree var, tree block)
4641	{
4642	tree t;
4643
4644	for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
4645	if (t == var)
4646	return block;
4647
4648	for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t))
4649	{
4650	tree ret = debug_find_var_in_block_tree (var, block: t);
4651	if (ret)
4652	return ret;
4653	}
4654
4655	return NULL_TREE;
4656	}
4657
4658	/* Keep track of whether we're in a dummy function context. If we are,
4659	we don't want to invoke the set_current_function hook, because we'll
4660	get into trouble if the hook calls target_reinit () recursively or
4661	when the initial initialization is not yet complete. */
4662
4663	static bool in_dummy_function;
4664
4665	/* Invoke the target hook when setting cfun. Update the optimization options
4666	if the function uses different options than the default. */
4667
4668	static void
4669	invoke_set_current_function_hook (tree fndecl)
4670	{
4671	if (!in_dummy_function)
4672	{
4673	tree opts = ((fndecl)
4674	? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl)
4675	: optimization_default_node);
4676
4677	if (!opts)
4678	opts = optimization_default_node;
4679
4680	/* Change optimization options if needed. */
4681	if (optimization_current_node != opts)
4682	{
4683	optimization_current_node = opts;
4684	cl_optimization_restore (&global_options, &global_options_set,
4685	TREE_OPTIMIZATION (opts));
4686	}
4687
4688	targetm.set_current_function (fndecl);
4689	this_fn_optabs = this_target_optabs;
4690
4691	/* Initialize global alignment variables after op. */
4692	parse_alignment_opts ();
4693
4694	if (opts != optimization_default_node)
4695	{
4696	init_tree_optimization_optabs (opts);
4697	if (TREE_OPTIMIZATION_OPTABS (opts))
4698	this_fn_optabs = (struct target_optabs *)
4699	TREE_OPTIMIZATION_OPTABS (opts);
4700	}
4701	}
4702	}
4703
4704	/* cfun should never be set directly; use this function. */
4705
4706	void
4707	set_cfun (struct function *new_cfun, bool force)
4708	{
4709	if (cfun != new_cfun || force)
4710	{
4711	cfun = new_cfun;
4712	invoke_set_current_function_hook (fndecl: new_cfun ? new_cfun->decl : NULL_TREE);
4713	redirect_edge_var_map_empty ();
4714	}
4715	}
4716
4717	/* Initialized with NOGC, making this poisonous to the garbage collector. */
4718
4719	static vec<function *> cfun_stack;
4720
4721	/* Push the current cfun onto the stack, and set cfun to new_cfun. Also set
4722	current_function_decl accordingly. */
4723
4724	void
4725	push_cfun (struct function *new_cfun)
4726	{
4727	gcc_assert ((!cfun && !current_function_decl)
4728	|| (cfun && current_function_decl == cfun->decl));
4729	cfun_stack.safe_push (obj: cfun);
4730	current_function_decl = new_cfun ? new_cfun->decl : NULL_TREE;
4731	set_cfun (new_cfun);
4732	}
4733
4734	/* Pop cfun from the stack. Also set current_function_decl accordingly. */
4735
4736	void
4737	pop_cfun (void)
4738	{
4739	struct function *new_cfun = cfun_stack.pop ();
4740	/* When in_dummy_function, we do have a cfun but current_function_decl is
4741	NULL. We also allow pushing NULL cfun and subsequently changing
4742	current_function_decl to something else and have both restored by
4743	pop_cfun. */
4744	gcc_checking_assert (in_dummy_function
4745	|| !cfun
4746	|| current_function_decl == cfun->decl);
4747	set_cfun (new_cfun);
4748	current_function_decl = new_cfun ? new_cfun->decl : NULL_TREE;
4749	}
4750
4751	/* Return value of funcdef and increase it. */
4752	int
4753	get_next_funcdef_no (void)
4754	{
4755	return funcdef_no++;
4756	}
4757
4758	/* Return value of funcdef. */
4759	int
4760	get_last_funcdef_no (void)
4761	{
4762	return funcdef_no;
4763	}
4764
4765	/* Allocate and initialize the stack usage info data structure for the
4766	current function. */
4767	static void
4768	allocate_stack_usage_info (void)
4769	{
4770	gcc_assert (!cfun->su);
4771	cfun->su = ggc_cleared_alloc<stack_usage> ();
4772	cfun->su->static_stack_size = -1;
4773	}
4774
4775	/* Allocate a function structure for FNDECL and set its contents
4776	to the defaults. Set cfun to the newly-allocated object.
4777	Some of the helper functions invoked during initialization assume
4778	that cfun has already been set. Therefore, assign the new object
4779	directly into cfun and invoke the back end hook explicitly at the
4780	very end, rather than initializing a temporary and calling set_cfun
4781	on it.
4782
4783	ABSTRACT_P is true if this is a function that will never be seen by
4784	the middle-end. Such functions are front-end concepts (like C++
4785	function templates) that do not correspond directly to functions
4786	placed in object files. */
4787
4788	void
4789	allocate_struct_function (tree fndecl, bool abstract_p)
4790	{
4791	tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE;
4792
4793	cfun = ggc_cleared_alloc<function> ();
4794
4795	init_eh_for_function ();
4796
4797	if (init_machine_status)
4798	cfun->machine = (*init_machine_status) ();
4799
4800	#ifdef OVERRIDE_ABI_FORMAT
4801	OVERRIDE_ABI_FORMAT (fndecl);
4802	#endif
4803
4804	if (fndecl != NULL_TREE)
4805	{
4806	DECL_STRUCT_FUNCTION (fndecl) = cfun;
4807	cfun->decl = fndecl;
4808	current_function_funcdef_no = get_next_funcdef_no ();
4809	}
4810
4811	invoke_set_current_function_hook (fndecl);
4812
4813	if (fndecl != NULL_TREE)
4814	{
4815	tree result = DECL_RESULT (fndecl);
4816
4817	if (!abstract_p)
4818	{
4819	/* Now that we have activated any function-specific attributes
4820	that might affect layout, particularly vector modes, relayout
4821	each of the parameters and the result. */
4822	relayout_decl (result);
4823	for (tree parm = DECL_ARGUMENTS (fndecl); parm;
4824	parm = DECL_CHAIN (parm))
4825	relayout_decl (parm);
4826
4827	/* Similarly relayout the function decl. */
4828	targetm.target_option.relayout_function (fndecl);
4829	}
4830
4831	if (!abstract_p && aggregate_value_p (exp: result, fntype: fndecl))
4832	{
4833	#ifdef PCC_STATIC_STRUCT_RETURN
4834	cfun->returns_pcc_struct = 1;
4835	#endif
4836	cfun->returns_struct = 1;
4837	}
4838
4839	cfun->stdarg = stdarg_p (fntype);
4840
4841	/* Assume all registers in stdarg functions need to be saved. */
4842	cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
4843	cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
4844
4845	/* ??? This could be set on a per-function basis by the front-end
4846	but is this worth the hassle? */
4847	cfun->can_throw_non_call_exceptions = flag_non_call_exceptions;
4848	cfun->can_delete_dead_exceptions = flag_delete_dead_exceptions;
4849
4850	if (!profile_flag && !flag_instrument_function_entry_exit)
4851	DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl) = 1;
4852
4853	if (flag_callgraph_info)
4854	allocate_stack_usage_info ();
4855	}
4856
4857	/* Don't enable begin stmt markers if var-tracking at assignments is
4858	disabled. The markers make little sense without the variable
4859	binding annotations among them. */
4860	cfun->debug_nonbind_markers = lang_hooks.emits_begin_stmt
4861	&& MAY_HAVE_DEBUG_MARKER_STMTS;
4862	}
4863
4864	/* This is like allocate_struct_function, but pushes a new cfun for FNDECL
4865	instead of just setting it. */
4866
4867	void
4868	push_struct_function (tree fndecl, bool abstract_p)
4869	{
4870	/* When in_dummy_function we might be in the middle of a pop_cfun and
4871	current_function_decl and cfun may not match. */
4872	gcc_assert (in_dummy_function
4873	|| (!cfun && !current_function_decl)
4874	|| (cfun && current_function_decl == cfun->decl));
4875	cfun_stack.safe_push (obj: cfun);
4876	current_function_decl = fndecl;
4877	allocate_struct_function (fndecl, abstract_p);
4878	}
4879
4880	/* Reset crtl and other non-struct-function variables to defaults as
4881	appropriate for emitting rtl at the start of a function. */
4882
4883	static void
4884	prepare_function_start (void)
4885	{
4886	gcc_assert (!get_last_insn ());
4887
4888	if (in_dummy_function)
4889	crtl->abi = &default_function_abi;
4890	else
4891	crtl->abi = &fndecl_abi (cfun->decl).base_abi ();
4892
4893	init_temp_slots ();
4894	init_emit ();
4895	init_varasm_status ();
4896	init_expr ();
4897	default_rtl_profile ();
4898
4899	if (flag_stack_usage_info && !flag_callgraph_info)
4900	allocate_stack_usage_info ();
4901
4902	cse_not_expected = ! optimize;
4903
4904	/* Caller save not needed yet. */
4905	caller_save_needed = 0;
4906
4907	/* We haven't done register allocation yet. */
4908	reg_renumber = 0;
4909
4910	/* Indicate that we have not instantiated virtual registers yet. */
4911	virtuals_instantiated = 0;
4912
4913	/* Indicate that we want CONCATs now. */
4914	generating_concat_p = 1;
4915
4916	/* Indicate we have no need of a frame pointer yet. */
4917	frame_pointer_needed = 0;
4918	}
4919
4920	void
4921	push_dummy_function (bool with_decl)
4922	{
4923	tree fn_decl, fn_type, fn_result_decl;
4924
4925	gcc_assert (!in_dummy_function);
4926	in_dummy_function = true;
4927
4928	if (with_decl)
4929	{
4930	fn_type = build_function_type_list (void_type_node, NULL_TREE);
4931	fn_decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, NULL_TREE,
4932	fn_type);
4933	fn_result_decl = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
4934	NULL_TREE, void_type_node);
4935	DECL_RESULT (fn_decl) = fn_result_decl;
4936	DECL_ARTIFICIAL (fn_decl) = 1;
4937	tree fn_name = get_identifier (" ");
4938	SET_DECL_ASSEMBLER_NAME (fn_decl, fn_name);
4939	}
4940	else
4941	fn_decl = NULL_TREE;
4942
4943	push_struct_function (fndecl: fn_decl);
4944	}
4945
4946	/* Initialize the rtl expansion mechanism so that we can do simple things
4947	like generate sequences. This is used to provide a context during global
4948	initialization of some passes. You must call expand_dummy_function_end
4949	to exit this context. */
4950
4951	void
4952	init_dummy_function_start (void)
4953	{
4954	push_dummy_function (with_decl: false);
4955	prepare_function_start ();
4956	}
4957
4958	/* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
4959	and initialize static variables for generating RTL for the statements
4960	of the function. */
4961
4962	void
4963	init_function_start (tree subr)
4964	{
4965	/* Initialize backend, if needed. */
4966	initialize_rtl ();
4967
4968	prepare_function_start ();
4969	decide_function_section (subr);
4970
4971	/* Warn if this value is an aggregate type,
4972	regardless of which calling convention we are using for it. */
4973	if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
4974	warning_at (DECL_SOURCE_LOCATION (DECL_RESULT (subr)),
4975	OPT_Waggregate_return, "function returns an aggregate");
4976	}
4977
4978	/* Expand code to verify the stack_protect_guard. This is invoked at
4979	the end of a function to be protected. */
4980
4981	void
4982	stack_protect_epilogue (void)
4983	{
4984	tree guard_decl = crtl->stack_protect_guard_decl;
4985	rtx_code_label *label = gen_label_rtx ();
4986	rtx x, y;
4987	rtx_insn *seq = NULL;
4988
4989	x = expand_normal (crtl->stack_protect_guard);
4990
4991	if (targetm.have_stack_protect_combined_test () && guard_decl)
4992	{
4993	gcc_assert (DECL_P (guard_decl));
4994	y = DECL_RTL (guard_decl);
4995	/* Allow the target to compute address of Y and compare it with X without
4996	leaking Y into a register. This combined address + compare pattern
4997	allows the target to prevent spilling of any intermediate results by
4998	splitting it after register allocator. */
4999	seq = targetm.gen_stack_protect_combined_test (x, y, label);
5000	}
5001	else
5002	{
5003	if (guard_decl)
5004	y = expand_normal (exp: guard_decl);
5005	else
5006	y = const0_rtx;
5007
5008	/* Allow the target to compare Y with X without leaking either into
5009	a register. */
5010	if (targetm.have_stack_protect_test ())
5011	seq = targetm.gen_stack_protect_test (x, y, label);
5012	}
5013
5014	if (seq)
5015	emit_insn (seq);
5016	else
5017	emit_cmp_and_jump_insns (x, y, EQ, NULL_RTX, ptr_mode, 1, label);
5018
5019	/* The noreturn predictor has been moved to the tree level. The rtl-level
5020	predictors estimate this branch about 20%, which isn't enough to get
5021	things moved out of line. Since this is the only extant case of adding
5022	a noreturn function at the rtl level, it doesn't seem worth doing ought
5023	except adding the prediction by hand. */
5024	rtx_insn *tmp = get_last_insn ();
5025	if (JUMP_P (tmp))
5026	predict_insn_def (tmp, PRED_NORETURN, TAKEN);
5027
5028	expand_call (targetm.stack_protect_fail (), NULL_RTX, /*ignore=*/true);
5029	free_temp_slots ();
5030	emit_label (label);
5031	}
5032
5033	/* Start the RTL for a new function, and set variables used for
5034	emitting RTL.
5035	SUBR is the FUNCTION_DECL node.
5036	PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
5037	the function's parameters, which must be run at any return statement. */
5038
5039	bool currently_expanding_function_start;
5040	void
5041	expand_function_start (tree subr)
5042	{
5043	currently_expanding_function_start = true;
5044
5045	/* Make sure volatile mem refs aren't considered
5046	valid operands of arithmetic insns. */
5047	init_recog_no_volatile ();
5048
5049	crtl->profile
5050	= (profile_flag
5051	&& ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
5052
5053	crtl->limit_stack
5054	= (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr));
5055
5056	/* Make the label for return statements to jump to. Do not special
5057	case machines with special return instructions -- they will be
5058	handled later during jump, ifcvt, or epilogue creation. */
5059	return_label = gen_label_rtx ();
5060
5061	/* Initialize rtx used to return the value. */
5062	/* Do this before assign_parms so that we copy the struct value address
5063	before any library calls that assign parms might generate. */
5064
5065	/* Decide whether to return the value in memory or in a register. */
5066	tree res = DECL_RESULT (subr);
5067	if (aggregate_value_p (exp: res, fntype: subr))
5068	{
5069	/* Returning something that won't go in a register. */
5070	rtx value_address = 0;
5071
5072	#ifdef PCC_STATIC_STRUCT_RETURN
5073	if (cfun->returns_pcc_struct)
5074	{
5075	int size = int_size_in_bytes (TREE_TYPE (res));
5076	value_address = assemble_static_space (size);
5077	}
5078	else
5079	#endif
5080	{
5081	rtx sv = targetm.calls.struct_value_rtx (TREE_TYPE (subr), 2);
5082	/* Expect to be passed the address of a place to store the value.
5083	If it is passed as an argument, assign_parms will take care of
5084	it. */
5085	if (sv)
5086	{
5087	value_address = gen_reg_rtx (Pmode);
5088	emit_move_insn (value_address, sv);
5089	}
5090	}
5091	if (value_address)
5092	{
5093	rtx x = value_address;
5094	if (!DECL_BY_REFERENCE (res))
5095	{
5096	x = gen_rtx_MEM (DECL_MODE (res), x);
5097	set_mem_attributes (x, res, 1);
5098	}
5099	set_parm_rtl (res, x);
5100	}
5101	}
5102	else if (DECL_MODE (res) == VOIDmode)
5103	/* If return mode is void, this decl rtl should not be used. */
5104	set_parm_rtl (res, NULL_RTX);
5105	else
5106	{
5107	/* Compute the return values into a pseudo reg, which we will copy
5108	into the true return register after the cleanups are done. */
5109	tree return_type = TREE_TYPE (res);
5110
5111	/* If we may coalesce this result, make sure it has the expected mode
5112	in case it was promoted. But we need not bother about BLKmode. */
5113	machine_mode promoted_mode
5114	= flag_tree_coalesce_vars && is_gimple_reg (res)
5115	? promote_ssa_mode (ssa_default_def (cfun, res), NULL)
5116	: BLKmode;
5117
5118	if (promoted_mode != BLKmode)
5119	set_parm_rtl (res, gen_reg_rtx (promoted_mode));
5120	else if (TYPE_MODE (return_type) != BLKmode
5121	&& targetm.calls.return_in_msb (return_type))
5122	/* expand_function_end will insert the appropriate padding in
5123	this case. Use the return value's natural (unpadded) mode
5124	within the function proper. */
5125	set_parm_rtl (res, gen_reg_rtx (TYPE_MODE (return_type)));
5126	else
5127	{
5128	/* In order to figure out what mode to use for the pseudo, we
5129	figure out what the mode of the eventual return register will
5130	actually be, and use that. */
5131	rtx hard_reg = hard_function_value (return_type, subr, 0, 1);
5132
5133	/* Structures that are returned in registers are not
5134	aggregate_value_p, so we may see a PARALLEL or a REG. */
5135	if (REG_P (hard_reg))
5136	set_parm_rtl (res, gen_reg_rtx (GET_MODE (hard_reg)));
5137	else
5138	{
5139	gcc_assert (GET_CODE (hard_reg) == PARALLEL);
5140	set_parm_rtl (res, gen_group_rtx (hard_reg));
5141	}
5142	}
5143
5144	/* Set DECL_REGISTER flag so that expand_function_end will copy the
5145	result to the real return register(s). */
5146	DECL_REGISTER (res) = 1;
5147	}
5148
5149	/* Initialize rtx for parameters and local variables.
5150	In some cases this requires emitting insns. */
5151	assign_parms (fndecl: subr);
5152
5153	/* If function gets a static chain arg, store it. */
5154	if (cfun->static_chain_decl)
5155	{
5156	tree parm = cfun->static_chain_decl;
5157	rtx local, chain;
5158	rtx_insn *insn;
5159	int unsignedp;
5160
5161	local = gen_reg_rtx (promote_decl_mode (parm, &unsignedp));
5162	chain = targetm.calls.static_chain (current_function_decl, true);
5163
5164	set_decl_incoming_rtl (parm, chain, false);
5165	set_parm_rtl (parm, local);
5166	mark_reg_pointer (local, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
5167
5168	if (GET_MODE (local) != GET_MODE (chain))
5169	{
5170	convert_move (local, chain, unsignedp);
5171	insn = get_last_insn ();
5172	}
5173	else
5174	insn = emit_move_insn (local, chain);
5175
5176	/* Mark the register as eliminable, similar to parameters. */
5177	if (MEM_P (chain)
5178	&& reg_mentioned_p (arg_pointer_rtx, XEXP (chain, 0)))
5179	set_dst_reg_note (insn, REG_EQUIV, chain, local);
5180
5181	/* If we aren't optimizing, save the static chain onto the stack. */
5182	if (!optimize)
5183	{
5184	tree saved_static_chain_decl
5185	= build_decl (DECL_SOURCE_LOCATION (parm), VAR_DECL,
5186	DECL_NAME (parm), TREE_TYPE (parm));
5187	rtx saved_static_chain_rtx
5188	= assign_stack_local (Pmode, size: GET_MODE_SIZE (Pmode), align: 0);
5189	SET_DECL_RTL (saved_static_chain_decl, saved_static_chain_rtx);
5190	emit_move_insn (saved_static_chain_rtx, chain);
5191	SET_DECL_VALUE_EXPR (parm, saved_static_chain_decl);
5192	DECL_HAS_VALUE_EXPR_P (parm) = 1;
5193	}
5194	}
5195
5196	/* The following was moved from init_function_start.
5197	The move was supposed to make sdb output more accurate. */
5198	/* Indicate the beginning of the function body,
5199	as opposed to parm setup. */
5200	emit_note (NOTE_INSN_FUNCTION_BEG);
5201
5202	gcc_assert (NOTE_P (get_last_insn ()));
5203
5204	parm_birth_insn = get_last_insn ();
5205
5206	/* If the function receives a non-local goto, then store the
5207	bits we need to restore the frame pointer. */
5208	if (cfun->nonlocal_goto_save_area)
5209	{
5210	tree t_save;
5211	rtx r_save;
5212
5213	tree var = TREE_OPERAND (cfun->nonlocal_goto_save_area, 0);
5214	gcc_assert (DECL_RTL_SET_P (var));
5215
5216	t_save = build4 (ARRAY_REF,
5217	TREE_TYPE (TREE_TYPE (cfun->nonlocal_goto_save_area)),
5218	cfun->nonlocal_goto_save_area,
5219	integer_zero_node, NULL_TREE, NULL_TREE);
5220	r_save = expand_expr (exp: t_save, NULL_RTX, VOIDmode, modifier: EXPAND_WRITE);
5221	gcc_assert (GET_MODE (r_save) == Pmode);
5222
5223	emit_move_insn (r_save, hard_frame_pointer_rtx);
5224	update_nonlocal_goto_save_area ();
5225	}
5226
5227	if (crtl->profile)
5228	{
5229	#ifdef PROFILE_HOOK
5230	PROFILE_HOOK (current_function_funcdef_no);
5231	#endif
5232	}
5233
5234	/* If we are doing generic stack checking, the probe should go here. */
5235	if (flag_stack_check == GENERIC_STACK_CHECK)
5236	stack_check_probe_note = emit_note (NOTE_INSN_DELETED);
5237
5238	currently_expanding_function_start = false;
5239	}
5240
5241	void
5242	pop_dummy_function (void)
5243	{
5244	pop_cfun ();
5245	in_dummy_function = false;
5246	}
5247
5248	/* Undo the effects of init_dummy_function_start. */
5249	void
5250	expand_dummy_function_end (void)
5251	{
5252	gcc_assert (in_dummy_function);
5253
5254	/* End any sequences that failed to be closed due to syntax errors. */
5255	while (in_sequence_p ())
5256	end_sequence ();
5257
5258	/* Outside function body, can't compute type's actual size
5259	until next function's body starts. */
5260
5261	free_after_parsing (f: cfun);
5262	free_after_compilation (f: cfun);
5263	pop_dummy_function ();
5264	}
5265
5266	/* Helper for diddle_return_value. */
5267
5268	void
5269	diddle_return_value_1 (void (*doit) (rtx, void *), void *arg, rtx outgoing)
5270	{
5271	if (! outgoing)
5272	return;
5273
5274	if (REG_P (outgoing))
5275	(*doit) (outgoing, arg);
5276	else if (GET_CODE (outgoing) == PARALLEL)
5277	{
5278	int i;
5279
5280	for (i = 0; i < XVECLEN (outgoing, 0); i++)
5281	{
5282	rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
5283
5284	if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
5285	(*doit) (x, arg);
5286	}
5287	}
5288	}
5289
5290	/* Call DOIT for each hard register used as a return value from
5291	the current function. */
5292
5293	void
5294	diddle_return_value (void (*doit) (rtx, void *), void *arg)
5295	{
5296	diddle_return_value_1 (doit, arg, crtl->return_rtx);
5297	}
5298
5299	static void
5300	do_clobber_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
5301	{
5302	emit_clobber (reg);
5303	}
5304
5305	void
5306	clobber_return_register (void)
5307	{
5308	diddle_return_value (doit: do_clobber_return_reg, NULL);
5309
5310	/* In case we do use pseudo to return value, clobber it too. */
5311	if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
5312	{
5313	tree decl_result = DECL_RESULT (current_function_decl);
5314	rtx decl_rtl = DECL_RTL (decl_result);
5315	if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER)
5316	{
5317	do_clobber_return_reg (reg: decl_rtl, NULL);
5318	}
5319	}
5320	}
5321
5322	static void
5323	do_use_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
5324	{
5325	emit_use (reg);
5326	}
5327
5328	static void
5329	use_return_register (void)
5330	{
5331	diddle_return_value (doit: do_use_return_reg, NULL);
5332	}
5333
5334	/* Generate RTL for the end of the current function. */
5335
5336	void
5337	expand_function_end (void)
5338	{
5339	/* If arg_pointer_save_area was referenced only from a nested
5340	function, we will not have initialized it yet. Do that now. */
5341	if (arg_pointer_save_area && ! crtl->arg_pointer_save_area_init)
5342	get_arg_pointer_save_area ();
5343
5344	/* If we are doing generic stack checking and this function makes calls,
5345	do a stack probe at the start of the function to ensure we have enough
5346	space for another stack frame. */
5347	if (flag_stack_check == GENERIC_STACK_CHECK)
5348	{
5349	rtx_insn *insn, *seq;
5350
5351	for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
5352	if (CALL_P (insn))
5353	{
5354	rtx max_frame_size = GEN_INT (STACK_CHECK_MAX_FRAME_SIZE);
5355	start_sequence ();
5356	if (STACK_CHECK_MOVING_SP)
5357	anti_adjust_stack_and_probe (max_frame_size, true);
5358	else
5359	probe_stack_range (STACK_OLD_CHECK_PROTECT, max_frame_size);
5360	seq = get_insns ();
5361	end_sequence ();
5362	set_insn_locations (seq, prologue_location);
5363	emit_insn_before (seq, stack_check_probe_note);
5364	break;
5365	}
5366	}
5367
5368	/* End any sequences that failed to be closed due to syntax errors. */
5369	while (in_sequence_p ())
5370	end_sequence ();
5371
5372	clear_pending_stack_adjust ();
5373	do_pending_stack_adjust ();
5374
5375	/* Output a linenumber for the end of the function.
5376	SDB depended on this. */
5377	set_curr_insn_location (input_location);
5378
5379	/* Before the return label (if any), clobber the return
5380	registers so that they are not propagated live to the rest of
5381	the function. This can only happen with functions that drop
5382	through; if there had been a return statement, there would
5383	have either been a return rtx, or a jump to the return label.
5384
5385	We delay actual code generation after the current_function_value_rtx
5386	is computed. */
5387	rtx_insn *clobber_after = get_last_insn ();
5388
5389	/* Output the label for the actual return from the function. */
5390	emit_label (return_label);
5391
5392	if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
5393	{
5394	/* Let except.cc know where it should emit the call to unregister
5395	the function context for sjlj exceptions. */
5396	if (flag_exceptions)
5397	sjlj_emit_function_exit_after (get_last_insn ());
5398	}
5399
5400	/* If this is an implementation of throw, do what's necessary to
5401	communicate between __builtin_eh_return and the epilogue. */
5402	expand_eh_return ();
5403
5404	/* If stack protection is enabled for this function, check the guard. */
5405	if (crtl->stack_protect_guard
5406	&& targetm.stack_protect_runtime_enabled_p ()
5407	&& naked_return_label == NULL_RTX)
5408	stack_protect_epilogue ();
5409
5410	/* If scalar return value was computed in a pseudo-reg, or was a named
5411	return value that got dumped to the stack, copy that to the hard
5412	return register. */
5413	if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
5414	{
5415	tree decl_result = DECL_RESULT (current_function_decl);
5416	rtx decl_rtl = DECL_RTL (decl_result);
5417
5418	if ((REG_P (decl_rtl)
5419	? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
5420	: DECL_REGISTER (decl_result))
5421	/* Unless the psABI says not to. */
5422	&& !TYPE_EMPTY_P (TREE_TYPE (decl_result)))
5423	{
5424	rtx real_decl_rtl = crtl->return_rtx;
5425	complex_mode cmode;
5426
5427	/* This should be set in assign_parms. */
5428	gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl));
5429
5430	/* If this is a BLKmode structure being returned in registers,
5431	then use the mode computed in expand_return. Note that if
5432	decl_rtl is memory, then its mode may have been changed,
5433	but that crtl->return_rtx has not. */
5434	if (GET_MODE (real_decl_rtl) == BLKmode)
5435	PUT_MODE (x: real_decl_rtl, GET_MODE (decl_rtl));
5436
5437	/* If a non-BLKmode return value should be padded at the least
5438	significant end of the register, shift it left by the appropriate
5439	amount. BLKmode results are handled using the group load/store
5440	machinery. */
5441	if (TYPE_MODE (TREE_TYPE (decl_result)) != BLKmode
5442	&& REG_P (real_decl_rtl)
5443	&& targetm.calls.return_in_msb (TREE_TYPE (decl_result)))
5444	{
5445	emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl),
5446	REGNO (real_decl_rtl)),
5447	decl_rtl);
5448	shift_return_value (GET_MODE (decl_rtl), true, real_decl_rtl);
5449	}
5450	else if (GET_CODE (real_decl_rtl) == PARALLEL)
5451	{
5452	/* If expand_function_start has created a PARALLEL for decl_rtl,
5453	move the result to the real return registers. Otherwise, do
5454	a group load from decl_rtl for a named return. */
5455	if (GET_CODE (decl_rtl) == PARALLEL)
5456	emit_group_move (real_decl_rtl, decl_rtl);
5457	else
5458	emit_group_load (real_decl_rtl, decl_rtl,
5459	TREE_TYPE (decl_result),
5460	int_size_in_bytes (TREE_TYPE (decl_result)));
5461	}
5462	/* In the case of complex integer modes smaller than a word, we'll
5463	need to generate some non-trivial bitfield insertions. Do that
5464	on a pseudo and not the hard register. */
5465	else if (GET_CODE (decl_rtl) == CONCAT
5466	&& is_complex_int_mode (GET_MODE (decl_rtl), cmode: &cmode)
5467	&& GET_MODE_BITSIZE (mode: cmode) <= BITS_PER_WORD)
5468	{
5469	int old_generating_concat_p;
5470	rtx tmp;
5471
5472	old_generating_concat_p = generating_concat_p;
5473	generating_concat_p = 0;
5474	tmp = gen_reg_rtx (GET_MODE (decl_rtl));
5475	generating_concat_p = old_generating_concat_p;
5476
5477	emit_move_insn (tmp, decl_rtl);
5478	emit_move_insn (real_decl_rtl, tmp);
5479	}
5480	/* If a named return value dumped decl_return to memory, then
5481	we may need to re-do the PROMOTE_MODE signed/unsigned
5482	extension. */
5483	else if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl))
5484	{
5485	int unsignedp = TYPE_UNSIGNED (TREE_TYPE (decl_result));
5486	promote_function_mode (TREE_TYPE (decl_result),
5487	GET_MODE (decl_rtl), &unsignedp,
5488	TREE_TYPE (current_function_decl), 1);
5489
5490	convert_move (real_decl_rtl, decl_rtl, unsignedp);
5491	}
5492	else
5493	emit_move_insn (real_decl_rtl, decl_rtl);
5494	}
5495	}
5496
5497	/* If returning a structure, arrange to return the address of the value
5498	in a place where debuggers expect to find it.
5499
5500	If returning a structure PCC style,
5501	the caller also depends on this value.
5502	And cfun->returns_pcc_struct is not necessarily set. */
5503	if ((cfun->returns_struct || cfun->returns_pcc_struct)
5504	&& !targetm.calls.omit_struct_return_reg)
5505	{
5506	rtx value_address = DECL_RTL (DECL_RESULT (current_function_decl));
5507	tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
5508	rtx outgoing;
5509
5510	if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
5511	type = TREE_TYPE (type);
5512	else
5513	value_address = XEXP (value_address, 0);
5514
5515	outgoing = targetm.calls.function_value (build_pointer_type (type),
5516	current_function_decl, true);
5517
5518	/* Mark this as a function return value so integrate will delete the
5519	assignment and USE below when inlining this function. */
5520	REG_FUNCTION_VALUE_P (outgoing) = 1;
5521
5522	/* The address may be ptr_mode and OUTGOING may be Pmode. */
5523	scalar_int_mode mode = as_a <scalar_int_mode> (GET_MODE (outgoing));
5524	value_address = convert_memory_address (mode, value_address);
5525
5526	emit_move_insn (outgoing, value_address);
5527
5528	/* Show return register used to hold result (in this case the address
5529	of the result. */
5530	crtl->return_rtx = outgoing;
5531	}
5532
5533	/* Emit the actual code to clobber return register. Don't emit
5534	it if clobber_after is a barrier, then the previous basic block
5535	certainly doesn't fall thru into the exit block. */
5536	if (!BARRIER_P (clobber_after))
5537	{
5538	start_sequence ();
5539	clobber_return_register ();
5540	rtx_insn *seq = get_insns ();
5541	end_sequence ();
5542
5543	emit_insn_after (seq, clobber_after);
5544	}
5545
5546	/* Output the label for the naked return from the function. */
5547	if (naked_return_label)
5548	emit_label (naked_return_label);
5549
5550	/* @@@ This is a kludge. We want to ensure that instructions that
5551	may trap are not moved into the epilogue by scheduling, because
5552	we don't always emit unwind information for the epilogue. */
5553	if (cfun->can_throw_non_call_exceptions
5554	&& targetm_common.except_unwind_info (&global_options) != UI_SJLJ)
5555	emit_insn (gen_blockage ());
5556
5557	/* If stack protection is enabled for this function, check the guard. */
5558	if (crtl->stack_protect_guard
5559	&& targetm.stack_protect_runtime_enabled_p ()
5560	&& naked_return_label)
5561	stack_protect_epilogue ();
5562
5563	/* If we had calls to alloca, and this machine needs
5564	an accurate stack pointer to exit the function,
5565	insert some code to save and restore the stack pointer. */
5566	if (! EXIT_IGNORE_STACK
5567	&& cfun->calls_alloca)
5568	{
5569	rtx tem = 0;
5570
5571	start_sequence ();
5572	emit_stack_save (SAVE_FUNCTION, &tem);
5573	rtx_insn *seq = get_insns ();
5574	end_sequence ();
5575	emit_insn_before (seq, parm_birth_insn);
5576
5577	emit_stack_restore (SAVE_FUNCTION, tem);
5578	}
5579
5580	/* ??? This should no longer be necessary since stupid is no longer with
5581	us, but there are some parts of the compiler (eg reload_combine, and
5582	sh mach_dep_reorg) that still try and compute their own lifetime info
5583	instead of using the general framework. */
5584	use_return_register ();
5585	}
5586
5587	rtx
5588	get_arg_pointer_save_area (void)
5589	{
5590	rtx ret = arg_pointer_save_area;
5591
5592	if (! ret)
5593	{
5594	ret = assign_stack_local (Pmode, size: GET_MODE_SIZE (Pmode), align: 0);
5595	arg_pointer_save_area = ret;
5596	}
5597
5598	if (! crtl->arg_pointer_save_area_init)
5599	{
5600	/* Save the arg pointer at the beginning of the function. The
5601	generated stack slot may not be a valid memory address, so we
5602	have to check it and fix it if necessary. */
5603	start_sequence ();
5604	emit_move_insn (validize_mem (copy_rtx (ret)),
5605	crtl->args.internal_arg_pointer);
5606	rtx_insn *seq = get_insns ();
5607	end_sequence ();
5608
5609	push_topmost_sequence ();
5610	emit_insn_after (seq, entry_of_function ());
5611	pop_topmost_sequence ();
5612
5613	crtl->arg_pointer_save_area_init = true;
5614	}
5615
5616	return ret;
5617	}
5618
5619
5620	/* If debugging dumps are requested, dump information about how the
5621	target handled -fstack-check=clash for the prologue.
5622
5623	PROBES describes what if any probes were emitted.
5624
5625	RESIDUALS indicates if the prologue had any residual allocation
5626	(i.e. total allocation was not a multiple of PROBE_INTERVAL). */
5627
5628	void
5629	dump_stack_clash_frame_info (enum stack_clash_probes probes, bool residuals)
5630	{
5631	if (!dump_file)
5632	return;
5633
5634	switch (probes)
5635	{
5636	case NO_PROBE_NO_FRAME:
5637	fprintf (stream: dump_file,
5638	format: "Stack clash no probe no stack adjustment in prologue.\n");
5639	break;
5640	case NO_PROBE_SMALL_FRAME:
5641	fprintf (stream: dump_file,
5642	format: "Stack clash no probe small stack adjustment in prologue.\n");
5643	break;
5644	case PROBE_INLINE:
5645	fprintf (stream: dump_file, format: "Stack clash inline probes in prologue.\n");
5646	break;
5647	case PROBE_LOOP:
5648	fprintf (stream: dump_file, format: "Stack clash probe loop in prologue.\n");
5649	break;
5650	}
5651
5652	if (residuals)
5653	fprintf (stream: dump_file, format: "Stack clash residual allocation in prologue.\n");
5654	else
5655	fprintf (stream: dump_file, format: "Stack clash no residual allocation in prologue.\n");
5656
5657	if (frame_pointer_needed)
5658	fprintf (stream: dump_file, format: "Stack clash frame pointer needed.\n");
5659	else
5660	fprintf (stream: dump_file, format: "Stack clash no frame pointer needed.\n");
5661
5662	if (TREE_THIS_VOLATILE (cfun->decl))
5663	fprintf (stream: dump_file,
5664	format: "Stack clash noreturn prologue, assuming no implicit"
5665	" probes in caller.\n");
5666	else
5667	fprintf (stream: dump_file,
5668	format: "Stack clash not noreturn prologue.\n");
5669	}
5670
5671	/* Add a list of INSNS to the hash HASHP, possibly allocating HASHP
5672	for the first time. */
5673
5674	static void
5675	record_insns (rtx_insn *insns, rtx end, hash_table<insn_cache_hasher> **hashp)
5676	{
5677	rtx_insn *tmp;
5678	hash_table<insn_cache_hasher> *hash = *hashp;
5679
5680	if (hash == NULL)
5681	*hashp = hash = hash_table<insn_cache_hasher>::create_ggc (n: 17);
5682
5683	for (tmp = insns; tmp != end; tmp = NEXT_INSN (insn: tmp))
5684	{
5685	rtx *slot = hash->find_slot (value: tmp, insert: INSERT);
5686	gcc_assert (*slot == NULL);
5687	*slot = tmp;
5688	}
5689	}
5690
5691	/* INSN has been duplicated or replaced by as COPY, perhaps by duplicating a
5692	basic block, splitting or peepholes. If INSN is a prologue or epilogue
5693	insn, then record COPY as well. */
5694
5695	void
5696	maybe_copy_prologue_epilogue_insn (rtx insn, rtx copy)
5697	{
5698	hash_table<insn_cache_hasher> *hash;
5699	rtx *slot;
5700
5701	hash = epilogue_insn_hash;
5702	if (!hash || !hash->find (value: insn))
5703	{
5704	hash = prologue_insn_hash;
5705	if (!hash || !hash->find (value: insn))
5706	return;
5707	}
5708
5709	slot = hash->find_slot (value: copy, insert: INSERT);
5710	gcc_assert (*slot == NULL);
5711	*slot = copy;
5712	}
5713
5714	/* Determine if any INSNs in HASH are, or are part of, INSN. Because
5715	we can be running after reorg, SEQUENCE rtl is possible. */
5716
5717	static bool
5718	contains (const rtx_insn *insn, hash_table<insn_cache_hasher> *hash)
5719	{
5720	if (hash == NULL)
5721	return false;
5722
5723	if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
5724	{
5725	rtx_sequence *seq = as_a <rtx_sequence *> (p: PATTERN (insn));
5726	int i;
5727	for (i = seq->len () - 1; i >= 0; i--)
5728	if (hash->find (value: seq->element (index: i)))
5729	return true;
5730	return false;
5731	}
5732
5733	return hash->find (value: const_cast<rtx_insn *> (insn)) != NULL;
5734	}
5735
5736	bool
5737	prologue_contains (const rtx_insn *insn)
5738	{
5739	return contains (insn, hash: prologue_insn_hash);
5740	}
5741
5742	bool
5743	epilogue_contains (const rtx_insn *insn)
5744	{
5745	return contains (insn, hash: epilogue_insn_hash);
5746	}
5747
5748	bool
5749	prologue_epilogue_contains (const rtx_insn *insn)
5750	{
5751	if (contains (insn, hash: prologue_insn_hash))
5752	return true;
5753	if (contains (insn, hash: epilogue_insn_hash))
5754	return true;
5755	return false;
5756	}
5757
5758	void
5759	record_prologue_seq (rtx_insn *seq)
5760	{
5761	record_insns (insns: seq, NULL, hashp: &prologue_insn_hash);
5762	}
5763
5764	void
5765	record_epilogue_seq (rtx_insn *seq)
5766	{
5767	record_insns (insns: seq, NULL, hashp: &epilogue_insn_hash);
5768	}
5769
5770	/* Set JUMP_LABEL for a return insn. */
5771
5772	void
5773	set_return_jump_label (rtx_insn *returnjump)
5774	{
5775	rtx pat = PATTERN (insn: returnjump);
5776	if (GET_CODE (pat) == PARALLEL)
5777	pat = XVECEXP (pat, 0, 0);
5778	if (ANY_RETURN_P (pat))
5779	JUMP_LABEL (returnjump) = pat;
5780	else
5781	JUMP_LABEL (returnjump) = ret_rtx;
5782	}
5783
5784	/* Return a sequence to be used as the split prologue for the current
5785	function, or NULL. */
5786
5787	static rtx_insn *
5788	make_split_prologue_seq (void)
5789	{
5790	if (!flag_split_stack
5791	|| lookup_attribute (attr_name: "no_split_stack", DECL_ATTRIBUTES (cfun->decl)))
5792	return NULL;
5793
5794	start_sequence ();
5795	emit_insn (targetm.gen_split_stack_prologue ());
5796	rtx_insn *seq = get_insns ();
5797	end_sequence ();
5798
5799	record_insns (insns: seq, NULL, hashp: &prologue_insn_hash);
5800	set_insn_locations (seq, prologue_location);
5801
5802	return seq;
5803	}
5804
5805	/* Return a sequence to be used as the prologue for the current function,
5806	or NULL. */
5807
5808	static rtx_insn *
5809	make_prologue_seq (void)
5810	{
5811	if (!targetm.have_prologue ())
5812	return NULL;
5813
5814	start_sequence ();
5815	rtx_insn *seq = targetm.gen_prologue ();
5816	emit_insn (seq);
5817
5818	/* Insert an explicit USE for the frame pointer
5819	if the profiling is on and the frame pointer is required. */
5820	if (crtl->profile && frame_pointer_needed)
5821	emit_use (hard_frame_pointer_rtx);
5822
5823	/* Retain a map of the prologue insns. */
5824	record_insns (insns: seq, NULL, hashp: &prologue_insn_hash);
5825	emit_note (NOTE_INSN_PROLOGUE_END);
5826
5827	/* Ensure that instructions are not moved into the prologue when
5828	profiling is on. The call to the profiling routine can be
5829	emitted within the live range of a call-clobbered register. */
5830	if (!targetm.profile_before_prologue () && crtl->profile)
5831	emit_insn (gen_blockage ());
5832
5833	seq = get_insns ();
5834	end_sequence ();
5835	set_insn_locations (seq, prologue_location);
5836
5837	return seq;
5838	}
5839
5840	/* Emit a sequence of insns to zero the call-used registers before RET
5841	according to ZERO_REGS_TYPE. */
5842
5843	static void
5844	gen_call_used_regs_seq (rtx_insn *ret, unsigned int zero_regs_type)
5845	{
5846	bool only_gpr = true;
5847	bool only_used = true;
5848	bool only_arg = true;
5849
5850	/* No need to zero call-used-regs in main (). */
5851	if (MAIN_NAME_P (DECL_NAME (current_function_decl)))
5852	return;
5853
5854	/* No need to zero call-used-regs if __builtin_eh_return is called
5855	since it isn't a normal function return. */
5856	if (crtl->calls_eh_return)
5857	return;
5858
5859	/* If only_gpr is true, only zero call-used registers that are
5860	general-purpose registers; if only_used is true, only zero
5861	call-used registers that are used in the current function;
5862	if only_arg is true, only zero call-used registers that pass
5863	parameters defined by the flatform's calling conversion. */
5864
5865	using namespace zero_regs_flags;
5866
5867	only_gpr = zero_regs_type & ONLY_GPR;
5868	only_used = zero_regs_type & ONLY_USED;
5869	only_arg = zero_regs_type & ONLY_ARG;
5870
5871	if ((zero_regs_type & LEAFY_MODE) && leaf_function_p ())
5872	only_used = true;
5873
5874	/* For each of the hard registers, we should zero it if:
5875	1. it is a call-used register;
5876	and 2. it is not a fixed register;
5877	and 3. it is not live at the return of the routine;
5878	and 4. it is general registor if only_gpr is true;
5879	and 5. it is used in the routine if only_used is true;
5880	and 6. it is a register that passes parameter if only_arg is true. */
5881
5882	/* First, prepare the data flow information. */
5883	basic_block bb = BLOCK_FOR_INSN (insn: ret);
5884	auto_bitmap live_out;
5885	bitmap_copy (live_out, df_get_live_out (bb));
5886	df_simulate_initialize_backwards (bb, live_out);
5887	df_simulate_one_insn_backwards (bb, ret, live_out);
5888
5889	HARD_REG_SET selected_hardregs;
5890	HARD_REG_SET all_call_used_regs;
5891	CLEAR_HARD_REG_SET (set&: selected_hardregs);
5892	CLEAR_HARD_REG_SET (set&: all_call_used_regs);
5893	for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
5894	{
5895	if (!crtl->abi->clobbers_full_reg_p (regno))
5896	continue;
5897	if (fixed_regs[regno])
5898	continue;
5899	if (REGNO_REG_SET_P (live_out, regno))
5900	continue;
5901	#ifdef LEAF_REG_REMAP
5902	if (crtl->uses_only_leaf_regs && LEAF_REG_REMAP (regno) < 0)
5903	continue;
5904	#endif
5905	/* This is a call used register that is dead at return. */
5906	SET_HARD_REG_BIT (set&: all_call_used_regs, bit: regno);
5907
5908	if (only_gpr
5909	&& !TEST_HARD_REG_BIT (reg_class_contents[GENERAL_REGS], bit: regno))
5910	continue;
5911	if (only_used && !df_regs_ever_live_p (regno))
5912	continue;
5913	if (only_arg && !FUNCTION_ARG_REGNO_P (regno))
5914	continue;
5915
5916	/* Now this is a register that we might want to zero. */
5917	SET_HARD_REG_BIT (set&: selected_hardregs, bit: regno);
5918	}
5919
5920	if (hard_reg_set_empty_p (x: selected_hardregs))
5921	return;
5922
5923	/* Now that we have a hard register set that needs to be zeroed, pass it to
5924	target to generate zeroing sequence. */
5925	HARD_REG_SET zeroed_hardregs;
5926	start_sequence ();
5927	zeroed_hardregs = targetm.calls.zero_call_used_regs (selected_hardregs);
5928
5929	/* For most targets, the returned set of registers is a subset of
5930	selected_hardregs, however, for some of the targets (for example MIPS),
5931	clearing some registers that are in selected_hardregs requires clearing
5932	other call used registers that are not in the selected_hardregs, under
5933	such situation, the returned set of registers must be a subset of
5934	all call used registers. */
5935	gcc_assert (hard_reg_set_subset_p (zeroed_hardregs, all_call_used_regs));
5936
5937	rtx_insn *seq = get_insns ();
5938	end_sequence ();
5939	if (seq)
5940	{
5941	/* Emit the memory blockage and register clobber asm volatile before
5942	the whole sequence. */
5943	start_sequence ();
5944	expand_asm_reg_clobber_mem_blockage (zeroed_hardregs);
5945	rtx_insn *seq_barrier = get_insns ();
5946	end_sequence ();
5947
5948	emit_insn_before (seq_barrier, ret);
5949	emit_insn_before (seq, ret);
5950
5951	/* Update the data flow information. */
5952	crtl->must_be_zero_on_return |= zeroed_hardregs;
5953	df_update_exit_block_uses ();
5954	}
5955	}
5956
5957
5958	/* Return a sequence to be used as the epilogue for the current function,
5959	or NULL. */
5960
5961	static rtx_insn *
5962	make_epilogue_seq (void)
5963	{
5964	if (!targetm.have_epilogue ())
5965	return NULL;
5966
5967	start_sequence ();
5968	emit_note (NOTE_INSN_EPILOGUE_BEG);
5969	rtx_insn *seq = targetm.gen_epilogue ();
5970	if (seq)
5971	emit_jump_insn (seq);
5972
5973	/* Retain a map of the epilogue insns. */
5974	record_insns (insns: seq, NULL, hashp: &epilogue_insn_hash);
5975	set_insn_locations (seq, epilogue_location);
5976
5977	seq = get_insns ();
5978	rtx_insn *returnjump = get_last_insn ();
5979	end_sequence ();
5980
5981	if (JUMP_P (returnjump))
5982	set_return_jump_label (returnjump);
5983
5984	return seq;
5985	}
5986
5987
5988	/* Generate the prologue and epilogue RTL if the machine supports it. Thread
5989	this into place with notes indicating where the prologue ends and where
5990	the epilogue begins. Update the basic block information when possible.
5991
5992	Notes on epilogue placement:
5993	There are several kinds of edges to the exit block:
5994	* a single fallthru edge from LAST_BB
5995	* possibly, edges from blocks containing sibcalls
5996	* possibly, fake edges from infinite loops
5997
5998	The epilogue is always emitted on the fallthru edge from the last basic
5999	block in the function, LAST_BB, into the exit block.
6000
6001	If LAST_BB is empty except for a label, it is the target of every
6002	other basic block in the function that ends in a return. If a
6003	target has a return or simple_return pattern (possibly with
6004	conditional variants), these basic blocks can be changed so that a
6005	return insn is emitted into them, and their target is adjusted to
6006	the real exit block.
6007
6008	Notes on shrink wrapping: We implement a fairly conservative
6009	version of shrink-wrapping rather than the textbook one. We only
6010	generate a single prologue and a single epilogue. This is
6011	sufficient to catch a number of interesting cases involving early
6012	exits.
6013
6014	First, we identify the blocks that require the prologue to occur before
6015	them. These are the ones that modify a call-saved register, or reference
6016	any of the stack or frame pointer registers. To simplify things, we then
6017	mark everything reachable from these blocks as also requiring a prologue.
6018	This takes care of loops automatically, and avoids the need to examine
6019	whether MEMs reference the frame, since it is sufficient to check for
6020	occurrences of the stack or frame pointer.
6021
6022	We then compute the set of blocks for which the need for a prologue
6023	is anticipatable (borrowing terminology from the shrink-wrapping
6024	description in Muchnick's book). These are the blocks which either
6025	require a prologue themselves, or those that have only successors
6026	where the prologue is anticipatable. The prologue needs to be
6027	inserted on all edges from BB1->BB2 where BB2 is in ANTIC and BB1
6028	is not. For the moment, we ensure that only one such edge exists.
6029
6030	The epilogue is placed as described above, but we make a
6031	distinction between inserting return and simple_return patterns
6032	when modifying other blocks that end in a return. Blocks that end
6033	in a sibcall omit the sibcall_epilogue if the block is not in
6034	ANTIC. */
6035
6036	void
6037	thread_prologue_and_epilogue_insns (void)
6038	{
6039	df_analyze ();
6040
6041	/* Can't deal with multiple successors of the entry block at the
6042	moment. Function should always have at least one entry
6043	point. */
6044	gcc_assert (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
6045
6046	edge entry_edge = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
6047	edge orig_entry_edge = entry_edge;
6048
6049	rtx_insn *split_prologue_seq = make_split_prologue_seq ();
6050	rtx_insn *prologue_seq = make_prologue_seq ();
6051	rtx_insn *epilogue_seq = make_epilogue_seq ();
6052
6053	/* Try to perform a kind of shrink-wrapping, making sure the
6054	prologue/epilogue is emitted only around those parts of the
6055	function that require it. */
6056	try_shrink_wrapping (entry_edge: &entry_edge, prologue_seq);
6057
6058	/* If the target can handle splitting the prologue/epilogue into separate
6059	components, try to shrink-wrap these components separately. */
6060	try_shrink_wrapping_separate (first_bb: entry_edge->dest);
6061
6062	/* If that did anything for any component we now need the generate the
6063	"main" prologue again. Because some targets require some of these
6064	to be called in a specific order (i386 requires the split prologue
6065	to be first, for example), we create all three sequences again here.
6066	If this does not work for some target, that target should not enable
6067	separate shrink-wrapping. */
6068	if (crtl->shrink_wrapped_separate)
6069	{
6070	split_prologue_seq = make_split_prologue_seq ();
6071	prologue_seq = make_prologue_seq ();
6072	epilogue_seq = make_epilogue_seq ();
6073	}
6074
6075	rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun));
6076
6077	/* A small fib -- epilogue is not yet completed, but we wish to re-use
6078	this marker for the splits of EH_RETURN patterns, and nothing else
6079	uses the flag in the meantime. */
6080	epilogue_completed = 1;
6081
6082	/* Find non-fallthru edges that end with EH_RETURN instructions. On
6083	some targets, these get split to a special version of the epilogue
6084	code. In order to be able to properly annotate these with unwind
6085	info, try to split them now. If we get a valid split, drop an
6086	EPILOGUE_BEG note and mark the insns as epilogue insns. */
6087	edge e;
6088	edge_iterator ei;
6089	FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
6090	{
6091	rtx_insn *prev, *last, *trial;
6092
6093	if (e->flags & EDGE_FALLTHRU)
6094	continue;
6095	last = BB_END (e->src);
6096	if (!eh_returnjump_p (last))
6097	continue;
6098
6099	prev = PREV_INSN (insn: last);
6100	trial = try_split (PATTERN (insn: last), last, 1);
6101	if (trial == last)
6102	continue;
6103
6104	record_insns (insns: NEXT_INSN (insn: prev), end: NEXT_INSN (insn: trial), hashp: &epilogue_insn_hash);
6105	emit_note_after (NOTE_INSN_EPILOGUE_BEG, prev);
6106	}
6107
6108	edge exit_fallthru_edge = find_fallthru_edge (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds);
6109
6110	if (exit_fallthru_edge)
6111	{
6112	if (epilogue_seq)
6113	{
6114	insert_insn_on_edge (epilogue_seq, exit_fallthru_edge);
6115	commit_edge_insertions ();
6116
6117	/* The epilogue insns we inserted may cause the exit edge to no longer
6118	be fallthru. */
6119	FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
6120	{
6121	if (((e->flags & EDGE_FALLTHRU) != 0)
6122	&& returnjump_p (BB_END (e->src)))
6123	e->flags &= ~EDGE_FALLTHRU;
6124	}
6125
6126	find_sub_basic_blocks (BLOCK_FOR_INSN (insn: epilogue_seq));
6127	}
6128	else if (next_active_insn (BB_END (exit_fallthru_edge->src)))
6129	{
6130	/* We have a fall-through edge to the exit block, the source is not
6131	at the end of the function, and there will be an assembler epilogue
6132	at the end of the function.
6133	We can't use force_nonfallthru here, because that would try to
6134	use return. Inserting a jump 'by hand' is extremely messy, so
6135	we take advantage of cfg_layout_finalize using
6136	fixup_fallthru_exit_predecessor. */
6137	cfg_layout_initialize (0);
6138	basic_block cur_bb;
6139	FOR_EACH_BB_FN (cur_bb, cfun)
6140	if (cur_bb->index >= NUM_FIXED_BLOCKS
6141	&& cur_bb->next_bb->index >= NUM_FIXED_BLOCKS)
6142	cur_bb->aux = cur_bb->next_bb;
6143	cfg_layout_finalize ();
6144	}
6145	}
6146
6147	/* Insert the prologue. */
6148
6149	rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun));
6150
6151	if (split_prologue_seq || prologue_seq)
6152	{
6153	rtx_insn *split_prologue_insn = split_prologue_seq;
6154	if (split_prologue_seq)
6155	{
6156	while (split_prologue_insn && !NONDEBUG_INSN_P (split_prologue_insn))
6157	split_prologue_insn = NEXT_INSN (insn: split_prologue_insn);
6158	insert_insn_on_edge (split_prologue_seq, orig_entry_edge);
6159	}
6160
6161	rtx_insn *prologue_insn = prologue_seq;
6162	if (prologue_seq)
6163	{
6164	while (prologue_insn && !NONDEBUG_INSN_P (prologue_insn))
6165	prologue_insn = NEXT_INSN (insn: prologue_insn);
6166	insert_insn_on_edge (prologue_seq, entry_edge);
6167	}
6168
6169	commit_edge_insertions ();
6170
6171	/* Look for basic blocks within the prologue insns. */
6172	if (split_prologue_insn
6173	&& BLOCK_FOR_INSN (insn: split_prologue_insn) == NULL)
6174	split_prologue_insn = NULL;
6175	if (prologue_insn
6176	&& BLOCK_FOR_INSN (insn: prologue_insn) == NULL)
6177	prologue_insn = NULL;
6178	if (split_prologue_insn || prologue_insn)
6179	{
6180	auto_sbitmap blocks (last_basic_block_for_fn (cfun));
6181	bitmap_clear (blocks);
6182	if (split_prologue_insn)
6183	bitmap_set_bit (map: blocks,
6184	bitno: BLOCK_FOR_INSN (insn: split_prologue_insn)->index);
6185	if (prologue_insn)
6186	bitmap_set_bit (map: blocks, bitno: BLOCK_FOR_INSN (insn: prologue_insn)->index);
6187	find_many_sub_basic_blocks (blocks);
6188	}
6189	}
6190
6191	default_rtl_profile ();
6192
6193	/* Emit sibling epilogues before any sibling call sites. */
6194	for (ei = ei_start (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds);
6195	(e = ei_safe_edge (i: ei));
6196	ei_next (i: &ei))
6197	{
6198	/* Skip those already handled, the ones that run without prologue. */
6199	if (e->flags & EDGE_IGNORE)
6200	{
6201	e->flags &= ~EDGE_IGNORE;
6202	continue;
6203	}
6204
6205	rtx_insn *insn = BB_END (e->src);
6206
6207	if (!(CALL_P (insn) && SIBLING_CALL_P (insn)))
6208	continue;
6209
6210	if (rtx_insn *ep_seq = targetm.gen_sibcall_epilogue ())
6211	{
6212	start_sequence ();
6213	emit_note (NOTE_INSN_EPILOGUE_BEG);
6214	emit_insn (ep_seq);
6215	rtx_insn *seq = get_insns ();
6216	end_sequence ();
6217
6218	/* Retain a map of the epilogue insns. Used in life analysis to
6219	avoid getting rid of sibcall epilogue insns. Do this before we
6220	actually emit the sequence. */
6221	record_insns (insns: seq, NULL, hashp: &epilogue_insn_hash);
6222	set_insn_locations (seq, epilogue_location);
6223
6224	emit_insn_before (seq, insn);
6225
6226	find_sub_basic_blocks (BLOCK_FOR_INSN (insn));
6227	}
6228	}
6229
6230	if (epilogue_seq)
6231	{
6232	rtx_insn *insn, *next;
6233
6234	/* Similarly, move any line notes that appear after the epilogue.
6235	There is no need, however, to be quite so anal about the existence
6236	of such a note. Also possibly move
6237	NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
6238	info generation. */
6239	for (insn = epilogue_seq; insn; insn = next)
6240	{
6241	next = NEXT_INSN (insn);
6242	if (NOTE_P (insn)
6243	&& (NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG))
6244	reorder_insns (insn, insn, PREV_INSN (insn: epilogue_seq));
6245	}
6246	}
6247
6248	/* Threading the prologue and epilogue changes the artificial refs in the
6249	entry and exit blocks, and may invalidate DF info for tail calls. */
6250	if (optimize
6251	|| flag_optimize_sibling_calls
6252	|| flag_ipa_icf_functions
6253	|| in_lto_p)
6254	df_update_entry_exit_and_calls ();
6255	else
6256	{
6257	df_update_entry_block_defs ();
6258	df_update_exit_block_uses ();
6259	}
6260	}
6261
6262	/* Reposition the prologue-end and epilogue-begin notes after
6263	instruction scheduling. */
6264
6265	void
6266	reposition_prologue_and_epilogue_notes (void)
6267	{
6268	if (!targetm.have_prologue ()
6269	&& !targetm.have_epilogue ()
6270	&& !targetm.have_sibcall_epilogue ())
6271	return;
6272
6273	/* Since the hash table is created on demand, the fact that it is
6274	non-null is a signal that it is non-empty. */
6275	if (prologue_insn_hash != NULL)
6276	{
6277	size_t len = prologue_insn_hash->elements ();
6278	rtx_insn *insn, *last = NULL, *note = NULL;
6279
6280	/* Scan from the beginning until we reach the last prologue insn. */
6281	/* ??? While we do have the CFG intact, there are two problems:
6282	(1) The prologue can contain loops (typically probing the stack),
6283	which means that the end of the prologue isn't in the first bb.
6284	(2) Sometimes the PROLOGUE_END note gets pushed into the next bb. */
6285	for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
6286	{
6287	if (NOTE_P (insn))
6288	{
6289	if (NOTE_KIND (insn) == NOTE_INSN_PROLOGUE_END)
6290	note = insn;
6291	}
6292	else if (contains (insn, hash: prologue_insn_hash))
6293	{
6294	last = insn;
6295	if (--len == 0)
6296	break;
6297	}
6298	}
6299
6300	if (last)
6301	{
6302	if (note == NULL)
6303	{
6304	/* Scan forward looking for the PROLOGUE_END note. It should
6305	be right at the beginning of the block, possibly with other
6306	insn notes that got moved there. */
6307	for (note = NEXT_INSN (insn: last); ; note = NEXT_INSN (insn: note))
6308	{
6309	if (NOTE_P (note)
6310	&& NOTE_KIND (note) == NOTE_INSN_PROLOGUE_END)
6311	break;
6312	}
6313	}
6314
6315	/* Avoid placing note between CODE_LABEL and BASIC_BLOCK note. */
6316	if (LABEL_P (last))
6317	last = NEXT_INSN (insn: last);
6318	reorder_insns (note, note, last);
6319	}
6320	}
6321
6322	if (epilogue_insn_hash != NULL)
6323	{
6324	edge_iterator ei;
6325	edge e;
6326
6327	FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
6328	{
6329	rtx_insn *insn, *first = NULL, *note = NULL;
6330	basic_block bb = e->src;
6331
6332	/* Scan from the beginning until we reach the first epilogue insn. */
6333	FOR_BB_INSNS (bb, insn)
6334	{
6335	if (NOTE_P (insn))
6336	{
6337	if (NOTE_KIND (insn) == NOTE_INSN_EPILOGUE_BEG)
6338	{
6339	note = insn;
6340	if (first != NULL)
6341	break;
6342	}
6343	}
6344	else if (first == NULL && contains (insn, hash: epilogue_insn_hash))
6345	{
6346	first = insn;
6347	if (note != NULL)
6348	break;
6349	}
6350	}
6351
6352	if (note)
6353	{
6354	/* If the function has a single basic block, and no real
6355	epilogue insns (e.g. sibcall with no cleanup), the
6356	epilogue note can get scheduled before the prologue
6357	note. If we have frame related prologue insns, having
6358	them scanned during the epilogue will result in a crash.
6359	In this case re-order the epilogue note to just before
6360	the last insn in the block. */
6361	if (first == NULL)
6362	first = BB_END (bb);
6363
6364	if (PREV_INSN (insn: first) != note)
6365	reorder_insns (note, note, PREV_INSN (insn: first));
6366	}
6367	}
6368	}
6369	}
6370
6371	/* Returns the name of function declared by FNDECL. */
6372	const char *
6373	fndecl_name (tree fndecl)
6374	{
6375	if (fndecl == NULL)
6376	return "(nofn)";
6377	return lang_hooks.decl_printable_name (fndecl, 1);
6378	}
6379
6380	/* Returns the name of function FN. */
6381	const char *
6382	function_name (struct function *fn)
6383	{
6384	tree fndecl = (fn == NULL) ? NULL : fn->decl;
6385	return fndecl_name (fndecl);
6386	}
6387
6388	/* Returns the name of the current function. */
6389	const char *
6390	current_function_name (void)
6391	{
6392	return function_name (fn: cfun);
6393	}
6394
6395
6396	static void
6397	rest_of_handle_check_leaf_regs (void)
6398	{
6399	#ifdef LEAF_REGISTERS
6400	crtl->uses_only_leaf_regs
6401	= optimize > 0 && only_leaf_regs_used () && leaf_function_p ();
6402	#endif
6403	}
6404
6405	/* Insert a TYPE into the used types hash table of CFUN. */
6406
6407	static void
6408	used_types_insert_helper (tree type, struct function *func)
6409	{
6410	if (type != NULL && func != NULL)
6411	{
6412	if (func->used_types_hash == NULL)
6413	func->used_types_hash = hash_set<tree>::create_ggc (n: 37);
6414
6415	func->used_types_hash->add (k: type);
6416	}
6417	}
6418
6419	/* Given a type, insert it into the used hash table in cfun. */
6420	void
6421	used_types_insert (tree t)
6422	{
6423	while (POINTER_TYPE_P (t) || TREE_CODE (t) == ARRAY_TYPE)
6424	if (TYPE_NAME (t))
6425	break;
6426	else
6427	t = TREE_TYPE (t);
6428	if (TREE_CODE (t) == ERROR_MARK)
6429	return;
6430	if (TYPE_NAME (t) == NULL_TREE
6431	|| TYPE_NAME (t) == TYPE_NAME (TYPE_MAIN_VARIANT (t)))
6432	t = TYPE_MAIN_VARIANT (t);
6433	if (debug_info_level > DINFO_LEVEL_NONE)
6434	{
6435	if (cfun)
6436	used_types_insert_helper (type: t, func: cfun);
6437	else
6438	{
6439	/* So this might be a type referenced by a global variable.
6440	Record that type so that we can later decide to emit its
6441	debug information. */
6442	vec_safe_push (v&: types_used_by_cur_var_decl, obj: t);
6443	}
6444	}
6445	}
6446
6447	/* Helper to Hash a struct types_used_by_vars_entry. */
6448
6449	static hashval_t
6450	hash_types_used_by_vars_entry (const struct types_used_by_vars_entry *entry)
6451	{
6452	gcc_assert (entry && entry->var_decl && entry->type);
6453
6454	return iterative_hash_object (entry->type,
6455	iterative_hash_object (entry->var_decl, 0));
6456	}
6457
6458	/* Hash function of the types_used_by_vars_entry hash table. */
6459
6460	hashval_t
6461	used_type_hasher::hash (types_used_by_vars_entry *entry)
6462	{
6463	return hash_types_used_by_vars_entry (entry);
6464	}
6465
6466	/*Equality function of the types_used_by_vars_entry hash table. */
6467
6468	bool
6469	used_type_hasher::equal (types_used_by_vars_entry *e1,
6470	types_used_by_vars_entry *e2)
6471	{
6472	return (e1->var_decl == e2->var_decl && e1->type == e2->type);
6473	}
6474
6475	/* Inserts an entry into the types_used_by_vars_hash hash table. */
6476
6477	void
6478	types_used_by_var_decl_insert (tree type, tree var_decl)
6479	{
6480	if (type != NULL && var_decl != NULL)
6481	{
6482	types_used_by_vars_entry **slot;
6483	struct types_used_by_vars_entry e;
6484	e.var_decl = var_decl;
6485	e.type = type;
6486	if (types_used_by_vars_hash == NULL)
6487	types_used_by_vars_hash
6488	= hash_table<used_type_hasher>::create_ggc (n: 37);
6489
6490	slot = types_used_by_vars_hash->find_slot (value: &e, insert: INSERT);
6491	if (*slot == NULL)
6492	{
6493	struct types_used_by_vars_entry *entry;
6494	entry = ggc_alloc<types_used_by_vars_entry> ();
6495	entry->type = type;
6496	entry->var_decl = var_decl;
6497	*slot = entry;
6498	}
6499	}
6500	}
6501
6502	namespace {
6503
6504	const pass_data pass_data_leaf_regs =
6505	{
6506	.type: RTL_PASS, /* type */
6507	.name: "*leaf_regs", /* name */
6508	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
6509	.tv_id: TV_NONE, /* tv_id */
6510	.properties_required: 0, /* properties_required */
6511	.properties_provided: 0, /* properties_provided */
6512	.properties_destroyed: 0, /* properties_destroyed */
6513	.todo_flags_start: 0, /* todo_flags_start */
6514	.todo_flags_finish: 0, /* todo_flags_finish */
6515	};
6516
6517	class pass_leaf_regs : public rtl_opt_pass
6518	{
6519	public:
6520	pass_leaf_regs (gcc::context *ctxt)
6521	: rtl_opt_pass (pass_data_leaf_regs, ctxt)
6522	{}
6523
6524	/* opt_pass methods: */
6525	unsigned int execute (function *) final override
6526	{
6527	rest_of_handle_check_leaf_regs ();
6528	return 0;
6529	}
6530
6531	}; // class pass_leaf_regs
6532
6533	} // anon namespace
6534
6535	rtl_opt_pass *
6536	make_pass_leaf_regs (gcc::context *ctxt)
6537	{
6538	return new pass_leaf_regs (ctxt);
6539	}
6540
6541	static void
6542	rest_of_handle_thread_prologue_and_epilogue (function *fun)
6543	{
6544	/* prepare_shrink_wrap is sensitive to the block structure of the control
6545	flow graph, so clean it up first. */
6546	if (optimize)
6547	cleanup_cfg (0);
6548
6549	/* On some machines, the prologue and epilogue code, or parts thereof,
6550	can be represented as RTL. Doing so lets us schedule insns between
6551	it and the rest of the code and also allows delayed branch
6552	scheduling to operate in the epilogue. */
6553	thread_prologue_and_epilogue_insns ();
6554
6555	/* Some non-cold blocks may now be only reachable from cold blocks.
6556	Fix that up. */
6557	fixup_partitions ();
6558
6559	/* After prologue and epilogue generation, the judgement on whether
6560	one memory access onto stack frame may trap or not could change,
6561	since we get more exact stack information by now. So try to
6562	remove any EH edges here, see PR90259. */
6563	if (fun->can_throw_non_call_exceptions)
6564	purge_all_dead_edges ();
6565
6566	/* Shrink-wrapping can result in unreachable edges in the epilogue,
6567	see PR57320. */
6568	cleanup_cfg (optimize ? CLEANUP_EXPENSIVE : 0);
6569
6570	/* The stack usage info is finalized during prologue expansion. */
6571	if (flag_stack_usage_info || flag_callgraph_info)
6572	output_stack_usage ();
6573	}
6574
6575	/* Record a final call to CALLEE at LOCATION. */
6576
6577	void
6578	record_final_call (tree callee, location_t location)
6579	{
6580	struct callinfo_callee datum = { .location: location, .decl: callee };
6581	vec_safe_push (v&: cfun->su->callees, obj: datum);
6582	}
6583
6584	/* Record a dynamic allocation made for DECL_OR_EXP. */
6585
6586	void
6587	record_dynamic_alloc (tree decl_or_exp)
6588	{
6589	struct callinfo_dalloc datum;
6590
6591	if (DECL_P (decl_or_exp))
6592	{
6593	datum.location = DECL_SOURCE_LOCATION (decl_or_exp);
6594	const char *name = lang_hooks.decl_printable_name (decl_or_exp, 2);
6595	const char *dot = strrchr (s: name, c: '.');
6596	if (dot)
6597	name = dot + 1;
6598	datum.name = ggc_strdup (name);
6599	}
6600	else
6601	{
6602	datum.location = EXPR_LOCATION (decl_or_exp);
6603	datum.name = NULL;
6604	}
6605
6606	vec_safe_push (v&: cfun->su->dallocs, obj: datum);
6607	}
6608
6609	namespace {
6610
6611	const pass_data pass_data_thread_prologue_and_epilogue =
6612	{
6613	.type: RTL_PASS, /* type */
6614	.name: "pro_and_epilogue", /* name */
6615	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
6616	.tv_id: TV_THREAD_PROLOGUE_AND_EPILOGUE, /* tv_id */
6617	.properties_required: 0, /* properties_required */
6618	.properties_provided: 0, /* properties_provided */
6619	.properties_destroyed: 0, /* properties_destroyed */
6620	.todo_flags_start: 0, /* todo_flags_start */
6621	.todo_flags_finish: ( TODO_df_verify | TODO_df_finish ), /* todo_flags_finish */
6622	};
6623
6624	class pass_thread_prologue_and_epilogue : public rtl_opt_pass
6625	{
6626	public:
6627	pass_thread_prologue_and_epilogue (gcc::context *ctxt)
6628	: rtl_opt_pass (pass_data_thread_prologue_and_epilogue, ctxt)
6629	{}
6630
6631	/* opt_pass methods: */
6632	unsigned int execute (function * fun) final override
6633	{
6634	rest_of_handle_thread_prologue_and_epilogue (fun);
6635	return 0;
6636	}
6637
6638	}; // class pass_thread_prologue_and_epilogue
6639
6640	} // anon namespace
6641
6642	rtl_opt_pass *
6643	make_pass_thread_prologue_and_epilogue (gcc::context *ctxt)
6644	{
6645	return new pass_thread_prologue_and_epilogue (ctxt);
6646	}
6647
6648	namespace {
6649
6650	const pass_data pass_data_zero_call_used_regs =
6651	{
6652	.type: RTL_PASS, /* type */
6653	.name: "zero_call_used_regs", /* name */
6654	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
6655	.tv_id: TV_NONE, /* tv_id */
6656	.properties_required: 0, /* properties_required */
6657	.properties_provided: 0, /* properties_provided */
6658	.properties_destroyed: 0, /* properties_destroyed */
6659	.todo_flags_start: 0, /* todo_flags_start */
6660	.todo_flags_finish: 0, /* todo_flags_finish */
6661	};
6662
6663	class pass_zero_call_used_regs: public rtl_opt_pass
6664	{
6665	public:
6666	pass_zero_call_used_regs (gcc::context *ctxt)
6667	: rtl_opt_pass (pass_data_zero_call_used_regs, ctxt)
6668	{}
6669
6670	/* opt_pass methods: */
6671	unsigned int execute (function *) final override;
6672
6673	}; // class pass_zero_call_used_regs
6674
6675	unsigned int
6676	pass_zero_call_used_regs::execute (function *fun)
6677	{
6678	using namespace zero_regs_flags;
6679	unsigned int zero_regs_type = UNSET;
6680
6681	tree attr_zero_regs = lookup_attribute (attr_name: "zero_call_used_regs",
6682	DECL_ATTRIBUTES (fun->decl));
6683
6684	/* Get the type of zero_call_used_regs from function attribute.
6685	We have filtered out invalid attribute values already at this point. */
6686	if (attr_zero_regs)
6687	{
6688	/* The TREE_VALUE of an attribute is a TREE_LIST whose TREE_VALUE
6689	is the attribute argument's value. */
6690	attr_zero_regs = TREE_VALUE (attr_zero_regs);
6691	gcc_assert (TREE_CODE (attr_zero_regs) == TREE_LIST);
6692	attr_zero_regs = TREE_VALUE (attr_zero_regs);
6693	gcc_assert (TREE_CODE (attr_zero_regs) == STRING_CST);
6694
6695	for (unsigned int i = 0; zero_call_used_regs_opts[i].name != NULL; ++i)
6696	if (strcmp (TREE_STRING_POINTER (attr_zero_regs),
6697	s2: zero_call_used_regs_opts[i].name) == 0)
6698	{
6699	zero_regs_type = zero_call_used_regs_opts[i].flag;
6700	break;
6701	}
6702	}
6703
6704	if (!zero_regs_type)
6705	zero_regs_type = flag_zero_call_used_regs;
6706
6707	/* No need to zero call-used-regs when no user request is present. */
6708	if (!(zero_regs_type & ENABLED))
6709	return 0;
6710
6711	edge_iterator ei;
6712	edge e;
6713
6714	/* This pass needs data flow information. */
6715	df_analyze ();
6716
6717	/* Iterate over the function's return instructions and insert any
6718	register zeroing required by the -fzero-call-used-regs command-line
6719	option or the "zero_call_used_regs" function attribute. */
6720	FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
6721	{
6722	rtx_insn *insn = BB_END (e->src);
6723	if (JUMP_P (insn) && ANY_RETURN_P (JUMP_LABEL (insn)))
6724	gen_call_used_regs_seq (ret: insn, zero_regs_type);
6725	}
6726
6727	return 0;
6728	}
6729
6730	} // anon namespace
6731
6732	rtl_opt_pass *
6733	make_pass_zero_call_used_regs (gcc::context *ctxt)
6734	{
6735	return new pass_zero_call_used_regs (ctxt);
6736	}
6737
6738	/* If CONSTRAINT is a matching constraint, then return its number.
6739	Otherwise, return -1. */
6740
6741	static int
6742	matching_constraint_num (const char *constraint)
6743	{
6744	if (*constraint == '%')
6745	constraint++;
6746
6747	if (IN_RANGE (*constraint, '0', '9'))
6748	return strtoul (nptr: constraint, NULL, base: 10);
6749
6750	return -1;
6751	}
6752
6753	/* This mini-pass fixes fall-out from SSA in asm statements that have
6754	in-out constraints. Say you start with
6755
6756	orig = inout;
6757	asm ("": "+mr" (inout));
6758	use (orig);
6759
6760	which is transformed very early to use explicit output and match operands:
6761
6762	orig = inout;
6763	asm ("": "=mr" (inout) : "0" (inout));
6764	use (orig);
6765
6766	Or, after SSA and copyprop,
6767
6768	asm ("": "=mr" (inout_2) : "0" (inout_1));
6769	use (inout_1);
6770
6771	Clearly inout_2 and inout_1 can't be coalesced easily anymore, as
6772	they represent two separate values, so they will get different pseudo
6773	registers during expansion. Then, since the two operands need to match
6774	per the constraints, but use different pseudo registers, reload can
6775	only register a reload for these operands. But reloads can only be
6776	satisfied by hardregs, not by memory, so we need a register for this
6777	reload, just because we are presented with non-matching operands.
6778	So, even though we allow memory for this operand, no memory can be
6779	used for it, just because the two operands don't match. This can
6780	cause reload failures on register-starved targets.
6781
6782	So it's a symptom of reload not being able to use memory for reloads
6783	or, alternatively it's also a symptom of both operands not coming into
6784	reload as matching (in which case the pseudo could go to memory just
6785	fine, as the alternative allows it, and no reload would be necessary).
6786	We fix the latter problem here, by transforming
6787
6788	asm ("": "=mr" (inout_2) : "0" (inout_1));
6789
6790	back to
6791
6792	inout_2 = inout_1;
6793	asm ("": "=mr" (inout_2) : "0" (inout_2)); */
6794
6795	static void
6796	match_asm_constraints_1 (rtx_insn *insn, rtx *p_sets, int noutputs)
6797	{
6798	int i;
6799	bool changed = false;
6800	rtx op = SET_SRC (p_sets[0]);
6801	int ninputs = ASM_OPERANDS_INPUT_LENGTH (op);
6802	rtvec inputs = ASM_OPERANDS_INPUT_VEC (op);
6803	bool *output_matched = XALLOCAVEC (bool, noutputs);
6804
6805	memset (s: output_matched, c: 0, n: noutputs * sizeof (bool));
6806	for (i = 0; i < ninputs; i++)
6807	{
6808	rtx input, output;
6809	rtx_insn *insns;
6810	const char *constraint = ASM_OPERANDS_INPUT_CONSTRAINT (op, i);
6811	int match, j;
6812
6813	match = matching_constraint_num (constraint);
6814	if (match < 0)
6815	continue;
6816
6817	gcc_assert (match < noutputs);
6818	output = SET_DEST (p_sets[match]);
6819	input = RTVEC_ELT (inputs, i);
6820	/* Only do the transformation for pseudos. */
6821	if (! REG_P (output)
6822	|| rtx_equal_p (output, input)
6823	|| !(REG_P (input) || SUBREG_P (input)
6824	|| MEM_P (input) || CONSTANT_P (input))
6825	|| !general_operand (input, GET_MODE (output)))
6826	continue;
6827
6828	/* We can't do anything if the output is also used as input,
6829	as we're going to overwrite it. */
6830	for (j = 0; j < ninputs; j++)
6831	if (reg_overlap_mentioned_p (output, RTVEC_ELT (inputs, j)))
6832	break;
6833	if (j != ninputs)
6834	continue;
6835
6836	/* Avoid changing the same input several times. For
6837	asm ("" : "=mr" (out1), "=mr" (out2) : "0" (in), "1" (in));
6838	only change it once (to out1), rather than changing it
6839	first to out1 and afterwards to out2. */
6840	if (i > 0)
6841	{
6842	for (j = 0; j < noutputs; j++)
6843	if (output_matched[j] && input == SET_DEST (p_sets[j]))
6844	break;
6845	if (j != noutputs)
6846	continue;
6847	}
6848	output_matched[match] = true;
6849
6850	start_sequence ();
6851	emit_move_insn (output, copy_rtx (input));
6852	insns = get_insns ();
6853	end_sequence ();
6854	emit_insn_before (insns, insn);
6855
6856	constraint = ASM_OPERANDS_OUTPUT_CONSTRAINT(SET_SRC(p_sets[match]));
6857	bool early_clobber_p = strchr (s: constraint, c: '&') != NULL;
6858
6859	/* Now replace all mentions of the input with output. We can't
6860	just replace the occurrence in inputs[i], as the register might
6861	also be used in some other input (or even in an address of an
6862	output), which would mean possibly increasing the number of
6863	inputs by one (namely 'output' in addition), which might pose
6864	a too complicated problem for reload to solve. E.g. this situation:
6865
6866	asm ("" : "=r" (output), "=m" (input) : "0" (input))
6867
6868	Here 'input' is used in two occurrences as input (once for the
6869	input operand, once for the address in the second output operand).
6870	If we would replace only the occurrence of the input operand (to
6871	make the matching) we would be left with this:
6872
6873	output = input
6874	asm ("" : "=r" (output), "=m" (input) : "0" (output))
6875
6876	Now we suddenly have two different input values (containing the same
6877	value, but different pseudos) where we formerly had only one.
6878	With more complicated asms this might lead to reload failures
6879	which wouldn't have happen without this pass. So, iterate over
6880	all operands and replace all occurrences of the register used.
6881
6882	However, if one or more of the 'input' uses have a non-matching
6883	constraint and the matched output operand is an early clobber
6884	operand, then do not replace the input operand, since by definition
6885	it conflicts with the output operand and cannot share the same
6886	register. See PR89313 for details. */
6887
6888	for (j = 0; j < noutputs; j++)
6889	if (!rtx_equal_p (SET_DEST (p_sets[j]), input)
6890	&& reg_overlap_mentioned_p (input, SET_DEST (p_sets[j])))
6891	SET_DEST (p_sets[j]) = replace_rtx (SET_DEST (p_sets[j]),
6892	input, output);
6893	for (j = 0; j < ninputs; j++)
6894	if (reg_overlap_mentioned_p (input, RTVEC_ELT (inputs, j)))
6895	{
6896	if (!early_clobber_p
6897	|| match == matching_constraint_num
6898	(ASM_OPERANDS_INPUT_CONSTRAINT (op, j)))
6899	RTVEC_ELT (inputs, j) = replace_rtx (RTVEC_ELT (inputs, j),
6900	input, output);
6901	}
6902
6903	changed = true;
6904	}
6905
6906	if (changed)
6907	df_insn_rescan (insn);
6908	}
6909
6910	/* Add the decl D to the local_decls list of FUN. */
6911
6912	void
6913	add_local_decl (struct function *fun, tree d)
6914	{
6915	gcc_assert (VAR_P (d));
6916	vec_safe_push (v&: fun->local_decls, obj: d);
6917	}
6918
6919	namespace {
6920
6921	const pass_data pass_data_match_asm_constraints =
6922	{
6923	.type: RTL_PASS, /* type */
6924	.name: "asmcons", /* name */
6925	.optinfo_flags: OPTGROUP_NONE, /* optinfo_flags */
6926	.tv_id: TV_NONE, /* tv_id */
6927	.properties_required: 0, /* properties_required */
6928	.properties_provided: 0, /* properties_provided */
6929	.properties_destroyed: 0, /* properties_destroyed */
6930	.todo_flags_start: 0, /* todo_flags_start */
6931	.todo_flags_finish: 0, /* todo_flags_finish */
6932	};
6933
6934	class pass_match_asm_constraints : public rtl_opt_pass
6935	{
6936	public:
6937	pass_match_asm_constraints (gcc::context *ctxt)
6938	: rtl_opt_pass (pass_data_match_asm_constraints, ctxt)
6939	{}
6940
6941	/* opt_pass methods: */
6942	unsigned int execute (function *) final override;
6943
6944	}; // class pass_match_asm_constraints
6945
6946	unsigned
6947	pass_match_asm_constraints::execute (function *fun)
6948	{
6949	basic_block bb;
6950	rtx_insn *insn;
6951	rtx pat, *p_sets;
6952	int noutputs;
6953
6954	if (!crtl->has_asm_statement)
6955	return 0;
6956
6957	df_set_flags (DF_DEFER_INSN_RESCAN);
6958	FOR_EACH_BB_FN (bb, fun)
6959	{
6960	FOR_BB_INSNS (bb, insn)
6961	{
6962	if (!INSN_P (insn))
6963	continue;
6964
6965	pat = PATTERN (insn);
6966	if (GET_CODE (pat) == PARALLEL)
6967	p_sets = &XVECEXP (pat, 0, 0), noutputs = XVECLEN (pat, 0);
6968	else if (GET_CODE (pat) == SET)
6969	p_sets = &PATTERN (insn), noutputs = 1;
6970	else
6971	continue;
6972
6973	if (GET_CODE (*p_sets) == SET
6974	&& GET_CODE (SET_SRC (*p_sets)) == ASM_OPERANDS)
6975	match_asm_constraints_1 (insn, p_sets, noutputs);
6976	}
6977	}
6978
6979	return TODO_df_finish;
6980	}
6981
6982	} // anon namespace
6983
6984	rtl_opt_pass *
6985	make_pass_match_asm_constraints (gcc::context *ctxt)
6986	{
6987	return new pass_match_asm_constraints (ctxt);
6988	}
6989
6990
6991	#include "gt-function.h"
6992