1 /* Perform doloop optimizations
2 Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 Contributed 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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
28 #include "hard-reg-set.h"
29 #include "basic-block.h"
34 /* This module is used to modify loops with a determinable number of
35 iterations to use special low-overhead looping instructions.
37 It first validates whether the loop is well behaved and has a
38 determinable number of iterations (either at compile or run-time).
39 It then modifies the loop to use a low-overhead looping pattern as
42 1. A pseudo register is allocated as the loop iteration counter.
44 2. The number of loop iterations is calculated and is stored
47 3. At the end of the loop, the jump insn is replaced by the
48 doloop_end pattern. The compare must remain because it might be
49 used elsewhere. If the loop-variable or condition register are
50 used elsewhere, they will be eliminated by flow.
52 4. An optional doloop_begin pattern is inserted at the top of the
57 #ifdef HAVE_doloop_end
59 static rtx doloop_condition_get
61 static unsigned HOST_WIDE_INT doloop_iterations_max
62 PARAMS ((const struct loop_info *, enum machine_mode, int));
63 static int doloop_valid_p
64 PARAMS ((const struct loop *, rtx));
65 static int doloop_modify
66 PARAMS ((const struct loop *, rtx, rtx, rtx, rtx, rtx));
67 static int doloop_modify_runtime
68 PARAMS ((const struct loop *, rtx, rtx, rtx, enum machine_mode, rtx));
71 /* Return the loop termination condition for PATTERN or zero
72 if it is not a decrement and branch jump insn. */
74 doloop_condition_get (pattern)
82 /* The canonical doloop pattern we expect is:
84 (parallel [(set (pc) (if_then_else (condition)
87 (set (reg) (plus (reg) (const_int -1)))
88 (additional clobbers and uses)])
90 Some machines (IA-64) make the decrement conditional on
91 the condition as well, so we don't bother verifying the
92 actual decrement. In summary, the branch must be the
93 first entry of the parallel (also required by jump.c),
94 and the second entry of the parallel must be a set of
95 the loop counter register. */
97 if (GET_CODE (pattern) != PARALLEL)
100 cmp = XVECEXP (pattern, 0, 0);
101 inc = XVECEXP (pattern, 0, 1);
103 /* Check for (set (reg) (something)). */
104 if (GET_CODE (inc) != SET || ! REG_P (SET_DEST (inc)))
107 /* Extract loop counter register. */
108 reg = SET_DEST (inc);
110 /* Check for (set (pc) (if_then_else (condition)
113 if (GET_CODE (cmp) != SET
114 || SET_DEST (cmp) != pc_rtx
115 || GET_CODE (SET_SRC (cmp)) != IF_THEN_ELSE
116 || GET_CODE (XEXP (SET_SRC (cmp), 1)) != LABEL_REF
117 || XEXP (SET_SRC (cmp), 2) != pc_rtx)
120 /* Extract loop termination condition. */
121 condition = XEXP (SET_SRC (cmp), 0);
123 if ((GET_CODE (condition) != GE && GET_CODE (condition) != NE)
124 || GET_CODE (XEXP (condition, 1)) != CONST_INT)
127 if (XEXP (condition, 0) == reg)
130 if (GET_CODE (XEXP (condition, 0)) == PLUS
131 && XEXP (XEXP (condition, 0), 0) == reg)
134 /* ??? If a machine uses a funny comparison, we could return a
135 canonicalised form here. */
141 /* Return an estimate of the maximum number of loop iterations for the
142 loop specified by LOOP or zero if the loop is not normal.
143 MODE is the mode of the iteration count and NONNEG is nonzero if
144 the iteration count has been proved to be non-negative. */
145 static unsigned HOST_WIDE_INT
146 doloop_iterations_max (loop_info, mode, nonneg)
147 const struct loop_info *loop_info;
148 enum machine_mode mode;
151 unsigned HOST_WIDE_INT n_iterations_max;
155 HOST_WIDE_INT abs_inc;
159 abs_inc = INTVAL (loop_info->increment);
168 code = swap_condition (loop_info->comparison_code);
169 min_value = loop_info->final_equiv_value;
170 max_value = loop_info->initial_equiv_value;
174 code = loop_info->comparison_code;
175 min_value = loop_info->initial_equiv_value;
176 max_value = loop_info->final_equiv_value;
179 /* Since the loop has a VTOP, we know that the initial test will be
180 true and thus the value of max_value should be greater than the
181 value of min_value. Thus the difference should always be positive
182 and the code must be LT, LE, LTU, LEU, or NE. Otherwise the loop is
183 not normal, e.g., `for (i = 0; i < 10; i--)'. */
189 unsigned HOST_WIDE_INT umax;
190 unsigned HOST_WIDE_INT umin;
192 if (GET_CODE (min_value) == CONST_INT)
193 umin = INTVAL (min_value);
197 if (GET_CODE (max_value) == CONST_INT)
198 umax = INTVAL (max_value);
200 umax = ((unsigned) 2 << (GET_MODE_BITSIZE (mode) - 1)) - 1;
202 n_iterations_max = umax - umin;
212 if (GET_CODE (min_value) == CONST_INT)
213 smin = INTVAL (min_value);
215 smin = -((unsigned) 1 << (GET_MODE_BITSIZE (mode) - 1));
217 if (GET_CODE (max_value) == CONST_INT)
218 smax = INTVAL (max_value);
220 smax = ((unsigned) 1 << (GET_MODE_BITSIZE (mode) - 1)) - 1;
222 n_iterations_max = smax - smin;
227 if (GET_CODE (min_value) == CONST_INT
228 && GET_CODE (max_value) == CONST_INT)
229 n_iterations_max = INTVAL (max_value) - INTVAL (min_value);
231 /* We need to conservatively assume that we might have the maximum
232 number of iterations without any additional knowledge. */
233 n_iterations_max = ((unsigned) 2 << (GET_MODE_BITSIZE (mode) - 1)) - 1;
240 n_iterations_max /= abs_inc;
242 /* If we know that the iteration count is non-negative then adjust
243 n_iterations_max if it is so large that it appears negative. */
245 && n_iterations_max > ((unsigned) 1 << (GET_MODE_BITSIZE (mode) - 1)))
246 n_iterations_max = ((unsigned) 1 << (GET_MODE_BITSIZE (mode) - 1)) - 1;
248 return n_iterations_max;
252 /* Return nonzero if the loop specified by LOOP is suitable for
253 the use of special low-overhead looping instructions. */
255 doloop_valid_p (loop, jump_insn)
256 const struct loop *loop;
259 const struct loop_info *loop_info = LOOP_INFO (loop);
261 /* The loop must have a conditional jump at the end. */
262 if (! any_condjump_p (jump_insn)
263 || ! onlyjump_p (jump_insn))
265 if (loop_dump_stream)
266 fprintf (loop_dump_stream,
267 "Doloop: Invalid jump at loop end.\n");
271 /* Give up if a loop has been completely unrolled. */
272 if (loop_info->n_iterations == loop_info->unroll_number)
274 if (loop_dump_stream)
275 fprintf (loop_dump_stream,
276 "Doloop: Loop completely unrolled.\n");
280 /* The loop must have a single exit target. A break or return
281 statement within a loop will generate multiple loop exits.
282 Another example of a loop that currently generates multiple exit
283 targets is for (i = 0; i < (foo ? 8 : 4); i++) { }. */
284 if (loop_info->has_multiple_exit_targets || loop->exit_count)
286 if (loop_dump_stream)
287 fprintf (loop_dump_stream,
288 "Doloop: Loop has multiple exit targets.\n");
292 /* An indirect jump may jump out of the loop. */
293 if (loop_info->has_indirect_jump)
295 if (loop_dump_stream)
296 fprintf (loop_dump_stream,
297 "Doloop: Indirect jump in function.\n");
301 /* A called function may clobber any special registers required for
302 low-overhead looping. */
303 if (loop_info->has_call)
305 if (loop_dump_stream)
306 fprintf (loop_dump_stream,
307 "Doloop: Function call in loop.\n");
311 /* Some targets (eg, PPC) use the count register for branch on table
312 instructions. ??? This should be a target specific check. */
313 if (loop_info->has_tablejump)
315 if (loop_dump_stream)
316 fprintf (loop_dump_stream,
317 "Doloop: Computed branch in the loop.\n");
321 if (! loop_info->increment)
323 if (loop_dump_stream)
324 fprintf (loop_dump_stream,
325 "Doloop: Could not determine iteration info.\n");
329 if (GET_CODE (loop_info->increment) != CONST_INT)
331 if (loop_dump_stream)
332 fprintf (loop_dump_stream,
333 "Doloop: Increment not an integer constant.\n");
337 /* There is no guarantee that a NE loop will terminate if the
338 absolute increment is not unity. ??? We could compute this
339 condition at run-time and have an additional jump around the loop
340 to ensure an infinite loop. */
341 if (loop_info->comparison_code == NE
342 && !loop_info->preconditioned
343 && INTVAL (loop_info->increment) != -1
344 && INTVAL (loop_info->increment) != 1)
346 if (loop_dump_stream)
347 fprintf (loop_dump_stream,
348 "Doloop: NE loop with non-unity increment.\n");
352 /* Check for loops that may not terminate under special conditions. */
353 if (! loop_info->n_iterations
354 && ((loop_info->comparison_code == LEU
355 && INTVAL (loop_info->increment) > 0)
356 || (loop_info->comparison_code == GEU
357 && INTVAL (loop_info->increment) < 0)
358 || (loop_info->comparison_code == LTU
359 && INTVAL (loop_info->increment) > 1)
360 || (loop_info->comparison_code == GTU
361 && INTVAL (loop_info->increment) < -1)))
363 /* If the comparison is LEU and the comparison value is UINT_MAX
364 then the loop will not terminate. Similarly, if the
365 comparison code is GEU and the comparison value is 0, the
366 loop will not terminate.
368 If the absolute increment is not 1, the loop can be infinite
369 even with LTU/GTU, e.g. for (i = 3; i > 0; i -= 2)
371 Note that with LE and GE, the loop behavior is undefined
372 (C++ standard section 5 clause 5) if an overflow occurs, say
373 between INT_MAX and INT_MAX + 1. We thus don't have to worry
374 about these two cases.
376 ??? We could compute these conditions at run-time and have a
377 additional jump around the loop to ensure an infinite loop.
378 However, it is very unlikely that this is the intended
379 behavior of the loop and checking for these rare boundary
380 conditions would pessimize all other code.
382 If the loop is executed only a few times an extra check to
383 restart the loop could use up most of the benefits of using a
384 count register loop. Note however, that normally, this
385 restart branch would never execute, so it could be predicted
386 well by the CPU. We should generate the pessimistic code by
387 default, and have an option, e.g. -funsafe-loops that would
388 enable count-register loops in this case. */
389 if (loop_dump_stream)
390 fprintf (loop_dump_stream,
391 "Doloop: Possible infinite iteration case ignored.\n");
398 /* Modify the loop to use the low-overhead looping insn where LOOP
399 describes the loop, ITERATIONS is an RTX containing the desired
400 number of loop iterations, ITERATIONS_MAX is a CONST_INT specifying
401 the maximum number of loop iterations, and DOLOOP_INSN is the
402 low-overhead looping insn to emit at the end of the loop. This
403 returns nonzero if it was successful. */
405 doloop_modify (loop, iterations, iterations_max,
406 doloop_seq, start_label, condition)
407 const struct loop *loop;
421 jump_insn = prev_nonnote_insn (loop->end);
423 if (loop_dump_stream)
425 fprintf (loop_dump_stream, "Doloop: Inserting doloop pattern (");
426 if (GET_CODE (iterations) == CONST_INT)
427 fprintf (loop_dump_stream, HOST_WIDE_INT_PRINT_DEC,
428 INTVAL (iterations));
430 fputs ("runtime", loop_dump_stream);
431 fputs (" iterations).", loop_dump_stream);
434 /* Emit the label that will delimit the top of the loop.
435 This has to be done before the delete_insn call below, to prevent
436 delete_insn from deleting too much. */
437 emit_label_after (start_label, loop->top ? loop->top : loop->start);
438 LABEL_NUSES (start_label)++;
440 /* Discard original jump to continue loop. The original compare
441 result may still be live, so it cannot be discarded explicitly. */
442 delete_related_insns (jump_insn);
444 counter_reg = XEXP (condition, 0);
445 if (GET_CODE (counter_reg) == PLUS)
446 counter_reg = XEXP (counter_reg, 0);
452 switch (GET_CODE (condition))
455 /* Currently only NE tests against zero and one are supported. */
456 if (XEXP (condition, 1) == const0_rtx)
458 else if (XEXP (condition, 1) != const1_rtx)
463 /* Currently only GE tests against zero are supported. */
464 if (XEXP (condition, 1) != const0_rtx)
467 /* The iteration count needs decrementing for a GE test. */
470 /* Determine if the iteration counter will be non-negative.
471 Note that the maximum value loaded is iterations_max - 1. */
472 if ((unsigned HOST_WIDE_INT) INTVAL (iterations_max)
473 <= ((unsigned) 1 << (GET_MODE_BITSIZE (GET_MODE (counter_reg)) - 1)))
477 /* Abort if an invalid doloop pattern has been generated. */
484 if (GET_CODE (count) == CONST_INT)
485 count = GEN_INT (INTVAL (count) - 1);
487 count = expand_simple_binop (GET_MODE (counter_reg), MINUS,
489 0, 0, OPTAB_LIB_WIDEN);
492 /* Insert initialization of the count register into the loop header. */
493 convert_move (counter_reg, count, 1);
494 sequence = get_insns ();
496 emit_insn_before (sequence, loop->start);
498 /* Some targets (eg, C4x) need to initialize special looping
500 #ifdef HAVE_doloop_begin
504 init = gen_doloop_begin (counter_reg,
505 GET_CODE (iterations) == CONST_INT
506 ? iterations : const0_rtx, iterations_max,
507 GEN_INT (loop->level));
512 sequence = get_insns ();
514 emit_insn_after (sequence, loop->start);
519 /* Insert the new low-overhead looping insn. */
520 emit_jump_insn_before (doloop_seq, loop->end);
521 jump_insn = prev_nonnote_insn (loop->end);
522 JUMP_LABEL (jump_insn) = start_label;
524 /* Add a REG_NONNEG note if the actual or estimated maximum number
525 of iterations is non-negative. */
528 REG_NOTES (jump_insn)
529 = gen_rtx_EXPR_LIST (REG_NONNEG, NULL_RTX, REG_NOTES (jump_insn));
535 /* Handle the more complex case, where the bounds are not known at
536 compile time. In this case we generate a run_time calculation of
537 the number of iterations. We rely on the existence of a run-time
538 guard to ensure that the loop executes at least once, i.e.,
539 initial_value obeys the loop comparison condition. If a guard is
540 not present, we emit one. The loop to modify is described by LOOP.
541 ITERATIONS_MAX is a CONST_INT specifying the estimated maximum
542 number of loop iterations. DOLOOP_INSN is the low-overhead looping
543 insn to insert. Returns nonzero if loop successfully modified. */
545 doloop_modify_runtime (loop, iterations_max,
546 doloop_seq, start_label, mode, condition)
547 const struct loop *loop;
551 enum machine_mode mode;
554 const struct loop_info *loop_info = LOOP_INFO (loop);
555 HOST_WIDE_INT abs_inc;
556 HOST_WIDE_INT abs_loop_inc;
565 enum rtx_code comparison_code;
567 increment = loop_info->increment;
568 initial_value = loop_info->initial_value;
569 final_value = loop_info->final_value;
572 abs_inc = INTVAL (increment);
579 comparison_code = loop_info->comparison_code;
580 unsigned_p = (comparison_code == LTU
581 || comparison_code == LEU
582 || comparison_code == GTU
583 || comparison_code == GEU
584 || comparison_code == NE);
586 /* The number of iterations (prior to any loop unrolling) is given by:
588 n = (abs (final - initial) + abs_inc - 1) / abs_inc.
590 However, it is possible for the summation to overflow, and a
593 n = abs (final - initial) / abs_inc;
594 n += (abs (final - initial) % abs_inc) != 0;
596 But when abs_inc is a power of two, the summation won't overflow
597 except in cases where the loop never terminates. So we don't
598 need to use this more costly calculation.
600 If the loop has been unrolled, the full calculation is
602 t1 = abs_inc * unroll_number; increment per loop
603 n = abs (final - initial) / t1; full loops
604 n += (abs (final - initial) % t1) != 0; partial loop
606 However, in certain cases the unrolled loop will be preconditioned
607 by emitting copies of the loop body with conditional branches,
608 so that the unrolled loop is always a full loop and thus needs
609 no exit tests. In this case we don't want to add the partial
610 loop count. As above, when t1 is a power of two we don't need to
611 worry about overflow.
613 The division and modulo operations can be avoided by requiring
614 that the increment is a power of 2 (precondition_loop_p enforces
615 this requirement). Nevertheless, the RTX_COSTS should be checked
616 to see if a fast divmod is available. */
619 /* abs (final - initial) */
620 diff = expand_simple_binop (mode, MINUS,
621 copy_rtx (neg_inc ? initial_value : final_value),
622 copy_rtx (neg_inc ? final_value : initial_value),
623 NULL_RTX, unsigned_p, OPTAB_LIB_WIDEN);
625 /* Some code transformations can result in code akin to
636 We'll have already detected this form of loop in scan_loop,
637 and set loop->top and loop->scan_start appropriately.
639 In this situation, we skip the increment the first time through
640 the loop, which results in an incorrect estimate of the number
641 of iterations. Adjust the difference to compensate. */
642 /* ??? Logically, it would seem this belongs in loop_iterations.
643 However, this causes regressions e.g. on x86 execute/20011008-3.c,
644 so I do not believe we've properly characterized the exact nature
645 of the problem. In the meantime, this fixes execute/20011126-2.c
646 on ia64 and some Ada front end miscompilation on ppc. */
648 if (loop->scan_start)
650 rtx iteration_var = loop_info->iteration_var;
651 struct loop_ivs *ivs = LOOP_IVS (loop);
654 if (REG_IV_TYPE (ivs, REGNO (iteration_var)) == BASIC_INDUCT)
655 bl = REG_IV_CLASS (ivs, REGNO (iteration_var));
656 else if (REG_IV_TYPE (ivs, REGNO (iteration_var)) == GENERAL_INDUCT)
658 struct induction *v = REG_IV_INFO (ivs, REGNO (iteration_var));
659 bl = REG_IV_CLASS (ivs, REGNO (v->src_reg));
662 /* Iteration var must be an induction variable to get here. */
665 if (INSN_UID (bl->biv->insn) < max_uid_for_loop
666 && INSN_LUID (bl->biv->insn) < INSN_LUID (loop->scan_start))
668 if (loop_dump_stream)
669 fprintf (loop_dump_stream,
670 "Doloop: Basic induction var skips initial incr.\n");
672 diff = expand_simple_binop (mode, PLUS, diff, GEN_INT (abs_inc),
673 diff, unsigned_p, OPTAB_LIB_WIDEN);
677 abs_loop_inc = abs_inc * loop_info->unroll_number;
678 if (abs_loop_inc != 1)
682 shift_count = exact_log2 (abs_loop_inc);
686 if (!loop_info->preconditioned)
687 diff = expand_simple_binop (GET_MODE (diff), PLUS,
688 diff, GEN_INT (abs_loop_inc - 1),
689 diff, 1, OPTAB_LIB_WIDEN);
691 /* (abs (final - initial) + abs_inc * unroll_number - 1)
692 / (abs_inc * unroll_number) */
693 diff = expand_simple_binop (GET_MODE (diff), LSHIFTRT,
694 diff, GEN_INT (shift_count),
695 diff, 1, OPTAB_LIB_WIDEN);
699 /* If there is a NOTE_INSN_LOOP_VTOP, we have a `for' or `while'
700 style loop, with a loop exit test at the start. Thus, we can
701 assume that the loop condition was true when the loop was
704 `do-while' loops require special treatment since the exit test is
705 not executed before the start of the loop. We need to determine
706 if the loop will terminate after the first pass and to limit the
707 iteration count to one if necessary. */
710 if (loop_dump_stream)
711 fprintf (loop_dump_stream, "Doloop: Do-while loop.\n");
713 /* A `do-while' loop must iterate at least once. For code like
714 i = initial; do { ... } while (++i < final);
715 we will calculate a bogus iteration count if initial > final.
716 So detect this and set the iteration count to 1.
717 Note that if the loop has been unrolled, then the loop body
718 is guaranteed to execute at least once. Also, when the
719 comparison is NE, our calculated count will be OK. */
720 if (loop_info->unroll_number == 1 && comparison_code != NE)
724 /* Emit insns to test if the loop will immediately
725 terminate and to set the iteration count to 1 if true. */
726 label = gen_label_rtx();
727 emit_cmp_and_jump_insns (copy_rtx (initial_value),
728 copy_rtx (loop_info->comparison_value),
729 comparison_code, NULL_RTX, mode, 0,
731 JUMP_LABEL (get_last_insn ()) = label;
732 LABEL_NUSES (label)++;
733 emit_move_insn (iterations, const1_rtx);
738 sequence = get_insns ();
740 emit_insn_before (sequence, loop->start);
742 return doloop_modify (loop, iterations, iterations_max, doloop_seq,
743 start_label, condition);
747 /* This is the main entry point. Process loop described by LOOP
748 validating that the loop is suitable for conversion to use a low
749 overhead looping instruction, replacing the jump insn where
750 suitable. We distinguish between loops with compile-time bounds
751 and those with run-time bounds. Information from LOOP is used to
752 compute the number of iterations and to determine whether the loop
753 is a candidate for this optimization. Returns nonzero if loop
754 successfully modified. */
756 doloop_optimize (loop)
757 const struct loop *loop;
759 struct loop_info *loop_info = LOOP_INFO (loop);
764 enum machine_mode mode;
765 unsigned HOST_WIDE_INT n_iterations;
766 unsigned HOST_WIDE_INT n_iterations_max;
767 rtx doloop_seq, doloop_pat, doloop_reg;
773 if (loop_dump_stream)
774 fprintf (loop_dump_stream,
775 "Doloop: Processing loop %d, enclosed levels %d.\n",
776 loop->num, loop->level);
778 jump_insn = prev_nonnote_insn (loop->end);
780 /* Check that loop is a candidate for a low-overhead looping insn. */
781 if (! doloop_valid_p (loop, jump_insn))
784 /* Determine if the loop can be safely, and profitably,
785 preconditioned. While we don't precondition the loop in a loop
786 unrolling sense, this test ensures that the loop is well behaved
787 and that the increment is a constant integer. */
788 if (! precondition_loop_p (loop, &initial_value, &final_value,
791 if (loop_dump_stream)
792 fprintf (loop_dump_stream,
793 "Doloop: Cannot precondition loop.\n");
797 /* Determine or estimate the maximum number of loop iterations. */
798 n_iterations = loop_info->n_iterations;
801 /* This is the simple case where the initial and final loop
802 values are constants. */
803 n_iterations_max = n_iterations;
807 int nonneg = find_reg_note (jump_insn, REG_NONNEG, 0) != 0;
809 /* This is the harder case where the initial and final loop
810 values may not be constants. */
811 n_iterations_max = doloop_iterations_max (loop_info, mode, nonneg);
813 if (! n_iterations_max)
815 /* We have something like `for (i = 0; i < 10; i--)'. */
816 if (loop_dump_stream)
817 fprintf (loop_dump_stream,
818 "Doloop: Not normal loop.\n");
823 /* Account for loop unrolling in the iteration count. This will
824 have no effect if loop_iterations could not determine the number
826 n_iterations /= loop_info->unroll_number;
827 n_iterations_max /= loop_info->unroll_number;
829 if (n_iterations && n_iterations < 3)
831 if (loop_dump_stream)
832 fprintf (loop_dump_stream,
833 "Doloop: Too few iterations (%ld) to be profitable.\n",
834 (long int) n_iterations);
838 iterations = GEN_INT (n_iterations);
839 iterations_max = GEN_INT (n_iterations_max);
841 /* Generate looping insn. If the pattern FAILs then give up trying
842 to modify the loop since there is some aspect the back-end does
844 start_label = gen_label_rtx ();
845 doloop_reg = gen_reg_rtx (mode);
846 doloop_seq = gen_doloop_end (doloop_reg, iterations, iterations_max,
847 GEN_INT (loop->level), start_label);
848 if (! doloop_seq && mode != word_mode)
850 PUT_MODE (doloop_reg, word_mode);
851 doloop_seq = gen_doloop_end (doloop_reg, iterations, iterations_max,
852 GEN_INT (loop->level), start_label);
856 if (loop_dump_stream)
857 fprintf (loop_dump_stream,
858 "Doloop: Target unwilling to use doloop pattern!\n");
862 /* If multiple instructions were created, the last must be the
863 jump instruction. Also, a raw define_insn may yield a plain
865 doloop_pat = doloop_seq;
866 if (INSN_P (doloop_pat))
868 while (NEXT_INSN (doloop_pat) != NULL_RTX)
869 doloop_pat = NEXT_INSN (doloop_pat);
870 if (GET_CODE (doloop_pat) == JUMP_INSN)
871 doloop_pat = PATTERN (doloop_pat);
873 doloop_pat = NULL_RTX;
877 || ! (condition = doloop_condition_get (doloop_pat)))
879 if (loop_dump_stream)
880 fprintf (loop_dump_stream,
881 "Doloop: Unrecognizable doloop pattern!\n");
885 if (n_iterations != 0)
886 /* Handle the simpler case, where we know the iteration count at
888 return doloop_modify (loop, iterations, iterations_max, doloop_seq,
889 start_label, condition);
891 /* Handle the harder case, where we must add additional runtime tests. */
892 return doloop_modify_runtime (loop, iterations_max, doloop_seq,
893 start_label, mode, condition);
896 #endif /* HAVE_doloop_end */