/cp
[official-gcc.git] / gcc / loop-doloop.c
blob6554597ba860130ed0d3f6bbc6ca622607c7a1b8
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
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
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/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "backend.h"
25 #include "cfghooks.h"
26 #include "rtl.h"
27 #include "flags.h"
28 #include "tree.h"
29 #include "alias.h"
30 #include "insn-config.h"
31 #include "expmed.h"
32 #include "dojump.h"
33 #include "explow.h"
34 #include "calls.h"
35 #include "emit-rtl.h"
36 #include "varasm.h"
37 #include "stmt.h"
38 #include "expr.h"
39 #include "diagnostic-core.h"
40 #include "tm_p.h"
41 #include "cfgloop.h"
42 #include "cfgrtl.h"
43 #include "params.h"
44 #include "target.h"
45 #include "dumpfile.h"
46 #include "loop-unroll.h"
48 /* This module is used to modify loops with a determinable number of
49 iterations to use special low-overhead looping instructions.
51 It first validates whether the loop is well behaved and has a
52 determinable number of iterations (either at compile or run-time).
53 It then modifies the loop to use a low-overhead looping pattern as
54 follows:
56 1. A pseudo register is allocated as the loop iteration counter.
58 2. The number of loop iterations is calculated and is stored
59 in the loop counter.
61 3. At the end of the loop, the jump insn is replaced by the
62 doloop_end pattern. The compare must remain because it might be
63 used elsewhere. If the loop-variable or condition register are
64 used elsewhere, they will be eliminated by flow.
66 4. An optional doloop_begin pattern is inserted at the top of the
67 loop.
69 TODO The optimization should only performed when either the biv used for exit
70 condition is unused at all except for the exit test, or if we do not have to
71 change its value, since otherwise we have to add a new induction variable,
72 which usually will not pay up (unless the cost of the doloop pattern is
73 somehow extremely lower than the cost of compare & jump, or unless the bct
74 register cannot be used for anything else but doloop -- ??? detect these
75 cases). */
77 /* Return the loop termination condition for PATTERN or zero
78 if it is not a decrement and branch jump insn. */
80 rtx
81 doloop_condition_get (rtx doloop_pat)
83 rtx cmp;
84 rtx inc;
85 rtx reg;
86 rtx inc_src;
87 rtx condition;
88 rtx pattern;
89 rtx cc_reg = NULL_RTX;
90 rtx reg_orig = NULL_RTX;
92 /* The canonical doloop pattern we expect has one of the following
93 forms:
95 1) (parallel [(set (pc) (if_then_else (condition)
96 (label_ref (label))
97 (pc)))
98 (set (reg) (plus (reg) (const_int -1)))
99 (additional clobbers and uses)])
101 The branch must be the first entry of the parallel (also required
102 by jump.c), and the second entry of the parallel must be a set of
103 the loop counter register. Some targets (IA-64) wrap the set of
104 the loop counter in an if_then_else too.
106 2) (set (reg) (plus (reg) (const_int -1))
107 (set (pc) (if_then_else (reg != 0)
108 (label_ref (label))
109 (pc))).
111 Some targets (ARM) do the comparison before the branch, as in the
112 following form:
114 3) (parallel [(set (cc) (compare ((plus (reg) (const_int -1), 0)))
115 (set (reg) (plus (reg) (const_int -1)))])
116 (set (pc) (if_then_else (cc == NE)
117 (label_ref (label))
118 (pc))) */
120 pattern = PATTERN (doloop_pat);
122 if (GET_CODE (pattern) != PARALLEL)
124 rtx cond;
125 rtx_insn *prev_insn = prev_nondebug_insn (doloop_pat);
126 rtx cmp_arg1, cmp_arg2;
127 rtx cmp_orig;
129 /* In case the pattern is not PARALLEL we expect two forms
130 of doloop which are cases 2) and 3) above: in case 2) the
131 decrement immediately precedes the branch, while in case 3)
132 the compare and decrement instructions immediately precede
133 the branch. */
135 if (prev_insn == NULL_RTX || !INSN_P (prev_insn))
136 return 0;
138 cmp = pattern;
139 if (GET_CODE (PATTERN (prev_insn)) == PARALLEL)
141 /* The third case: the compare and decrement instructions
142 immediately precede the branch. */
143 cmp_orig = XVECEXP (PATTERN (prev_insn), 0, 0);
144 if (GET_CODE (cmp_orig) != SET)
145 return 0;
146 if (GET_CODE (SET_SRC (cmp_orig)) != COMPARE)
147 return 0;
148 cmp_arg1 = XEXP (SET_SRC (cmp_orig), 0);
149 cmp_arg2 = XEXP (SET_SRC (cmp_orig), 1);
150 if (cmp_arg2 != const0_rtx
151 || GET_CODE (cmp_arg1) != PLUS)
152 return 0;
153 reg_orig = XEXP (cmp_arg1, 0);
154 if (XEXP (cmp_arg1, 1) != GEN_INT (-1)
155 || !REG_P (reg_orig))
156 return 0;
157 cc_reg = SET_DEST (cmp_orig);
159 inc = XVECEXP (PATTERN (prev_insn), 0, 1);
161 else
162 inc = PATTERN (prev_insn);
163 /* We expect the condition to be of the form (reg != 0) */
164 cond = XEXP (SET_SRC (cmp), 0);
165 if (GET_CODE (cond) != NE || XEXP (cond, 1) != const0_rtx)
166 return 0;
168 else
170 cmp = XVECEXP (pattern, 0, 0);
171 inc = XVECEXP (pattern, 0, 1);
174 /* Check for (set (reg) (something)). */
175 if (GET_CODE (inc) != SET)
176 return 0;
177 reg = SET_DEST (inc);
178 if (! REG_P (reg))
179 return 0;
181 /* Check if something = (plus (reg) (const_int -1)).
182 On IA-64, this decrement is wrapped in an if_then_else. */
183 inc_src = SET_SRC (inc);
184 if (GET_CODE (inc_src) == IF_THEN_ELSE)
185 inc_src = XEXP (inc_src, 1);
186 if (GET_CODE (inc_src) != PLUS
187 || XEXP (inc_src, 0) != reg
188 || XEXP (inc_src, 1) != constm1_rtx)
189 return 0;
191 /* Check for (set (pc) (if_then_else (condition)
192 (label_ref (label))
193 (pc))). */
194 if (GET_CODE (cmp) != SET
195 || SET_DEST (cmp) != pc_rtx
196 || GET_CODE (SET_SRC (cmp)) != IF_THEN_ELSE
197 || GET_CODE (XEXP (SET_SRC (cmp), 1)) != LABEL_REF
198 || XEXP (SET_SRC (cmp), 2) != pc_rtx)
199 return 0;
201 /* Extract loop termination condition. */
202 condition = XEXP (SET_SRC (cmp), 0);
204 /* We expect a GE or NE comparison with 0 or 1. */
205 if ((GET_CODE (condition) != GE
206 && GET_CODE (condition) != NE)
207 || (XEXP (condition, 1) != const0_rtx
208 && XEXP (condition, 1) != const1_rtx))
209 return 0;
211 if ((XEXP (condition, 0) == reg)
212 /* For the third case: */
213 || ((cc_reg != NULL_RTX)
214 && (XEXP (condition, 0) == cc_reg)
215 && (reg_orig == reg))
216 || (GET_CODE (XEXP (condition, 0)) == PLUS
217 && XEXP (XEXP (condition, 0), 0) == reg))
219 if (GET_CODE (pattern) != PARALLEL)
220 /* For the second form we expect:
222 (set (reg) (plus (reg) (const_int -1))
223 (set (pc) (if_then_else (reg != 0)
224 (label_ref (label))
225 (pc))).
227 is equivalent to the following:
229 (parallel [(set (pc) (if_then_else (reg != 1)
230 (label_ref (label))
231 (pc)))
232 (set (reg) (plus (reg) (const_int -1)))
233 (additional clobbers and uses)])
235 For the third form we expect:
237 (parallel [(set (cc) (compare ((plus (reg) (const_int -1)), 0))
238 (set (reg) (plus (reg) (const_int -1)))])
239 (set (pc) (if_then_else (cc == NE)
240 (label_ref (label))
241 (pc)))
243 which is equivalent to the following:
245 (parallel [(set (cc) (compare (reg, 1))
246 (set (reg) (plus (reg) (const_int -1)))
247 (set (pc) (if_then_else (NE == cc)
248 (label_ref (label))
249 (pc))))])
251 So we return the second form instead for the two cases.
254 condition = gen_rtx_fmt_ee (NE, VOIDmode, inc_src, const1_rtx);
256 return condition;
259 /* ??? If a machine uses a funny comparison, we could return a
260 canonicalized form here. */
262 return 0;
265 /* Return nonzero if the loop specified by LOOP is suitable for
266 the use of special low-overhead looping instructions. DESC
267 describes the number of iterations of the loop. */
269 static bool
270 doloop_valid_p (struct loop *loop, struct niter_desc *desc)
272 basic_block *body = get_loop_body (loop), bb;
273 rtx_insn *insn;
274 unsigned i;
275 bool result = true;
277 /* Check for loops that may not terminate under special conditions. */
278 if (!desc->simple_p
279 || desc->assumptions
280 || desc->infinite)
282 /* There are some cases that would require a special attention.
283 For example if the comparison is LEU and the comparison value
284 is UINT_MAX then the loop will not terminate. Similarly, if the
285 comparison code is GEU and the comparison value is 0, the
286 loop will not terminate.
288 If the absolute increment is not 1, the loop can be infinite
289 even with LTU/GTU, e.g. for (i = 3; i > 0; i -= 2)
291 ??? We could compute these conditions at run-time and have a
292 additional jump around the loop to ensure an infinite loop.
293 However, it is very unlikely that this is the intended
294 behavior of the loop and checking for these rare boundary
295 conditions would pessimize all other code.
297 If the loop is executed only a few times an extra check to
298 restart the loop could use up most of the benefits of using a
299 count register loop. Note however, that normally, this
300 restart branch would never execute, so it could be predicted
301 well by the CPU. We should generate the pessimistic code by
302 default, and have an option, e.g. -funsafe-loops that would
303 enable count-register loops in this case. */
304 if (dump_file)
305 fprintf (dump_file, "Doloop: Possible infinite iteration case.\n");
306 result = false;
307 goto cleanup;
310 for (i = 0; i < loop->num_nodes; i++)
312 bb = body[i];
314 for (insn = BB_HEAD (bb);
315 insn != NEXT_INSN (BB_END (bb));
316 insn = NEXT_INSN (insn))
318 /* Different targets have different necessities for low-overhead
319 looping. Call the back end for each instruction within the loop
320 to let it decide whether the insn prohibits a low-overhead loop.
321 It will then return the cause for it to emit to the dump file. */
322 const char * invalid = targetm.invalid_within_doloop (insn);
323 if (invalid)
325 if (dump_file)
326 fprintf (dump_file, "Doloop: %s\n", invalid);
327 result = false;
328 goto cleanup;
332 result = true;
334 cleanup:
335 free (body);
337 return result;
340 /* Adds test of COND jumping to DEST on edge *E and set *E to the new fallthru
341 edge. If the condition is always false, do not do anything. If it is always
342 true, redirect E to DEST and return false. In all other cases, true is
343 returned. */
345 static bool
346 add_test (rtx cond, edge *e, basic_block dest)
348 rtx_insn *seq, *jump;
349 rtx_code_label *label;
350 machine_mode mode;
351 rtx op0 = XEXP (cond, 0), op1 = XEXP (cond, 1);
352 enum rtx_code code = GET_CODE (cond);
353 basic_block bb;
355 mode = GET_MODE (XEXP (cond, 0));
356 if (mode == VOIDmode)
357 mode = GET_MODE (XEXP (cond, 1));
359 start_sequence ();
360 op0 = force_operand (op0, NULL_RTX);
361 op1 = force_operand (op1, NULL_RTX);
362 label = block_label (dest);
363 do_compare_rtx_and_jump (op0, op1, code, 0, mode, NULL_RTX, NULL, label, -1);
365 jump = get_last_insn ();
366 if (!jump || !JUMP_P (jump))
368 /* The condition is always false and the jump was optimized out. */
369 end_sequence ();
370 return true;
373 seq = get_insns ();
374 end_sequence ();
376 /* There always is at least the jump insn in the sequence. */
377 gcc_assert (seq != NULL_RTX);
379 bb = split_edge_and_insert (*e, seq);
380 *e = single_succ_edge (bb);
382 if (any_uncondjump_p (jump))
384 /* The condition is always true. */
385 delete_insn (jump);
386 redirect_edge_and_branch_force (*e, dest);
387 return false;
390 JUMP_LABEL (jump) = label;
392 /* The jump is supposed to handle an unlikely special case. */
393 add_int_reg_note (jump, REG_BR_PROB, 0);
395 LABEL_NUSES (label)++;
397 make_edge (bb, dest, (*e)->flags & ~EDGE_FALLTHRU);
398 return true;
401 /* Modify the loop to use the low-overhead looping insn where LOOP
402 describes the loop, DESC describes the number of iterations of the
403 loop, and DOLOOP_INSN is the low-overhead looping insn to emit at the
404 end of the loop. CONDITION is the condition separated from the
405 DOLOOP_SEQ. COUNT is the number of iterations of the LOOP. */
407 static void
408 doloop_modify (struct loop *loop, struct niter_desc *desc,
409 rtx_insn *doloop_seq, rtx condition, rtx count)
411 rtx counter_reg;
412 rtx tmp, noloop = NULL_RTX;
413 rtx_insn *sequence;
414 rtx_insn *jump_insn;
415 rtx_code_label *jump_label;
416 int nonneg = 0;
417 bool increment_count;
418 basic_block loop_end = desc->out_edge->src;
419 machine_mode mode;
420 rtx true_prob_val;
421 widest_int iterations;
423 jump_insn = BB_END (loop_end);
425 if (dump_file)
427 fprintf (dump_file, "Doloop: Inserting doloop pattern (");
428 if (desc->const_iter)
429 fprintf (dump_file, "%" PRId64, desc->niter);
430 else
431 fputs ("runtime", dump_file);
432 fputs (" iterations).\n", dump_file);
435 /* Get the probability of the original branch. If it exists we would
436 need to update REG_BR_PROB of the new jump_insn. */
437 true_prob_val = find_reg_note (jump_insn, REG_BR_PROB, NULL_RTX);
439 /* Discard original jump to continue loop. The original compare
440 result may still be live, so it cannot be discarded explicitly. */
441 delete_insn (jump_insn);
443 counter_reg = XEXP (condition, 0);
444 if (GET_CODE (counter_reg) == PLUS)
445 counter_reg = XEXP (counter_reg, 0);
446 mode = GET_MODE (counter_reg);
448 increment_count = false;
449 switch (GET_CODE (condition))
451 case NE:
452 /* Currently only NE tests against zero and one are supported. */
453 noloop = XEXP (condition, 1);
454 if (noloop != const0_rtx)
456 gcc_assert (noloop == const1_rtx);
457 increment_count = true;
459 break;
461 case GE:
462 /* Currently only GE tests against zero are supported. */
463 gcc_assert (XEXP (condition, 1) == const0_rtx);
465 noloop = constm1_rtx;
467 /* The iteration count does not need incrementing for a GE test. */
468 increment_count = false;
470 /* Determine if the iteration counter will be non-negative.
471 Note that the maximum value loaded is iterations_max - 1. */
472 if (get_max_loop_iterations (loop, &iterations)
473 && wi::leu_p (iterations,
474 wi::set_bit_in_zero <widest_int>
475 (GET_MODE_PRECISION (mode) - 1)))
476 nonneg = 1;
477 break;
479 /* Abort if an invalid doloop pattern has been generated. */
480 default:
481 gcc_unreachable ();
484 if (increment_count)
485 count = simplify_gen_binary (PLUS, mode, count, const1_rtx);
487 /* Insert initialization of the count register into the loop header. */
488 start_sequence ();
489 tmp = force_operand (count, counter_reg);
490 convert_move (counter_reg, tmp, 1);
491 sequence = get_insns ();
492 end_sequence ();
493 emit_insn_after (sequence, BB_END (loop_preheader_edge (loop)->src));
495 if (desc->noloop_assumptions)
497 rtx ass = copy_rtx (desc->noloop_assumptions);
498 basic_block preheader = loop_preheader_edge (loop)->src;
499 basic_block set_zero
500 = split_edge (loop_preheader_edge (loop));
501 basic_block new_preheader
502 = split_edge (loop_preheader_edge (loop));
503 edge te;
505 /* Expand the condition testing the assumptions and if it does not pass,
506 reset the count register to 0. */
507 redirect_edge_and_branch_force (single_succ_edge (preheader), new_preheader);
508 set_immediate_dominator (CDI_DOMINATORS, new_preheader, preheader);
510 set_zero->count = 0;
511 set_zero->frequency = 0;
513 te = single_succ_edge (preheader);
514 for (; ass; ass = XEXP (ass, 1))
515 if (!add_test (XEXP (ass, 0), &te, set_zero))
516 break;
518 if (ass)
520 /* We reached a condition that is always true. This is very hard to
521 reproduce (such a loop does not roll, and thus it would most
522 likely get optimized out by some of the preceding optimizations).
523 In fact, I do not have any testcase for it. However, it would
524 also be very hard to show that it is impossible, so we must
525 handle this case. */
526 set_zero->count = preheader->count;
527 set_zero->frequency = preheader->frequency;
530 if (EDGE_COUNT (set_zero->preds) == 0)
532 /* All the conditions were simplified to false, remove the
533 unreachable set_zero block. */
534 delete_basic_block (set_zero);
536 else
538 /* Reset the counter to zero in the set_zero block. */
539 start_sequence ();
540 convert_move (counter_reg, noloop, 0);
541 sequence = get_insns ();
542 end_sequence ();
543 emit_insn_after (sequence, BB_END (set_zero));
545 set_immediate_dominator (CDI_DOMINATORS, set_zero,
546 recompute_dominator (CDI_DOMINATORS,
547 set_zero));
550 set_immediate_dominator (CDI_DOMINATORS, new_preheader,
551 recompute_dominator (CDI_DOMINATORS,
552 new_preheader));
555 /* Some targets (eg, C4x) need to initialize special looping
556 registers. */
557 if (targetm.have_doloop_begin ())
558 if (rtx_insn *seq = targetm.gen_doloop_begin (counter_reg, doloop_seq))
559 emit_insn_after (seq, BB_END (loop_preheader_edge (loop)->src));
561 /* Insert the new low-overhead looping insn. */
562 emit_jump_insn_after (doloop_seq, BB_END (loop_end));
563 jump_insn = BB_END (loop_end);
564 jump_label = block_label (desc->in_edge->dest);
565 JUMP_LABEL (jump_insn) = jump_label;
566 LABEL_NUSES (jump_label)++;
568 /* Ensure the right fallthru edge is marked, for case we have reversed
569 the condition. */
570 desc->in_edge->flags &= ~EDGE_FALLTHRU;
571 desc->out_edge->flags |= EDGE_FALLTHRU;
573 /* Add a REG_NONNEG note if the actual or estimated maximum number
574 of iterations is non-negative. */
575 if (nonneg)
576 add_reg_note (jump_insn, REG_NONNEG, NULL_RTX);
578 /* Update the REG_BR_PROB note. */
579 if (true_prob_val)
581 /* Seems safer to use the branch probability. */
582 add_int_reg_note (jump_insn, REG_BR_PROB, desc->in_edge->probability);
586 /* Process loop described by LOOP validating that the loop is suitable for
587 conversion to use a low overhead looping instruction, replacing the jump
588 insn where suitable. Returns true if the loop was successfully
589 modified. */
591 static bool
592 doloop_optimize (struct loop *loop)
594 machine_mode mode;
595 rtx doloop_reg;
596 rtx count;
597 widest_int iterations, iterations_max;
598 rtx_code_label *start_label;
599 rtx condition;
600 unsigned level, est_niter;
601 int max_cost;
602 struct niter_desc *desc;
603 unsigned word_mode_size;
604 unsigned HOST_WIDE_INT word_mode_max;
605 int entered_at_top;
607 if (dump_file)
608 fprintf (dump_file, "Doloop: Processing loop %d.\n", loop->num);
610 iv_analysis_loop_init (loop);
612 /* Find the simple exit of a LOOP. */
613 desc = get_simple_loop_desc (loop);
615 /* Check that loop is a candidate for a low-overhead looping insn. */
616 if (!doloop_valid_p (loop, desc))
618 if (dump_file)
619 fprintf (dump_file,
620 "Doloop: The loop is not suitable.\n");
621 return false;
623 mode = desc->mode;
625 est_niter = 3;
626 if (desc->const_iter)
627 est_niter = desc->niter;
628 /* If the estimate on number of iterations is reliable (comes from profile
629 feedback), use it. Do not use it normally, since the expected number
630 of iterations of an unrolled loop is 2. */
631 if (loop->header->count)
632 est_niter = expected_loop_iterations (loop);
634 if (est_niter < 3)
636 if (dump_file)
637 fprintf (dump_file,
638 "Doloop: Too few iterations (%u) to be profitable.\n",
639 est_niter);
640 return false;
643 max_cost
644 = COSTS_N_INSNS (PARAM_VALUE (PARAM_MAX_ITERATIONS_COMPUTATION_COST));
645 if (set_src_cost (desc->niter_expr, mode, optimize_loop_for_speed_p (loop))
646 > max_cost)
648 if (dump_file)
649 fprintf (dump_file,
650 "Doloop: number of iterations too costly to compute.\n");
651 return false;
654 if (desc->const_iter)
655 iterations = widest_int::from (std::make_pair (desc->niter_expr, mode),
656 UNSIGNED);
657 else
658 iterations = 0;
659 if (!get_max_loop_iterations (loop, &iterations_max))
660 iterations_max = 0;
661 level = get_loop_level (loop) + 1;
662 entered_at_top = (loop->latch == desc->in_edge->dest
663 && contains_no_active_insn_p (loop->latch));
664 if (!targetm.can_use_doloop_p (iterations, iterations_max, level,
665 entered_at_top))
667 if (dump_file)
668 fprintf (dump_file, "Loop rejected by can_use_doloop_p.\n");
669 return false;
672 /* Generate looping insn. If the pattern FAILs then give up trying
673 to modify the loop since there is some aspect the back-end does
674 not like. */
675 count = copy_rtx (desc->niter_expr);
676 start_label = block_label (desc->in_edge->dest);
677 doloop_reg = gen_reg_rtx (mode);
678 rtx_insn *doloop_seq = targetm.gen_doloop_end (doloop_reg, start_label);
680 word_mode_size = GET_MODE_PRECISION (word_mode);
681 word_mode_max
682 = ((unsigned HOST_WIDE_INT) 1 << (word_mode_size - 1) << 1) - 1;
683 if (! doloop_seq
684 && mode != word_mode
685 /* Before trying mode different from the one in that # of iterations is
686 computed, we must be sure that the number of iterations fits into
687 the new mode. */
688 && (word_mode_size >= GET_MODE_PRECISION (mode)
689 || wi::leu_p (iterations_max, word_mode_max)))
691 if (word_mode_size > GET_MODE_PRECISION (mode))
692 count = simplify_gen_unary (ZERO_EXTEND, word_mode, count, mode);
693 else
694 count = lowpart_subreg (word_mode, count, mode);
695 PUT_MODE (doloop_reg, word_mode);
696 doloop_seq = targetm.gen_doloop_end (doloop_reg, start_label);
698 if (! doloop_seq)
700 if (dump_file)
701 fprintf (dump_file,
702 "Doloop: Target unwilling to use doloop pattern!\n");
703 return false;
706 /* If multiple instructions were created, the last must be the
707 jump instruction. */
708 rtx_insn *doloop_insn = doloop_seq;
709 while (NEXT_INSN (doloop_insn) != NULL_RTX)
710 doloop_insn = NEXT_INSN (doloop_insn);
711 if (!JUMP_P (doloop_insn)
712 || !(condition = doloop_condition_get (doloop_insn)))
714 if (dump_file)
715 fprintf (dump_file, "Doloop: Unrecognizable doloop pattern!\n");
716 return false;
719 doloop_modify (loop, desc, doloop_seq, condition, count);
720 return true;
723 /* This is the main entry point. Process all loops using doloop_optimize. */
725 void
726 doloop_optimize_loops (void)
728 struct loop *loop;
730 FOR_EACH_LOOP (loop, 0)
732 doloop_optimize (loop);
735 iv_analysis_done ();
737 #ifdef ENABLE_CHECKING
738 verify_loop_structure ();
739 #endif