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"
29 #include "hard-reg-set.h"
36 #include "diagnostic-core.h"
39 #include "dominance.h"
43 #include "basic-block.h"
47 #include "loop-unroll.h"
49 /* This module is used to modify loops with a determinable number of
50 iterations to use special low-overhead looping instructions.
52 It first validates whether the loop is well behaved and has a
53 determinable number of iterations (either at compile or run-time).
54 It then modifies the loop to use a low-overhead looping pattern as
57 1. A pseudo register is allocated as the loop iteration counter.
59 2. The number of loop iterations is calculated and is stored
62 3. At the end of the loop, the jump insn is replaced by the
63 doloop_end pattern. The compare must remain because it might be
64 used elsewhere. If the loop-variable or condition register are
65 used elsewhere, they will be eliminated by flow.
67 4. An optional doloop_begin pattern is inserted at the top of the
70 TODO The optimization should only performed when either the biv used for exit
71 condition is unused at all except for the exit test, or if we do not have to
72 change its value, since otherwise we have to add a new induction variable,
73 which usually will not pay up (unless the cost of the doloop pattern is
74 somehow extremely lower than the cost of compare & jump, or unless the bct
75 register cannot be used for anything else but doloop -- ??? detect these
78 #ifdef HAVE_doloop_end
80 /* Return the loop termination condition for PATTERN or zero
81 if it is not a decrement and branch jump insn. */
84 doloop_condition_get (rtx doloop_pat
)
92 rtx cc_reg
= NULL_RTX
;
93 rtx reg_orig
= NULL_RTX
;
95 /* The canonical doloop pattern we expect has one of the following
98 1) (parallel [(set (pc) (if_then_else (condition)
101 (set (reg) (plus (reg) (const_int -1)))
102 (additional clobbers and uses)])
104 The branch must be the first entry of the parallel (also required
105 by jump.c), and the second entry of the parallel must be a set of
106 the loop counter register. Some targets (IA-64) wrap the set of
107 the loop counter in an if_then_else too.
109 2) (set (reg) (plus (reg) (const_int -1))
110 (set (pc) (if_then_else (reg != 0)
114 Some targets (ARM) do the comparison before the branch, as in the
117 3) (parallel [(set (cc) (compare ((plus (reg) (const_int -1), 0)))
118 (set (reg) (plus (reg) (const_int -1)))])
119 (set (pc) (if_then_else (cc == NE)
123 pattern
= PATTERN (doloop_pat
);
125 if (GET_CODE (pattern
) != PARALLEL
)
128 rtx prev_insn
= prev_nondebug_insn (doloop_pat
);
129 rtx cmp_arg1
, cmp_arg2
;
132 /* In case the pattern is not PARALLEL we expect two forms
133 of doloop which are cases 2) and 3) above: in case 2) the
134 decrement immediately precedes the branch, while in case 3)
135 the compare and decrement instructions immediately precede
138 if (prev_insn
== NULL_RTX
|| !INSN_P (prev_insn
))
142 if (GET_CODE (PATTERN (prev_insn
)) == PARALLEL
)
144 /* The third case: the compare and decrement instructions
145 immediately precede the branch. */
146 cmp_orig
= XVECEXP (PATTERN (prev_insn
), 0, 0);
147 if (GET_CODE (cmp_orig
) != SET
)
149 if (GET_CODE (SET_SRC (cmp_orig
)) != COMPARE
)
151 cmp_arg1
= XEXP (SET_SRC (cmp_orig
), 0);
152 cmp_arg2
= XEXP (SET_SRC (cmp_orig
), 1);
153 if (cmp_arg2
!= const0_rtx
154 || GET_CODE (cmp_arg1
) != PLUS
)
156 reg_orig
= XEXP (cmp_arg1
, 0);
157 if (XEXP (cmp_arg1
, 1) != GEN_INT (-1)
158 || !REG_P (reg_orig
))
160 cc_reg
= SET_DEST (cmp_orig
);
162 inc
= XVECEXP (PATTERN (prev_insn
), 0, 1);
165 inc
= PATTERN (prev_insn
);
166 /* We expect the condition to be of the form (reg != 0) */
167 cond
= XEXP (SET_SRC (cmp
), 0);
168 if (GET_CODE (cond
) != NE
|| XEXP (cond
, 1) != const0_rtx
)
173 cmp
= XVECEXP (pattern
, 0, 0);
174 inc
= XVECEXP (pattern
, 0, 1);
177 /* Check for (set (reg) (something)). */
178 if (GET_CODE (inc
) != SET
)
180 reg
= SET_DEST (inc
);
184 /* Check if something = (plus (reg) (const_int -1)).
185 On IA-64, this decrement is wrapped in an if_then_else. */
186 inc_src
= SET_SRC (inc
);
187 if (GET_CODE (inc_src
) == IF_THEN_ELSE
)
188 inc_src
= XEXP (inc_src
, 1);
189 if (GET_CODE (inc_src
) != PLUS
190 || XEXP (inc_src
, 0) != reg
191 || XEXP (inc_src
, 1) != constm1_rtx
)
194 /* Check for (set (pc) (if_then_else (condition)
197 if (GET_CODE (cmp
) != SET
198 || SET_DEST (cmp
) != pc_rtx
199 || GET_CODE (SET_SRC (cmp
)) != IF_THEN_ELSE
200 || GET_CODE (XEXP (SET_SRC (cmp
), 1)) != LABEL_REF
201 || XEXP (SET_SRC (cmp
), 2) != pc_rtx
)
204 /* Extract loop termination condition. */
205 condition
= XEXP (SET_SRC (cmp
), 0);
207 /* We expect a GE or NE comparison with 0 or 1. */
208 if ((GET_CODE (condition
) != GE
209 && GET_CODE (condition
) != NE
)
210 || (XEXP (condition
, 1) != const0_rtx
211 && XEXP (condition
, 1) != const1_rtx
))
214 if ((XEXP (condition
, 0) == reg
)
215 /* For the third case: */
216 || ((cc_reg
!= NULL_RTX
)
217 && (XEXP (condition
, 0) == cc_reg
)
218 && (reg_orig
== reg
))
219 || (GET_CODE (XEXP (condition
, 0)) == PLUS
220 && XEXP (XEXP (condition
, 0), 0) == reg
))
222 if (GET_CODE (pattern
) != PARALLEL
)
223 /* For the second form we expect:
225 (set (reg) (plus (reg) (const_int -1))
226 (set (pc) (if_then_else (reg != 0)
230 is equivalent to the following:
232 (parallel [(set (pc) (if_then_else (reg != 1)
235 (set (reg) (plus (reg) (const_int -1)))
236 (additional clobbers and uses)])
238 For the third form we expect:
240 (parallel [(set (cc) (compare ((plus (reg) (const_int -1)), 0))
241 (set (reg) (plus (reg) (const_int -1)))])
242 (set (pc) (if_then_else (cc == NE)
246 which is equivalent to the following:
248 (parallel [(set (cc) (compare (reg, 1))
249 (set (reg) (plus (reg) (const_int -1)))
250 (set (pc) (if_then_else (NE == cc)
254 So we return the second form instead for the two cases.
257 condition
= gen_rtx_fmt_ee (NE
, VOIDmode
, inc_src
, const1_rtx
);
262 /* ??? If a machine uses a funny comparison, we could return a
263 canonicalized form here. */
268 /* Return nonzero if the loop specified by LOOP is suitable for
269 the use of special low-overhead looping instructions. DESC
270 describes the number of iterations of the loop. */
273 doloop_valid_p (struct loop
*loop
, struct niter_desc
*desc
)
275 basic_block
*body
= get_loop_body (loop
), bb
;
280 /* Check for loops that may not terminate under special conditions. */
285 /* There are some cases that would require a special attention.
286 For example if the comparison is LEU and the comparison value
287 is UINT_MAX then the loop will not terminate. Similarly, if the
288 comparison code is GEU and the comparison value is 0, the
289 loop will not terminate.
291 If the absolute increment is not 1, the loop can be infinite
292 even with LTU/GTU, e.g. for (i = 3; i > 0; i -= 2)
294 ??? We could compute these conditions at run-time and have a
295 additional jump around the loop to ensure an infinite loop.
296 However, it is very unlikely that this is the intended
297 behavior of the loop and checking for these rare boundary
298 conditions would pessimize all other code.
300 If the loop is executed only a few times an extra check to
301 restart the loop could use up most of the benefits of using a
302 count register loop. Note however, that normally, this
303 restart branch would never execute, so it could be predicted
304 well by the CPU. We should generate the pessimistic code by
305 default, and have an option, e.g. -funsafe-loops that would
306 enable count-register loops in this case. */
308 fprintf (dump_file
, "Doloop: Possible infinite iteration case.\n");
313 for (i
= 0; i
< loop
->num_nodes
; i
++)
317 for (insn
= BB_HEAD (bb
);
318 insn
!= NEXT_INSN (BB_END (bb
));
319 insn
= NEXT_INSN (insn
))
321 /* Different targets have different necessities for low-overhead
322 looping. Call the back end for each instruction within the loop
323 to let it decide whether the insn prohibits a low-overhead loop.
324 It will then return the cause for it to emit to the dump file. */
325 const char * invalid
= targetm
.invalid_within_doloop (insn
);
329 fprintf (dump_file
, "Doloop: %s\n", invalid
);
343 /* Adds test of COND jumping to DEST on edge *E and set *E to the new fallthru
344 edge. If the condition is always false, do not do anything. If it is always
345 true, redirect E to DEST and return false. In all other cases, true is
349 add_test (rtx cond
, edge
*e
, basic_block dest
)
351 rtx_insn
*seq
, *jump
;
354 rtx op0
= XEXP (cond
, 0), op1
= XEXP (cond
, 1);
355 enum rtx_code code
= GET_CODE (cond
);
358 mode
= GET_MODE (XEXP (cond
, 0));
359 if (mode
== VOIDmode
)
360 mode
= GET_MODE (XEXP (cond
, 1));
363 op0
= force_operand (op0
, NULL_RTX
);
364 op1
= force_operand (op1
, NULL_RTX
);
365 label
= block_label (dest
);
366 do_compare_rtx_and_jump (op0
, op1
, code
, 0, mode
, NULL_RTX
,
367 NULL_RTX
, label
, -1);
369 jump
= get_last_insn ();
370 if (!jump
|| !JUMP_P (jump
))
372 /* The condition is always false and the jump was optimized out. */
380 /* There always is at least the jump insn in the sequence. */
381 gcc_assert (seq
!= NULL_RTX
);
383 bb
= split_edge_and_insert (*e
, seq
);
384 *e
= single_succ_edge (bb
);
386 if (any_uncondjump_p (jump
))
388 /* The condition is always true. */
390 redirect_edge_and_branch_force (*e
, dest
);
394 JUMP_LABEL (jump
) = label
;
396 /* The jump is supposed to handle an unlikely special case. */
397 add_int_reg_note (jump
, REG_BR_PROB
, 0);
399 LABEL_NUSES (label
)++;
401 make_edge (bb
, dest
, (*e
)->flags
& ~EDGE_FALLTHRU
);
405 /* Modify the loop to use the low-overhead looping insn where LOOP
406 describes the loop, DESC describes the number of iterations of the
407 loop, and DOLOOP_INSN is the low-overhead looping insn to emit at the
408 end of the loop. CONDITION is the condition separated from the
409 DOLOOP_SEQ. COUNT is the number of iterations of the LOOP. */
412 doloop_modify (struct loop
*loop
, struct niter_desc
*desc
,
413 rtx doloop_seq
, rtx condition
, rtx count
)
416 rtx tmp
, noloop
= NULL_RTX
;
421 bool increment_count
;
422 basic_block loop_end
= desc
->out_edge
->src
;
425 widest_int iterations
;
427 jump_insn
= BB_END (loop_end
);
431 fprintf (dump_file
, "Doloop: Inserting doloop pattern (");
432 if (desc
->const_iter
)
433 fprintf (dump_file
, "%"PRId64
, desc
->niter
);
435 fputs ("runtime", dump_file
);
436 fputs (" iterations).\n", dump_file
);
439 /* Get the probability of the original branch. If it exists we would
440 need to update REG_BR_PROB of the new jump_insn. */
441 true_prob_val
= find_reg_note (jump_insn
, REG_BR_PROB
, NULL_RTX
);
443 /* Discard original jump to continue loop. The original compare
444 result may still be live, so it cannot be discarded explicitly. */
445 delete_insn (jump_insn
);
447 counter_reg
= XEXP (condition
, 0);
448 if (GET_CODE (counter_reg
) == PLUS
)
449 counter_reg
= XEXP (counter_reg
, 0);
450 mode
= GET_MODE (counter_reg
);
452 increment_count
= false;
453 switch (GET_CODE (condition
))
456 /* Currently only NE tests against zero and one are supported. */
457 noloop
= XEXP (condition
, 1);
458 if (noloop
!= const0_rtx
)
460 gcc_assert (noloop
== const1_rtx
);
461 increment_count
= true;
466 /* Currently only GE tests against zero are supported. */
467 gcc_assert (XEXP (condition
, 1) == const0_rtx
);
469 noloop
= constm1_rtx
;
471 /* The iteration count does not need incrementing for a GE test. */
472 increment_count
= false;
474 /* Determine if the iteration counter will be non-negative.
475 Note that the maximum value loaded is iterations_max - 1. */
476 if (get_max_loop_iterations (loop
, &iterations
)
477 && wi::leu_p (iterations
,
478 wi::set_bit_in_zero
<widest_int
>
479 (GET_MODE_PRECISION (mode
) - 1)))
483 /* Abort if an invalid doloop pattern has been generated. */
489 count
= simplify_gen_binary (PLUS
, mode
, count
, const1_rtx
);
491 /* Insert initialization of the count register into the loop header. */
493 tmp
= force_operand (count
, counter_reg
);
494 convert_move (counter_reg
, tmp
, 1);
495 sequence
= get_insns ();
497 emit_insn_after (sequence
, BB_END (loop_preheader_edge (loop
)->src
));
499 if (desc
->noloop_assumptions
)
501 rtx ass
= copy_rtx (desc
->noloop_assumptions
);
502 basic_block preheader
= loop_preheader_edge (loop
)->src
;
504 = split_edge (loop_preheader_edge (loop
));
505 basic_block new_preheader
506 = split_edge (loop_preheader_edge (loop
));
509 /* Expand the condition testing the assumptions and if it does not pass,
510 reset the count register to 0. */
511 redirect_edge_and_branch_force (single_succ_edge (preheader
), new_preheader
);
512 set_immediate_dominator (CDI_DOMINATORS
, new_preheader
, preheader
);
515 set_zero
->frequency
= 0;
517 te
= single_succ_edge (preheader
);
518 for (; ass
; ass
= XEXP (ass
, 1))
519 if (!add_test (XEXP (ass
, 0), &te
, set_zero
))
524 /* We reached a condition that is always true. This is very hard to
525 reproduce (such a loop does not roll, and thus it would most
526 likely get optimized out by some of the preceding optimizations).
527 In fact, I do not have any testcase for it. However, it would
528 also be very hard to show that it is impossible, so we must
530 set_zero
->count
= preheader
->count
;
531 set_zero
->frequency
= preheader
->frequency
;
534 if (EDGE_COUNT (set_zero
->preds
) == 0)
536 /* All the conditions were simplified to false, remove the
537 unreachable set_zero block. */
538 delete_basic_block (set_zero
);
542 /* Reset the counter to zero in the set_zero block. */
544 convert_move (counter_reg
, noloop
, 0);
545 sequence
= get_insns ();
547 emit_insn_after (sequence
, BB_END (set_zero
));
549 set_immediate_dominator (CDI_DOMINATORS
, set_zero
,
550 recompute_dominator (CDI_DOMINATORS
,
554 set_immediate_dominator (CDI_DOMINATORS
, new_preheader
,
555 recompute_dominator (CDI_DOMINATORS
,
559 /* Some targets (eg, C4x) need to initialize special looping
561 #ifdef HAVE_doloop_begin
565 init
= gen_doloop_begin (counter_reg
, doloop_seq
);
570 sequence
= get_insns ();
572 emit_insn_after (sequence
, BB_END (loop_preheader_edge (loop
)->src
));
577 /* Insert the new low-overhead looping insn. */
578 emit_jump_insn_after (doloop_seq
, BB_END (loop_end
));
579 jump_insn
= BB_END (loop_end
);
580 jump_label
= block_label (desc
->in_edge
->dest
);
581 JUMP_LABEL (jump_insn
) = jump_label
;
582 LABEL_NUSES (jump_label
)++;
584 /* Ensure the right fallthru edge is marked, for case we have reversed
586 desc
->in_edge
->flags
&= ~EDGE_FALLTHRU
;
587 desc
->out_edge
->flags
|= EDGE_FALLTHRU
;
589 /* Add a REG_NONNEG note if the actual or estimated maximum number
590 of iterations is non-negative. */
592 add_reg_note (jump_insn
, REG_NONNEG
, NULL_RTX
);
594 /* Update the REG_BR_PROB note. */
597 /* Seems safer to use the branch probability. */
598 add_int_reg_note (jump_insn
, REG_BR_PROB
, desc
->in_edge
->probability
);
602 /* Process loop described by LOOP validating that the loop is suitable for
603 conversion to use a low overhead looping instruction, replacing the jump
604 insn where suitable. Returns true if the loop was successfully
608 doloop_optimize (struct loop
*loop
)
611 rtx doloop_seq
, doloop_pat
, doloop_reg
;
613 widest_int iterations
, iterations_max
;
616 unsigned level
, est_niter
;
618 struct niter_desc
*desc
;
619 unsigned word_mode_size
;
620 unsigned HOST_WIDE_INT word_mode_max
;
624 fprintf (dump_file
, "Doloop: Processing loop %d.\n", loop
->num
);
626 iv_analysis_loop_init (loop
);
628 /* Find the simple exit of a LOOP. */
629 desc
= get_simple_loop_desc (loop
);
631 /* Check that loop is a candidate for a low-overhead looping insn. */
632 if (!doloop_valid_p (loop
, desc
))
636 "Doloop: The loop is not suitable.\n");
642 if (desc
->const_iter
)
643 est_niter
= desc
->niter
;
644 /* If the estimate on number of iterations is reliable (comes from profile
645 feedback), use it. Do not use it normally, since the expected number
646 of iterations of an unrolled loop is 2. */
647 if (loop
->header
->count
)
648 est_niter
= expected_loop_iterations (loop
);
654 "Doloop: Too few iterations (%u) to be profitable.\n",
660 = COSTS_N_INSNS (PARAM_VALUE (PARAM_MAX_ITERATIONS_COMPUTATION_COST
));
661 if (set_src_cost (desc
->niter_expr
, optimize_loop_for_speed_p (loop
))
666 "Doloop: number of iterations too costly to compute.\n");
670 if (desc
->const_iter
)
671 iterations
= widest_int::from (std::make_pair (desc
->niter_expr
, mode
),
675 if (!get_max_loop_iterations (loop
, &iterations_max
))
677 level
= get_loop_level (loop
) + 1;
678 entered_at_top
= (loop
->latch
== desc
->in_edge
->dest
679 && contains_no_active_insn_p (loop
->latch
));
680 if (!targetm
.can_use_doloop_p (iterations
, iterations_max
, level
,
684 fprintf (dump_file
, "Loop rejected by can_use_doloop_p.\n");
688 /* Generate looping insn. If the pattern FAILs then give up trying
689 to modify the loop since there is some aspect the back-end does
691 count
= copy_rtx (desc
->niter_expr
);
692 start_label
= block_label (desc
->in_edge
->dest
);
693 doloop_reg
= gen_reg_rtx (mode
);
694 doloop_seq
= gen_doloop_end (doloop_reg
, start_label
);
696 word_mode_size
= GET_MODE_PRECISION (word_mode
);
698 = ((unsigned HOST_WIDE_INT
) 1 << (word_mode_size
- 1) << 1) - 1;
701 /* Before trying mode different from the one in that # of iterations is
702 computed, we must be sure that the number of iterations fits into
704 && (word_mode_size
>= GET_MODE_PRECISION (mode
)
705 || wi::leu_p (iterations_max
, word_mode_max
)))
707 if (word_mode_size
> GET_MODE_PRECISION (mode
))
708 count
= simplify_gen_unary (ZERO_EXTEND
, word_mode
, count
, mode
);
710 count
= lowpart_subreg (word_mode
, count
, mode
);
711 PUT_MODE (doloop_reg
, word_mode
);
712 doloop_seq
= gen_doloop_end (doloop_reg
, start_label
);
718 "Doloop: Target unwilling to use doloop pattern!\n");
722 /* If multiple instructions were created, the last must be the
723 jump instruction. Also, a raw define_insn may yield a plain
725 doloop_pat
= doloop_seq
;
726 if (INSN_P (doloop_pat
))
728 rtx_insn
*doloop_insn
= as_a
<rtx_insn
*> (doloop_pat
);
729 while (NEXT_INSN (doloop_insn
) != NULL_RTX
)
730 doloop_insn
= NEXT_INSN (doloop_insn
);
731 if (!JUMP_P (doloop_insn
))
733 doloop_pat
= doloop_insn
;
737 || ! (condition
= doloop_condition_get (doloop_pat
)))
740 fprintf (dump_file
, "Doloop: Unrecognizable doloop pattern!\n");
744 doloop_modify (loop
, desc
, doloop_seq
, condition
, count
);
748 /* This is the main entry point. Process all loops using doloop_optimize. */
751 doloop_optimize_loops (void)
755 FOR_EACH_LOOP (loop
, 0)
757 doloop_optimize (loop
);
762 #ifdef ENABLE_CHECKING
763 verify_loop_structure ();
766 #endif /* HAVE_doloop_end */