Branch data Line data Source code
1 : : /* Scheduler hooks for IA-32 which implement CPU specific logic.
2 : : Copyright (C) 1988-2025 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
7 : : it under the terms of the GNU General Public License as published by
8 : : the Free Software Foundation; either version 3, or (at your option)
9 : : any later version.
10 : :
11 : : GCC is distributed in the hope that it will be useful,
12 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : GNU General Public License 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 : : #define IN_TARGET_CODE 1
21 : :
22 : : #include "config.h"
23 : : #include "system.h"
24 : : #include "coretypes.h"
25 : : #include "backend.h"
26 : : #include "rtl.h"
27 : : #include "tree.h"
28 : : #include "cfghooks.h"
29 : : #include "tm_p.h"
30 : : #include "target.h"
31 : : #include "insn-config.h"
32 : : #include "insn-attr.h"
33 : : #include "insn-opinit.h"
34 : : #include "recog.h"
35 : : #include "tm-constrs.h"
36 : :
37 : : /* Return the maximum number of instructions a cpu can issue. */
38 : :
39 : : int
40 : 36627360 : ix86_issue_rate (void)
41 : : {
42 : 36627360 : switch (ix86_tune)
43 : : {
44 : : case PROCESSOR_PENTIUM:
45 : : case PROCESSOR_LAKEMONT:
46 : : case PROCESSOR_BONNELL:
47 : : case PROCESSOR_SILVERMONT:
48 : : case PROCESSOR_K6:
49 : : case PROCESSOR_BTVER2:
50 : : case PROCESSOR_PENTIUM4:
51 : : case PROCESSOR_NOCONA:
52 : : return 2;
53 : :
54 : : case PROCESSOR_PENTIUMPRO:
55 : : case PROCESSOR_ATHLON:
56 : : case PROCESSOR_K8:
57 : : case PROCESSOR_AMDFAM10:
58 : : case PROCESSOR_BTVER1:
59 : : case PROCESSOR_LUJIAZUI:
60 : : return 3;
61 : :
62 : : case PROCESSOR_BDVER1:
63 : : case PROCESSOR_BDVER2:
64 : : case PROCESSOR_BDVER3:
65 : : case PROCESSOR_BDVER4:
66 : : case PROCESSOR_ZNVER1:
67 : : case PROCESSOR_ZNVER2:
68 : : case PROCESSOR_ZNVER3:
69 : : case PROCESSOR_ZNVER4:
70 : : case PROCESSOR_CORE2:
71 : : case PROCESSOR_NEHALEM:
72 : : case PROCESSOR_SANDYBRIDGE:
73 : : case PROCESSOR_HASWELL:
74 : : case PROCESSOR_TREMONT:
75 : : case PROCESSOR_SKYLAKE:
76 : : case PROCESSOR_SKYLAKE_AVX512:
77 : : case PROCESSOR_CASCADELAKE:
78 : : case PROCESSOR_CANNONLAKE:
79 : : case PROCESSOR_ALDERLAKE:
80 : : case PROCESSOR_YONGFENG:
81 : : case PROCESSOR_SHIJIDADAO:
82 : : case PROCESSOR_SIERRAFOREST:
83 : : case PROCESSOR_INTEL:
84 : : case PROCESSOR_GENERIC:
85 : : /* For znver5 decoder can handle 4 or 8 instructions per cycle,
86 : : op cache 12 instruction/cycle, dispatch 8 instructions
87 : : integer rename 8 instructions and Fp 6 instructions.
88 : :
89 : : The scheduler, without understanding out of order nature of the CPU
90 : : is not going to be able to use more than 4 instructions since that
91 : : is limits of the decoders. */
92 : : case PROCESSOR_ZNVER5:
93 : : return 4;
94 : :
95 : : case PROCESSOR_ICELAKE_CLIENT:
96 : : case PROCESSOR_ICELAKE_SERVER:
97 : : case PROCESSOR_TIGERLAKE:
98 : : case PROCESSOR_COOPERLAKE:
99 : : case PROCESSOR_ROCKETLAKE:
100 : : return 5;
101 : :
102 : : case PROCESSOR_SAPPHIRERAPIDS:
103 : : case PROCESSOR_GRANITERAPIDS:
104 : : case PROCESSOR_GRANITERAPIDS_D:
105 : : case PROCESSOR_DIAMONDRAPIDS:
106 : : case PROCESSOR_GRANDRIDGE:
107 : : case PROCESSOR_CLEARWATERFOREST:
108 : : case PROCESSOR_ARROWLAKE:
109 : : case PROCESSOR_ARROWLAKE_S:
110 : : case PROCESSOR_PANTHERLAKE:
111 : : return 6;
112 : :
113 : : default:
114 : : return 1;
115 : : }
116 : : }
117 : :
118 : : /* Return true iff USE_INSN has a memory address with operands set by
119 : : SET_INSN. */
120 : :
121 : : bool
122 : 10006585 : ix86_agi_dependent (rtx_insn *set_insn, rtx_insn *use_insn)
123 : : {
124 : 10006585 : int i;
125 : 10006585 : extract_insn_cached (use_insn);
126 : 12188301 : for (i = recog_data.n_operands - 1; i >= 0; --i)
127 : 11848655 : if (MEM_P (recog_data.operand[i]))
128 : : {
129 : 9666939 : rtx addr = XEXP (recog_data.operand[i], 0);
130 : 9666939 : if (modified_in_p (addr, set_insn) != 0)
131 : : {
132 : : /* No AGI stall if SET_INSN is a push or pop and USE_INSN
133 : : has SP based memory (unless index reg is modified in a pop). */
134 : 4315861 : rtx set = single_set (set_insn);
135 : 4315861 : if (set
136 : 4315861 : && (push_operand (SET_DEST (set), GET_MODE (SET_DEST (set)))
137 : 3537581 : || pop_operand (SET_SRC (set), GET_MODE (SET_SRC (set)))))
138 : : {
139 : 591855 : struct ix86_address parts;
140 : 591855 : if (ix86_decompose_address (addr, &parts)
141 : 591855 : && parts.base == stack_pointer_rtx
142 : 1183484 : && (parts.index == NULL_RTX
143 : 504 : || MEM_P (SET_DEST (set))
144 : 2 : || !modified_in_p (parts.index, set_insn)))
145 : 591628 : return false;
146 : : }
147 : 3724233 : return true;
148 : : }
149 : : return false;
150 : : }
151 : : return false;
152 : : }
153 : :
154 : : /* A subroutine of ix86_adjust_cost -- return TRUE iff INSN reads flags set
155 : : by DEP_INSN and nothing set by DEP_INSN. */
156 : :
157 : : static bool
158 : 0 : ix86_flags_dependent (rtx_insn *insn, rtx_insn *dep_insn, enum attr_type insn_type)
159 : : {
160 : 0 : rtx set, set2;
161 : :
162 : : /* Simplify the test for uninteresting insns. */
163 : 0 : if (insn_type != TYPE_SETCC
164 : 0 : && insn_type != TYPE_ICMOV
165 : 0 : && insn_type != TYPE_FCMOV
166 : 0 : && insn_type != TYPE_IBR)
167 : : return false;
168 : :
169 : 0 : if ((set = single_set (dep_insn)) != 0)
170 : : {
171 : 0 : set = SET_DEST (set);
172 : 0 : set2 = NULL_RTX;
173 : : }
174 : 0 : else if (GET_CODE (PATTERN (dep_insn)) == PARALLEL
175 : 0 : && XVECLEN (PATTERN (dep_insn), 0) == 2
176 : 0 : && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 0)) == SET
177 : 0 : && GET_CODE (XVECEXP (PATTERN (dep_insn), 0, 1)) == SET)
178 : : {
179 : 0 : set = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
180 : 0 : set2 = SET_DEST (XVECEXP (PATTERN (dep_insn), 0, 0));
181 : : }
182 : : else
183 : : return false;
184 : :
185 : 0 : if (!REG_P (set) || REGNO (set) != FLAGS_REG)
186 : : return false;
187 : :
188 : : /* This test is true if the dependent insn reads the flags but
189 : : not any other potentially set register. */
190 : 0 : if (!reg_overlap_mentioned_p (set, PATTERN (insn)))
191 : : return false;
192 : :
193 : 0 : if (set2 && reg_overlap_mentioned_p (set2, PATTERN (insn)))
194 : : return false;
195 : :
196 : : return true;
197 : : }
198 : :
199 : : /* Helper function for exact_store_load_dependency.
200 : : Return true if addr is found in insn. */
201 : : static bool
202 : 0 : exact_dependency_1 (rtx addr, rtx insn)
203 : : {
204 : 0 : enum rtx_code code;
205 : 0 : const char *format_ptr;
206 : 0 : int i, j;
207 : :
208 : 0 : code = GET_CODE (insn);
209 : 0 : switch (code)
210 : : {
211 : 0 : case MEM:
212 : 0 : if (rtx_equal_p (addr, insn))
213 : : return true;
214 : : break;
215 : : case REG:
216 : : CASE_CONST_ANY:
217 : : case SYMBOL_REF:
218 : : case CODE_LABEL:
219 : : case PC:
220 : : case EXPR_LIST:
221 : : return false;
222 : : default:
223 : : break;
224 : : }
225 : :
226 : 0 : format_ptr = GET_RTX_FORMAT (code);
227 : 0 : for (i = 0; i < GET_RTX_LENGTH (code); i++)
228 : : {
229 : 0 : switch (*format_ptr++)
230 : : {
231 : 0 : case 'e':
232 : 0 : if (exact_dependency_1 (addr, XEXP (insn, i)))
233 : : return true;
234 : : break;
235 : : case 'E':
236 : 0 : for (j = 0; j < XVECLEN (insn, i); j++)
237 : 0 : if (exact_dependency_1 (addr, XVECEXP (insn, i, j)))
238 : : return true;
239 : : break;
240 : : }
241 : : }
242 : : return false;
243 : : }
244 : :
245 : : /* Return true if there exists exact dependency for store & load, i.e.
246 : : the same memory address is used in them. */
247 : : static bool
248 : 0 : exact_store_load_dependency (rtx_insn *store, rtx_insn *load)
249 : : {
250 : 0 : rtx set1, set2;
251 : :
252 : 0 : set1 = single_set (store);
253 : 0 : if (!set1)
254 : : return false;
255 : 0 : if (!MEM_P (SET_DEST (set1)))
256 : : return false;
257 : 0 : set2 = single_set (load);
258 : 0 : if (!set2)
259 : : return false;
260 : 0 : if (exact_dependency_1 (SET_DEST (set1), SET_SRC (set2)))
261 : : return true;
262 : : return false;
263 : : }
264 : :
265 : :
266 : : /* This function corrects the value of COST (latency) based on the relationship
267 : : between INSN and DEP_INSN through a dependence of type DEP_TYPE, and strength
268 : : DW. It should return the new value.
269 : :
270 : : On x86 CPUs this is most commonly used to model the fact that valus of
271 : : registers used to compute address of memory operand needs to be ready
272 : : earlier than values of registers used in the actual operation. */
273 : :
274 : : int
275 : 151029830 : ix86_adjust_cost (rtx_insn *insn, int dep_type, rtx_insn *dep_insn, int cost,
276 : : unsigned int)
277 : : {
278 : 151029830 : enum attr_type insn_type, dep_insn_type;
279 : 151029830 : enum attr_memory memory;
280 : 151029830 : rtx set, set2;
281 : 151029830 : int dep_insn_code_number;
282 : :
283 : : /* Anti and output dependencies have zero cost on all CPUs. */
284 : 151029830 : if (dep_type != 0)
285 : : return 0;
286 : :
287 : 52681254 : dep_insn_code_number = recog_memoized (dep_insn);
288 : :
289 : : /* If we can't recognize the insns, we can't really do anything. */
290 : 52681254 : if (dep_insn_code_number < 0 || recog_memoized (insn) < 0)
291 : 350704 : return cost;
292 : :
293 : 52330550 : insn_type = get_attr_type (insn);
294 : 52330550 : dep_insn_type = get_attr_type (dep_insn);
295 : :
296 : 52330550 : switch (ix86_tune)
297 : : {
298 : 0 : case PROCESSOR_PENTIUM:
299 : 0 : case PROCESSOR_LAKEMONT:
300 : : /* Address Generation Interlock adds a cycle of latency. */
301 : 0 : if (insn_type == TYPE_LEA)
302 : : {
303 : 0 : rtx addr = PATTERN (insn);
304 : :
305 : 0 : if (GET_CODE (addr) == PARALLEL)
306 : 0 : addr = XVECEXP (addr, 0, 0);
307 : :
308 : 0 : gcc_assert (GET_CODE (addr) == SET);
309 : :
310 : 0 : addr = SET_SRC (addr);
311 : 0 : if (modified_in_p (addr, dep_insn))
312 : 0 : cost += 1;
313 : : }
314 : 0 : else if (ix86_agi_dependent (dep_insn, insn))
315 : 0 : cost += 1;
316 : :
317 : : /* ??? Compares pair with jump/setcc. */
318 : 0 : if (ix86_flags_dependent (insn, dep_insn, insn_type))
319 : 0 : cost = 0;
320 : :
321 : : /* Floating point stores require value to be ready one cycle earlier. */
322 : 0 : if (insn_type == TYPE_FMOV
323 : 0 : && get_attr_memory (insn) == MEMORY_STORE
324 : 0 : && !ix86_agi_dependent (dep_insn, insn))
325 : 0 : cost += 1;
326 : : break;
327 : :
328 : 0 : case PROCESSOR_PENTIUMPRO:
329 : : /* INT->FP conversion is expensive. */
330 : 0 : if (get_attr_fp_int_src (dep_insn))
331 : 0 : cost += 5;
332 : :
333 : : /* There is one cycle extra latency between an FP op and a store. */
334 : 0 : if (insn_type == TYPE_FMOV
335 : 0 : && (set = single_set (dep_insn)) != NULL_RTX
336 : 0 : && (set2 = single_set (insn)) != NULL_RTX
337 : 0 : && rtx_equal_p (SET_DEST (set), SET_SRC (set2))
338 : 0 : && MEM_P (SET_DEST (set2)))
339 : 0 : cost += 1;
340 : :
341 : 0 : memory = get_attr_memory (insn);
342 : :
343 : : /* Show ability of reorder buffer to hide latency of load by executing
344 : : in parallel with previous instruction in case
345 : : previous instruction is not needed to compute the address. */
346 : 0 : if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
347 : 0 : && !ix86_agi_dependent (dep_insn, insn))
348 : : {
349 : : /* Claim moves to take one cycle, as core can issue one load
350 : : at time and the next load can start cycle later. */
351 : 0 : if (dep_insn_type == TYPE_IMOV
352 : 0 : || dep_insn_type == TYPE_FMOV)
353 : : cost = 1;
354 : 0 : else if (cost > 1)
355 : 0 : cost--;
356 : : }
357 : : break;
358 : :
359 : 0 : case PROCESSOR_K6:
360 : : /* The esp dependency is resolved before
361 : : the instruction is really finished. */
362 : 0 : if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
363 : 0 : && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
364 : : return 1;
365 : :
366 : : /* INT->FP conversion is expensive. */
367 : 0 : if (get_attr_fp_int_src (dep_insn))
368 : 0 : cost += 5;
369 : :
370 : 0 : memory = get_attr_memory (insn);
371 : :
372 : : /* Show ability of reorder buffer to hide latency of load by executing
373 : : in parallel with previous instruction in case
374 : : previous instruction is not needed to compute the address. */
375 : 0 : if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
376 : 0 : && !ix86_agi_dependent (dep_insn, insn))
377 : : {
378 : : /* Claim moves to take one cycle, as core can issue one load
379 : : at time and the next load can start cycle later. */
380 : 0 : if (dep_insn_type == TYPE_IMOV
381 : 0 : || dep_insn_type == TYPE_FMOV)
382 : : cost = 1;
383 : 0 : else if (cost > 2)
384 : 0 : cost -= 2;
385 : : else
386 : : cost = 1;
387 : : }
388 : : break;
389 : :
390 : 9902 : case PROCESSOR_AMDFAM10:
391 : 9902 : case PROCESSOR_BDVER1:
392 : 9902 : case PROCESSOR_BDVER2:
393 : 9902 : case PROCESSOR_BDVER3:
394 : 9902 : case PROCESSOR_BDVER4:
395 : 9902 : case PROCESSOR_BTVER1:
396 : 9902 : case PROCESSOR_BTVER2:
397 : : /* Stack engine allows to execute push&pop instructions in parall. */
398 : 9902 : if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
399 : 292 : && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
400 : : return 0;
401 : : /* FALLTHRU */
402 : :
403 : 75390 : case PROCESSOR_ATHLON:
404 : 75390 : case PROCESSOR_K8:
405 : 75390 : memory = get_attr_memory (insn);
406 : :
407 : : /* Show ability of reorder buffer to hide latency of load by executing
408 : : in parallel with previous instruction in case
409 : : previous instruction is not needed to compute the address. */
410 : 75390 : if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
411 : 75390 : && !ix86_agi_dependent (dep_insn, insn))
412 : : {
413 : 11645 : enum attr_unit unit = get_attr_unit (insn);
414 : 11645 : int loadcost = 3;
415 : :
416 : : /* Because of the difference between the length of integer and
417 : : floating unit pipeline preparation stages, the memory operands
418 : : for floating point are cheaper.
419 : :
420 : : ??? For Athlon it the difference is most probably 2. */
421 : 11645 : if (unit == UNIT_INTEGER || unit == UNIT_UNKNOWN)
422 : : loadcost = 3;
423 : : else
424 : 6312 : loadcost = TARGET_CPU_P (ATHLON) ? 2 : 0;
425 : :
426 : 11645 : if (cost >= loadcost)
427 : 7084 : cost -= loadcost;
428 : : else
429 : : cost = 0;
430 : : }
431 : : break;
432 : :
433 : 3619 : case PROCESSOR_ZNVER1:
434 : 3619 : case PROCESSOR_ZNVER2:
435 : 3619 : case PROCESSOR_ZNVER3:
436 : 3619 : case PROCESSOR_ZNVER4:
437 : 3619 : case PROCESSOR_ZNVER5:
438 : : /* Stack engine allows to execute push&pop instructions in parall. */
439 : 3619 : if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
440 : 553 : && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
441 : : return 0;
442 : :
443 : 3365 : memory = get_attr_memory (insn);
444 : :
445 : : /* Show ability of reorder buffer to hide latency of load by executing
446 : : in parallel with previous instruction in case
447 : : previous instruction is not needed to compute the address. */
448 : 3365 : if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
449 : 3365 : && !ix86_agi_dependent (dep_insn, insn))
450 : : {
451 : 534 : enum attr_unit unit = get_attr_unit (insn);
452 : 534 : int loadcost;
453 : :
454 : : /* TODO: On znver5 complex addressing modes have
455 : : greater latency. */
456 : 534 : if (unit == UNIT_INTEGER || unit == UNIT_UNKNOWN)
457 : : loadcost = 4;
458 : : else
459 : 367 : loadcost = 7;
460 : :
461 : 534 : if (cost >= loadcost)
462 : 64 : cost -= loadcost;
463 : : else
464 : : cost = 0;
465 : : }
466 : : break;
467 : :
468 : 0 : case PROCESSOR_YONGFENG:
469 : 0 : case PROCESSOR_SHIJIDADAO:
470 : : /* Stack engine allows to execute push&pop instructions in parallel. */
471 : 0 : if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
472 : 0 : && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
473 : : return 0;
474 : : /* FALLTHRU */
475 : :
476 : 0 : case PROCESSOR_LUJIAZUI:
477 : 0 : memory = get_attr_memory (insn);
478 : :
479 : : /* Show ability of reorder buffer to hide latency of load by executing
480 : : in parallel with previous instruction in case
481 : : previous instruction is not needed to compute the address. */
482 : 0 : if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
483 : 0 : && !ix86_agi_dependent (dep_insn, insn))
484 : : {
485 : 0 : int loadcost = 4;
486 : :
487 : 0 : if (cost >= loadcost)
488 : 0 : cost -= loadcost;
489 : : else
490 : : cost = 0;
491 : : }
492 : : break;
493 : :
494 : 52220169 : case PROCESSOR_CORE2:
495 : 52220169 : case PROCESSOR_NEHALEM:
496 : 52220169 : case PROCESSOR_SANDYBRIDGE:
497 : 52220169 : case PROCESSOR_HASWELL:
498 : 52220169 : case PROCESSOR_TREMONT:
499 : 52220169 : case PROCESSOR_ALDERLAKE:
500 : 52220169 : case PROCESSOR_INTEL:
501 : 52220169 : case PROCESSOR_GENERIC:
502 : : /* Stack engine allows to execute push&pop instructions in parall. */
503 : 52220169 : if ((insn_type == TYPE_PUSH || insn_type == TYPE_POP)
504 : 8778510 : && (dep_insn_type == TYPE_PUSH || dep_insn_type == TYPE_POP))
505 : : return 0;
506 : :
507 : 46620573 : memory = get_attr_memory (insn);
508 : :
509 : : /* Show ability of reorder buffer to hide latency of load by executing
510 : : in parallel with previous instruction in case
511 : : previous instruction is not needed to compute the address. */
512 : 46620573 : if ((memory == MEMORY_LOAD || memory == MEMORY_BOTH)
513 : 46620573 : && !ix86_agi_dependent (dep_insn, insn))
514 : : {
515 : 6270102 : if (cost >= 4)
516 : 205789 : cost -= 4;
517 : : else
518 : : cost = 0;
519 : : }
520 : : break;
521 : :
522 : 937 : case PROCESSOR_SILVERMONT:
523 : 937 : if (!reload_completed)
524 : : return cost;
525 : :
526 : : /* Increase cost of integer loads. */
527 : 937 : memory = get_attr_memory (dep_insn);
528 : 937 : if (memory == MEMORY_LOAD || memory == MEMORY_BOTH)
529 : : {
530 : 214 : enum attr_unit unit = get_attr_unit (dep_insn);
531 : 214 : if (unit == UNIT_INTEGER && cost == 1)
532 : : {
533 : 165 : if (memory == MEMORY_LOAD)
534 : : cost = 3;
535 : : else
536 : : {
537 : : /* Increase cost of ld/st for short int types only
538 : : because of store forwarding issue. */
539 : 0 : rtx set = single_set (dep_insn);
540 : 0 : if (set && (GET_MODE (SET_DEST (set)) == QImode
541 : 0 : || GET_MODE (SET_DEST (set)) == HImode))
542 : : {
543 : : /* Increase cost of store/load insn if exact
544 : : dependence exists and it is load insn. */
545 : 0 : enum attr_memory insn_memory = get_attr_memory (insn);
546 : 0 : if (insn_memory == MEMORY_LOAD
547 : 0 : && exact_store_load_dependency (dep_insn, insn))
548 : : cost = 3;
549 : : }
550 : : }
551 : : }
552 : : }
553 : :
554 : : default:
555 : : break;
556 : : }
557 : :
558 : : return cost;
559 : : }
560 : :
561 : : /* How many alternative schedules to try. This should be as wide as the
562 : : scheduling freedom in the DFA, but no wider. Making this value too
563 : : large results extra work for the scheduler. */
564 : :
565 : : int
566 : 950584 : ia32_multipass_dfa_lookahead (void)
567 : : {
568 : : /* Generally, we want haifa-sched:max_issue() to look ahead as far
569 : : as many instructions can be executed on a cycle, i.e.,
570 : : issue_rate. */
571 : 950584 : if (reload_completed)
572 : 950332 : return ix86_issue_rate ();
573 : : /* Don't use lookahead for pre-reload schedule to save compile time. */
574 : : return 0;
575 : : }
576 : :
577 : : /* Return true if target platform supports macro-fusion. */
578 : :
579 : : bool
580 : 106310446 : ix86_macro_fusion_p ()
581 : : {
582 : 106310446 : return TARGET_FUSE_CMP_AND_BRANCH;
583 : : }
584 : :
585 : : /* Check whether MOV is a reg-reg move and ALU is an
586 : : ALU operation that allows macro-op fusion. */
587 : :
588 : : static bool
589 : 929 : ix86_fuse_mov_alu_p (rtx_insn *mov, rtx_insn *alu)
590 : : {
591 : : /* Validate mov:
592 : : - It should be reg-reg move with opcode 0x89 or 0x8B. */
593 : 929 : rtx set1 = PATTERN (mov);
594 : 929 : if (GET_CODE (set1) != SET
595 : 744 : || !GENERAL_REG_P (SET_SRC (set1))
596 : 1113 : || !GENERAL_REG_P (SET_DEST (set1)))
597 : : return false;
598 : 70 : rtx reg = SET_DEST (set1);
599 : : /* - it should have 0x89 or 0x8B opcode. */
600 : 70 : if (!INTEGRAL_MODE_P (GET_MODE (reg))
601 : 140 : || GET_MODE_SIZE (GET_MODE (reg)) < 2
602 : 140 : || GET_MODE_SIZE (GET_MODE (reg)) > 8)
603 : : return false;
604 : : /* Validate ALU. */
605 : 70 : if (GET_CODE (PATTERN (alu)) != PARALLEL)
606 : : return false;
607 : 9 : rtx set2 = XVECEXP (PATTERN (alu), 0, 0);
608 : 9 : if (GET_CODE (set2) != SET)
609 : : return false;
610 : : /* If this is instruction setting both compare and normal
611 : : register, the first set always sets flags, while
612 : : second set writes to the output operan. Pick
613 : : the second set. */
614 : 9 : if (GET_CODE (SET_SRC (set2)) == COMPARE)
615 : : {
616 : 0 : set2 = XVECEXP (PATTERN (alu), 0, 1);
617 : 0 : if (GET_CODE (set2) != SET)
618 : : return false;
619 : : }
620 : : /* Match one of:
621 : : ADD ADC AND XOR OR SUB SBB INC DEC NOT SAL SHL SHR SAR
622 : : We also may add insn attribute to handle some of sporadic
623 : : case we output those with different RTX expressions. */
624 : :
625 : 9 : if (GET_CODE (SET_SRC (set2)) != PLUS
626 : 9 : && GET_CODE (SET_SRC (set2)) != MINUS
627 : : && GET_CODE (SET_SRC (set2)) != XOR
628 : : && GET_CODE (SET_SRC (set2)) != AND
629 : : && GET_CODE (SET_SRC (set2)) != IOR
630 : : && GET_CODE (SET_SRC (set2)) != NOT
631 : : && GET_CODE (SET_SRC (set2)) != ASHIFT
632 : : && GET_CODE (SET_SRC (set2)) != ASHIFTRT
633 : : && GET_CODE (SET_SRC (set2)) != LSHIFTRT)
634 : : return false;
635 : 9 : rtx op0 = XEXP (SET_SRC (set2), 0);
636 : 9 : rtx op1 = GET_CODE (SET_SRC (set2)) != NOT ? XEXP (SET_SRC (set2), 1) : NULL;
637 : : /* One of operands should be register. */
638 : 9 : if (op1 && (!REG_P (op0) || REGNO (op0) != REGNO (reg)))
639 : : std::swap (op0, op1);
640 : 9 : if (!REG_P (op0) || REGNO (op0) != REGNO (reg))
641 : : return false;
642 : 8 : if (op1
643 : 8 : && !REG_P (op1)
644 : 12 : && !x86_64_immediate_operand (op1, VOIDmode))
645 : : return false;
646 : : /* Only one of two parameters must be move destination. */
647 : 8 : if (op1 && REG_P (op1) && REGNO (op1) == REGNO (reg))
648 : : return false;
649 : : return true;
650 : : }
651 : :
652 : : /* Check whether current microarchitecture support macro fusion
653 : : for insn pair "CONDGEN + CONDJMP". Refer to
654 : : "Intel Architectures Optimization Reference Manual". */
655 : :
656 : : bool
657 : 42359649 : ix86_macro_fusion_pair_p (rtx_insn *condgen, rtx_insn *condjmp)
658 : : {
659 : 42359649 : if (TARGET_FUSE_MOV_AND_ALU
660 : 42359649 : && ix86_fuse_mov_alu_p (condgen, condjmp))
661 : : return true;
662 : 42359641 : rtx src, imm = NULL_RTX;
663 : 42359641 : enum rtx_code ccode;
664 : 42359641 : rtx compare_set = NULL_RTX, test_if, cond;
665 : 42359641 : rtx alu_set = NULL_RTX, addr = NULL_RTX;
666 : 42359641 : rtx alu_clobber = NULL_RTX;
667 : 42359641 : enum attr_type condgen_type;
668 : :
669 : 42359641 : if (!any_condjump_p (condjmp))
670 : : return false;
671 : :
672 : 4636765 : unsigned int condreg1, condreg2;
673 : 4636765 : rtx cc_reg_1;
674 : 4636765 : targetm.fixed_condition_code_regs (&condreg1, &condreg2);
675 : 4636765 : cc_reg_1 = gen_rtx_REG (CCmode, condreg1);
676 : 4636765 : if (!reg_referenced_p (cc_reg_1, PATTERN (condjmp))
677 : 4636765 : || !condgen
678 : 9273530 : || !modified_in_p (cc_reg_1, condgen))
679 : 120212 : return false;
680 : :
681 : 4516553 : condgen_type = get_attr_type (condgen);
682 : 4516553 : if (condgen_type == TYPE_MULTI
683 : 165 : && INSN_CODE (condgen) == code_for_stack_protect_test_1 (ptr_mode)
684 : 4516718 : && TARGET_FUSE_ALU_AND_BRANCH)
685 : : {
686 : : /* stack_protect_test_<mode> ends with a sub, which subtracts
687 : : a non-rip special memory operand from a GPR. */
688 : 165 : src = NULL_RTX;
689 : 165 : alu_set = XVECEXP (PATTERN (condgen), 0, 1);
690 : 165 : goto handle_stack_protect_test;
691 : : }
692 : : /* ??? zen5 can fuse cmp, test, sub, add, inc, dec, or, and xor.
693 : : Cores can not fuse or and xor which will pass the test below
694 : : since type is ALU. */
695 : 4516388 : else if (condgen_type != TYPE_TEST
696 : 4516388 : && condgen_type != TYPE_ICMP
697 : 4516388 : && condgen_type != TYPE_INCDEC
698 : 392202 : && condgen_type != TYPE_ALU)
699 : : return false;
700 : :
701 : 4302990 : compare_set = single_set (condgen);
702 : 4302990 : if (compare_set == NULL_RTX && !TARGET_FUSE_ALU_AND_BRANCH)
703 : : return false;
704 : :
705 : 73698 : if (compare_set == NULL_RTX)
706 : : {
707 : 73698 : int i;
708 : 73698 : rtx pat = PATTERN (condgen);
709 : 221094 : for (i = 0; i < XVECLEN (pat, 0); i++)
710 : 147396 : if (GET_CODE (XVECEXP (pat, 0, i)) == SET)
711 : : {
712 : 147396 : rtx set_src = SET_SRC (XVECEXP (pat, 0, i));
713 : 147396 : if (GET_CODE (set_src) == COMPARE)
714 : : compare_set = XVECEXP (pat, 0, i);
715 : : else
716 : 78103 : alu_set = XVECEXP (pat, 0, i);
717 : : }
718 : : /* We also possibly generated ALU instruction only to set
719 : : flags. In this case there will be clobber. */
720 : 0 : else if (GET_CODE (XVECEXP (pat, 0, i)) == CLOBBER
721 : 0 : && GENERAL_REG_P (XEXP (XVECEXP (pat, 0, i), 0)))
722 : : alu_clobber = XVECEXP (pat, 0, i);
723 : : }
724 : 73698 : if (compare_set == NULL_RTX)
725 : : return false;
726 : 4298570 : src = SET_SRC (compare_set);
727 : 4298570 : if (GET_CODE (src) != COMPARE)
728 : : return false;
729 : :
730 : : /* Check for memory operand. */
731 : 4292728 : if (MEM_P (XEXP (src, 0)))
732 : 560387 : addr = XEXP (XEXP (src, 0), 0);
733 : 3732341 : else if (MEM_P (XEXP (src, 1)))
734 : 361513 : addr = XEXP (XEXP (src, 1), 0);
735 : : /* Some CPUs, i.e. tigerlake and cooperlake does not fuse
736 : : ALU with memory operand. */
737 : 921900 : if (addr && !TARGET_FUSE_ALU_AND_BRANCH_MEM)
738 : : return false;
739 : 4292719 : if (CONST_INT_P (XEXP (src, 0)))
740 : : imm = XEXP (src, 0);
741 : 4292719 : else if (CONST_INT_P (XEXP (src, 1)))
742 : : imm = XEXP (src, 1);
743 : : /* Check that the instruction really has immediate.
744 : : In particular compare with 0 is done using test with no immediate. */
745 : 2797984 : if (imm && !get_attr_length_immediate (condgen))
746 : : imm = NULL;
747 : : /* Macro-fusion for cmp/test MEM-IMM + conditional jmp is not
748 : : supported. */
749 : 4292719 : if (addr && imm && !TARGET_FUSE_ALU_AND_BRANCH_MEM_IMM)
750 : : return false;
751 : :
752 : : /* No fusion for RIP-relative address. */
753 : 4292603 : if (addr && !TARGET_FUSE_ALU_AND_BRANCH_RIP_RELATIVE)
754 : : {
755 : 921775 : ix86_address parts;
756 : 921775 : int ok = ix86_decompose_address (addr, &parts);
757 : 921775 : gcc_assert (ok);
758 : :
759 : 921775 : if (ix86_rip_relative_addr_p (&parts))
760 : 68342 : return false;
761 : : }
762 : : /* Znver5 supports fussion fusion with their reg/reg, reg/imm and
763 : : reg/mem forms. They are also supported when the instruction has an
764 : : immediate and displacement that meets the criteria of 4 byte displacement
765 : : and 2 byte immediate or the case of 2 byte displacement and 4 byte
766 : : immediate. We do not know the displacement size, so we ignore this
767 : : limitation. */
768 : :
769 : 3370828 : handle_stack_protect_test:
770 : 4224426 : test_if = SET_SRC (pc_set (condjmp));
771 : 4224426 : cond = XEXP (test_if, 0);
772 : 4224426 : ccode = GET_CODE (cond);
773 : : /* Check whether conditional jump use Sign or Overflow Flags. */
774 : 4224426 : if (!TARGET_FUSE_CMP_AND_BRANCH_SOFLAGS
775 : 0 : && (ccode == GE || ccode == GT || ccode == LE || ccode == LT))
776 : : return false;
777 : :
778 : : /* Return true for TYPE_TEST and TYPE_ICMP. */
779 : 4224426 : if (condgen_type == TYPE_TEST || condgen_type == TYPE_ICMP)
780 : : return true;
781 : :
782 : : /* The following is the case that macro-fusion for alu + jmp. */
783 : 174727 : if (!TARGET_FUSE_ALU_AND_BRANCH || (!alu_set && !alu_clobber))
784 : : return false;
785 : :
786 : : /* No fusion for alu op with memory destination operand. */
787 : 69458 : if (alu_set && MEM_P (SET_DEST (alu_set)))
788 : : return false;
789 : :
790 : :
791 : : /* Macro-fusion for inc/dec + unsigned conditional jump is not
792 : : supported on some CPUs while supported on others (znver5 and core_avx512).
793 : : We however never generate it, so we do not need a specific tune for it. */
794 : 66443 : gcc_checking_assert (!(condgen_type == TYPE_INCDEC
795 : : && (ccode == GEU || ccode == GTU || ccode == LEU || ccode == LTU)));
796 : :
797 : : return true;
798 : : }
|
