1 /* Perform doloop optimizations
2 Copyright (C) 2004-2015 Free Software Foundation, Inc.
3 Based on code by Michael P. Hayes (m.hayes@elec.canterbury.ac.nz)
5 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
36 #include "loop-unroll.h"
38 /* This module is used to modify loops with a determinable number of
39 iterations to use special low-overhead looping instructions.
41 It first validates whether the loop is well behaved and has a
42 determinable number of iterations (either at compile or run-time).
43 It then modifies the loop to use a low-overhead looping pattern as
46 1. A pseudo register is allocated as the loop iteration counter.
48 2. The number of loop iterations is calculated and is stored
51 3. At the end of the loop, the jump insn is replaced by the
52 doloop_end pattern. The compare must remain because it might be
53 used elsewhere. If the loop-variable or condition register are
54 used elsewhere, they will be eliminated by flow.
56 4. An optional doloop_begin pattern is inserted at the top of the
59 TODO The optimization should only performed when either the biv used for exit
60 condition is unused at all except for the exit test, or if we do not have to
61 change its value, since otherwise we have to add a new induction variable,
62 which usually will not pay up (unless the cost of the doloop pattern is
63 somehow extremely lower than the cost of compare & jump, or unless the bct
64 register cannot be used for anything else but doloop -- ??? detect these
67 /* Return the loop termination condition for PATTERN or zero
68 if it is not a decrement and branch jump insn. */
71 doloop_condition_get (rtx doloop_pat
)
79 rtx cc_reg
= NULL_RTX
;
80 rtx reg_orig
= NULL_RTX
;
82 /* The canonical doloop pattern we expect has one of the following
85 1) (parallel [(set (pc) (if_then_else (condition)
88 (set (reg) (plus (reg) (const_int -1)))
89 (additional clobbers and uses)])
91 The branch must be the first entry of the parallel (also required
92 by jump.c), and the second entry of the parallel must be a set of
93 the loop counter register. Some targets (IA-64) wrap the set of
94 the loop counter in an if_then_else too.
96 2) (set (reg) (plus (reg) (const_int -1))
97 (set (pc) (if_then_else (reg != 0)
101 Some targets (ARM) do the comparison before the branch, as in the
104 3) (parallel [(set (cc) (compare ((plus (reg) (const_int -1), 0)))
105 (set (reg) (plus (reg) (const_int -1)))])
106 (set (pc) (if_then_else (cc == NE)
110 pattern
= PATTERN (doloop_pat
);
112 if (GET_CODE (pattern
) != PARALLEL
)
115 rtx_insn
*prev_insn
= prev_nondebug_insn (doloop_pat
);
116 rtx cmp_arg1
, cmp_arg2
;
119 /* In case the pattern is not PARALLEL we expect two forms
120 of doloop which are cases 2) and 3) above: in case 2) the
121 decrement immediately precedes the branch, while in case 3)
122 the compare and decrement instructions immediately precede
125 if (prev_insn
== NULL_RTX
|| !INSN_P (prev_insn
))
129 if (GET_CODE (PATTERN (prev_insn
)) == PARALLEL
)
131 /* The third case: the compare and decrement instructions
132 immediately precede the branch. */
133 cmp_orig
= XVECEXP (PATTERN (prev_insn
), 0, 0);
134 if (GET_CODE (cmp_orig
) != SET
)
136 if (GET_CODE (SET_SRC (cmp_orig
)) != COMPARE
)
138 cmp_arg1
= XEXP (SET_SRC (cmp_orig
), 0);
139 cmp_arg2
= XEXP (SET_SRC (cmp_orig
), 1);
140 if (cmp_arg2
!= const0_rtx
141 || GET_CODE (cmp_arg1
) != PLUS
)
143 reg_orig
= XEXP (cmp_arg1
, 0);
144 if (XEXP (cmp_arg1
, 1) != GEN_INT (-1)
145 || !REG_P (reg_orig
))
147 cc_reg
= SET_DEST (cmp_orig
);
149 inc
= XVECEXP (PATTERN (prev_insn
), 0, 1);
152 inc
= PATTERN (prev_insn
);
153 /* We expect the condition to be of the form (reg != 0) */
154 cond
= XEXP (SET_SRC (cmp
), 0);
155 if (GET_CODE (cond
) != NE
|| XEXP (cond
, 1) != const0_rtx
)
160 cmp
= XVECEXP (pattern
, 0, 0);
161 inc
= XVECEXP (pattern
, 0, 1);
164 /* Check for (set (reg) (something)). */
165 if (GET_CODE (inc
) != SET
)
167 reg
= SET_DEST (inc
);
171 /* Check if something = (plus (reg) (const_int -1)).
172 On IA-64, this decrement is wrapped in an if_then_else. */
173 inc_src
= SET_SRC (inc
);
174 if (GET_CODE (inc_src
) == IF_THEN_ELSE
)
175 inc_src
= XEXP (inc_src
, 1);
176 if (GET_CODE (inc_src
) != PLUS
177 || XEXP (inc_src
, 0) != reg
178 || XEXP (inc_src
, 1) != constm1_rtx
)
181 /* Check for (set (pc) (if_then_else (condition)
184 if (GET_CODE (cmp
) != SET
185 || SET_DEST (cmp
) != pc_rtx
186 || GET_CODE (SET_SRC (cmp
)) != IF_THEN_ELSE
187 || GET_CODE (XEXP (SET_SRC (cmp
), 1)) != LABEL_REF
188 || XEXP (SET_SRC (cmp
), 2) != pc_rtx
)
191 /* Extract loop termination condition. */
192 condition
= XEXP (SET_SRC (cmp
), 0);
194 /* We expect a GE or NE comparison with 0 or 1. */
195 if ((GET_CODE (condition
) != GE
196 && GET_CODE (condition
) != NE
)
197 || (XEXP (condition
, 1) != const0_rtx
198 && XEXP (condition
, 1) != const1_rtx
))
201 if ((XEXP (condition
, 0) == reg
)
202 /* For the third case: */
203 || ((cc_reg
!= NULL_RTX
)
204 && (XEXP (condition
, 0) == cc_reg
)
205 && (reg_orig
== reg
))
206 || (GET_CODE (XEXP (condition
, 0)) == PLUS
207 && XEXP (XEXP (condition
, 0), 0) == reg
))
209 if (GET_CODE (pattern
) != PARALLEL
)
210 /* For the second form we expect:
212 (set (reg) (plus (reg) (const_int -1))
213 (set (pc) (if_then_else (reg != 0)
217 is equivalent to the following:
219 (parallel [(set (pc) (if_then_else (reg != 1)
222 (set (reg) (plus (reg) (const_int -1)))
223 (additional clobbers and uses)])
225 For the third form we expect:
227 (parallel [(set (cc) (compare ((plus (reg) (const_int -1)), 0))
228 (set (reg) (plus (reg) (const_int -1)))])
229 (set (pc) (if_then_else (cc == NE)
233 which is equivalent to the following:
235 (parallel [(set (cc) (compare (reg, 1))
236 (set (reg) (plus (reg) (const_int -1)))
237 (set (pc) (if_then_else (NE == cc)
241 So we return the second form instead for the two cases.
244 condition
= gen_rtx_fmt_ee (NE
, VOIDmode
, inc_src
, const1_rtx
);
249 /* ??? If a machine uses a funny comparison, we could return a
250 canonicalized form here. */
255 /* Return nonzero if the loop specified by LOOP is suitable for
256 the use of special low-overhead looping instructions. DESC
257 describes the number of iterations of the loop. */
260 doloop_valid_p (struct loop
*loop
, struct niter_desc
*desc
)
262 basic_block
*body
= get_loop_body (loop
), bb
;
267 /* Check for loops that may not terminate under special conditions. */
272 /* There are some cases that would require a special attention.
273 For example if the comparison is LEU and the comparison value
274 is UINT_MAX then the loop will not terminate. Similarly, if the
275 comparison code is GEU and the comparison value is 0, the
276 loop will not terminate.
278 If the absolute increment is not 1, the loop can be infinite
279 even with LTU/GTU, e.g. for (i = 3; i > 0; i -= 2)
281 ??? We could compute these conditions at run-time and have a
282 additional jump around the loop to ensure an infinite loop.
283 However, it is very unlikely that this is the intended
284 behavior of the loop and checking for these rare boundary
285 conditions would pessimize all other code.
287 If the loop is executed only a few times an extra check to
288 restart the loop could use up most of the benefits of using a
289 count register loop. Note however, that normally, this
290 restart branch would never execute, so it could be predicted
291 well by the CPU. We should generate the pessimistic code by
292 default, and have an option, e.g. -funsafe-loops that would
293 enable count-register loops in this case. */
295 fprintf (dump_file
, "Doloop: Possible infinite iteration case.\n");
300 for (i
= 0; i
< loop
->num_nodes
; i
++)
304 for (insn
= BB_HEAD (bb
);
305 insn
!= NEXT_INSN (BB_END (bb
));
306 insn
= NEXT_INSN (insn
))
308 /* Different targets have different necessities for low-overhead
309 looping. Call the back end for each instruction within the loop
310 to let it decide whether the insn prohibits a low-overhead loop.
311 It will then return the cause for it to emit to the dump file. */
312 const char * invalid
= targetm
.invalid_within_doloop (insn
);
316 fprintf (dump_file
, "Doloop: %s\n", invalid
);
330 /* Adds test of COND jumping to DEST on edge *E and set *E to the new fallthru
331 edge. If the condition is always false, do not do anything. If it is always
332 true, redirect E to DEST and return false. In all other cases, true is
336 add_test (rtx cond
, edge
*e
, basic_block dest
)
338 rtx_insn
*seq
, *jump
;
339 rtx_code_label
*label
;
341 rtx op0
= XEXP (cond
, 0), op1
= XEXP (cond
, 1);
342 enum rtx_code code
= GET_CODE (cond
);
345 mode
= GET_MODE (XEXP (cond
, 0));
346 if (mode
== VOIDmode
)
347 mode
= GET_MODE (XEXP (cond
, 1));
350 op0
= force_operand (op0
, NULL_RTX
);
351 op1
= force_operand (op1
, NULL_RTX
);
352 label
= block_label (dest
);
353 do_compare_rtx_and_jump (op0
, op1
, code
, 0, mode
, NULL_RTX
, NULL
, label
, -1);
355 jump
= get_last_insn ();
356 if (!jump
|| !JUMP_P (jump
))
358 /* The condition is always false and the jump was optimized out. */
366 /* There always is at least the jump insn in the sequence. */
367 gcc_assert (seq
!= NULL_RTX
);
369 bb
= split_edge_and_insert (*e
, seq
);
370 *e
= single_succ_edge (bb
);
372 if (any_uncondjump_p (jump
))
374 /* The condition is always true. */
376 redirect_edge_and_branch_force (*e
, dest
);
380 JUMP_LABEL (jump
) = label
;
382 /* The jump is supposed to handle an unlikely special case. */
383 add_int_reg_note (jump
, REG_BR_PROB
, 0);
385 LABEL_NUSES (label
)++;
387 make_edge (bb
, dest
, (*e
)->flags
& ~EDGE_FALLTHRU
);
391 /* Modify the loop to use the low-overhead looping insn where LOOP
392 describes the loop, DESC describes the number of iterations of the
393 loop, and DOLOOP_INSN is the low-overhead looping insn to emit at the
394 end of the loop. CONDITION is the condition separated from the
395 DOLOOP_SEQ. COUNT is the number of iterations of the LOOP. */
398 doloop_modify (struct loop
*loop
, struct niter_desc
*desc
,
399 rtx_insn
*doloop_seq
, rtx condition
, rtx count
)
402 rtx tmp
, noloop
= NULL_RTX
;
405 rtx_code_label
*jump_label
;
407 bool increment_count
;
408 basic_block loop_end
= desc
->out_edge
->src
;
411 widest_int iterations
;
413 jump_insn
= BB_END (loop_end
);
417 fprintf (dump_file
, "Doloop: Inserting doloop pattern (");
418 if (desc
->const_iter
)
419 fprintf (dump_file
, "%" PRId64
, desc
->niter
);
421 fputs ("runtime", dump_file
);
422 fputs (" iterations).\n", dump_file
);
425 /* Get the probability of the original branch. If it exists we would
426 need to update REG_BR_PROB of the new jump_insn. */
427 true_prob_val
= find_reg_note (jump_insn
, REG_BR_PROB
, NULL_RTX
);
429 /* Discard original jump to continue loop. The original compare
430 result may still be live, so it cannot be discarded explicitly. */
431 delete_insn (jump_insn
);
433 counter_reg
= XEXP (condition
, 0);
434 if (GET_CODE (counter_reg
) == PLUS
)
435 counter_reg
= XEXP (counter_reg
, 0);
436 mode
= GET_MODE (counter_reg
);
438 increment_count
= false;
439 switch (GET_CODE (condition
))
442 /* Currently only NE tests against zero and one are supported. */
443 noloop
= XEXP (condition
, 1);
444 if (noloop
!= const0_rtx
)
446 gcc_assert (noloop
== const1_rtx
);
447 increment_count
= true;
452 /* Currently only GE tests against zero are supported. */
453 gcc_assert (XEXP (condition
, 1) == const0_rtx
);
455 noloop
= constm1_rtx
;
457 /* The iteration count does not need incrementing for a GE test. */
458 increment_count
= false;
460 /* Determine if the iteration counter will be non-negative.
461 Note that the maximum value loaded is iterations_max - 1. */
462 if (get_max_loop_iterations (loop
, &iterations
)
463 && wi::leu_p (iterations
,
464 wi::set_bit_in_zero
<widest_int
>
465 (GET_MODE_PRECISION (mode
) - 1)))
469 /* Abort if an invalid doloop pattern has been generated. */
475 count
= simplify_gen_binary (PLUS
, mode
, count
, const1_rtx
);
477 /* Insert initialization of the count register into the loop header. */
479 tmp
= force_operand (count
, counter_reg
);
480 convert_move (counter_reg
, tmp
, 1);
481 sequence
= get_insns ();
483 emit_insn_after (sequence
, BB_END (loop_preheader_edge (loop
)->src
));
485 if (desc
->noloop_assumptions
)
487 rtx ass
= copy_rtx (desc
->noloop_assumptions
);
488 basic_block preheader
= loop_preheader_edge (loop
)->src
;
490 = split_edge (loop_preheader_edge (loop
));
491 basic_block new_preheader
492 = split_edge (loop_preheader_edge (loop
));
495 /* Expand the condition testing the assumptions and if it does not pass,
496 reset the count register to 0. */
497 redirect_edge_and_branch_force (single_succ_edge (preheader
), new_preheader
);
498 set_immediate_dominator (CDI_DOMINATORS
, new_preheader
, preheader
);
501 set_zero
->frequency
= 0;
503 te
= single_succ_edge (preheader
);
504 for (; ass
; ass
= XEXP (ass
, 1))
505 if (!add_test (XEXP (ass
, 0), &te
, set_zero
))
510 /* We reached a condition that is always true. This is very hard to
511 reproduce (such a loop does not roll, and thus it would most
512 likely get optimized out by some of the preceding optimizations).
513 In fact, I do not have any testcase for it. However, it would
514 also be very hard to show that it is impossible, so we must
516 set_zero
->count
= preheader
->count
;
517 set_zero
->frequency
= preheader
->frequency
;
520 if (EDGE_COUNT (set_zero
->preds
) == 0)
522 /* All the conditions were simplified to false, remove the
523 unreachable set_zero block. */
524 delete_basic_block (set_zero
);
528 /* Reset the counter to zero in the set_zero block. */
530 convert_move (counter_reg
, noloop
, 0);
531 sequence
= get_insns ();
533 emit_insn_after (sequence
, BB_END (set_zero
));
535 set_immediate_dominator (CDI_DOMINATORS
, set_zero
,
536 recompute_dominator (CDI_DOMINATORS
,
540 set_immediate_dominator (CDI_DOMINATORS
, new_preheader
,
541 recompute_dominator (CDI_DOMINATORS
,
545 /* Some targets (eg, C4x) need to initialize special looping
547 if (targetm
.have_doloop_begin ())
548 if (rtx_insn
*seq
= targetm
.gen_doloop_begin (counter_reg
, doloop_seq
))
549 emit_insn_after (seq
, BB_END (loop_preheader_edge (loop
)->src
));
551 /* Insert the new low-overhead looping insn. */
552 emit_jump_insn_after (doloop_seq
, BB_END (loop_end
));
553 jump_insn
= BB_END (loop_end
);
554 jump_label
= block_label (desc
->in_edge
->dest
);
555 JUMP_LABEL (jump_insn
) = jump_label
;
556 LABEL_NUSES (jump_label
)++;
558 /* Ensure the right fallthru edge is marked, for case we have reversed
560 desc
->in_edge
->flags
&= ~EDGE_FALLTHRU
;
561 desc
->out_edge
->flags
|= EDGE_FALLTHRU
;
563 /* Add a REG_NONNEG note if the actual or estimated maximum number
564 of iterations is non-negative. */
566 add_reg_note (jump_insn
, REG_NONNEG
, NULL_RTX
);
568 /* Update the REG_BR_PROB note. */
571 /* Seems safer to use the branch probability. */
572 add_int_reg_note (jump_insn
, REG_BR_PROB
, desc
->in_edge
->probability
);
576 /* Process loop described by LOOP validating that the loop is suitable for
577 conversion to use a low overhead looping instruction, replacing the jump
578 insn where suitable. Returns true if the loop was successfully
582 doloop_optimize (struct loop
*loop
)
587 widest_int iterations
, iterations_max
;
588 rtx_code_label
*start_label
;
590 unsigned level
, est_niter
;
592 struct niter_desc
*desc
;
593 unsigned word_mode_size
;
594 unsigned HOST_WIDE_INT word_mode_max
;
598 fprintf (dump_file
, "Doloop: Processing loop %d.\n", loop
->num
);
600 iv_analysis_loop_init (loop
);
602 /* Find the simple exit of a LOOP. */
603 desc
= get_simple_loop_desc (loop
);
605 /* Check that loop is a candidate for a low-overhead looping insn. */
606 if (!doloop_valid_p (loop
, desc
))
610 "Doloop: The loop is not suitable.\n");
616 if (desc
->const_iter
)
617 est_niter
= desc
->niter
;
618 /* If the estimate on number of iterations is reliable (comes from profile
619 feedback), use it. Do not use it normally, since the expected number
620 of iterations of an unrolled loop is 2. */
621 if (loop
->header
->count
)
622 est_niter
= expected_loop_iterations (loop
);
628 "Doloop: Too few iterations (%u) to be profitable.\n",
634 = COSTS_N_INSNS (PARAM_VALUE (PARAM_MAX_ITERATIONS_COMPUTATION_COST
));
635 if (set_src_cost (desc
->niter_expr
, mode
, optimize_loop_for_speed_p (loop
))
640 "Doloop: number of iterations too costly to compute.\n");
644 if (desc
->const_iter
)
645 iterations
= widest_int::from (std::make_pair (desc
->niter_expr
, mode
),
649 if (!get_max_loop_iterations (loop
, &iterations_max
))
651 level
= get_loop_level (loop
) + 1;
652 entered_at_top
= (loop
->latch
== desc
->in_edge
->dest
653 && contains_no_active_insn_p (loop
->latch
));
654 if (!targetm
.can_use_doloop_p (iterations
, iterations_max
, level
,
658 fprintf (dump_file
, "Loop rejected by can_use_doloop_p.\n");
662 /* Generate looping insn. If the pattern FAILs then give up trying
663 to modify the loop since there is some aspect the back-end does
665 count
= copy_rtx (desc
->niter_expr
);
666 start_label
= block_label (desc
->in_edge
->dest
);
667 doloop_reg
= gen_reg_rtx (mode
);
668 rtx_insn
*doloop_seq
= targetm
.gen_doloop_end (doloop_reg
, start_label
);
670 word_mode_size
= GET_MODE_PRECISION (word_mode
);
672 = ((unsigned HOST_WIDE_INT
) 1 << (word_mode_size
- 1) << 1) - 1;
675 /* Before trying mode different from the one in that # of iterations is
676 computed, we must be sure that the number of iterations fits into
678 && (word_mode_size
>= GET_MODE_PRECISION (mode
)
679 || wi::leu_p (iterations_max
, word_mode_max
)))
681 if (word_mode_size
> GET_MODE_PRECISION (mode
))
682 count
= simplify_gen_unary (ZERO_EXTEND
, word_mode
, count
, mode
);
684 count
= lowpart_subreg (word_mode
, count
, mode
);
685 PUT_MODE (doloop_reg
, word_mode
);
686 doloop_seq
= targetm
.gen_doloop_end (doloop_reg
, start_label
);
692 "Doloop: Target unwilling to use doloop pattern!\n");
696 /* If multiple instructions were created, the last must be the
698 rtx_insn
*doloop_insn
= doloop_seq
;
699 while (NEXT_INSN (doloop_insn
) != NULL_RTX
)
700 doloop_insn
= NEXT_INSN (doloop_insn
);
701 if (!JUMP_P (doloop_insn
)
702 || !(condition
= doloop_condition_get (doloop_insn
)))
705 fprintf (dump_file
, "Doloop: Unrecognizable doloop pattern!\n");
709 doloop_modify (loop
, desc
, doloop_seq
, condition
, count
);
713 /* This is the main entry point. Process all loops using doloop_optimize. */
716 doloop_optimize_loops (void)
720 FOR_EACH_LOOP (loop
, 0)
722 doloop_optimize (loop
);
727 checking_verify_loop_structure ();