1	/* IRA hard register and memory cost calculation for allocnos or pseudos.
2	Copyright (C) 2006-2023 Free Software Foundation, Inc.
3	Contributed by Vladimir Makarov <vmakarov@redhat.com>.
4
5	This file is part of GCC.
6
7	GCC is free software; you can redistribute it and/or modify it under
8	the terms of the GNU General Public License as published by the Free
9	Software Foundation; either version 3, or (at your option) any later
10	version.
11
12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15	for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with GCC; see the file COPYING3. If not see
19	<http://www.gnu.org/licenses/>. */
20
21	#include "config.h"
22	#include "system.h"
23	#include "coretypes.h"
24	#include "backend.h"
25	#include "target.h"
26	#include "rtl.h"
27	#include "tree.h"
28	#include "predict.h"
29	#include "memmodel.h"
30	#include "tm_p.h"
31	#include "insn-config.h"
32	#include "regs.h"
33	#include "regset.h"
34	#include "ira.h"
35	#include "ira-int.h"
36	#include "addresses.h"
37	#include "reload.h"
38	#include "print-rtl.h"
39
40	/* The flags is set up every time when we calculate pseudo register
41	classes through function ira_set_pseudo_classes. */
42	static bool pseudo_classes_defined_p = false;
43
44	/* TRUE if we work with allocnos. Otherwise we work with pseudos. */
45	static bool allocno_p;
46
47	/* Number of elements in array `costs'. */
48	static int cost_elements_num;
49
50	/* The `costs' struct records the cost of using hard registers of each
51	class considered for the calculation and of using memory for each
52	allocno or pseudo. */
53	struct costs
54	{
55	int mem_cost;
56	/* Costs for register classes start here. We process only some
57	allocno classes. */
58	int cost[1];
59	};
60
61	#define max_struct_costs_size \
62	(this_target_ira_int->x_max_struct_costs_size)
63	#define init_cost \
64	(this_target_ira_int->x_init_cost)
65	#define temp_costs \
66	(this_target_ira_int->x_temp_costs)
67	#define op_costs \
68	(this_target_ira_int->x_op_costs)
69	#define this_op_costs \
70	(this_target_ira_int->x_this_op_costs)
71
72	/* Costs of each class for each allocno or pseudo. */
73	static struct costs *costs;
74
75	/* Accumulated costs of each class for each allocno. */
76	static struct costs *total_allocno_costs;
77
78	/* It is the current size of struct costs. */
79	static size_t struct_costs_size;
80
81	/* Return pointer to structure containing costs of allocno or pseudo
82	with given NUM in array ARR. */
83	#define COSTS(arr, num) \
84	((struct costs *) ((char *) (arr) + (num) * struct_costs_size))
85
86	/* Return index in COSTS when processing reg with REGNO. */
87	#define COST_INDEX(regno) (allocno_p \
88	? ALLOCNO_NUM (ira_curr_regno_allocno_map[regno]) \
89	: (int) regno)
90
91	/* Record register class preferences of each allocno or pseudo. Null
92	value means no preferences. It happens on the 1st iteration of the
93	cost calculation. */
94	static enum reg_class *pref;
95
96	/* Allocated buffers for pref. */
97	static enum reg_class *pref_buffer;
98
99	/* Record allocno class of each allocno with the same regno. */
100	static enum reg_class *regno_aclass;
101
102	/* Record cost gains for not allocating a register with an invariant
103	equivalence. */
104	static int *regno_equiv_gains;
105
106	/* Execution frequency of the current insn. */
107	static int frequency;
108
109
110
111	/* Info about reg classes whose costs are calculated for a pseudo. */
112	struct cost_classes
113	{
114	/* Number of the cost classes in the subsequent array. */
115	int num;
116	/* Container of the cost classes. */
117	enum reg_class classes[N_REG_CLASSES];
118	/* Map reg class -> index of the reg class in the previous array.
119	-1 if it is not a cost class. */
120	int index[N_REG_CLASSES];
121	/* Map hard regno index of first class in array CLASSES containing
122	the hard regno, -1 otherwise. */
123	int hard_regno_index[FIRST_PSEUDO_REGISTER];
124	};
125
126	/* Types of pointers to the structure above. */
127	typedef struct cost_classes *cost_classes_t;
128	typedef const struct cost_classes *const_cost_classes_t;
129
130	/* Info about cost classes for each pseudo. */
131	static cost_classes_t *regno_cost_classes;
132
133	/* Helper for cost_classes hashing. */
134
135	struct cost_classes_hasher : pointer_hash <cost_classes>
136	{
137	static inline hashval_t hash (const cost_classes *);
138	static inline bool equal (const cost_classes *, const cost_classes *);
139	static inline void remove (cost_classes *);
140	};
141
142	/* Returns hash value for cost classes info HV. */
143	inline hashval_t
144	cost_classes_hasher::hash (const cost_classes *hv)
145	{
146	return iterative_hash (&hv->classes, sizeof (enum reg_class) * hv->num, 0);
147	}
148
149	/* Compares cost classes info HV1 and HV2. */
150	inline bool
151	cost_classes_hasher::equal (const cost_classes *hv1, const cost_classes *hv2)
152	{
153	return (hv1->num == hv2->num
154	&& memcmp (s1: hv1->classes, s2: hv2->classes,
155	n: sizeof (enum reg_class) * hv1->num) == 0);
156	}
157
158	/* Delete cost classes info V from the hash table. */
159	inline void
160	cost_classes_hasher::remove (cost_classes *v)
161	{
162	ira_free (addr: v);
163	}
164
165	/* Hash table of unique cost classes. */
166	static hash_table<cost_classes_hasher> *cost_classes_htab;
167
168	/* Map allocno class -> cost classes for pseudo of given allocno
169	class. */
170	static cost_classes_t cost_classes_aclass_cache[N_REG_CLASSES];
171
172	/* Map mode -> cost classes for pseudo of give mode. */
173	static cost_classes_t cost_classes_mode_cache[MAX_MACHINE_MODE];
174
175	/* Cost classes that include all classes in ira_important_classes. */
176	static cost_classes all_cost_classes;
177
178	/* Use the array of classes in CLASSES_PTR to fill out the rest of
179	the structure. */
180	static void
181	complete_cost_classes (cost_classes_t classes_ptr)
182	{
183	for (int i = 0; i < N_REG_CLASSES; i++)
184	classes_ptr->index[i] = -1;
185	for (int i = 0; i < FIRST_PSEUDO_REGISTER; i++)
186	classes_ptr->hard_regno_index[i] = -1;
187	for (int i = 0; i < classes_ptr->num; i++)
188	{
189	enum reg_class cl = classes_ptr->classes[i];
190	classes_ptr->index[cl] = i;
191	for (int j = ira_class_hard_regs_num[cl] - 1; j >= 0; j--)
192	{
193	unsigned int hard_regno = ira_class_hard_regs[cl][j];
194	if (classes_ptr->hard_regno_index[hard_regno] < 0)
195	classes_ptr->hard_regno_index[hard_regno] = i;
196	}
197	}
198	}
199
200	/* Initialize info about the cost classes for each pseudo. */
201	static void
202	initiate_regno_cost_classes (void)
203	{
204	int size = sizeof (cost_classes_t) * max_reg_num ();
205
206	regno_cost_classes = (cost_classes_t *) ira_allocate (size);
207	memset (s: regno_cost_classes, c: 0, n: size);
208	memset (s: cost_classes_aclass_cache, c: 0,
209	n: sizeof (cost_classes_t) * N_REG_CLASSES);
210	memset (s: cost_classes_mode_cache, c: 0,
211	n: sizeof (cost_classes_t) * MAX_MACHINE_MODE);
212	cost_classes_htab = new hash_table<cost_classes_hasher> (200);
213	all_cost_classes.num = ira_important_classes_num;
214	for (int i = 0; i < ira_important_classes_num; i++)
215	all_cost_classes.classes[i] = ira_important_classes[i];
216	complete_cost_classes (classes_ptr: &all_cost_classes);
217	}
218
219	/* Create new cost classes from cost classes FROM and set up members
220	index and hard_regno_index. Return the new classes. The function
221	implements some common code of two functions
222	setup_regno_cost_classes_by_aclass and
223	setup_regno_cost_classes_by_mode. */
224	static cost_classes_t
225	setup_cost_classes (cost_classes_t from)
226	{
227	cost_classes_t classes_ptr;
228
229	classes_ptr = (cost_classes_t) ira_allocate (sizeof (struct cost_classes));
230	classes_ptr->num = from->num;
231	for (int i = 0; i < from->num; i++)
232	classes_ptr->classes[i] = from->classes[i];
233	complete_cost_classes (classes_ptr);
234	return classes_ptr;
235	}
236
237	/* Return a version of FULL that only considers registers in REGS that are
238	valid for mode MODE. Both FULL and the returned class are globally
239	allocated. */
240	static cost_classes_t
241	restrict_cost_classes (cost_classes_t full, machine_mode mode,
242	const_hard_reg_set regs)
243	{
244	static struct cost_classes narrow;
245	int map[N_REG_CLASSES];
246	narrow.num = 0;
247	for (int i = 0; i < full->num; i++)
248	{
249	/* Assume that we'll drop the class. */
250	map[i] = -1;
251
252	/* Ignore classes that are too small for the mode. */
253	enum reg_class cl = full->classes[i];
254	if (!contains_reg_of_mode[cl][mode])
255	continue;
256
257	/* Calculate the set of registers in CL that belong to REGS and
258	are valid for MODE. */
259	HARD_REG_SET valid_for_cl = reg_class_contents[cl] & regs;
260	valid_for_cl &= ~(ira_prohibited_class_mode_regs[cl][mode]
261	| ira_no_alloc_regs);
262	if (hard_reg_set_empty_p (x: valid_for_cl))
263	continue;
264
265	/* Don't use this class if the set of valid registers is a subset
266	of an existing class. For example, suppose we have two classes
267	GR_REGS and FR_REGS and a union class GR_AND_FR_REGS. Suppose
268	that the mode changes allowed by FR_REGS are not as general as
269	the mode changes allowed by GR_REGS.
270
271	In this situation, the mode changes for GR_AND_FR_REGS could
272	either be seen as the union or the intersection of the mode
273	changes allowed by the two subclasses. The justification for
274	the union-based definition would be that, if you want a mode
275	change that's only allowed by GR_REGS, you can pick a register
276	from the GR_REGS subclass. The justification for the
277	intersection-based definition would be that every register
278	from the class would allow the mode change.
279
280	However, if we have a register that needs to be in GR_REGS,
281	using GR_AND_FR_REGS with the intersection-based definition
282	would be too pessimistic, since it would bring in restrictions
283	that only apply to FR_REGS. Conversely, if we have a register
284	that needs to be in FR_REGS, using GR_AND_FR_REGS with the
285	union-based definition would lose the extra restrictions
286	placed on FR_REGS. GR_AND_FR_REGS is therefore only useful
287	for cases where GR_REGS and FP_REGS are both valid. */
288	int pos;
289	for (pos = 0; pos < narrow.num; ++pos)
290	{
291	enum reg_class cl2 = narrow.classes[pos];
292	if (hard_reg_set_subset_p (x: valid_for_cl, reg_class_contents[cl2]))
293	break;
294	}
295	map[i] = pos;
296	if (pos == narrow.num)
297	{
298	/* If several classes are equivalent, prefer to use the one
299	that was chosen as the allocno class. */
300	enum reg_class cl2 = ira_allocno_class_translate[cl];
301	if (ira_class_hard_regs_num[cl] == ira_class_hard_regs_num[cl2])
302	cl = cl2;
303	narrow.classes[narrow.num++] = cl;
304	}
305	}
306	if (narrow.num == full->num)
307	return full;
308
309	cost_classes **slot = cost_classes_htab->find_slot (value: &narrow, insert: INSERT);
310	if (*slot == NULL)
311	{
312	cost_classes_t classes = setup_cost_classes (&narrow);
313	/* Map equivalent classes to the representative that we chose above. */
314	for (int i = 0; i < ira_important_classes_num; i++)
315	{
316	enum reg_class cl = ira_important_classes[i];
317	int index = full->index[cl];
318	if (index >= 0)
319	classes->index[cl] = map[index];
320	}
321	*slot = classes;
322	}
323	return *slot;
324	}
325
326	/* Setup cost classes for pseudo REGNO whose allocno class is ACLASS.
327	This function is used when we know an initial approximation of
328	allocno class of the pseudo already, e.g. on the second iteration
329	of class cost calculation or after class cost calculation in
330	register-pressure sensitive insn scheduling or register-pressure
331	sensitive loop-invariant motion. */
332	static void
333	setup_regno_cost_classes_by_aclass (int regno, enum reg_class aclass)
334	{
335	static struct cost_classes classes;
336	cost_classes_t classes_ptr;
337	enum reg_class cl;
338	int i;
339	cost_classes **slot;
340	HARD_REG_SET temp, temp2;
341	bool exclude_p;
342
343	if ((classes_ptr = cost_classes_aclass_cache[aclass]) == NULL)
344	{
345	temp = reg_class_contents[aclass] & ~ira_no_alloc_regs;
346	/* We exclude classes from consideration which are subsets of
347	ACLASS only if ACLASS is an uniform class. */
348	exclude_p = ira_uniform_class_p[aclass];
349	classes.num = 0;
350	for (i = 0; i < ira_important_classes_num; i++)
351	{
352	cl = ira_important_classes[i];
353	if (exclude_p)
354	{
355	/* Exclude non-uniform classes which are subsets of
356	ACLASS. */
357	temp2 = reg_class_contents[cl] & ~ira_no_alloc_regs;
358	if (hard_reg_set_subset_p (x: temp2, y: temp) && cl != aclass)
359	continue;
360	}
361	classes.classes[classes.num++] = cl;
362	}
363	slot = cost_classes_htab->find_slot (value: &classes, insert: INSERT);
364	if (*slot == NULL)
365	{
366	classes_ptr = setup_cost_classes (&classes);
367	*slot = classes_ptr;
368	}
369	classes_ptr = cost_classes_aclass_cache[aclass] = (cost_classes_t) *slot;
370	}
371	if (regno_reg_rtx[regno] != NULL_RTX)
372	{
373	/* Restrict the classes to those that are valid for REGNO's mode
374	(which might for example exclude singleton classes if the mode
375	requires two registers). Also restrict the classes to those that
376	are valid for subregs of REGNO. */
377	const HARD_REG_SET *valid_regs = valid_mode_changes_for_regno (regno);
378	if (!valid_regs)
379	valid_regs = &reg_class_contents[ALL_REGS];
380	classes_ptr = restrict_cost_classes (full: classes_ptr,
381	PSEUDO_REGNO_MODE (regno),
382	regs: *valid_regs);
383	}
384	regno_cost_classes[regno] = classes_ptr;
385	}
386
387	/* Setup cost classes for pseudo REGNO with MODE. Usage of MODE can
388	decrease number of cost classes for the pseudo, if hard registers
389	of some important classes cannot hold a value of MODE. So the
390	pseudo cannot get hard register of some important classes and cost
391	calculation for such important classes is only wasting CPU
392	time. */
393	static void
394	setup_regno_cost_classes_by_mode (int regno, machine_mode mode)
395	{
396	if (const HARD_REG_SET *valid_regs = valid_mode_changes_for_regno (regno))
397	regno_cost_classes[regno] = restrict_cost_classes (full: &all_cost_classes,
398	mode, regs: *valid_regs);
399	else
400	{
401	if (cost_classes_mode_cache[mode] == NULL)
402	cost_classes_mode_cache[mode]
403	= restrict_cost_classes (full: &all_cost_classes, mode,
404	reg_class_contents[ALL_REGS]);
405	regno_cost_classes[regno] = cost_classes_mode_cache[mode];
406	}
407	}
408
409	/* Finalize info about the cost classes for each pseudo. */
410	static void
411	finish_regno_cost_classes (void)
412	{
413	ira_free (addr: regno_cost_classes);
414	delete cost_classes_htab;
415	cost_classes_htab = NULL;
416	}
417
418
419
420	/* Compute the cost of loading X into (if TO_P is TRUE) or from (if
421	TO_P is FALSE) a register of class RCLASS in mode MODE. X must not
422	be a pseudo register. */
423	static int
424	copy_cost (rtx x, machine_mode mode, reg_class_t rclass, bool to_p,
425	secondary_reload_info *prev_sri)
426	{
427	secondary_reload_info sri;
428	reg_class_t secondary_class = NO_REGS;
429
430	/* If X is a SCRATCH, there is actually nothing to move since we are
431	assuming optimal allocation. */
432	if (GET_CODE (x) == SCRATCH)
433	return 0;
434
435	/* Get the class we will actually use for a reload. */
436	rclass = targetm.preferred_reload_class (x, rclass);
437
438	/* If we need a secondary reload for an intermediate, the cost is
439	that to load the input into the intermediate register, then to
440	copy it. */
441	sri.prev_sri = prev_sri;
442	sri.extra_cost = 0;
443	/* PR 68770: Secondary reload might examine the t_icode field. */
444	sri.t_icode = CODE_FOR_nothing;
445
446	secondary_class = targetm.secondary_reload (to_p, x, rclass, mode, &sri);
447
448	if (secondary_class != NO_REGS)
449	{
450	ira_init_register_move_cost_if_necessary (mode);
451	return (ira_register_move_cost[mode][(int) secondary_class][(int) rclass]
452	+ sri.extra_cost
453	+ copy_cost (x, mode, rclass: secondary_class, to_p, prev_sri: &sri));
454	}
455
456	/* For memory, use the memory move cost, for (hard) registers, use
457	the cost to move between the register classes, and use 2 for
458	everything else (constants). */
459	if (MEM_P (x) || rclass == NO_REGS)
460	return sri.extra_cost
461	+ ira_memory_move_cost[mode][(int) rclass][to_p != 0];
462	else if (REG_P (x))
463	{
464	reg_class_t x_class = REGNO_REG_CLASS (REGNO (x));
465
466	ira_init_register_move_cost_if_necessary (mode);
467	return (sri.extra_cost
468	+ ira_register_move_cost[mode][(int) x_class][(int) rclass]);
469	}
470	else
471	/* If this is a constant, we may eventually want to call rtx_cost
472	here. */
473	return sri.extra_cost + COSTS_N_INSNS (1);
474	}
475
476
477
478	/* Record the cost of using memory or hard registers of various
479	classes for the operands in INSN.
480
481	N_ALTS is the number of alternatives.
482	N_OPS is the number of operands.
483	OPS is an array of the operands.
484	MODES are the modes of the operands, in case any are VOIDmode.
485	CONSTRAINTS are the constraints to use for the operands. This array
486	is modified by this procedure.
487
488	This procedure works alternative by alternative. For each
489	alternative we assume that we will be able to allocate all allocnos
490	to their ideal register class and calculate the cost of using that
491	alternative. Then we compute, for each operand that is a
492	pseudo-register, the cost of having the allocno allocated to each
493	register class and using it in that alternative. To this cost is
494	added the cost of the alternative.
495
496	The cost of each class for this insn is its lowest cost among all
497	the alternatives. */
498	static void
499	record_reg_classes (int n_alts, int n_ops, rtx *ops,
500	machine_mode *modes, const char **constraints,
501	rtx_insn *insn, enum reg_class *pref)
502	{
503	int alt;
504	int i, j, k;
505	int insn_allows_mem[MAX_RECOG_OPERANDS];
506	move_table *move_in_cost, *move_out_cost;
507	short (*mem_cost)[2];
508	const char *p;
509
510	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5)
511	{
512	fprintf (stream: ira_dump_file, format: " Processing insn %u", INSN_UID (insn));
513	if (INSN_CODE (insn) >= 0
514	&& (p = get_insn_name (INSN_CODE (insn))) != NULL)
515	fprintf (stream: ira_dump_file, format: " {%s}", p);
516	fprintf (stream: ira_dump_file, format: " (freq=%d)\n",
517	REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn)));
518	dump_insn_slim (ira_dump_file, insn);
519	}
520
521	for (i = 0; i < n_ops; i++)
522	insn_allows_mem[i] = 0;
523
524	/* Process each alternative, each time minimizing an operand's cost
525	with the cost for each operand in that alternative. */
526	alternative_mask preferred = get_preferred_alternatives (insn);
527	for (alt = 0; alt < n_alts; alt++)
528	{
529	enum reg_class classes[MAX_RECOG_OPERANDS];
530	int allows_mem[MAX_RECOG_OPERANDS];
531	enum reg_class rclass;
532	int alt_fail = 0;
533	int alt_cost = 0, op_cost_add;
534
535	if (!TEST_BIT (preferred, alt))
536	{
537	for (i = 0; i < recog_data.n_operands; i++)
538	constraints[i] = skip_alternative (p: constraints[i]);
539
540	continue;
541	}
542
543	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5)
544	{
545	fprintf (stream: ira_dump_file, format: " Alt %d:", alt);
546	for (i = 0; i < n_ops; i++)
547	{
548	p = constraints[i];
549	if (*p == '\0')
550	continue;
551	fprintf (stream: ira_dump_file, format: " (%d) ", i);
552	for (; *p != '\0' && *p != ',' && *p != '#'; p++)
553	fputc (c: *p, stream: ira_dump_file);
554	}
555	fprintf (stream: ira_dump_file, format: "\n");
556	}
557
558	for (i = 0; i < n_ops; i++)
559	{
560	unsigned char c;
561	const char *p = constraints[i];
562	rtx op = ops[i];
563	machine_mode mode = modes[i];
564	int allows_addr = 0;
565	int win = 0;
566
567	/* Initially show we know nothing about the register class. */
568	classes[i] = NO_REGS;
569	allows_mem[i] = 0;
570
571	/* If this operand has no constraints at all, we can
572	conclude nothing about it since anything is valid. */
573	if (*p == 0)
574	{
575	if (REG_P (op) && REGNO (op) >= FIRST_PSEUDO_REGISTER)
576	memset (this_op_costs[i], c: 0, n: struct_costs_size);
577	continue;
578	}
579
580	/* If this alternative is only relevant when this operand
581	matches a previous operand, we do different things
582	depending on whether this operand is a allocno-reg or not.
583	We must process any modifiers for the operand before we
584	can make this test. */
585	while (*p == '%' || *p == '=' || *p == '+' || *p == '&')
586	p++;
587
588	if (p[0] >= '0' && p[0] <= '0' + i)
589	{
590	/* Copy class and whether memory is allowed from the
591	matching alternative. Then perform any needed cost
592	computations and/or adjustments. */
593	j = p[0] - '0';
594	classes[i] = classes[j];
595	allows_mem[i] = allows_mem[j];
596	if (allows_mem[i])
597	insn_allows_mem[i] = 1;
598
599	if (! REG_P (op) || REGNO (op) < FIRST_PSEUDO_REGISTER)
600	{
601	/* If this matches the other operand, we have no
602	added cost and we win. */
603	if (rtx_equal_p (ops[j], op))
604	win = 1;
605	/* If we can put the other operand into a register,
606	add to the cost of this alternative the cost to
607	copy this operand to the register used for the
608	other operand. */
609	else if (classes[j] != NO_REGS)
610	{
611	alt_cost += copy_cost (x: op, mode, rclass: classes[j], to_p: 1, NULL);
612	win = 1;
613	}
614	}
615	else if (! REG_P (ops[j])
616	|| REGNO (ops[j]) < FIRST_PSEUDO_REGISTER)
617	{
618	/* This op is an allocno but the one it matches is
619	not. */
620
621	/* If we can't put the other operand into a
622	register, this alternative can't be used. */
623
624	if (classes[j] == NO_REGS)
625	{
626	alt_fail = 1;
627	}
628	else
629	/* Otherwise, add to the cost of this alternative the cost
630	to copy the other operand to the hard register used for
631	this operand. */
632	{
633	alt_cost += copy_cost (x: ops[j], mode, rclass: classes[j], to_p: 1, NULL);
634	}
635	}
636	else
637	{
638	/* The costs of this operand are not the same as the
639	other operand since move costs are not symmetric.
640	Moreover, if we cannot tie them, this alternative
641	needs to do a copy, which is one insn. */
642	struct costs *pp = this_op_costs[i];
643	int *pp_costs = pp->cost;
644	cost_classes_t cost_classes_ptr
645	= regno_cost_classes[REGNO (op)];
646	enum reg_class *cost_classes = cost_classes_ptr->classes;
647	bool in_p = recog_data.operand_type[i] != OP_OUT;
648	bool out_p = recog_data.operand_type[i] != OP_IN;
649	enum reg_class op_class = classes[i];
650
651	ira_init_register_move_cost_if_necessary (mode);
652	if (! in_p)
653	{
654	ira_assert (out_p);
655	if (op_class == NO_REGS)
656	{
657	mem_cost = ira_memory_move_cost[mode];
658	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
659	{
660	rclass = cost_classes[k];
661	pp_costs[k] = mem_cost[rclass][0] * frequency;
662	}
663	}
664	else
665	{
666	move_out_cost = ira_may_move_out_cost[mode];
667	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
668	{
669	rclass = cost_classes[k];
670	pp_costs[k]
671	= move_out_cost[op_class][rclass] * frequency;
672	}
673	}
674	}
675	else if (! out_p)
676	{
677	ira_assert (in_p);
678	if (op_class == NO_REGS)
679	{
680	mem_cost = ira_memory_move_cost[mode];
681	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
682	{
683	rclass = cost_classes[k];
684	pp_costs[k] = mem_cost[rclass][1] * frequency;
685	}
686	}
687	else
688	{
689	move_in_cost = ira_may_move_in_cost[mode];
690	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
691	{
692	rclass = cost_classes[k];
693	pp_costs[k]
694	= move_in_cost[rclass][op_class] * frequency;
695	}
696	}
697	}
698	else
699	{
700	if (op_class == NO_REGS)
701	{
702	mem_cost = ira_memory_move_cost[mode];
703	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
704	{
705	rclass = cost_classes[k];
706	pp_costs[k] = ((mem_cost[rclass][0]
707	+ mem_cost[rclass][1])
708	* frequency);
709	}
710	}
711	else
712	{
713	move_in_cost = ira_may_move_in_cost[mode];
714	move_out_cost = ira_may_move_out_cost[mode];
715	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
716	{
717	rclass = cost_classes[k];
718	pp_costs[k] = ((move_in_cost[rclass][op_class]
719	+ move_out_cost[op_class][rclass])
720	* frequency);
721	}
722	}
723	}
724
725	/* If the alternative actually allows memory, make
726	things a bit cheaper since we won't need an extra
727	insn to load it. */
728	pp->mem_cost
729	= ((out_p ? ira_memory_move_cost[mode][op_class][0] : 0)
730	+ (in_p ? ira_memory_move_cost[mode][op_class][1] : 0)
731	- allows_mem[i]) * frequency;
732
733	/* If we have assigned a class to this allocno in
734	our first pass, add a cost to this alternative
735	corresponding to what we would add if this
736	allocno were not in the appropriate class. */
737	if (pref)
738	{
739	enum reg_class pref_class = pref[COST_INDEX (REGNO (op))];
740
741	if (pref_class == NO_REGS)
742	alt_cost
743	+= ((out_p
744	? ira_memory_move_cost[mode][op_class][0] : 0)
745	+ (in_p
746	? ira_memory_move_cost[mode][op_class][1]
747	: 0));
748	else if (ira_reg_class_intersect
749	[pref_class][op_class] == NO_REGS)
750	alt_cost
751	+= ira_register_move_cost[mode][pref_class][op_class];
752	}
753	if (REGNO (ops[i]) != REGNO (ops[j])
754	&& ! find_reg_note (insn, REG_DEAD, op))
755	alt_cost += 2;
756
757	p++;
758	}
759	}
760
761	/* Scan all the constraint letters. See if the operand
762	matches any of the constraints. Collect the valid
763	register classes and see if this operand accepts
764	memory. */
765	while ((c = *p))
766	{
767	switch (c)
768	{
769	case '*':
770	/* Ignore the next letter for this pass. */
771	c = *++p;
772	break;
773
774	case '^':
775	alt_cost += 2;
776	break;
777
778	case '?':
779	alt_cost += 2;
780	break;
781
782	case 'g':
783	if (MEM_P (op)
784	|| (CONSTANT_P (op)
785	&& (! flag_pic || LEGITIMATE_PIC_OPERAND_P (op))))
786	win = 1;
787	insn_allows_mem[i] = allows_mem[i] = 1;
788	classes[i] = ira_reg_class_subunion[classes[i]][GENERAL_REGS];
789	break;
790
791	default:
792	enum constraint_num cn = lookup_constraint (p);
793	enum reg_class cl;
794	switch (get_constraint_type (c: cn))
795	{
796	case CT_REGISTER:
797	cl = reg_class_for_constraint (c: cn);
798	if (cl != NO_REGS)
799	classes[i] = ira_reg_class_subunion[classes[i]][cl];
800	break;
801
802	case CT_CONST_INT:
803	if (CONST_INT_P (op)
804	&& insn_const_int_ok_for_constraint (INTVAL (op), cn))
805	win = 1;
806	break;
807
808	case CT_MEMORY:
809	case CT_RELAXED_MEMORY:
810	/* Every MEM can be reloaded to fit. */
811	insn_allows_mem[i] = allows_mem[i] = 1;
812	if (MEM_P (op))
813	win = 1;
814	break;
815
816	case CT_SPECIAL_MEMORY:
817	insn_allows_mem[i] = allows_mem[i] = 1;
818	if (MEM_P (extract_mem_from_operand (op))
819	&& constraint_satisfied_p (x: op, c: cn))
820	win = 1;
821	break;
822
823	case CT_ADDRESS:
824	/* Every address can be reloaded to fit. */
825	allows_addr = 1;
826	if (address_operand (op, GET_MODE (op))
827	|| constraint_satisfied_p (x: op, c: cn))
828	win = 1;
829	/* We know this operand is an address, so we
830	want it to be allocated to a hard register
831	that can be the base of an address,
832	i.e. BASE_REG_CLASS. */
833	classes[i]
834	= ira_reg_class_subunion[classes[i]]
835	[base_reg_class (VOIDmode, ADDR_SPACE_GENERIC,
836	outer_code: ADDRESS, index_code: SCRATCH)];
837	break;
838
839	case CT_FIXED_FORM:
840	if (constraint_satisfied_p (x: op, c: cn))
841	win = 1;
842	break;
843	}
844	break;
845	}
846	p += CONSTRAINT_LEN (c, p);
847	if (c == ',')
848	break;
849	}
850
851	constraints[i] = p;
852
853	if (alt_fail)
854	break;
855
856	/* How we account for this operand now depends on whether it
857	is a pseudo register or not. If it is, we first check if
858	any register classes are valid. If not, we ignore this
859	alternative, since we want to assume that all allocnos get
860	allocated for register preferencing. If some register
861	class is valid, compute the costs of moving the allocno
862	into that class. */
863	if (REG_P (op) && REGNO (op) >= FIRST_PSEUDO_REGISTER)
864	{
865	if (classes[i] == NO_REGS && ! allows_mem[i])
866	{
867	/* We must always fail if the operand is a REG, but
868	we did not find a suitable class and memory is
869	not allowed.
870
871	Otherwise we may perform an uninitialized read
872	from this_op_costs after the `continue' statement
873	below. */
874	alt_fail = 1;
875	}
876	else
877	{
878	unsigned int regno = REGNO (op);
879	struct costs *pp = this_op_costs[i];
880	int *pp_costs = pp->cost;
881	cost_classes_t cost_classes_ptr = regno_cost_classes[regno];
882	enum reg_class *cost_classes = cost_classes_ptr->classes;
883	bool in_p = recog_data.operand_type[i] != OP_OUT;
884	bool out_p = recog_data.operand_type[i] != OP_IN;
885	enum reg_class op_class = classes[i];
886
887	ira_init_register_move_cost_if_necessary (mode);
888	if (! in_p)
889	{
890	ira_assert (out_p);
891	if (op_class == NO_REGS)
892	{
893	mem_cost = ira_memory_move_cost[mode];
894	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
895	{
896	rclass = cost_classes[k];
897	pp_costs[k] = mem_cost[rclass][0] * frequency;
898	}
899	}
900	else
901	{
902	move_out_cost = ira_may_move_out_cost[mode];
903	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
904	{
905	rclass = cost_classes[k];
906	pp_costs[k]
907	= move_out_cost[op_class][rclass] * frequency;
908	}
909	}
910	}
911	else if (! out_p)
912	{
913	ira_assert (in_p);
914	if (op_class == NO_REGS)
915	{
916	mem_cost = ira_memory_move_cost[mode];
917	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
918	{
919	rclass = cost_classes[k];
920	pp_costs[k] = mem_cost[rclass][1] * frequency;
921	}
922	}
923	else
924	{
925	move_in_cost = ira_may_move_in_cost[mode];
926	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
927	{
928	rclass = cost_classes[k];
929	pp_costs[k]
930	= move_in_cost[rclass][op_class] * frequency;
931	}
932	}
933	}
934	else
935	{
936	if (op_class == NO_REGS)
937	{
938	mem_cost = ira_memory_move_cost[mode];
939	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
940	{
941	rclass = cost_classes[k];
942	pp_costs[k] = ((mem_cost[rclass][0]
943	+ mem_cost[rclass][1])
944	* frequency);
945	}
946	}
947	else
948	{
949	move_in_cost = ira_may_move_in_cost[mode];
950	move_out_cost = ira_may_move_out_cost[mode];
951	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
952	{
953	rclass = cost_classes[k];
954	pp_costs[k] = ((move_in_cost[rclass][op_class]
955	+ move_out_cost[op_class][rclass])
956	* frequency);
957	}
958	}
959	}
960
961	if (op_class == NO_REGS)
962	/* Although we don't need insn to reload from
963	memory, still accessing memory is usually more
964	expensive than a register. */
965	pp->mem_cost = frequency;
966	else
967	/* If the alternative actually allows memory, make
968	things a bit cheaper since we won't need an
969	extra insn to load it. */
970	pp->mem_cost
971	= ((out_p ? ira_memory_move_cost[mode][op_class][0] : 0)
972	+ (in_p ? ira_memory_move_cost[mode][op_class][1] : 0)
973	- allows_mem[i]) * frequency;
974	/* If we have assigned a class to this allocno in
975	our first pass, add a cost to this alternative
976	corresponding to what we would add if this
977	allocno were not in the appropriate class. */
978	if (pref)
979	{
980	enum reg_class pref_class = pref[COST_INDEX (REGNO (op))];
981
982	if (pref_class == NO_REGS)
983	{
984	if (op_class != NO_REGS)
985	alt_cost
986	+= ((out_p
987	? ira_memory_move_cost[mode][op_class][0]
988	: 0)
989	+ (in_p
990	? ira_memory_move_cost[mode][op_class][1]
991	: 0));
992	}
993	else if (op_class == NO_REGS)
994	alt_cost
995	+= ((out_p
996	? ira_memory_move_cost[mode][pref_class][1]
997	: 0)
998	+ (in_p
999	? ira_memory_move_cost[mode][pref_class][0]
1000	: 0));
1001	else if (ira_reg_class_intersect[pref_class][op_class]
1002	== NO_REGS)
1003	alt_cost += (ira_register_move_cost
1004	[mode][pref_class][op_class]);
1005	}
1006	}
1007	}
1008
1009	/* Otherwise, if this alternative wins, either because we
1010	have already determined that or if we have a hard
1011	register of the proper class, there is no cost for this
1012	alternative. */
1013	else if (win || (REG_P (op)
1014	&& reg_fits_class_p (op, classes[i],
1015	0, GET_MODE (op))))
1016	;
1017
1018	/* If registers are valid, the cost of this alternative
1019	includes copying the object to and/or from a
1020	register. */
1021	else if (classes[i] != NO_REGS)
1022	{
1023	if (recog_data.operand_type[i] != OP_OUT)
1024	alt_cost += copy_cost (x: op, mode, rclass: classes[i], to_p: 1, NULL);
1025
1026	if (recog_data.operand_type[i] != OP_IN)
1027	alt_cost += copy_cost (x: op, mode, rclass: classes[i], to_p: 0, NULL);
1028	}
1029	/* The only other way this alternative can be used is if
1030	this is a constant that could be placed into memory. */
1031	else if (CONSTANT_P (op) && (allows_addr || allows_mem[i]))
1032	alt_cost += ira_memory_move_cost[mode][classes[i]][1];
1033	else
1034	alt_fail = 1;
1035
1036	if (alt_fail)
1037	break;
1038	}
1039
1040	if (alt_fail)
1041	{
1042	/* The loop above might have exited early once the failure
1043	was seen. Skip over the constraints for the remaining
1044	operands. */
1045	i += 1;
1046	for (; i < n_ops; ++i)
1047	constraints[i] = skip_alternative (p: constraints[i]);
1048	continue;
1049	}
1050
1051	op_cost_add = alt_cost * frequency;
1052	/* Finally, update the costs with the information we've
1053	calculated about this alternative. */
1054	for (i = 0; i < n_ops; i++)
1055	if (REG_P (ops[i]) && REGNO (ops[i]) >= FIRST_PSEUDO_REGISTER)
1056	{
1057	int old_cost;
1058	bool cost_change_p = false;
1059	struct costs *pp = op_costs[i], *qq = this_op_costs[i];
1060	int *pp_costs = pp->cost, *qq_costs = qq->cost;
1061	int scale = 1 + (recog_data.operand_type[i] == OP_INOUT);
1062	cost_classes_t cost_classes_ptr
1063	= regno_cost_classes[REGNO (ops[i])];
1064
1065	old_cost = pp->mem_cost;
1066	pp->mem_cost = MIN (old_cost,
1067	(qq->mem_cost + op_cost_add) * scale);
1068
1069	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5
1070	&& pp->mem_cost < old_cost)
1071	{
1072	cost_change_p = true;
1073	fprintf (stream: ira_dump_file, format: " op %d(r=%u) new costs MEM:%d",
1074	i, REGNO(ops[i]), pp->mem_cost);
1075	}
1076	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
1077	{
1078	old_cost = pp_costs[k];
1079	pp_costs[k]
1080	= MIN (old_cost, (qq_costs[k] + op_cost_add) * scale);
1081	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5
1082	&& pp_costs[k] < old_cost)
1083	{
1084	if (!cost_change_p)
1085	fprintf (stream: ira_dump_file, format: " op %d(r=%u) new costs",
1086	i, REGNO(ops[i]));
1087	cost_change_p = true;
1088	fprintf (stream: ira_dump_file, format: " %s:%d",
1089	reg_class_names[cost_classes_ptr->classes[k]],
1090	pp_costs[k]);
1091	}
1092	}
1093	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5
1094	&& cost_change_p)
1095	fprintf (stream: ira_dump_file, format: "\n");
1096	}
1097	}
1098
1099	if (allocno_p)
1100	for (i = 0; i < n_ops; i++)
1101	{
1102	ira_allocno_t a;
1103	rtx op = ops[i];
1104
1105	if (! REG_P (op) || REGNO (op) < FIRST_PSEUDO_REGISTER)
1106	continue;
1107	a = ira_curr_regno_allocno_map [REGNO (op)];
1108	if (! ALLOCNO_BAD_SPILL_P (a) && insn_allows_mem[i] == 0)
1109	ALLOCNO_BAD_SPILL_P (a) = true;
1110	}
1111
1112	}
1113
1114
1115
1116	/* Wrapper around REGNO_OK_FOR_INDEX_P, to allow pseudo registers. */
1117	static inline bool
1118	ok_for_index_p_nonstrict (rtx reg)
1119	{
1120	unsigned regno = REGNO (reg);
1121
1122	return regno >= FIRST_PSEUDO_REGISTER || REGNO_OK_FOR_INDEX_P (regno);
1123	}
1124
1125	/* A version of regno_ok_for_base_p for use here, when all
1126	pseudo-registers should count as OK. Arguments as for
1127	regno_ok_for_base_p. */
1128	static inline bool
1129	ok_for_base_p_nonstrict (rtx reg, machine_mode mode, addr_space_t as,
1130	enum rtx_code outer_code, enum rtx_code index_code)
1131	{
1132	unsigned regno = REGNO (reg);
1133
1134	if (regno >= FIRST_PSEUDO_REGISTER)
1135	return true;
1136	return ok_for_base_p_1 (regno, mode, as, outer_code, index_code);
1137	}
1138
1139	/* Record the pseudo registers we must reload into hard registers in a
1140	subexpression of a memory address, X.
1141
1142	If CONTEXT is 0, we are looking at the base part of an address,
1143	otherwise we are looking at the index part.
1144
1145	MODE and AS are the mode and address space of the memory reference;
1146	OUTER_CODE and INDEX_CODE give the context that the rtx appears in.
1147	These four arguments are passed down to base_reg_class.
1148
1149	SCALE is twice the amount to multiply the cost by (it is twice so
1150	we can represent half-cost adjustments). */
1151	static void
1152	record_address_regs (machine_mode mode, addr_space_t as, rtx x,
1153	int context, enum rtx_code outer_code,
1154	enum rtx_code index_code, int scale)
1155	{
1156	enum rtx_code code = GET_CODE (x);
1157	enum reg_class rclass;
1158
1159	if (context == 1)
1160	rclass = INDEX_REG_CLASS;
1161	else
1162	rclass = base_reg_class (mode, as, outer_code, index_code);
1163
1164	switch (code)
1165	{
1166	case CONST_INT:
1167	case CONST:
1168	case PC:
1169	case SYMBOL_REF:
1170	case LABEL_REF:
1171	return;
1172
1173	case PLUS:
1174	/* When we have an address that is a sum, we must determine
1175	whether registers are "base" or "index" regs. If there is a
1176	sum of two registers, we must choose one to be the "base".
1177	Luckily, we can use the REG_POINTER to make a good choice
1178	most of the time. We only need to do this on machines that
1179	can have two registers in an address and where the base and
1180	index register classes are different.
1181
1182	??? This code used to set REGNO_POINTER_FLAG in some cases,
1183	but that seems bogus since it should only be set when we are
1184	sure the register is being used as a pointer. */
1185	{
1186	rtx arg0 = XEXP (x, 0);
1187	rtx arg1 = XEXP (x, 1);
1188	enum rtx_code code0 = GET_CODE (arg0);
1189	enum rtx_code code1 = GET_CODE (arg1);
1190
1191	/* Look inside subregs. */
1192	if (code0 == SUBREG)
1193	arg0 = SUBREG_REG (arg0), code0 = GET_CODE (arg0);
1194	if (code1 == SUBREG)
1195	arg1 = SUBREG_REG (arg1), code1 = GET_CODE (arg1);
1196
1197	/* If index registers do not appear, or coincide with base registers,
1198	just record registers in any non-constant operands. We
1199	assume here, as well as in the tests below, that all
1200	addresses are in canonical form. */
1201	if (MAX_REGS_PER_ADDRESS == 1
1202	|| INDEX_REG_CLASS == base_reg_class (VOIDmode, as, outer_code: PLUS, index_code: SCRATCH))
1203	{
1204	record_address_regs (mode, as, x: arg0, context, outer_code: PLUS, index_code: code1, scale);
1205	if (! CONSTANT_P (arg1))
1206	record_address_regs (mode, as, x: arg1, context, outer_code: PLUS, index_code: code0, scale);
1207	}
1208
1209	/* If the second operand is a constant integer, it doesn't
1210	change what class the first operand must be. */
1211	else if (CONST_SCALAR_INT_P (arg1))
1212	record_address_regs (mode, as, x: arg0, context, outer_code: PLUS, index_code: code1, scale);
1213	/* If the second operand is a symbolic constant, the first
1214	operand must be an index register. */
1215	else if (code1 == SYMBOL_REF || code1 == CONST || code1 == LABEL_REF)
1216	record_address_regs (mode, as, x: arg0, context: 1, outer_code: PLUS, index_code: code1, scale);
1217	/* If both operands are registers but one is already a hard
1218	register of index or reg-base class, give the other the
1219	class that the hard register is not. */
1220	else if (code0 == REG && code1 == REG
1221	&& REGNO (arg0) < FIRST_PSEUDO_REGISTER
1222	&& (ok_for_base_p_nonstrict (reg: arg0, mode, as, outer_code: PLUS, index_code: REG)
1223	|| ok_for_index_p_nonstrict (reg: arg0)))
1224	record_address_regs (mode, as, x: arg1,
1225	context: ok_for_base_p_nonstrict (reg: arg0, mode, as,
1226	outer_code: PLUS, index_code: REG) ? 1 : 0,
1227	outer_code: PLUS, index_code: REG, scale);
1228	else if (code0 == REG && code1 == REG
1229	&& REGNO (arg1) < FIRST_PSEUDO_REGISTER
1230	&& (ok_for_base_p_nonstrict (reg: arg1, mode, as, outer_code: PLUS, index_code: REG)
1231	|| ok_for_index_p_nonstrict (reg: arg1)))
1232	record_address_regs (mode, as, x: arg0,
1233	context: ok_for_base_p_nonstrict (reg: arg1, mode, as,
1234	outer_code: PLUS, index_code: REG) ? 1 : 0,
1235	outer_code: PLUS, index_code: REG, scale);
1236	/* If one operand is known to be a pointer, it must be the
1237	base with the other operand the index. Likewise if the
1238	other operand is a MULT. */
1239	else if ((code0 == REG && REG_POINTER (arg0)) || code1 == MULT)
1240	{
1241	record_address_regs (mode, as, x: arg0, context: 0, outer_code: PLUS, index_code: code1, scale);
1242	record_address_regs (mode, as, x: arg1, context: 1, outer_code: PLUS, index_code: code0, scale);
1243	}
1244	else if ((code1 == REG && REG_POINTER (arg1)) || code0 == MULT)
1245	{
1246	record_address_regs (mode, as, x: arg0, context: 1, outer_code: PLUS, index_code: code1, scale);
1247	record_address_regs (mode, as, x: arg1, context: 0, outer_code: PLUS, index_code: code0, scale);
1248	}
1249	/* Otherwise, count equal chances that each might be a base or
1250	index register. This case should be rare. */
1251	else
1252	{
1253	record_address_regs (mode, as, x: arg0, context: 0, outer_code: PLUS, index_code: code1, scale: scale / 2);
1254	record_address_regs (mode, as, x: arg0, context: 1, outer_code: PLUS, index_code: code1, scale: scale / 2);
1255	record_address_regs (mode, as, x: arg1, context: 0, outer_code: PLUS, index_code: code0, scale: scale / 2);
1256	record_address_regs (mode, as, x: arg1, context: 1, outer_code: PLUS, index_code: code0, scale: scale / 2);
1257	}
1258	}
1259	break;
1260
1261	/* Double the importance of an allocno that is incremented or
1262	decremented, since it would take two extra insns if it ends
1263	up in the wrong place. */
1264	case POST_MODIFY:
1265	case PRE_MODIFY:
1266	record_address_regs (mode, as, XEXP (x, 0), context: 0, outer_code: code,
1267	GET_CODE (XEXP (XEXP (x, 1), 1)), scale: 2 * scale);
1268	if (REG_P (XEXP (XEXP (x, 1), 1)))
1269	record_address_regs (mode, as, XEXP (XEXP (x, 1), 1), context: 1, outer_code: code, index_code: REG,
1270	scale: 2 * scale);
1271	break;
1272
1273	case POST_INC:
1274	case PRE_INC:
1275	case POST_DEC:
1276	case PRE_DEC:
1277	/* Double the importance of an allocno that is incremented or
1278	decremented, since it would take two extra insns if it ends
1279	up in the wrong place. */
1280	record_address_regs (mode, as, XEXP (x, 0), context: 0, outer_code: code, index_code: SCRATCH, scale: 2 * scale);
1281	break;
1282
1283	case REG:
1284	{
1285	struct costs *pp;
1286	int *pp_costs;
1287	enum reg_class i;
1288	int k, regno, add_cost;
1289	cost_classes_t cost_classes_ptr;
1290	enum reg_class *cost_classes;
1291	move_table *move_in_cost;
1292
1293	if (REGNO (x) < FIRST_PSEUDO_REGISTER)
1294	break;
1295
1296	regno = REGNO (x);
1297	if (allocno_p)
1298	ALLOCNO_BAD_SPILL_P (ira_curr_regno_allocno_map[regno]) = true;
1299	pp = COSTS (costs, COST_INDEX (regno));
1300	add_cost = (ira_memory_move_cost[Pmode][rclass][1] * scale) / 2;
1301	if (INT_MAX - add_cost < pp->mem_cost)
1302	pp->mem_cost = INT_MAX;
1303	else
1304	pp->mem_cost += add_cost;
1305	cost_classes_ptr = regno_cost_classes[regno];
1306	cost_classes = cost_classes_ptr->classes;
1307	pp_costs = pp->cost;
1308	ira_init_register_move_cost_if_necessary (Pmode);
1309	move_in_cost = ira_may_move_in_cost[Pmode];
1310	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
1311	{
1312	i = cost_classes[k];
1313	add_cost = (move_in_cost[i][rclass] * scale) / 2;
1314	if (INT_MAX - add_cost < pp_costs[k])
1315	pp_costs[k] = INT_MAX;
1316	else
1317	pp_costs[k] += add_cost;
1318	}
1319	}
1320	break;
1321
1322	default:
1323	{
1324	const char *fmt = GET_RTX_FORMAT (code);
1325	int i;
1326	for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1327	if (fmt[i] == 'e')
1328	record_address_regs (mode, as, XEXP (x, i), context, outer_code: code, index_code: SCRATCH,
1329	scale);
1330	}
1331	}
1332	}
1333
1334
1335
1336	/* Calculate the costs of insn operands. */
1337	static void
1338	record_operand_costs (rtx_insn *insn, enum reg_class *pref)
1339	{
1340	const char *constraints[MAX_RECOG_OPERANDS];
1341	machine_mode modes[MAX_RECOG_OPERANDS];
1342	rtx set;
1343	int i;
1344
1345	if ((set = single_set (insn)) != NULL_RTX
1346	/* In rare cases the single set insn might have less 2 operands
1347	as the source can be a fixed special reg. */
1348	&& recog_data.n_operands > 1
1349	&& recog_data.operand[0] == SET_DEST (set)
1350	&& recog_data.operand[1] == SET_SRC (set))
1351	{
1352	int regno, other_regno;
1353	rtx dest = SET_DEST (set);
1354	rtx src = SET_SRC (set);
1355
1356	if (GET_CODE (dest) == SUBREG
1357	&& known_eq (GET_MODE_SIZE (GET_MODE (dest)),
1358	GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))))
1359	dest = SUBREG_REG (dest);
1360	if (GET_CODE (src) == SUBREG
1361	&& known_eq (GET_MODE_SIZE (GET_MODE (src)),
1362	GET_MODE_SIZE (GET_MODE (SUBREG_REG (src)))))
1363	src = SUBREG_REG (src);
1364	if (REG_P (src) && REG_P (dest)
1365	&& (((regno = REGNO (src)) >= FIRST_PSEUDO_REGISTER
1366	&& (other_regno = REGNO (dest)) < FIRST_PSEUDO_REGISTER)
1367	|| ((regno = REGNO (dest)) >= FIRST_PSEUDO_REGISTER
1368	&& (other_regno = REGNO (src)) < FIRST_PSEUDO_REGISTER)))
1369	{
1370	machine_mode mode = GET_MODE (SET_SRC (set)), cost_mode = mode;
1371	machine_mode hard_reg_mode = GET_MODE(regno_reg_rtx[other_regno]);
1372	poly_int64 pmode_size = GET_MODE_SIZE (mode);
1373	poly_int64 phard_reg_mode_size = GET_MODE_SIZE (mode: hard_reg_mode);
1374	HOST_WIDE_INT mode_size, hard_reg_mode_size;
1375	cost_classes_t cost_classes_ptr = regno_cost_classes[regno];
1376	enum reg_class *cost_classes = cost_classes_ptr->classes;
1377	reg_class_t rclass, hard_reg_class, bigger_hard_reg_class;
1378	int cost_factor = 1, cost, k;
1379	move_table *move_costs;
1380	bool dead_p = find_regno_note (insn, REG_DEAD, REGNO (src));
1381
1382	hard_reg_class = REGNO_REG_CLASS (other_regno);
1383	bigger_hard_reg_class = ira_pressure_class_translate[hard_reg_class];
1384	/* Target code may return any cost for mode which does not fit the
1385	hard reg class (e.g. DImode for AREG on i386). Check this and use
1386	a bigger class to get the right cost. */
1387	if (bigger_hard_reg_class != NO_REGS
1388	&& ! ira_hard_reg_in_set_p (hard_regno: other_regno, mode,
1389	reg_class_contents[hard_reg_class]))
1390	hard_reg_class = bigger_hard_reg_class;
1391	ira_init_register_move_cost_if_necessary (mode);
1392	ira_init_register_move_cost_if_necessary (mode: hard_reg_mode);
1393	/* Use smaller movement cost for natural hard reg mode or its mode as
1394	operand. */
1395	if (pmode_size.is_constant (const_value: &mode_size)
1396	&& phard_reg_mode_size.is_constant (const_value: &hard_reg_mode_size))
1397	{
1398	/* Assume we are moving in the natural modes: */
1399	cost_factor = mode_size / hard_reg_mode_size;
1400	if (mode_size % hard_reg_mode_size != 0)
1401	cost_factor++;
1402	if (cost_factor
1403	* (ira_register_move_cost
1404	[hard_reg_mode][hard_reg_class][hard_reg_class])
1405	< (ira_register_move_cost
1406	[mode][hard_reg_class][hard_reg_class]))
1407	cost_mode = hard_reg_mode;
1408	else
1409	cost_factor = 1;
1410	}
1411	move_costs = ira_register_move_cost[cost_mode];
1412	i = regno == (int) REGNO (src) ? 1 : 0;
1413	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
1414	{
1415	rclass = cost_classes[k];
1416	cost = (i == 0
1417	? move_costs[hard_reg_class][rclass]
1418	: move_costs[rclass][hard_reg_class]);
1419	cost *= cost_factor;
1420	op_costs[i]->cost[k] = cost * frequency;
1421	/* If this insn is a single set copying operand 1 to
1422	operand 0 and one operand is an allocno with the
1423	other a hard reg or an allocno that prefers a hard
1424	register that is in its own register class then we
1425	may want to adjust the cost of that register class to
1426	-1.
1427
1428	Avoid the adjustment if the source does not die to
1429	avoid stressing of register allocator by preferencing
1430	two colliding registers into single class. */
1431	if (dead_p
1432	&& TEST_HARD_REG_BIT (reg_class_contents[rclass], bit: other_regno)
1433	&& (reg_class_size[(int) rclass]
1434	== (ira_reg_class_max_nregs
1435	[(int) rclass][(int) GET_MODE(src)])))
1436	{
1437	if (reg_class_size[rclass] == 1)
1438	op_costs[i]->cost[k] = -frequency;
1439	else if (in_hard_reg_set_p (reg_class_contents[rclass],
1440	GET_MODE(src), regno: other_regno))
1441	op_costs[i]->cost[k] = -frequency;
1442	}
1443	}
1444	op_costs[i]->mem_cost
1445	= ira_memory_move_cost[mode][hard_reg_class][i] * frequency;
1446	return;
1447	}
1448	}
1449
1450	for (i = 0; i < recog_data.n_operands; i++)
1451	{
1452	constraints[i] = recog_data.constraints[i];
1453	modes[i] = recog_data.operand_mode[i];
1454	}
1455
1456	/* If we get here, we are set up to record the costs of all the
1457	operands for this insn. Start by initializing the costs. Then
1458	handle any address registers. Finally record the desired classes
1459	for any allocnos, doing it twice if some pair of operands are
1460	commutative. */
1461	for (i = 0; i < recog_data.n_operands; i++)
1462	{
1463	rtx op_mem = extract_mem_from_operand (recog_data.operand[i]);
1464	memcpy (op_costs[i], init_cost, n: struct_costs_size);
1465
1466	if (GET_CODE (recog_data.operand[i]) == SUBREG)
1467	recog_data.operand[i] = SUBREG_REG (recog_data.operand[i]);
1468
1469	if (MEM_P (op_mem))
1470	record_address_regs (GET_MODE (op_mem),
1471	MEM_ADDR_SPACE (op_mem),
1472	XEXP (op_mem, 0),
1473	context: 0, outer_code: MEM, index_code: SCRATCH, scale: frequency * 2);
1474	else if (constraints[i][0] == 'p'
1475	|| (insn_extra_address_constraint
1476	(c: lookup_constraint (p: constraints[i]))))
1477	record_address_regs (VOIDmode, ADDR_SPACE_GENERIC,
1478	x: recog_data.operand[i], context: 0, outer_code: ADDRESS, index_code: SCRATCH,
1479	scale: frequency * 2);
1480	}
1481
1482	/* Check for commutative in a separate loop so everything will have
1483	been initialized. We must do this even if one operand is a
1484	constant--see addsi3 in m68k.md. */
1485	for (i = 0; i < (int) recog_data.n_operands - 1; i++)
1486	if (constraints[i][0] == '%')
1487	{
1488	const char *xconstraints[MAX_RECOG_OPERANDS];
1489	int j;
1490
1491	/* Handle commutative operands by swapping the
1492	constraints. We assume the modes are the same. */
1493	for (j = 0; j < recog_data.n_operands; j++)
1494	xconstraints[j] = constraints[j];
1495
1496	xconstraints[i] = constraints[i+1];
1497	xconstraints[i+1] = constraints[i];
1498	record_reg_classes (n_alts: recog_data.n_alternatives, n_ops: recog_data.n_operands,
1499	ops: recog_data.operand, modes,
1500	constraints: xconstraints, insn, pref);
1501	}
1502	record_reg_classes (n_alts: recog_data.n_alternatives, n_ops: recog_data.n_operands,
1503	ops: recog_data.operand, modes,
1504	constraints, insn, pref);
1505	}
1506
1507
1508
1509	/* Process one insn INSN. Scan it and record each time it would save
1510	code to put a certain allocnos in a certain class. Return the last
1511	insn processed, so that the scan can be continued from there. */
1512	static rtx_insn *
1513	scan_one_insn (rtx_insn *insn)
1514	{
1515	enum rtx_code pat_code;
1516	rtx set, note;
1517	int i, k;
1518	bool counted_mem;
1519
1520	if (!NONDEBUG_INSN_P (insn))
1521	return insn;
1522
1523	pat_code = GET_CODE (PATTERN (insn));
1524	if (pat_code == ASM_INPUT)
1525	return insn;
1526
1527	/* If INSN is a USE/CLOBBER of a pseudo in a mode M then go ahead
1528	and initialize the register move costs of mode M.
1529
1530	The pseudo may be related to another pseudo via a copy (implicit or
1531	explicit) and if there are no mode M uses/sets of the original
1532	pseudo, then we may leave the register move costs uninitialized for
1533	mode M. */
1534	if (pat_code == USE || pat_code == CLOBBER)
1535	{
1536	rtx x = XEXP (PATTERN (insn), 0);
1537	if (GET_CODE (x) == REG
1538	&& REGNO (x) >= FIRST_PSEUDO_REGISTER
1539	&& have_regs_of_mode[GET_MODE (x)])
1540	ira_init_register_move_cost_if_necessary (GET_MODE (x));
1541	return insn;
1542	}
1543
1544	counted_mem = false;
1545	set = single_set (insn);
1546	extract_insn (insn);
1547
1548	/* If this insn loads a parameter from its stack slot, then it
1549	represents a savings, rather than a cost, if the parameter is
1550	stored in memory. Record this fact.
1551
1552	Similarly if we're loading other constants from memory (constant
1553	pool, TOC references, small data areas, etc) and this is the only
1554	assignment to the destination pseudo.
1555
1556	Don't do this if SET_SRC (set) isn't a general operand, if it is
1557	a memory requiring special instructions to load it, decreasing
1558	mem_cost might result in it being loaded using the specialized
1559	instruction into a register, then stored into stack and loaded
1560	again from the stack. See PR52208.
1561
1562	Don't do this if SET_SRC (set) has side effect. See PR56124. */
1563	if (set != 0 && REG_P (SET_DEST (set)) && MEM_P (SET_SRC (set))
1564	&& (note = find_reg_note (insn, REG_EQUIV, NULL_RTX)) != NULL_RTX
1565	&& ((MEM_P (XEXP (note, 0))
1566	&& !side_effects_p (SET_SRC (set)))
1567	|| (CONSTANT_P (XEXP (note, 0))
1568	&& targetm.legitimate_constant_p (GET_MODE (SET_DEST (set)),
1569	XEXP (note, 0))
1570	&& REG_N_SETS (REGNO (SET_DEST (set))) == 1))
1571	&& general_operand (SET_SRC (set), GET_MODE (SET_SRC (set)))
1572	/* LRA does not use equiv with a symbol for PIC code. */
1573	&& (! ira_use_lra_p || ! pic_offset_table_rtx
1574	|| ! contains_symbol_ref_p (XEXP (note, 0))))
1575	{
1576	enum reg_class cl = GENERAL_REGS;
1577	rtx reg = SET_DEST (set);
1578	int num = COST_INDEX (REGNO (reg));
1579	/* Costs for NO_REGS are used in cost calculation on the
1580	1st pass when the preferred register classes are not
1581	known yet. In this case we take the best scenario when
1582	mode can't be put into GENERAL_REGS. */
1583	if (!targetm.hard_regno_mode_ok (ira_class_hard_regs[cl][0],
1584	GET_MODE (reg)))
1585	cl = NO_REGS;
1586
1587	COSTS (costs, num)->mem_cost
1588	-= ira_memory_move_cost[GET_MODE (reg)][cl][1] * frequency;
1589	record_address_regs (GET_MODE (SET_SRC (set)),
1590	MEM_ADDR_SPACE (SET_SRC (set)),
1591	XEXP (SET_SRC (set), 0), context: 0, outer_code: MEM, index_code: SCRATCH,
1592	scale: frequency * 2);
1593	counted_mem = true;
1594	}
1595
1596	record_operand_costs (insn, pref);
1597
1598	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5)
1599	{
1600	const char *p;
1601	fprintf (stream: ira_dump_file, format: " Final costs after insn %u", INSN_UID (insn));
1602	if (INSN_CODE (insn) >= 0
1603	&& (p = get_insn_name (INSN_CODE (insn))) != NULL)
1604	fprintf (stream: ira_dump_file, format: " {%s}", p);
1605	fprintf (stream: ira_dump_file, format: " (freq=%d)\n",
1606	REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn)));
1607	dump_insn_slim (ira_dump_file, insn);
1608	}
1609
1610	/* Now add the cost for each operand to the total costs for its
1611	allocno. */
1612	for (i = 0; i < recog_data.n_operands; i++)
1613	{
1614	rtx op = recog_data.operand[i];
1615
1616	if (GET_CODE (op) == SUBREG)
1617	op = SUBREG_REG (op);
1618	if (REG_P (op) && REGNO (op) >= FIRST_PSEUDO_REGISTER)
1619	{
1620	int regno = REGNO (op);
1621	struct costs *p = COSTS (costs, COST_INDEX (regno));
1622	struct costs *q = op_costs[i];
1623	int *p_costs = p->cost, *q_costs = q->cost;
1624	cost_classes_t cost_classes_ptr = regno_cost_classes[regno];
1625	int add_cost = 0;
1626
1627	/* If the already accounted for the memory "cost" above, don't
1628	do so again. */
1629	if (!counted_mem)
1630	{
1631	add_cost = q->mem_cost;
1632	if (add_cost > 0 && INT_MAX - add_cost < p->mem_cost)
1633	p->mem_cost = INT_MAX;
1634	else
1635	p->mem_cost += add_cost;
1636	}
1637	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5)
1638	{
1639	fprintf (stream: ira_dump_file, format: " op %d(r=%u) MEM:%d(+%d)",
1640	i, REGNO(op), p->mem_cost, add_cost);
1641	}
1642	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
1643	{
1644	add_cost = q_costs[k];
1645	if (add_cost > 0 && INT_MAX - add_cost < p_costs[k])
1646	p_costs[k] = INT_MAX;
1647	else
1648	p_costs[k] += add_cost;
1649	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5)
1650	{
1651	fprintf (stream: ira_dump_file, format: " %s:%d(+%d)",
1652	reg_class_names[cost_classes_ptr->classes[k]],
1653	p_costs[k], add_cost);
1654	}
1655	}
1656	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5)
1657	fprintf (stream: ira_dump_file, format: "\n");
1658	}
1659	}
1660	return insn;
1661	}
1662
1663
1664
1665	/* Print allocnos costs to file F. */
1666	static void
1667	print_allocno_costs (FILE *f)
1668	{
1669	int k;
1670	ira_allocno_t a;
1671	ira_allocno_iterator ai;
1672
1673	ira_assert (allocno_p);
1674	fprintf (stream: f, format: "\n");
1675	FOR_EACH_ALLOCNO (a, ai)
1676	{
1677	int i, rclass;
1678	basic_block bb;
1679	int regno = ALLOCNO_REGNO (a);
1680	cost_classes_t cost_classes_ptr = regno_cost_classes[regno];
1681	enum reg_class *cost_classes = cost_classes_ptr->classes;
1682
1683	i = ALLOCNO_NUM (a);
1684	fprintf (stream: f, format: " a%d(r%d,", i, regno);
1685	if ((bb = ALLOCNO_LOOP_TREE_NODE (a)->bb) != NULL)
1686	fprintf (stream: f, format: "b%d", bb->index);
1687	else
1688	fprintf (stream: f, format: "l%d", ALLOCNO_LOOP_TREE_NODE (a)->loop_num);
1689	fprintf (stream: f, format: ") costs:");
1690	for (k = 0; k < cost_classes_ptr->num; k++)
1691	{
1692	rclass = cost_classes[k];
1693	fprintf (stream: f, format: " %s:%d", reg_class_names[rclass],
1694	COSTS (costs, i)->cost[k]);
1695	if (flag_ira_region == IRA_REGION_ALL
1696	|| flag_ira_region == IRA_REGION_MIXED)
1697	fprintf (stream: f, format: ",%d", COSTS (total_allocno_costs, i)->cost[k]);
1698	}
1699	fprintf (stream: f, format: " MEM:%i", COSTS (costs, i)->mem_cost);
1700	if (flag_ira_region == IRA_REGION_ALL
1701	|| flag_ira_region == IRA_REGION_MIXED)
1702	fprintf (stream: f, format: ",%d", COSTS (total_allocno_costs, i)->mem_cost);
1703	fprintf (stream: f, format: "\n");
1704	}
1705	}
1706
1707	/* Print pseudo costs to file F. */
1708	static void
1709	print_pseudo_costs (FILE *f)
1710	{
1711	int regno, k;
1712	int rclass;
1713	cost_classes_t cost_classes_ptr;
1714	enum reg_class *cost_classes;
1715
1716	ira_assert (! allocno_p);
1717	fprintf (stream: f, format: "\n");
1718	for (regno = max_reg_num () - 1; regno >= FIRST_PSEUDO_REGISTER; regno--)
1719	{
1720	if (REG_N_REFS (regno) <= 0)
1721	continue;
1722	cost_classes_ptr = regno_cost_classes[regno];
1723	cost_classes = cost_classes_ptr->classes;
1724	fprintf (stream: f, format: " r%d costs:", regno);
1725	for (k = 0; k < cost_classes_ptr->num; k++)
1726	{
1727	rclass = cost_classes[k];
1728	fprintf (stream: f, format: " %s:%d", reg_class_names[rclass],
1729	COSTS (costs, regno)->cost[k]);
1730	}
1731	fprintf (stream: f, format: " MEM:%i\n", COSTS (costs, regno)->mem_cost);
1732	}
1733	}
1734
1735	/* Traverse the BB represented by LOOP_TREE_NODE to update the allocno
1736	costs. */
1737	static void
1738	process_bb_for_costs (basic_block bb)
1739	{
1740	rtx_insn *insn;
1741
1742	frequency = REG_FREQ_FROM_BB (bb);
1743	if (frequency == 0)
1744	frequency = 1;
1745	FOR_BB_INSNS (bb, insn)
1746	insn = scan_one_insn (insn);
1747	}
1748
1749	/* Traverse the BB represented by LOOP_TREE_NODE to update the allocno
1750	costs. */
1751	static void
1752	process_bb_node_for_costs (ira_loop_tree_node_t loop_tree_node)
1753	{
1754	basic_block bb;
1755
1756	bb = loop_tree_node->bb;
1757	if (bb != NULL)
1758	process_bb_for_costs (bb);
1759	}
1760
1761	/* Check that reg REGNO can be changed by TO in INSN. Return true in case the
1762	result insn would be valid one. */
1763	static bool
1764	equiv_can_be_consumed_p (int regno, rtx to, rtx_insn *insn)
1765	{
1766	validate_replace_src_group (regno_reg_rtx[regno], to, insn);
1767	bool res = verify_changes (0);
1768	cancel_changes (0);
1769	return res;
1770	}
1771
1772	/* Return true if X contains a pseudo with equivalence. In this case also
1773	return the pseudo through parameter REG. If the pseudo is a part of subreg,
1774	return the subreg through parameter SUBREG. */
1775
1776	static bool
1777	get_equiv_regno (rtx x, int &regno, rtx &subreg)
1778	{
1779	subreg = NULL_RTX;
1780	if (GET_CODE (x) == SUBREG)
1781	{
1782	subreg = x;
1783	x = SUBREG_REG (x);
1784	}
1785	if (REG_P (x)
1786	&& (ira_reg_equiv[REGNO (x)].memory != NULL
1787	|| ira_reg_equiv[REGNO (x)].invariant != NULL
1788	|| ira_reg_equiv[REGNO (x)].constant != NULL))
1789	{
1790	regno = REGNO (x);
1791	return true;
1792	}
1793	RTX_CODE code = GET_CODE (x);
1794	const char *fmt = GET_RTX_FORMAT (code);
1795
1796	for (int i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1797	if (fmt[i] == 'e')
1798	{
1799	if (get_equiv_regno (XEXP (x, i), regno, subreg))
1800	return true;
1801	}
1802	else if (fmt[i] == 'E')
1803	{
1804	for (int j = 0; j < XVECLEN (x, i); j++)
1805	if (get_equiv_regno (XVECEXP (x, i, j), regno, subreg))
1806	return true;
1807	}
1808	return false;
1809	}
1810
1811	/* A pass through the current function insns. Calculate costs of using
1812	equivalences for pseudos and store them in regno_equiv_gains. */
1813
1814	static void
1815	calculate_equiv_gains (void)
1816	{
1817	basic_block bb;
1818	int regno, freq, cost;
1819	rtx subreg;
1820	rtx_insn *insn;
1821	machine_mode mode;
1822	enum reg_class rclass;
1823	bitmap_head equiv_pseudos;
1824
1825	ira_assert (allocno_p);
1826	bitmap_initialize (head: &equiv_pseudos, obstack: &reg_obstack);
1827	for (regno = max_reg_num () - 1; regno >= FIRST_PSEUDO_REGISTER; regno--)
1828	if (ira_reg_equiv[regno].init_insns != NULL
1829	&& (ira_reg_equiv[regno].memory != NULL
1830	|| ira_reg_equiv[regno].invariant != NULL
1831	|| (ira_reg_equiv[regno].constant != NULL
1832	/* Ignore complicated constants which probably will be placed
1833	in memory: */
1834	&& GET_CODE (ira_reg_equiv[regno].constant) != CONST_DOUBLE
1835	&& GET_CODE (ira_reg_equiv[regno].constant) != CONST_VECTOR
1836	&& GET_CODE (ira_reg_equiv[regno].constant) != LABEL_REF)))
1837	{
1838	rtx_insn_list *x;
1839	for (x = ira_reg_equiv[regno].init_insns; x != NULL; x = x->next ())
1840	{
1841	insn = x->insn ();
1842	rtx set = single_set (insn);
1843
1844	if (set == NULL_RTX || SET_DEST (set) != regno_reg_rtx[regno])
1845	break;
1846	bb = BLOCK_FOR_INSN (insn);
1847	ira_curr_regno_allocno_map
1848	= ira_bb_nodes[bb->index].parent->regno_allocno_map;
1849	mode = PSEUDO_REGNO_MODE (regno);
1850	rclass = pref[COST_INDEX (regno)];
1851	ira_init_register_move_cost_if_necessary (mode);
1852	if (ira_reg_equiv[regno].memory != NULL)
1853	cost = ira_memory_move_cost[mode][rclass][1];
1854	else
1855	cost = ira_register_move_cost[mode][rclass][rclass];
1856	freq = REG_FREQ_FROM_BB (bb);
1857	regno_equiv_gains[regno] += cost * freq;
1858	}
1859	if (x != NULL)
1860	/* We found complicated equiv or reverse equiv mem=reg. Ignore
1861	them. */
1862	regno_equiv_gains[regno] = 0;
1863	else
1864	bitmap_set_bit (&equiv_pseudos, regno);
1865	}
1866
1867	FOR_EACH_BB_FN (bb, cfun)
1868	{
1869	freq = REG_FREQ_FROM_BB (bb);
1870	ira_curr_regno_allocno_map
1871	= ira_bb_nodes[bb->index].parent->regno_allocno_map;
1872	FOR_BB_INSNS (bb, insn)
1873	{
1874	if (!NONDEBUG_INSN_P (insn)
1875	|| !get_equiv_regno (x: PATTERN (insn), regno, subreg)
1876	|| !bitmap_bit_p (&equiv_pseudos, regno))
1877	continue;
1878	rtx subst = ira_reg_equiv[regno].memory;
1879
1880	if (subst == NULL)
1881	subst = ira_reg_equiv[regno].constant;
1882	if (subst == NULL)
1883	subst = ira_reg_equiv[regno].invariant;
1884	ira_assert (subst != NULL);
1885	mode = PSEUDO_REGNO_MODE (regno);
1886	ira_init_register_move_cost_if_necessary (mode);
1887	bool consumed_p = equiv_can_be_consumed_p (regno, to: subst, insn);
1888
1889	rclass = pref[COST_INDEX (regno)];
1890	if (MEM_P (subst)
1891	/* If it is a change of constant into double for example, the
1892	result constant probably will be placed in memory. */
1893	|| (subreg != NULL_RTX && !INTEGRAL_MODE_P (GET_MODE (subreg))))
1894	cost = ira_memory_move_cost[mode][rclass][1] + (consumed_p ? 0 : 1);
1895	else if (consumed_p)
1896	continue;
1897	else
1898	cost = ira_register_move_cost[mode][rclass][rclass];
1899	regno_equiv_gains[regno] -= cost * freq;
1900	}
1901	}
1902	bitmap_clear (&equiv_pseudos);
1903	}
1904
1905	/* Find costs of register classes and memory for allocnos or pseudos
1906	and their best costs. Set up preferred, alternative and allocno
1907	classes for pseudos. */
1908	static void
1909	find_costs_and_classes (FILE *dump_file)
1910	{
1911	int i, k, start, max_cost_classes_num;
1912	int pass;
1913	basic_block bb;
1914	enum reg_class *regno_best_class, new_class;
1915
1916	init_recog ();
1917	regno_best_class
1918	= (enum reg_class *) ira_allocate (max_reg_num ()
1919	* sizeof (enum reg_class));
1920	for (i = max_reg_num () - 1; i >= FIRST_PSEUDO_REGISTER; i--)
1921	regno_best_class[i] = NO_REGS;
1922	if (!resize_reg_info () && allocno_p
1923	&& pseudo_classes_defined_p && flag_expensive_optimizations)
1924	{
1925	ira_allocno_t a;
1926	ira_allocno_iterator ai;
1927
1928	pref = pref_buffer;
1929	max_cost_classes_num = 1;
1930	FOR_EACH_ALLOCNO (a, ai)
1931	{
1932	pref[ALLOCNO_NUM (a)] = reg_preferred_class (ALLOCNO_REGNO (a));
1933	setup_regno_cost_classes_by_aclass
1934	(ALLOCNO_REGNO (a), aclass: pref[ALLOCNO_NUM (a)]);
1935	max_cost_classes_num
1936	= MAX (max_cost_classes_num,
1937	regno_cost_classes[ALLOCNO_REGNO (a)]->num);
1938	}
1939	start = 1;
1940	}
1941	else
1942	{
1943	pref = NULL;
1944	max_cost_classes_num = ira_important_classes_num;
1945	for (i = max_reg_num () - 1; i >= FIRST_PSEUDO_REGISTER; i--)
1946	if (regno_reg_rtx[i] != NULL_RTX)
1947	setup_regno_cost_classes_by_mode (regno: i, PSEUDO_REGNO_MODE (i));
1948	else
1949	setup_regno_cost_classes_by_aclass (regno: i, aclass: ALL_REGS);
1950	start = 0;
1951	}
1952	if (allocno_p)
1953	/* Clear the flag for the next compiled function. */
1954	pseudo_classes_defined_p = false;
1955	/* Normally we scan the insns once and determine the best class to
1956	use for each allocno. However, if -fexpensive-optimizations are
1957	on, we do so twice, the second time using the tentative best
1958	classes to guide the selection. */
1959	for (pass = start; pass <= flag_expensive_optimizations; pass++)
1960	{
1961	if ((!allocno_p || internal_flag_ira_verbose > 0) && dump_file)
1962	fprintf (stream: dump_file,
1963	format: "\nPass %i for finding pseudo/allocno costs\n\n", pass);
1964
1965	if (pass != start)
1966	{
1967	max_cost_classes_num = 1;
1968	for (i = max_reg_num () - 1; i >= FIRST_PSEUDO_REGISTER; i--)
1969	{
1970	setup_regno_cost_classes_by_aclass (regno: i, aclass: regno_best_class[i]);
1971	max_cost_classes_num
1972	= MAX (max_cost_classes_num, regno_cost_classes[i]->num);
1973	}
1974	}
1975
1976	struct_costs_size
1977	= sizeof (struct costs) + sizeof (int) * (max_cost_classes_num - 1);
1978	/* Zero out our accumulation of the cost of each class for each
1979	allocno. */
1980	memset (s: costs, c: 0, n: cost_elements_num * struct_costs_size);
1981
1982	if (allocno_p)
1983	{
1984	/* Scan the instructions and record each time it would save code
1985	to put a certain allocno in a certain class. */
1986	ira_traverse_loop_tree (true, ira_loop_tree_root,
1987	process_bb_node_for_costs, NULL);
1988
1989	memcpy (dest: total_allocno_costs, src: costs,
1990	max_struct_costs_size * ira_allocnos_num);
1991	}
1992	else
1993	{
1994	basic_block bb;
1995
1996	FOR_EACH_BB_FN (bb, cfun)
1997	process_bb_for_costs (bb);
1998	}
1999
2000	if (pass == 0)
2001	pref = pref_buffer;
2002
2003	if (ira_use_lra_p && allocno_p && pass == 1)
2004	/* It is a pass through all insns. So do it once and only for RA (not
2005	for insn scheduler) when we already found preferable pseudo register
2006	classes on the previous pass. */
2007	calculate_equiv_gains ();
2008
2009	/* Now for each allocno look at how desirable each class is and
2010	find which class is preferred. */
2011	for (i = max_reg_num () - 1; i >= FIRST_PSEUDO_REGISTER; i--)
2012	{
2013	ira_allocno_t a, parent_a;
2014	int rclass, a_num, parent_a_num, add_cost;
2015	ira_loop_tree_node_t parent;
2016	int best_cost, allocno_cost;
2017	enum reg_class best, alt_class;
2018	cost_classes_t cost_classes_ptr = regno_cost_classes[i];
2019	enum reg_class *cost_classes;
2020	int *i_costs = temp_costs->cost;
2021	int i_mem_cost;
2022	int equiv_savings = regno_equiv_gains[i];
2023
2024	if (! allocno_p)
2025	{
2026	if (regno_reg_rtx[i] == NULL_RTX)
2027	continue;
2028	memcpy (temp_costs, COSTS (costs, i), n: struct_costs_size);
2029	i_mem_cost = temp_costs->mem_cost;
2030	cost_classes = cost_classes_ptr->classes;
2031	}
2032	else
2033	{
2034	if (ira_regno_allocno_map[i] == NULL)
2035	continue;
2036	memset (temp_costs, c: 0, n: struct_costs_size);
2037	i_mem_cost = 0;
2038	cost_classes = cost_classes_ptr->classes;
2039	/* Find cost of all allocnos with the same regno. */
2040	for (a = ira_regno_allocno_map[i];
2041	a != NULL;
2042	a = ALLOCNO_NEXT_REGNO_ALLOCNO (a))
2043	{
2044	int *a_costs, *p_costs;
2045
2046	a_num = ALLOCNO_NUM (a);
2047	if ((flag_ira_region == IRA_REGION_ALL
2048	|| flag_ira_region == IRA_REGION_MIXED)
2049	&& (parent = ALLOCNO_LOOP_TREE_NODE (a)->parent) != NULL
2050	&& (parent_a = parent->regno_allocno_map[i]) != NULL
2051	/* There are no caps yet. */
2052	&& bitmap_bit_p (ALLOCNO_LOOP_TREE_NODE
2053	(a)->border_allocnos,
2054	ALLOCNO_NUM (a)))
2055	{
2056	/* Propagate costs to upper levels in the region
2057	tree. */
2058	parent_a_num = ALLOCNO_NUM (parent_a);
2059	a_costs = COSTS (total_allocno_costs, a_num)->cost;
2060	p_costs = COSTS (total_allocno_costs, parent_a_num)->cost;
2061	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
2062	{
2063	add_cost = a_costs[k];
2064	if (add_cost > 0 && INT_MAX - add_cost < p_costs[k])
2065	p_costs[k] = INT_MAX;
2066	else
2067	p_costs[k] += add_cost;
2068	}
2069	add_cost = COSTS (total_allocno_costs, a_num)->mem_cost;
2070	if (add_cost > 0
2071	&& (INT_MAX - add_cost
2072	< COSTS (total_allocno_costs,
2073	parent_a_num)->mem_cost))
2074	COSTS (total_allocno_costs, parent_a_num)->mem_cost
2075	= INT_MAX;
2076	else
2077	COSTS (total_allocno_costs, parent_a_num)->mem_cost
2078	+= add_cost;
2079
2080	if (i >= first_moveable_pseudo && i < last_moveable_pseudo)
2081	COSTS (total_allocno_costs, parent_a_num)->mem_cost = 0;
2082	}
2083	a_costs = COSTS (costs, a_num)->cost;
2084	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
2085	{
2086	add_cost = a_costs[k];
2087	if (add_cost > 0 && INT_MAX - add_cost < i_costs[k])
2088	i_costs[k] = INT_MAX;
2089	else
2090	i_costs[k] += add_cost;
2091	}
2092	add_cost = COSTS (costs, a_num)->mem_cost;
2093	if (add_cost > 0 && INT_MAX - add_cost < i_mem_cost)
2094	i_mem_cost = INT_MAX;
2095	else
2096	i_mem_cost += add_cost;
2097	}
2098	}
2099	if (i >= first_moveable_pseudo && i < last_moveable_pseudo)
2100	i_mem_cost = 0;
2101	else if (ira_use_lra_p)
2102	{
2103	if (equiv_savings > 0)
2104	{
2105	i_mem_cost = 0;
2106	if (ira_dump_file != NULL && internal_flag_ira_verbose > 5)
2107	fprintf (stream: ira_dump_file,
2108	format: " Use MEM for r%d as the equiv savings is %d\n",
2109	i, equiv_savings);
2110	}
2111	}
2112	else if (equiv_savings < 0)
2113	i_mem_cost = -equiv_savings;
2114	else if (equiv_savings > 0)
2115	{
2116	i_mem_cost = 0;
2117	for (k = cost_classes_ptr->num - 1; k >= 0; k--)
2118	i_costs[k] += equiv_savings;
2119	}
2120
2121	best_cost = (1 << (HOST_BITS_PER_INT - 2)) - 1;
2122	best = ALL_REGS;
2123	alt_class = NO_REGS;
2124	/* Find best common class for all allocnos with the same
2125	regno. */
2126	for (k = 0; k < cost_classes_ptr->num; k++)
2127	{
2128	rclass = cost_classes[k];
2129	if (i_costs[k] < best_cost)
2130	{
2131	best_cost = i_costs[k];
2132	best = (enum reg_class) rclass;
2133	}
2134	else if (i_costs[k] == best_cost)
2135	best = ira_reg_class_subunion[best][rclass];
2136	if (pass == flag_expensive_optimizations
2137	/* We still prefer registers to memory even at this
2138	stage if their costs are the same. We will make
2139	a final decision during assigning hard registers
2140	when we have all info including more accurate
2141	costs which might be affected by assigning hard
2142	registers to other pseudos because the pseudos
2143	involved in moves can be coalesced. */
2144	&& i_costs[k] <= i_mem_cost
2145	&& (reg_class_size[reg_class_subunion[alt_class][rclass]]
2146	> reg_class_size[alt_class]))
2147	alt_class = reg_class_subunion[alt_class][rclass];
2148	}
2149	alt_class = ira_allocno_class_translate[alt_class];
2150	if (best_cost > i_mem_cost
2151	&& ! non_spilled_static_chain_regno_p (regno: i))
2152	regno_aclass[i] = NO_REGS;
2153	else if (!optimize && !targetm.class_likely_spilled_p (best))
2154	/* Registers in the alternative class are likely to need
2155	longer or slower sequences than registers in the best class.
2156	When optimizing we make some effort to use the best class
2157	over the alternative class where possible, but at -O0 we
2158	effectively give the alternative class equal weight.
2159	We then run the risk of using slower alternative registers
2160	when plenty of registers from the best class are still free.
2161	This is especially true because live ranges tend to be very
2162	short in -O0 code and so register pressure tends to be low.
2163
2164	Avoid that by ignoring the alternative class if the best
2165	class has plenty of registers.
2166
2167	The union class arrays give important classes and only
2168	part of it are allocno classes. So translate them into
2169	allocno classes. */
2170	regno_aclass[i] = ira_allocno_class_translate[best];
2171	else
2172	{
2173	/* Make the common class the biggest class of best and
2174	alt_class. Translate the common class into an
2175	allocno class too. */
2176	regno_aclass[i] = (ira_allocno_class_translate
2177	[ira_reg_class_superunion[best][alt_class]]);
2178	ira_assert (regno_aclass[i] != NO_REGS
2179	&& ira_reg_allocno_class_p[regno_aclass[i]]);
2180	}
2181	if (pic_offset_table_rtx != NULL
2182	&& i == (int) REGNO (pic_offset_table_rtx))
2183	{
2184	/* For some targets, integer pseudos can be assigned to fp
2185	regs. As we don't want reload pic offset table pseudo, we
2186	should avoid using non-integer regs. */
2187	regno_aclass[i]
2188	= ira_reg_class_intersect[regno_aclass[i]][GENERAL_REGS];
2189	alt_class = ira_reg_class_intersect[alt_class][GENERAL_REGS];
2190	}
2191	if ((new_class
2192	= (reg_class) (targetm.ira_change_pseudo_allocno_class
2193	(i, regno_aclass[i], best))) != regno_aclass[i])
2194	{
2195	regno_aclass[i] = new_class;
2196	if (hard_reg_set_subset_p (reg_class_contents[new_class],
2197	reg_class_contents[best]))
2198	best = new_class;
2199	if (hard_reg_set_subset_p (reg_class_contents[new_class],
2200	reg_class_contents[alt_class]))
2201	alt_class = new_class;
2202	}
2203	if (pass == flag_expensive_optimizations)
2204	{
2205	if (best_cost > i_mem_cost
2206	/* Do not assign NO_REGS to static chain pointer
2207	pseudo when non-local goto is used. */
2208	&& ! non_spilled_static_chain_regno_p (regno: i))
2209	best = alt_class = NO_REGS;
2210	else if (best == alt_class)
2211	alt_class = NO_REGS;
2212	setup_reg_classes (i, best, alt_class, regno_aclass[i]);
2213	if ((!allocno_p || internal_flag_ira_verbose > 2)
2214	&& dump_file != NULL)
2215	fprintf (stream: dump_file,
2216	format: " r%d: preferred %s, alternative %s, allocno %s\n",
2217	i, reg_class_names[best], reg_class_names[alt_class],
2218	reg_class_names[regno_aclass[i]]);
2219	}
2220	regno_best_class[i] = best;
2221	if (! allocno_p)
2222	{
2223	pref[i] = (best_cost > i_mem_cost
2224	&& ! non_spilled_static_chain_regno_p (regno: i)
2225	? NO_REGS : best);
2226	continue;
2227	}
2228	for (a = ira_regno_allocno_map[i];
2229	a != NULL;
2230	a = ALLOCNO_NEXT_REGNO_ALLOCNO (a))
2231	{
2232	enum reg_class aclass = regno_aclass[i];
2233	int a_num = ALLOCNO_NUM (a);
2234	int *total_a_costs = COSTS (total_allocno_costs, a_num)->cost;
2235	int *a_costs = COSTS (costs, a_num)->cost;
2236
2237	if (aclass == NO_REGS)
2238	best = NO_REGS;
2239	else
2240	{
2241	/* Finding best class which is subset of the common
2242	class. */
2243	best_cost = (1 << (HOST_BITS_PER_INT - 2)) - 1;
2244	allocno_cost = best_cost;
2245	best = ALL_REGS;
2246	for (k = 0; k < cost_classes_ptr->num; k++)
2247	{
2248	rclass = cost_classes[k];
2249	if (! ira_class_subset_p[rclass][aclass])
2250	continue;
2251	if (total_a_costs[k] < best_cost)
2252	{
2253	best_cost = total_a_costs[k];
2254	allocno_cost = a_costs[k];
2255	best = (enum reg_class) rclass;
2256	}
2257	else if (total_a_costs[k] == best_cost)
2258	{
2259	best = ira_reg_class_subunion[best][rclass];
2260	allocno_cost = MAX (allocno_cost, a_costs[k]);
2261	}
2262	}
2263	ALLOCNO_CLASS_COST (a) = allocno_cost;
2264	}
2265	if (internal_flag_ira_verbose > 2 && dump_file != NULL
2266	&& (pass == 0 || pref[a_num] != best))
2267	{
2268	fprintf (stream: dump_file, format: " a%d (r%d,", a_num, i);
2269	if ((bb = ALLOCNO_LOOP_TREE_NODE (a)->bb) != NULL)
2270	fprintf (stream: dump_file, format: "b%d", bb->index);
2271	else
2272	fprintf (stream: dump_file, format: "l%d",
2273	ALLOCNO_LOOP_TREE_NODE (a)->loop_num);
2274	fprintf (stream: dump_file, format: ") best %s, allocno %s\n",
2275	reg_class_names[best],
2276	reg_class_names[aclass]);
2277	}
2278	pref[a_num] = best;
2279	if (pass == flag_expensive_optimizations && best != aclass
2280	&& ira_class_hard_regs_num[best] > 0
2281	&& (ira_reg_class_max_nregs[best][ALLOCNO_MODE (a)]
2282	>= ira_class_hard_regs_num[best]))
2283	{
2284	int ind = cost_classes_ptr->index[aclass];
2285
2286	ira_assert (ind >= 0);
2287	ira_init_register_move_cost_if_necessary (ALLOCNO_MODE (a));
2288	ira_add_allocno_pref (a, ira_class_hard_regs[best][0],
2289	(a_costs[ind] - ALLOCNO_CLASS_COST (a))
2290	/ (ira_register_move_cost
2291	[ALLOCNO_MODE (a)][best][aclass]));
2292	for (k = 0; k < cost_classes_ptr->num; k++)
2293	if (ira_class_subset_p[cost_classes[k]][best])
2294	a_costs[k] = a_costs[ind];
2295	}
2296	}
2297	}
2298
2299	if (internal_flag_ira_verbose > 4 && dump_file)
2300	{
2301	if (allocno_p)
2302	print_allocno_costs (f: dump_file);
2303	else
2304	print_pseudo_costs (f: dump_file);
2305	fprintf (stream: dump_file,format: "\n");
2306	}
2307	}
2308	ira_free (addr: regno_best_class);
2309	}
2310
2311
2312
2313	/* Process moves involving hard regs to modify allocno hard register
2314	costs. We can do this only after determining allocno class. If a
2315	hard register forms a register class, then moves with the hard
2316	register are already taken into account in class costs for the
2317	allocno. */
2318	static void
2319	process_bb_node_for_hard_reg_moves (ira_loop_tree_node_t loop_tree_node)
2320	{
2321	int i, freq, src_regno, dst_regno, hard_regno, a_regno;
2322	bool to_p;
2323	ira_allocno_t a, curr_a;
2324	ira_loop_tree_node_t curr_loop_tree_node;
2325	enum reg_class rclass;
2326	basic_block bb;
2327	rtx_insn *insn;
2328	rtx set, src, dst;
2329
2330	bb = loop_tree_node->bb;
2331	if (bb == NULL)
2332	return;
2333	freq = REG_FREQ_FROM_BB (bb);
2334	if (freq == 0)
2335	freq = 1;
2336	FOR_BB_INSNS (bb, insn)
2337	{
2338	if (!NONDEBUG_INSN_P (insn))
2339	continue;
2340	set = single_set (insn);
2341	if (set == NULL_RTX)
2342	continue;
2343	dst = SET_DEST (set);
2344	src = SET_SRC (set);
2345	if (! REG_P (dst) || ! REG_P (src))
2346	continue;
2347	dst_regno = REGNO (dst);
2348	src_regno = REGNO (src);
2349	if (dst_regno >= FIRST_PSEUDO_REGISTER
2350	&& src_regno < FIRST_PSEUDO_REGISTER)
2351	{
2352	hard_regno = src_regno;
2353	a = ira_curr_regno_allocno_map[dst_regno];
2354	to_p = true;
2355	}
2356	else if (src_regno >= FIRST_PSEUDO_REGISTER
2357	&& dst_regno < FIRST_PSEUDO_REGISTER)
2358	{
2359	hard_regno = dst_regno;
2360	a = ira_curr_regno_allocno_map[src_regno];
2361	to_p = false;
2362	}
2363	else
2364	continue;
2365	if (reg_class_size[(int) REGNO_REG_CLASS (hard_regno)]
2366	== (ira_reg_class_max_nregs
2367	[REGNO_REG_CLASS (hard_regno)][(int) ALLOCNO_MODE(a)]))
2368	/* If the class can provide only one hard reg to the allocno,
2369	we processed the insn record_operand_costs already and we
2370	actually updated the hard reg cost there. */
2371	continue;
2372	rclass = ALLOCNO_CLASS (a);
2373	if (! TEST_HARD_REG_BIT (reg_class_contents[rclass], bit: hard_regno))
2374	continue;
2375	i = ira_class_hard_reg_index[rclass][hard_regno];
2376	if (i < 0)
2377	continue;
2378	a_regno = ALLOCNO_REGNO (a);
2379	for (curr_loop_tree_node = ALLOCNO_LOOP_TREE_NODE (a);
2380	curr_loop_tree_node != NULL;
2381	curr_loop_tree_node = curr_loop_tree_node->parent)
2382	if ((curr_a = curr_loop_tree_node->regno_allocno_map[a_regno]) != NULL)
2383	ira_add_allocno_pref (curr_a, hard_regno, freq);
2384	{
2385	int cost;
2386	enum reg_class hard_reg_class;
2387	machine_mode mode;
2388
2389	mode = ALLOCNO_MODE (a);
2390	hard_reg_class = REGNO_REG_CLASS (hard_regno);
2391	ira_init_register_move_cost_if_necessary (mode);
2392	cost = (to_p ? ira_register_move_cost[mode][hard_reg_class][rclass]
2393	: ira_register_move_cost[mode][rclass][hard_reg_class]) * freq;
2394	ira_allocate_and_set_costs (vec: &ALLOCNO_HARD_REG_COSTS (a), aclass: rclass,
2395	ALLOCNO_CLASS_COST (a));
2396	ira_allocate_and_set_costs (vec: &ALLOCNO_CONFLICT_HARD_REG_COSTS (a),
2397	aclass: rclass, val: 0);
2398	ALLOCNO_HARD_REG_COSTS (a)[i] -= cost;
2399	ALLOCNO_CONFLICT_HARD_REG_COSTS (a)[i] -= cost;
2400	ALLOCNO_CLASS_COST (a) = MIN (ALLOCNO_CLASS_COST (a),
2401	ALLOCNO_HARD_REG_COSTS (a)[i]);
2402	}
2403	}
2404	}
2405
2406	/* After we find hard register and memory costs for allocnos, define
2407	its class and modify hard register cost because insns moving
2408	allocno to/from hard registers. */
2409	static void
2410	setup_allocno_class_and_costs (void)
2411	{
2412	int i, j, n, regno, hard_regno, num;
2413	int *reg_costs;
2414	enum reg_class aclass, rclass;
2415	ira_allocno_t a;
2416	ira_allocno_iterator ai;
2417	cost_classes_t cost_classes_ptr;
2418
2419	ira_assert (allocno_p);
2420	FOR_EACH_ALLOCNO (a, ai)
2421	{
2422	i = ALLOCNO_NUM (a);
2423	regno = ALLOCNO_REGNO (a);
2424	aclass = regno_aclass[regno];
2425	cost_classes_ptr = regno_cost_classes[regno];
2426	ira_assert (pref[i] == NO_REGS || aclass != NO_REGS);
2427	ALLOCNO_MEMORY_COST (a) = COSTS (costs, i)->mem_cost;
2428	ira_set_allocno_class (a, aclass);
2429	if (aclass == NO_REGS)
2430	continue;
2431	if (optimize && ALLOCNO_CLASS (a) != pref[i])
2432	{
2433	n = ira_class_hard_regs_num[aclass];
2434	ALLOCNO_HARD_REG_COSTS (a)
2435	= reg_costs = ira_allocate_cost_vector (aclass);
2436	for (j = n - 1; j >= 0; j--)
2437	{
2438	hard_regno = ira_class_hard_regs[aclass][j];
2439	if (TEST_HARD_REG_BIT (reg_class_contents[pref[i]], bit: hard_regno))
2440	reg_costs[j] = ALLOCNO_CLASS_COST (a);
2441	else
2442	{
2443	rclass = REGNO_REG_CLASS (hard_regno);
2444	num = cost_classes_ptr->index[rclass];
2445	if (num < 0)
2446	{
2447	num = cost_classes_ptr->hard_regno_index[hard_regno];
2448	ira_assert (num >= 0);
2449	}
2450	reg_costs[j] = COSTS (costs, i)->cost[num];
2451	}
2452	}
2453	}
2454	}
2455	if (optimize)
2456	ira_traverse_loop_tree (true, ira_loop_tree_root,
2457	process_bb_node_for_hard_reg_moves, NULL);
2458	}
2459
2460
2461
2462	/* Function called once during compiler work. */
2463	void
2464	ira_init_costs_once (void)
2465	{
2466	int i;
2467
2468	init_cost = NULL;
2469	for (i = 0; i < MAX_RECOG_OPERANDS; i++)
2470	{
2471	op_costs[i] = NULL;
2472	this_op_costs[i] = NULL;
2473	}
2474	temp_costs = NULL;
2475	}
2476
2477	/* Free allocated temporary cost vectors. */
2478	void
2479	target_ira_int::free_ira_costs ()
2480	{
2481	int i;
2482
2483	free (ptr: x_init_cost);
2484	x_init_cost = NULL;
2485	for (i = 0; i < MAX_RECOG_OPERANDS; i++)
2486	{
2487	free (ptr: x_op_costs[i]);
2488	free (ptr: x_this_op_costs[i]);
2489	x_op_costs[i] = x_this_op_costs[i] = NULL;
2490	}
2491	free (ptr: x_temp_costs);
2492	x_temp_costs = NULL;
2493	}
2494
2495	/* This is called each time register related information is
2496	changed. */
2497	void
2498	ira_init_costs (void)
2499	{
2500	int i;
2501
2502	this_target_ira_int->free_ira_costs ();
2503	max_struct_costs_size
2504	= sizeof (struct costs) + sizeof (int) * (ira_important_classes_num - 1);
2505	/* Don't use ira_allocate because vectors live through several IRA
2506	calls. */
2507	init_cost = (struct costs *) xmalloc (max_struct_costs_size);
2508	init_cost->mem_cost = 1000000;
2509	for (i = 0; i < ira_important_classes_num; i++)
2510	init_cost->cost[i] = 1000000;
2511	for (i = 0; i < MAX_RECOG_OPERANDS; i++)
2512	{
2513	op_costs[i] = (struct costs *) xmalloc (max_struct_costs_size);
2514	this_op_costs[i] = (struct costs *) xmalloc (max_struct_costs_size);
2515	}
2516	temp_costs = (struct costs *) xmalloc (max_struct_costs_size);
2517	}
2518
2519
2520
2521	/* Common initialization function for ira_costs and
2522	ira_set_pseudo_classes. */
2523	static void
2524	init_costs (void)
2525	{
2526	init_subregs_of_mode ();
2527	costs = (struct costs *) ira_allocate (max_struct_costs_size
2528	* cost_elements_num);
2529	pref_buffer = (enum reg_class *) ira_allocate (sizeof (enum reg_class)
2530	* cost_elements_num);
2531	regno_aclass = (enum reg_class *) ira_allocate (sizeof (enum reg_class)
2532	* max_reg_num ());
2533	regno_equiv_gains = (int *) ira_allocate (sizeof (int) * max_reg_num ());
2534	memset (s: regno_equiv_gains, c: 0, n: sizeof (int) * max_reg_num ());
2535	}
2536
2537	/* Common finalization function for ira_costs and
2538	ira_set_pseudo_classes. */
2539	static void
2540	finish_costs (void)
2541	{
2542	finish_subregs_of_mode ();
2543	ira_free (addr: regno_equiv_gains);
2544	ira_free (addr: regno_aclass);
2545	ira_free (addr: pref_buffer);
2546	ira_free (addr: costs);
2547	}
2548
2549	/* Entry function which defines register class, memory and hard
2550	register costs for each allocno. */
2551	void
2552	ira_costs (void)
2553	{
2554	allocno_p = true;
2555	cost_elements_num = ira_allocnos_num;
2556	init_costs ();
2557	total_allocno_costs = (struct costs *) ira_allocate (max_struct_costs_size
2558	* ira_allocnos_num);
2559	initiate_regno_cost_classes ();
2560	if (!ira_use_lra_p)
2561	/* Process equivs in reload to update costs through hook
2562	ira_adjust_equiv_reg_cost. */
2563	calculate_elim_costs_all_insns ();
2564	find_costs_and_classes (dump_file: ira_dump_file);
2565	setup_allocno_class_and_costs ();
2566	finish_regno_cost_classes ();
2567	finish_costs ();
2568	ira_free (addr: total_allocno_costs);
2569	}
2570
2571	/* Entry function which defines classes for pseudos.
2572	Set pseudo_classes_defined_p only if DEFINE_PSEUDO_CLASSES is true. */
2573	void
2574	ira_set_pseudo_classes (bool define_pseudo_classes, FILE *dump_file)
2575	{
2576	allocno_p = false;
2577	internal_flag_ira_verbose = flag_ira_verbose;
2578	cost_elements_num = max_reg_num ();
2579	init_costs ();
2580	initiate_regno_cost_classes ();
2581	find_costs_and_classes (dump_file);
2582	finish_regno_cost_classes ();
2583	if (define_pseudo_classes)
2584	pseudo_classes_defined_p = true;
2585
2586	finish_costs ();
2587	}
2588
2589
2590
2591	/* Change hard register costs for allocnos which lives through
2592	function calls. This is called only when we found all intersected
2593	calls during building allocno live ranges. */
2594	void
2595	ira_tune_allocno_costs (void)
2596	{
2597	int j, n, regno;
2598	int cost, min_cost, *reg_costs;
2599	enum reg_class aclass;
2600	machine_mode mode;
2601	ira_allocno_t a;
2602	ira_allocno_iterator ai;
2603	ira_allocno_object_iterator oi;
2604	ira_object_t obj;
2605	bool skip_p;
2606
2607	FOR_EACH_ALLOCNO (a, ai)
2608	{
2609	aclass = ALLOCNO_CLASS (a);
2610	if (aclass == NO_REGS)
2611	continue;
2612	mode = ALLOCNO_MODE (a);
2613	n = ira_class_hard_regs_num[aclass];
2614	min_cost = INT_MAX;
2615	if (ALLOCNO_CALLS_CROSSED_NUM (a)
2616	!= ALLOCNO_CHEAP_CALLS_CROSSED_NUM (a))
2617	{
2618	ira_allocate_and_set_costs
2619	(vec: &ALLOCNO_HARD_REG_COSTS (a), aclass,
2620	ALLOCNO_CLASS_COST (a));
2621	reg_costs = ALLOCNO_HARD_REG_COSTS (a);
2622	for (j = n - 1; j >= 0; j--)
2623	{
2624	regno = ira_class_hard_regs[aclass][j];
2625	skip_p = false;
2626	FOR_EACH_ALLOCNO_OBJECT (a, obj, oi)
2627	{
2628	if (ira_hard_reg_set_intersection_p (hard_regno: regno, mode,
2629	OBJECT_CONFLICT_HARD_REGS
2630	(obj)))
2631	{
2632	skip_p = true;
2633	break;
2634	}
2635	}
2636	if (skip_p)
2637	continue;
2638	cost = 0;
2639	if (ira_need_caller_save_p (a, regno))
2640	cost += ira_caller_save_cost (a);
2641	#ifdef IRA_HARD_REGNO_ADD_COST_MULTIPLIER
2642	{
2643	auto rclass = REGNO_REG_CLASS (regno);
2644	cost += ((ira_memory_move_cost[mode][rclass][0]
2645	+ ira_memory_move_cost[mode][rclass][1])
2646	* ALLOCNO_FREQ (a)
2647	* IRA_HARD_REGNO_ADD_COST_MULTIPLIER (regno) / 2);
2648	}
2649	#endif
2650	if (INT_MAX - cost < reg_costs[j])
2651	reg_costs[j] = INT_MAX;
2652	else
2653	reg_costs[j] += cost;
2654	if (min_cost > reg_costs[j])
2655	min_cost = reg_costs[j];
2656	}
2657	}
2658	if (min_cost != INT_MAX)
2659	ALLOCNO_CLASS_COST (a) = min_cost;
2660
2661	/* Some targets allow pseudos to be allocated to unaligned sequences
2662	of hard registers. However, selecting an unaligned sequence can
2663	unnecessarily restrict later allocations. So increase the cost of
2664	unaligned hard regs to encourage the use of aligned hard regs. */
2665	{
2666	const int nregs = ira_reg_class_max_nregs[aclass][ALLOCNO_MODE (a)];
2667
2668	if (nregs > 1)
2669	{
2670	ira_allocate_and_set_costs
2671	(vec: &ALLOCNO_HARD_REG_COSTS (a), aclass, ALLOCNO_CLASS_COST (a));
2672	reg_costs = ALLOCNO_HARD_REG_COSTS (a);
2673	for (j = n - 1; j >= 0; j--)
2674	{
2675	regno = ira_non_ordered_class_hard_regs[aclass][j];
2676	if ((regno % nregs) != 0)
2677	{
2678	int index = ira_class_hard_reg_index[aclass][regno];
2679	ira_assert (index != -1);
2680	reg_costs[index] += ALLOCNO_FREQ (a);
2681	}
2682	}
2683	}
2684	}
2685	}
2686	}
2687
2688	/* A hook from the reload pass. Add COST to the estimated gain for eliminating
2689	REGNO with its equivalence. If COST is zero, record that no such
2690	elimination is possible. */
2691
2692	void
2693	ira_adjust_equiv_reg_cost (unsigned regno, int cost)
2694	{
2695	ira_assert (!ira_use_lra_p);
2696	if (cost == 0)
2697	regno_equiv_gains[regno] = 0;
2698	else
2699	regno_equiv_gains[regno] += cost;
2700	}
2701
2702	void
2703	ira_costs_cc_finalize (void)
2704	{
2705	this_target_ira_int->free_ira_costs ();
2706	}
2707