Branch data Line data Source code
1 : : /* High-level loop manipulation functions.
2 : : Copyright (C) 2004-2024 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 it
7 : : under the terms of the GNU General Public License as published by the
8 : : Free Software Foundation; either version 3, or (at your option) any
9 : : later version.
10 : :
11 : : GCC is distributed in the hope that it will be useful, but WITHOUT
12 : : ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : : 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 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "backend.h"
24 : : #include "tree.h"
25 : : #include "gimple.h"
26 : : #include "cfghooks.h"
27 : : #include "tree-pass.h" /* ??? for TODO_update_ssa but this isn't a pass. */
28 : : #include "ssa.h"
29 : : #include "gimple-pretty-print.h"
30 : : #include "fold-const.h"
31 : : #include "cfganal.h"
32 : : #include "gimplify.h"
33 : : #include "gimple-iterator.h"
34 : : #include "gimplify-me.h"
35 : : #include "tree-cfg.h"
36 : : #include "tree-ssa-loop-ivopts.h"
37 : : #include "tree-ssa-loop-manip.h"
38 : : #include "tree-ssa-loop-niter.h"
39 : : #include "tree-ssa-loop.h"
40 : : #include "tree-into-ssa.h"
41 : : #include "tree-ssa.h"
42 : : #include "cfgloop.h"
43 : : #include "tree-scalar-evolution.h"
44 : : #include "tree-inline.h"
45 : :
46 : : /* All bitmaps for rewriting into loop-closed SSA go on this obstack,
47 : : so that we can free them all at once. */
48 : : static bitmap_obstack loop_renamer_obstack;
49 : :
50 : : /* Creates an induction variable with value BASE (+/-) STEP * iteration in LOOP.
51 : : If INCR_OP is PLUS_EXPR, the induction variable is BASE + STEP * iteration.
52 : : If INCR_OP is MINUS_EXPR, the induction variable is BASE - STEP * iteration.
53 : : It is expected that neither BASE nor STEP are shared with other expressions
54 : : (unless the sharing rules allow this). Use VAR as a base var_decl for it
55 : : (if NULL, a new temporary will be created). The increment will occur at
56 : : INCR_POS (after it if AFTER is true, before it otherwise). INCR_POS and
57 : : AFTER can be computed using standard_iv_increment_position. The ssa versions
58 : : of the variable before and after increment will be stored in VAR_BEFORE and
59 : : VAR_AFTER (unless they are NULL). */
60 : :
61 : : void
62 : 910043 : create_iv (tree base, tree_code incr_op, tree step, tree var, class loop *loop,
63 : : gimple_stmt_iterator *incr_pos, bool after, tree *var_before,
64 : : tree *var_after)
65 : : {
66 : 910043 : gassign *stmt;
67 : 910043 : gphi *phi;
68 : 910043 : tree initial, step1;
69 : 910043 : gimple_seq stmts;
70 : 910043 : tree vb, va;
71 : 910043 : gcc_assert (incr_op == PLUS_EXPR || incr_op == MINUS_EXPR);
72 : 910043 : edge pe = loop_preheader_edge (loop);
73 : :
74 : 910043 : if (var != NULL_TREE)
75 : : {
76 : 560341 : vb = make_ssa_name (var);
77 : 560341 : va = make_ssa_name (var);
78 : : }
79 : : else
80 : : {
81 : 349702 : vb = make_temp_ssa_name (TREE_TYPE (base), NULL, "ivtmp");
82 : 349702 : va = make_temp_ssa_name (TREE_TYPE (base), NULL, "ivtmp");
83 : : }
84 : 910043 : if (var_before)
85 : 622665 : *var_before = vb;
86 : 910043 : if (var_after)
87 : 903597 : *var_after = va;
88 : :
89 : : /* For easier readability of the created code, produce MINUS_EXPRs
90 : : when suitable. */
91 : 910043 : if (TREE_CODE (step) == INTEGER_CST)
92 : : {
93 : 856011 : if (TYPE_UNSIGNED (TREE_TYPE (step)))
94 : : {
95 : 854496 : step1 = fold_build1 (NEGATE_EXPR, TREE_TYPE (step), step);
96 : 854496 : if (tree_int_cst_lt (step1, step))
97 : : {
98 : 301601 : incr_op = (incr_op == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
99 : : step = step1;
100 : : }
101 : : }
102 : : else
103 : : {
104 : 1515 : bool ovf;
105 : :
106 : 1515 : if (!tree_expr_nonnegative_warnv_p (step, &ovf)
107 : 1515 : && may_negate_without_overflow_p (step))
108 : : {
109 : 13 : incr_op = (incr_op == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
110 : 13 : step = fold_build1 (NEGATE_EXPR, TREE_TYPE (step), step);
111 : : }
112 : : }
113 : : }
114 : 910043 : if (POINTER_TYPE_P (TREE_TYPE (base)))
115 : : {
116 : 121975 : if (TREE_CODE (base) == ADDR_EXPR)
117 : 44894 : mark_addressable (TREE_OPERAND (base, 0));
118 : 121975 : step = convert_to_ptrofftype (step);
119 : 121975 : if (incr_op == MINUS_EXPR)
120 : 2907 : step = fold_build1 (NEGATE_EXPR, TREE_TYPE (step), step);
121 : : incr_op = POINTER_PLUS_EXPR;
122 : : }
123 : : /* Gimplify the step if necessary. We put the computations in front of the
124 : : loop (i.e. the step should be loop invariant). */
125 : 910043 : step = force_gimple_operand (step, &stmts, true, NULL_TREE);
126 : 910043 : if (stmts)
127 : 46031 : gsi_insert_seq_on_edge_immediate (pe, stmts);
128 : :
129 : 910043 : stmt = gimple_build_assign (va, incr_op, vb, step);
130 : : /* Prevent the increment from inheriting a bogus location if it is not put
131 : : immediately after a statement whose location is known. */
132 : 910043 : if (after)
133 : : {
134 : 10519 : gimple_stmt_iterator gsi = *incr_pos;
135 : 10519 : if (!gsi_end_p (gsi))
136 : 9060 : gsi_next_nondebug (&gsi);
137 : 10519 : if (gsi_end_p (gsi))
138 : : {
139 : 10519 : edge e = single_succ_edge (gsi_bb (*incr_pos));
140 : 10519 : gimple_set_location (stmt, e->goto_locus);
141 : : }
142 : 10519 : gsi_insert_after (incr_pos, stmt, GSI_NEW_STMT);
143 : : }
144 : : else
145 : : {
146 : 899524 : gimple_stmt_iterator gsi = *incr_pos;
147 : 899524 : if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
148 : 0 : gsi_next_nondebug (&gsi);
149 : 899524 : if (!gsi_end_p (gsi))
150 : 899051 : gimple_set_location (stmt, gimple_location (gsi_stmt (gsi)));
151 : 899524 : gsi_insert_before (incr_pos, stmt, GSI_NEW_STMT);
152 : : }
153 : :
154 : 910043 : initial = force_gimple_operand (base, &stmts, true, var);
155 : 910043 : if (stmts)
156 : 236072 : gsi_insert_seq_on_edge_immediate (pe, stmts);
157 : :
158 : 910043 : phi = create_phi_node (vb, loop->header);
159 : 910043 : add_phi_arg (phi, initial, loop_preheader_edge (loop), UNKNOWN_LOCATION);
160 : 910043 : add_phi_arg (phi, va, loop_latch_edge (loop), UNKNOWN_LOCATION);
161 : 910043 : }
162 : :
163 : : /* Return the innermost superloop LOOP of USE_LOOP that is a superloop of
164 : : both DEF_LOOP and USE_LOOP. */
165 : :
166 : : static inline class loop *
167 : 132054 : find_sibling_superloop (class loop *use_loop, class loop *def_loop)
168 : : {
169 : 132054 : unsigned ud = loop_depth (use_loop);
170 : 132054 : unsigned dd = loop_depth (def_loop);
171 : 132054 : gcc_assert (ud > 0 && dd > 0);
172 : 132054 : if (ud > dd)
173 : 14520 : use_loop = superloop_at_depth (use_loop, dd);
174 : 132054 : if (ud < dd)
175 : 26543 : def_loop = superloop_at_depth (def_loop, ud);
176 : 134643 : while (loop_outer (use_loop) != loop_outer (def_loop))
177 : : {
178 : 2589 : use_loop = loop_outer (use_loop);
179 : 2589 : def_loop = loop_outer (def_loop);
180 : 2589 : gcc_assert (use_loop && def_loop);
181 : : }
182 : 132054 : return use_loop;
183 : : }
184 : :
185 : : /* DEF_BB is a basic block containing a DEF that needs rewriting into
186 : : loop-closed SSA form. USE_BLOCKS is the set of basic blocks containing
187 : : uses of DEF that "escape" from the loop containing DEF_BB (i.e. blocks in
188 : : USE_BLOCKS are dominated by DEF_BB but not in the loop father of DEF_BB).
189 : : ALL_EXITS[I] is the set of all basic blocks that exit loop I.
190 : : DEF_LOOP_EXITS is a bitmap of loop exit blocks that exit the loop
191 : : containing DEF_BB or its outer loops.
192 : :
193 : : Compute the subset of loop exit destinations that exit the loop
194 : : containing DEF_BB or one of its loop fathers, in which DEF is live.
195 : : This set is returned in the bitmap LIVE_EXITS.
196 : :
197 : : Instead of computing the complete livein set of the def, we use the loop
198 : : nesting tree as a form of poor man's structure analysis. This greatly
199 : : speeds up the analysis, which is important because this function may be
200 : : called on all SSA names that need rewriting, one at a time. */
201 : :
202 : : static void
203 : 3030380 : compute_live_loop_exits (bitmap live_exits, bitmap use_blocks,
204 : : basic_block def_bb, bitmap def_loop_exits)
205 : : {
206 : 3030380 : unsigned i;
207 : 3030380 : bitmap_iterator bi;
208 : 3030380 : class loop *def_loop = def_bb->loop_father;
209 : 3030380 : unsigned def_loop_depth = loop_depth (def_loop);
210 : :
211 : : /* Normally the work list size is bounded by the number of basic
212 : : blocks in the largest loop. We don't know this number, but we
213 : : can be fairly sure that it will be relatively small. */
214 : 3030380 : auto_vec<basic_block, 8> worklist (MAX (8, n_basic_blocks_for_fn (cfun) / 128));
215 : :
216 : 7307788 : EXECUTE_IF_SET_IN_BITMAP (use_blocks, 0, i, bi)
217 : : {
218 : 4277408 : basic_block use_bb = BASIC_BLOCK_FOR_FN (cfun, i);
219 : 4277408 : class loop *use_loop = use_bb->loop_father;
220 : 4277408 : gcc_checking_assert (def_loop != use_loop
221 : : && ! flow_loop_nested_p (def_loop, use_loop));
222 : 4277408 : if (! flow_loop_nested_p (use_loop, def_loop))
223 : 108805 : use_bb = find_sibling_superloop (use_loop, def_loop)->header;
224 : 4277408 : if (bitmap_set_bit (live_exits, use_bb->index))
225 : 4243004 : worklist.safe_push (use_bb);
226 : : }
227 : :
228 : : /* Iterate until the worklist is empty. */
229 : 9723305 : while (! worklist.is_empty ())
230 : : {
231 : 6692925 : edge e;
232 : 6692925 : edge_iterator ei;
233 : :
234 : : /* Pull a block off the worklist. */
235 : 6692925 : basic_block bb = worklist.pop ();
236 : :
237 : : /* Make sure we have at least enough room in the work list
238 : : for all predecessors of this block. */
239 : 6692925 : worklist.reserve (EDGE_COUNT (bb->preds));
240 : :
241 : : /* For each predecessor block. */
242 : 14435609 : FOR_EACH_EDGE (e, ei, bb->preds)
243 : : {
244 : 7742684 : basic_block pred = e->src;
245 : 7742684 : class loop *pred_loop = pred->loop_father;
246 : 7742684 : unsigned pred_loop_depth = loop_depth (pred_loop);
247 : 7742684 : bool pred_visited;
248 : :
249 : : /* We should have met DEF_BB along the way. */
250 : 7742684 : gcc_assert (pred != ENTRY_BLOCK_PTR_FOR_FN (cfun));
251 : :
252 : 7742684 : if (pred_loop_depth >= def_loop_depth)
253 : : {
254 : 4585257 : if (pred_loop_depth > def_loop_depth)
255 : 143364 : pred_loop = superloop_at_depth (pred_loop, def_loop_depth);
256 : : /* If we've reached DEF_LOOP, our train ends here. */
257 : 4585257 : if (pred_loop == def_loop)
258 : 5292763 : continue;
259 : : }
260 : 3157427 : else if (! flow_loop_nested_p (pred_loop, def_loop))
261 : 23249 : pred = find_sibling_superloop (pred_loop, def_loop)->header;
262 : :
263 : : /* Add PRED to the LIVEIN set. PRED_VISITED is true if
264 : : we had already added PRED to LIVEIN before. */
265 : 4015552 : pred_visited = !bitmap_set_bit (live_exits, pred->index);
266 : :
267 : : /* If we have visited PRED before, don't add it to the worklist.
268 : : If BB dominates PRED, then we're probably looking at a loop.
269 : : We're only interested in looking up in the dominance tree
270 : : because DEF_BB dominates all the uses. */
271 : 4015552 : if (pred_visited || dominated_by_p (CDI_DOMINATORS, pred, bb))
272 : 1565631 : continue;
273 : :
274 : 2449921 : worklist.quick_push (pred);
275 : : }
276 : : }
277 : :
278 : 3030380 : bitmap_and_into (live_exits, def_loop_exits);
279 : 3030380 : }
280 : :
281 : : /* Add a loop-closing PHI for VAR in basic block EXIT. */
282 : :
283 : : static void
284 : 3671812 : add_exit_phi (basic_block exit, tree var)
285 : : {
286 : 3671812 : gphi *phi;
287 : 3671812 : edge e;
288 : 3671812 : edge_iterator ei;
289 : :
290 : : /* Check that at least one of the edges entering the EXIT block exits
291 : : the loop, or a superloop of that loop, that VAR is defined in. */
292 : 3671812 : if (flag_checking)
293 : : {
294 : 3671710 : gimple *def_stmt = SSA_NAME_DEF_STMT (var);
295 : 3671710 : basic_block def_bb = gimple_bb (def_stmt);
296 : 3681562 : FOR_EACH_EDGE (e, ei, exit->preds)
297 : : {
298 : 7363124 : class loop *aloop = find_common_loop (def_bb->loop_father,
299 : 3681562 : e->src->loop_father);
300 : 3681562 : if (!flow_bb_inside_loop_p (aloop, e->dest))
301 : : break;
302 : : }
303 : 3671710 : gcc_assert (e);
304 : : }
305 : :
306 : 3671812 : phi = create_phi_node (NULL_TREE, exit);
307 : 3671812 : create_new_def_for (var, phi, gimple_phi_result_ptr (phi));
308 : 7523652 : FOR_EACH_EDGE (e, ei, exit->preds)
309 : 3851840 : add_phi_arg (phi, var, e, UNKNOWN_LOCATION);
310 : :
311 : 3671812 : if (dump_file && (dump_flags & TDF_DETAILS))
312 : : {
313 : 1420 : fprintf (dump_file, ";; Created LCSSA PHI: ");
314 : 1420 : print_gimple_stmt (dump_file, phi, 0, dump_flags);
315 : : }
316 : 3671812 : }
317 : :
318 : : /* Add exit phis for VAR that is used in LIVEIN.
319 : : Exits of the loops are stored in LOOP_EXITS. Returns the number
320 : : of PHIs added for VAR. */
321 : :
322 : : static unsigned
323 : 3030380 : add_exit_phis_var (tree var, bitmap use_blocks, bitmap def_loop_exits)
324 : : {
325 : 3030380 : unsigned index;
326 : 3030380 : bitmap_iterator bi;
327 : 3030380 : basic_block def_bb = gimple_bb (SSA_NAME_DEF_STMT (var));
328 : :
329 : 3030380 : gcc_checking_assert (! bitmap_bit_p (use_blocks, def_bb->index));
330 : :
331 : 3030380 : auto_bitmap live_exits (&loop_renamer_obstack);
332 : 3030380 : compute_live_loop_exits (live_exits, use_blocks, def_bb, def_loop_exits);
333 : :
334 : 3030380 : unsigned cnt = 0;
335 : 6702192 : EXECUTE_IF_SET_IN_BITMAP (live_exits, 0, index, bi)
336 : : {
337 : 3671812 : add_exit_phi (BASIC_BLOCK_FOR_FN (cfun, index), var);
338 : 3671812 : cnt++;
339 : : }
340 : 3030380 : return cnt;
341 : 3030380 : }
342 : :
343 : : static int
344 : 45231263 : loop_name_cmp (const void *p1, const void *p2)
345 : : {
346 : 45231263 : auto l1 = (const std::pair<int, int> *)p1;
347 : 45231263 : auto l2 = (const std::pair<int, int> *)p2;
348 : 45231263 : if (l1->first < l2->first)
349 : : return -1;
350 : 27563756 : else if (l1->first > l2->first)
351 : 16568150 : return 1;
352 : : return 0;
353 : : }
354 : :
355 : : /* Add exit phis for the names marked in NAMES_TO_RENAME.
356 : : Exits of the loops are stored in EXITS. Sets of blocks where the ssa
357 : : names are used are stored in USE_BLOCKS. Returns whether any name
358 : : required multiple LC PHI nodes. */
359 : :
360 : : static bool
361 : 677422 : add_exit_phis (bitmap names_to_rename, bitmap *use_blocks)
362 : : {
363 : 677422 : unsigned i;
364 : 677422 : bitmap_iterator bi;
365 : 677422 : bool multiple_p = false;
366 : :
367 : : /* Sort names_to_rename after definition loop so we can avoid re-computing
368 : : def_loop_exits. */
369 : 677422 : auto_vec<std::pair<int, int> > names (bitmap_count_bits (names_to_rename));
370 : 3707802 : EXECUTE_IF_SET_IN_BITMAP (names_to_rename, 0, i, bi)
371 : : {
372 : 3030380 : tree name = ssa_name (i);
373 : 3030380 : loop_p def_loop = gimple_bb (SSA_NAME_DEF_STMT (name))->loop_father;
374 : 3030380 : names.quick_push (std::make_pair (def_loop->num, i));
375 : : }
376 : 677422 : names.qsort (loop_name_cmp);
377 : :
378 : 677422 : auto_bitmap def_loop_exits (&loop_renamer_obstack);
379 : 677422 : loop_p last_def_loop = NULL;
380 : 5062646 : for (auto p : names)
381 : : {
382 : 3030380 : loop_p def_loop = get_loop (cfun, p.first);
383 : 3030380 : if (def_loop != last_def_loop)
384 : : {
385 : 1605323 : bitmap_clear (def_loop_exits);
386 : 1605323 : last_def_loop = def_loop;
387 : 3756464 : for (class loop *loop = def_loop; loop != current_loops->tree_root;
388 : 2151141 : loop = loop_outer (loop))
389 : 8172054 : for (auto exit = loop->exits->next; exit->e; exit = exit->next)
390 : 6020913 : bitmap_set_bit (def_loop_exits, exit->e->dest->index);
391 : : }
392 : 3030380 : if (add_exit_phis_var (ssa_name (p.second), use_blocks[p.second],
393 : : def_loop_exits) > 1)
394 : 346307 : multiple_p = true;
395 : : }
396 : :
397 : 677422 : return multiple_p;
398 : 677422 : }
399 : :
400 : : /* For USE in BB, if it is used outside of the loop it is defined in,
401 : : mark it for rewrite. Record basic block BB where it is used
402 : : to USE_BLOCKS. Record the ssa name index to NEED_PHIS bitmap.
403 : : Note that for USEs in phis, BB should be the src of the edge corresponding to
404 : : the use, rather than the bb containing the phi. */
405 : :
406 : : static void
407 : 149046440 : find_uses_to_rename_use (basic_block bb, tree use, bitmap *use_blocks,
408 : : bitmap need_phis)
409 : : {
410 : 149046440 : unsigned ver;
411 : 149046440 : basic_block def_bb;
412 : 149046440 : class loop *def_loop;
413 : :
414 : 149046440 : if (TREE_CODE (use) != SSA_NAME)
415 : : return;
416 : :
417 : 143770501 : ver = SSA_NAME_VERSION (use);
418 : 143770501 : def_bb = gimple_bb (SSA_NAME_DEF_STMT (use));
419 : 143770501 : if (!def_bb)
420 : : return;
421 : 133182068 : def_loop = def_bb->loop_father;
422 : :
423 : : /* If the definition is not inside a loop, it is not interesting. */
424 : 133182068 : if (!loop_outer (def_loop))
425 : : return;
426 : :
427 : : /* If the use is not outside of the loop it is defined in, it is not
428 : : interesting. */
429 : 70608169 : if (flow_bb_inside_loop_p (def_loop, bb))
430 : : return;
431 : :
432 : : /* If we're seeing VER for the first time, we still have to allocate
433 : : a bitmap for its uses. */
434 : 4887884 : if (bitmap_set_bit (need_phis, ver))
435 : 3030380 : use_blocks[ver] = BITMAP_ALLOC (&loop_renamer_obstack);
436 : 4887884 : bitmap_set_bit (use_blocks[ver], bb->index);
437 : : }
438 : :
439 : : /* For uses matching USE_FLAGS in STMT, mark names that are used outside of the
440 : : loop they are defined to rewrite. Record the set of blocks in which the ssa
441 : : names are used to USE_BLOCKS, and the ssa names themselves to NEED_PHIS. */
442 : :
443 : : static void
444 : 177343905 : find_uses_to_rename_stmt (gimple *stmt, bitmap *use_blocks, bitmap need_phis,
445 : : int use_flags)
446 : : {
447 : 177343905 : ssa_op_iter iter;
448 : 177343905 : tree var;
449 : 177343905 : basic_block bb = gimple_bb (stmt);
450 : :
451 : 177343905 : if (is_gimple_debug (stmt))
452 : 95972050 : return;
453 : :
454 : : /* FOR_EACH_SSA_TREE_OPERAND iterator does not allows SSA_OP_VIRTUAL_USES
455 : : only. */
456 : 81371855 : if (use_flags == SSA_OP_VIRTUAL_USES)
457 : : {
458 : 81371855 : tree vuse = gimple_vuse (stmt);
459 : 0 : if (vuse != NULL_TREE)
460 : 0 : find_uses_to_rename_use (bb, gimple_vuse (stmt), use_blocks, need_phis);
461 : : }
462 : : else
463 : 196206919 : FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, use_flags)
464 : 114835064 : find_uses_to_rename_use (bb, var, use_blocks, need_phis);
465 : : }
466 : :
467 : : /* Marks names matching USE_FLAGS that are used in BB and outside of the loop
468 : : they are defined in for rewrite. Records the set of blocks in which the ssa
469 : : names are used to USE_BLOCKS. Record the SSA names that will
470 : : need exit PHIs in NEED_PHIS. */
471 : :
472 : : static void
473 : 28322591 : find_uses_to_rename_bb (basic_block bb, bitmap *use_blocks, bitmap need_phis,
474 : : int use_flags)
475 : : {
476 : 28322591 : edge e;
477 : 28322591 : edge_iterator ei;
478 : 28322591 : bool do_virtuals = (use_flags & SSA_OP_VIRTUAL_USES) != 0;
479 : 28322591 : bool do_nonvirtuals = (use_flags & SSA_OP_USE) != 0;
480 : :
481 : 68638018 : FOR_EACH_EDGE (e, ei, bb->succs)
482 : 74526803 : for (gphi_iterator bsi = gsi_start_phis (e->dest); !gsi_end_p (bsi);
483 : 34211376 : gsi_next (&bsi))
484 : : {
485 : 34211376 : gphi *phi = bsi.phi ();
486 : 34211376 : bool virtual_p = virtual_operand_p (gimple_phi_result (phi));
487 : 34211376 : if ((virtual_p && do_virtuals)
488 : 20021139 : || (!virtual_p && do_nonvirtuals))
489 : 34211376 : find_uses_to_rename_use (bb, PHI_ARG_DEF_FROM_EDGE (phi, e),
490 : : use_blocks, need_phis);
491 : : }
492 : :
493 : 233989087 : for (gimple_stmt_iterator bsi = gsi_start_bb (bb); !gsi_end_p (bsi);
494 : 177343905 : gsi_next (&bsi))
495 : 177343905 : find_uses_to_rename_stmt (gsi_stmt (bsi), use_blocks, need_phis,
496 : : use_flags);
497 : 28322591 : }
498 : :
499 : : /* Marks names matching USE_FLAGS that are used outside of the loop they are
500 : : defined in for rewrite. Records the set of blocks in which the ssa names are
501 : : used to USE_BLOCKS. Record the SSA names that will need exit PHIs in
502 : : NEED_PHIS. If CHANGED_BBS is not NULL, scan only blocks in this set. */
503 : :
504 : : static void
505 : 972098 : find_uses_to_rename (bitmap changed_bbs, bitmap *use_blocks, bitmap need_phis,
506 : : int use_flags)
507 : : {
508 : 972098 : basic_block bb;
509 : 972098 : unsigned index;
510 : 972098 : bitmap_iterator bi;
511 : :
512 : 972098 : if (changed_bbs)
513 : 25342 : EXECUTE_IF_SET_IN_BITMAP (changed_bbs, 0, index, bi)
514 : : {
515 : 18424 : bb = BASIC_BLOCK_FOR_FN (cfun, index);
516 : 18424 : if (bb)
517 : 18424 : find_uses_to_rename_bb (bb, use_blocks, need_phis, use_flags);
518 : : }
519 : : else
520 : 29269347 : FOR_EACH_BB_FN (bb, cfun)
521 : 28304167 : find_uses_to_rename_bb (bb, use_blocks, need_phis, use_flags);
522 : 972098 : }
523 : :
524 : : /* Rewrites the program into a loop closed ssa form -- i.e. inserts extra
525 : : phi nodes to ensure that no variable is used outside the loop it is
526 : : defined in.
527 : :
528 : : This strengthening of the basic ssa form has several advantages:
529 : :
530 : : 1) Updating it during unrolling/peeling/versioning is trivial, since
531 : : we do not need to care about the uses outside of the loop.
532 : : The same applies to virtual operands which are also rewritten into
533 : : loop closed SSA form. Note that virtual operands are always live
534 : : until function exit.
535 : : 2) The behavior of all uses of an induction variable is the same.
536 : : Without this, you need to distinguish the case when the variable
537 : : is used outside of the loop it is defined in, for example
538 : :
539 : : for (i = 0; i < 100; i++)
540 : : {
541 : : for (j = 0; j < 100; j++)
542 : : {
543 : : k = i + j;
544 : : use1 (k);
545 : : }
546 : : use2 (k);
547 : : }
548 : :
549 : : Looking from the outer loop with the normal SSA form, the first use of k
550 : : is not well-behaved, while the second one is an induction variable with
551 : : base 99 and step 1.
552 : :
553 : : If CHANGED_BBS is not NULL, we look for uses outside loops only in the
554 : : basic blocks in this set.
555 : :
556 : : USE_FLAGS allows us to specify whether we want virtual, non-virtual or
557 : : both variables rewritten.
558 : :
559 : : UPDATE_FLAG is used in the call to update_ssa. See
560 : : TODO_update_ssa* for documentation. */
561 : :
562 : : static void
563 : 4303960 : rewrite_into_loop_closed_ssa_1 (bitmap changed_bbs, unsigned update_flag,
564 : : int use_flags)
565 : : {
566 : 4303960 : bitmap *use_blocks;
567 : 4303960 : bitmap names_to_rename;
568 : :
569 : 4303960 : loops_state_set (LOOP_CLOSED_SSA);
570 : 4303960 : if (number_of_loops (cfun) <= 1)
571 : : return;
572 : :
573 : : /* If the pass has caused the SSA form to be out-of-date, update it
574 : : now. */
575 : 972098 : if (update_flag != 0)
576 : 971711 : update_ssa (update_flag);
577 : 387 : else if (flag_checking)
578 : 387 : verify_ssa (true, true);
579 : :
580 : 972098 : bitmap_obstack_initialize (&loop_renamer_obstack);
581 : :
582 : 972098 : names_to_rename = BITMAP_ALLOC (&loop_renamer_obstack);
583 : :
584 : : /* Uses of names to rename. We don't have to initialize this array,
585 : : because we know that we will only have entries for the SSA names
586 : : in NAMES_TO_RENAME. */
587 : 1944196 : use_blocks = XNEWVEC (bitmap, num_ssa_names);
588 : 972098 : find_uses_to_rename (changed_bbs, use_blocks, names_to_rename, use_flags);
589 : :
590 : 972098 : if (!bitmap_empty_p (names_to_rename))
591 : : {
592 : 677422 : bool release_recorded_exits_p = false;
593 : 677422 : if (!loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS))
594 : : {
595 : : /* Doing one scan over the whole function is cheaper than
596 : : traversing the loop tree and gathering BBs of each loop. */
597 : 0 : record_loop_exits ();
598 : 0 : release_recorded_exits_p = true;
599 : : }
600 : :
601 : : /* Add the PHI nodes on exits of the loops for the names we need to
602 : : rewrite. When no variable required multiple LC PHI nodes to be
603 : : inserted then we know that all uses outside of the loop are
604 : : dominated by the single LC SSA definition and no further PHI
605 : : node insertions are required. */
606 : 677422 : bool need_phis_p = add_exit_phis (names_to_rename, use_blocks);
607 : :
608 : 677422 : if (release_recorded_exits_p)
609 : 0 : release_recorded_exits (cfun);
610 : :
611 : : /* Fix up all the names found to be used outside their original
612 : : loops. */
613 : 1213243 : update_ssa (need_phis_p ? TODO_update_ssa : TODO_update_ssa_no_phi);
614 : : }
615 : :
616 : 972098 : bitmap_obstack_release (&loop_renamer_obstack);
617 : 972098 : free (use_blocks);
618 : : }
619 : :
620 : : /* Rewrites the defs and uses into a loop closed ssa form.
621 : : If CHANGED_BBS is not NULL, we look for uses outside loops only in the basic
622 : : blocks in this set. UPDATE_FLAG is used in the call to update_ssa. See
623 : : TODO_update_ssa* for documentation. */
624 : :
625 : : void
626 : 4303960 : rewrite_into_loop_closed_ssa (bitmap changed_bbs, unsigned update_flag)
627 : : {
628 : 4303960 : rewrite_into_loop_closed_ssa_1 (changed_bbs, update_flag, SSA_OP_ALL_USES);
629 : 4303960 : }
630 : :
631 : : /* Check invariants of the loop closed ssa form for the def in DEF_BB. */
632 : :
633 : : static void
634 : 164133640 : check_loop_closed_ssa_def (basic_block def_bb, tree def)
635 : : {
636 : 164133640 : use_operand_p use_p;
637 : 164133640 : imm_use_iterator iterator;
638 : 476274665 : FOR_EACH_IMM_USE_FAST (use_p, iterator, def)
639 : : {
640 : 312141025 : if (is_gimple_debug (USE_STMT (use_p)))
641 : 36753925 : continue;
642 : :
643 : 275387100 : basic_block use_bb = gimple_bb (USE_STMT (use_p));
644 : 275387100 : if (is_a <gphi *> (USE_STMT (use_p)))
645 : 74956449 : use_bb = EDGE_PRED (use_bb, PHI_ARG_INDEX_FROM_USE (use_p))->src;
646 : :
647 : 275387100 : gcc_assert (flow_bb_inside_loop_p (def_bb->loop_father, use_bb));
648 : : }
649 : 164133640 : }
650 : :
651 : : /* Checks invariants of loop closed ssa form in BB. */
652 : :
653 : : static void
654 : 48338397 : check_loop_closed_ssa_bb (basic_block bb)
655 : : {
656 : 88242171 : for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
657 : 39903774 : gsi_next (&bsi))
658 : : {
659 : 39903774 : gphi *phi = bsi.phi ();
660 : :
661 : 39903774 : check_loop_closed_ssa_def (bb, PHI_RESULT (phi));
662 : : }
663 : :
664 : 194110423 : for (gimple_stmt_iterator bsi = gsi_start_nondebug_bb (bb); !gsi_end_p (bsi);
665 : 145772026 : gsi_next_nondebug (&bsi))
666 : : {
667 : 145772026 : ssa_op_iter iter;
668 : 145772026 : tree var;
669 : 145772026 : gimple *stmt = gsi_stmt (bsi);
670 : :
671 : 270001892 : FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_DEFS)
672 : 124229866 : check_loop_closed_ssa_def (bb, var);
673 : : }
674 : 48338397 : }
675 : :
676 : : /* Checks that invariants of the loop closed ssa form are preserved.
677 : : Call verify_ssa when VERIFY_SSA_P is true. Note all loops are checked
678 : : if LOOP is NULL, otherwise, only LOOP is checked. */
679 : :
680 : : DEBUG_FUNCTION void
681 : 3647808 : verify_loop_closed_ssa (bool verify_ssa_p, class loop *loop)
682 : : {
683 : 7295616 : if (number_of_loops (cfun) <= 1)
684 : : return;
685 : :
686 : 3647808 : timevar_push (TV_VERIFY_LOOP_CLOSED);
687 : :
688 : 3647808 : if (loop == NULL)
689 : : {
690 : 3646409 : basic_block bb;
691 : :
692 : 3646409 : if (verify_ssa_p)
693 : 29682 : verify_ssa (false, true);
694 : :
695 : 123576734 : FOR_EACH_BB_FN (bb, cfun)
696 : 119930325 : if (bb->loop_father && bb->loop_father->num > 0)
697 : 48331251 : check_loop_closed_ssa_bb (bb);
698 : : }
699 : : else
700 : : {
701 : 1399 : basic_block *bbs = get_loop_body (loop);
702 : :
703 : : /* We do not have loop-local SSA verification so just
704 : : check there's no update queued. */
705 : 1399 : if (verify_ssa_p)
706 : 1399 : gcc_assert (!need_ssa_update_p (cfun));
707 : :
708 : 8545 : for (unsigned i = 0; i < loop->num_nodes; ++i)
709 : 7146 : check_loop_closed_ssa_bb (bbs[i]);
710 : :
711 : 1399 : free (bbs);
712 : : }
713 : :
714 : 3647808 : timevar_pop (TV_VERIFY_LOOP_CLOSED);
715 : : }
716 : :
717 : : /* Split loop exit edge EXIT. The things are a bit complicated by a need to
718 : : preserve the loop closed ssa form. If COPY_CONSTANTS_P is true then
719 : : forwarder PHIs are also created for constant arguments.
720 : : The newly created block is returned. */
721 : :
722 : : basic_block
723 : 52201 : split_loop_exit_edge (edge exit, bool copy_constants_p)
724 : : {
725 : 52201 : basic_block dest = exit->dest;
726 : 52201 : basic_block bb = split_edge (exit);
727 : 52201 : gphi *phi, *new_phi;
728 : 52201 : tree new_name, name;
729 : 52201 : use_operand_p op_p;
730 : 52201 : gphi_iterator psi;
731 : 52201 : location_t locus;
732 : :
733 : 125147 : for (psi = gsi_start_phis (dest); !gsi_end_p (psi); gsi_next (&psi))
734 : : {
735 : 72946 : phi = psi.phi ();
736 : 72946 : op_p = PHI_ARG_DEF_PTR_FROM_EDGE (phi, single_succ_edge (bb));
737 : 72946 : locus = gimple_phi_arg_location_from_edge (phi, single_succ_edge (bb));
738 : :
739 : 72946 : name = USE_FROM_PTR (op_p);
740 : :
741 : : /* If the argument of the PHI node is a constant, we do not need
742 : : to keep it inside loop. */
743 : 72946 : if (TREE_CODE (name) != SSA_NAME
744 : 3217 : && !copy_constants_p)
745 : 3208 : continue;
746 : :
747 : : /* Otherwise create an auxiliary phi node that will copy the value
748 : : of the SSA name out of the loop. */
749 : 69738 : new_name = duplicate_ssa_name (PHI_RESULT (phi), NULL);
750 : 69738 : new_phi = create_phi_node (new_name, bb);
751 : 69738 : add_phi_arg (new_phi, name, exit, locus);
752 : 69738 : SET_USE (op_p, new_name);
753 : : }
754 : :
755 : 52201 : return bb;
756 : : }
757 : :
758 : : /* Returns the basic block in that statements should be emitted for induction
759 : : variables incremented at the end of the LOOP. */
760 : :
761 : : basic_block
762 : 14894490 : ip_end_pos (class loop *loop)
763 : : {
764 : 14894490 : return loop->latch;
765 : : }
766 : :
767 : : /* Returns the basic block in that statements should be emitted for induction
768 : : variables incremented just before exit condition of a LOOP. */
769 : :
770 : : basic_block
771 : 46503516 : ip_normal_pos (class loop *loop)
772 : : {
773 : 46503516 : basic_block bb;
774 : 46503516 : edge exit;
775 : :
776 : 46569822 : if (!single_pred_p (loop->latch))
777 : : return NULL;
778 : :
779 : 46379730 : bb = single_pred (loop->latch);
780 : 92759460 : if (!safe_is_a <gcond *> (*gsi_last_bb (bb)))
781 : 13022 : return NULL;
782 : :
783 : 46366708 : exit = EDGE_SUCC (bb, 0);
784 : 46366708 : if (exit->dest == loop->latch)
785 : 35068957 : exit = EDGE_SUCC (bb, 1);
786 : :
787 : 46366708 : if (flow_bb_inside_loop_p (loop, exit->dest))
788 : : return NULL;
789 : :
790 : : return bb;
791 : : }
792 : :
793 : : /* Stores the standard position for induction variable increment in LOOP
794 : : (just before the exit condition if it is available and latch block is empty,
795 : : end of the latch block otherwise) to BSI. INSERT_AFTER is set to true if
796 : : the increment should be inserted after *BSI. */
797 : :
798 : : void
799 : 121975 : standard_iv_increment_position (class loop *loop, gimple_stmt_iterator *bsi,
800 : : bool *insert_after)
801 : : {
802 : 121975 : basic_block bb = ip_normal_pos (loop), latch = ip_end_pos (loop);
803 : 121975 : gimple *last = last_nondebug_stmt (latch);
804 : :
805 : 121975 : if (!bb
806 : 121975 : || (last && gimple_code (last) != GIMPLE_LABEL))
807 : : {
808 : 2 : *bsi = gsi_last_bb (latch);
809 : 2 : *insert_after = true;
810 : : }
811 : : else
812 : : {
813 : 121973 : *bsi = gsi_last_bb (bb);
814 : 121973 : *insert_after = false;
815 : : }
816 : 121975 : }
817 : :
818 : : /* Copies phi node arguments for duplicated blocks. The index of the first
819 : : duplicated block is FIRST_NEW_BLOCK. */
820 : :
821 : : static void
822 : 125940 : copy_phi_node_args (unsigned first_new_block)
823 : : {
824 : 125940 : unsigned i;
825 : :
826 : 1093727 : for (i = first_new_block; i < (unsigned) last_basic_block_for_fn (cfun); i++)
827 : 967787 : BASIC_BLOCK_FOR_FN (cfun, i)->flags |= BB_DUPLICATED;
828 : :
829 : 1093727 : for (i = first_new_block; i < (unsigned) last_basic_block_for_fn (cfun); i++)
830 : 967787 : add_phi_args_after_copy_bb (BASIC_BLOCK_FOR_FN (cfun, i));
831 : :
832 : 1093727 : for (i = first_new_block; i < (unsigned) last_basic_block_for_fn (cfun); i++)
833 : 967787 : BASIC_BLOCK_FOR_FN (cfun, i)->flags &= ~BB_DUPLICATED;
834 : 125940 : }
835 : :
836 : :
837 : : /* The same as cfgloopmanip.cc:duplicate_loop_body_to_header_edge, but also
838 : : updates the PHI nodes at start of the copied region. In order to
839 : : achieve this, only loops whose exits all lead to the same location
840 : : are handled.
841 : :
842 : : Notice that we do not completely update the SSA web after
843 : : duplication. The caller is responsible for calling update_ssa
844 : : after the loop has been duplicated. */
845 : :
846 : : bool
847 : 125958 : gimple_duplicate_loop_body_to_header_edge (class loop *loop, edge e,
848 : : unsigned int ndupl,
849 : : sbitmap wont_exit, edge orig,
850 : : vec<edge> *to_remove, int flags)
851 : : {
852 : 125958 : unsigned first_new_block;
853 : :
854 : 125958 : if (!loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES))
855 : : return false;
856 : 125958 : if (!loops_state_satisfies_p (LOOPS_HAVE_PREHEADERS))
857 : : return false;
858 : :
859 : 125958 : first_new_block = last_basic_block_for_fn (cfun);
860 : 125958 : if (!duplicate_loop_body_to_header_edge (loop, e, ndupl, wont_exit, orig,
861 : : to_remove, flags))
862 : : return false;
863 : :
864 : : /* Readd the removed phi args for e. */
865 : 125940 : flush_pending_stmts (e);
866 : :
867 : : /* Copy the phi node arguments. */
868 : 125940 : copy_phi_node_args (first_new_block);
869 : :
870 : 125940 : scev_reset ();
871 : :
872 : 125940 : return true;
873 : : }
874 : :
875 : : /* Returns true if we can unroll LOOP FACTOR times. Number
876 : : of iterations of the loop is returned in NITER. */
877 : :
878 : : bool
879 : 754 : can_unroll_loop_p (class loop *loop, unsigned factor,
880 : : class tree_niter_desc *niter)
881 : : {
882 : 754 : edge exit;
883 : :
884 : : /* Check whether unrolling is possible. We only want to unroll loops
885 : : for that we are able to determine number of iterations. We also
886 : : want to split the extra iterations of the loop from its end,
887 : : therefore we require that the loop has precisely one
888 : : exit. */
889 : :
890 : 754 : exit = single_dom_exit (loop);
891 : 754 : if (!exit)
892 : : return false;
893 : :
894 : 735 : if (!number_of_iterations_exit (loop, exit, niter, false)
895 : 734 : || niter->cmp == ERROR_MARK
896 : : /* Scalar evolutions analysis might have copy propagated
897 : : the abnormal ssa names into these expressions, hence
898 : : emitting the computations based on them during loop
899 : : unrolling might create overlapping life ranges for
900 : : them, and failures in out-of-ssa. */
901 : 732 : || contains_abnormal_ssa_name_p (niter->may_be_zero)
902 : 732 : || contains_abnormal_ssa_name_p (niter->control.base)
903 : 732 : || contains_abnormal_ssa_name_p (niter->control.step)
904 : 1467 : || contains_abnormal_ssa_name_p (niter->bound))
905 : 3 : return false;
906 : :
907 : : /* And of course, we must be able to duplicate the loop. */
908 : 732 : if (!can_duplicate_loop_p (loop))
909 : : return false;
910 : :
911 : : /* The final loop should be small enough. */
912 : 732 : if (tree_num_loop_insns (loop, &eni_size_weights) * factor
913 : 732 : > (unsigned) param_max_unrolled_insns)
914 : : return false;
915 : :
916 : : return true;
917 : : }
918 : :
919 : : /* Determines the conditions that control execution of LOOP unrolled FACTOR
920 : : times. DESC is number of iterations of LOOP. ENTER_COND is set to
921 : : condition that must be true if the main loop can be entered.
922 : : If the loop does not always iterate an exact multiple of FACTOR times,
923 : : EXIT_BASE, EXIT_STEP, EXIT_CMP and EXIT_BOUND are set to values describing
924 : : how the exit from the unrolled loop should be controlled. Otherwise,
925 : : the trees are set to null and EXIT_CMP is set to ERROR_MARK. */
926 : :
927 : : static void
928 : 712 : determine_exit_conditions (class loop *loop, class tree_niter_desc *desc,
929 : : unsigned factor, tree *enter_cond,
930 : : tree *exit_base, tree *exit_step,
931 : : enum tree_code *exit_cmp, tree *exit_bound)
932 : : {
933 : 712 : gimple_seq stmts;
934 : 712 : tree base = desc->control.base;
935 : 712 : tree step = desc->control.step;
936 : 712 : tree bound = desc->bound;
937 : 712 : tree type = TREE_TYPE (step);
938 : 712 : tree bigstep, delta;
939 : 712 : tree min = lower_bound_in_type (type, type);
940 : 712 : tree max = upper_bound_in_type (type, type);
941 : 712 : enum tree_code cmp = desc->cmp;
942 : 712 : tree cond = boolean_true_node, assum;
943 : :
944 : : /* For pointers, do the arithmetics in the type of step. */
945 : 712 : base = fold_convert (type, base);
946 : 712 : bound = fold_convert (type, bound);
947 : :
948 : 712 : *enter_cond = boolean_false_node;
949 : 712 : *exit_base = NULL_TREE;
950 : 712 : *exit_step = NULL_TREE;
951 : 712 : *exit_cmp = ERROR_MARK;
952 : 712 : *exit_bound = NULL_TREE;
953 : 712 : gcc_assert (cmp != ERROR_MARK);
954 : :
955 : : /* We only need to be correct when we answer question
956 : : "Do at least FACTOR more iterations remain?" in the unrolled loop.
957 : : Thus, transforming BASE + STEP * i <> BOUND to
958 : : BASE + STEP * i < BOUND is ok. */
959 : 712 : if (cmp == NE_EXPR)
960 : : {
961 : 71 : if (tree_int_cst_sign_bit (step))
962 : : cmp = GT_EXPR;
963 : : else
964 : 676 : cmp = LT_EXPR;
965 : : }
966 : 641 : else if (cmp == LT_EXPR)
967 : : {
968 : 641 : gcc_assert (!tree_int_cst_sign_bit (step));
969 : : }
970 : 0 : else if (cmp == GT_EXPR)
971 : : {
972 : 0 : gcc_assert (tree_int_cst_sign_bit (step));
973 : : }
974 : : else
975 : 0 : gcc_unreachable ();
976 : :
977 : : /* The main body of the loop may be entered iff:
978 : :
979 : : 1) desc->may_be_zero is false.
980 : : 2) it is possible to check that there are at least FACTOR iterations
981 : : of the loop, i.e., BOUND - step * FACTOR does not overflow.
982 : : 3) # of iterations is at least FACTOR */
983 : :
984 : 712 : if (!integer_zerop (desc->may_be_zero))
985 : 6 : cond = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
986 : : invert_truthvalue (desc->may_be_zero),
987 : : cond);
988 : :
989 : 712 : bigstep = fold_build2 (MULT_EXPR, type, step,
990 : : build_int_cst_type (type, factor));
991 : 712 : delta = fold_build2 (MINUS_EXPR, type, bigstep, step);
992 : 712 : if (cmp == LT_EXPR)
993 : 676 : assum = fold_build2 (GE_EXPR, boolean_type_node,
994 : : bound,
995 : : fold_build2 (PLUS_EXPR, type, min, delta));
996 : : else
997 : 36 : assum = fold_build2 (LE_EXPR, boolean_type_node,
998 : : bound,
999 : : fold_build2 (PLUS_EXPR, type, max, delta));
1000 : 712 : cond = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, assum, cond);
1001 : :
1002 : 712 : bound = fold_build2 (MINUS_EXPR, type, bound, delta);
1003 : 712 : assum = fold_build2 (cmp, boolean_type_node, base, bound);
1004 : 712 : cond = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, assum, cond);
1005 : :
1006 : 712 : if (integer_nonzerop (cond)
1007 : 712 : && integer_zerop (desc->may_be_zero))
1008 : : {
1009 : : /* Convert the latch count to an iteration count. */
1010 : 72 : tree niter = fold_build2 (PLUS_EXPR, type, desc->niter,
1011 : : build_one_cst (type));
1012 : 72 : if (multiple_of_p (type, niter, build_int_cst (type, factor)))
1013 : 25 : return;
1014 : : }
1015 : :
1016 : 687 : cond = force_gimple_operand (unshare_expr (cond), &stmts, false, NULL_TREE);
1017 : 687 : if (stmts)
1018 : 21 : gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts);
1019 : : /* cond now may be a gimple comparison, which would be OK, but also any
1020 : : other gimple rhs (say a && b). In this case we need to force it to
1021 : : operand. */
1022 : 687 : if (!is_gimple_condexpr_for_cond (cond))
1023 : : {
1024 : 18 : cond = force_gimple_operand (cond, &stmts, true, NULL_TREE);
1025 : 18 : if (stmts)
1026 : 18 : gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts);
1027 : : }
1028 : 687 : *enter_cond = cond;
1029 : :
1030 : 687 : base = force_gimple_operand (unshare_expr (base), &stmts, true, NULL_TREE);
1031 : 687 : if (stmts)
1032 : 49 : gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts);
1033 : 687 : bound = force_gimple_operand (unshare_expr (bound), &stmts, true, NULL_TREE);
1034 : 687 : if (stmts)
1035 : 601 : gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts);
1036 : :
1037 : 687 : *exit_base = base;
1038 : 687 : *exit_step = bigstep;
1039 : 687 : *exit_cmp = cmp;
1040 : 687 : *exit_bound = bound;
1041 : : }
1042 : :
1043 : : /* Unroll LOOP FACTOR times. LOOP is known to have a single exit edge
1044 : : whose source block dominates the latch. DESC describes the number of
1045 : : iterations of LOOP.
1046 : :
1047 : : If N is number of iterations of the loop and MAY_BE_ZERO is the condition
1048 : : under that loop exits in the first iteration even if N != 0,
1049 : :
1050 : : while (1)
1051 : : {
1052 : : x = phi (init, next);
1053 : :
1054 : : pre;
1055 : : if (st)
1056 : : break;
1057 : : post;
1058 : : }
1059 : :
1060 : : becomes (with possibly the exit conditions formulated a bit differently,
1061 : : avoiding the need to create a new iv):
1062 : :
1063 : : if (MAY_BE_ZERO || N < FACTOR)
1064 : : goto rest;
1065 : :
1066 : : do
1067 : : {
1068 : : x = phi (init, next);
1069 : :
1070 : : pre;
1071 : : post;
1072 : : pre;
1073 : : post;
1074 : : ...
1075 : : pre;
1076 : : post;
1077 : : N -= FACTOR;
1078 : :
1079 : : } while (N >= FACTOR);
1080 : :
1081 : : rest:
1082 : : init' = phi (init, x);
1083 : :
1084 : : while (1)
1085 : : {
1086 : : x = phi (init', next);
1087 : :
1088 : : pre;
1089 : : if (st)
1090 : : break;
1091 : : post;
1092 : : }
1093 : :
1094 : : Before the loop is unrolled, TRANSFORM is called for it (only for the
1095 : : unrolled loop, but not for its versioned copy). DATA is passed to
1096 : : TRANSFORM. */
1097 : :
1098 : : /* Probability in % that the unrolled loop is entered. Just a guess. */
1099 : : #define PROB_UNROLLED_LOOP_ENTERED 90
1100 : :
1101 : : void
1102 : 712 : tree_transform_and_unroll_loop (class loop *loop, unsigned factor,
1103 : : class tree_niter_desc *desc,
1104 : : transform_callback transform,
1105 : : void *data)
1106 : : {
1107 : 712 : unsigned irr = loop_preheader_edge (loop)->flags & EDGE_IRREDUCIBLE_LOOP;
1108 : :
1109 : 712 : enum tree_code exit_cmp;
1110 : 712 : tree enter_main_cond, exit_base, exit_step, exit_bound;
1111 : 712 : bool flat = maybe_flat_loop_profile (loop);
1112 : 712 : determine_exit_conditions (loop, desc, factor,
1113 : : &enter_main_cond, &exit_base, &exit_step,
1114 : : &exit_cmp, &exit_bound);
1115 : 712 : bool single_loop_p = !exit_base;
1116 : :
1117 : 712 : gcond *exit_if = nullptr;
1118 : 712 : class loop *new_loop = nullptr;
1119 : 712 : edge new_exit;
1120 : 712 : if (!single_loop_p)
1121 : : {
1122 : 687 : profile_count entry_count = loop_preheader_edge (loop)->src->count;
1123 : : /* Let us assume that the unrolled loop is quite likely to be entered. */
1124 : 687 : profile_probability prob_entry;
1125 : 687 : if (integer_nonzerop (enter_main_cond))
1126 : 47 : prob_entry = profile_probability::always ();
1127 : : else
1128 : 640 : prob_entry = profile_probability::guessed_always ()
1129 : 640 : .apply_scale (PROB_UNROLLED_LOOP_ENTERED, 100);
1130 : :
1131 : :
1132 : : /* The values for scales should keep profile consistent, and somewhat
1133 : : close to correct. */
1134 : 687 : new_loop = loop_version (loop, enter_main_cond, NULL, prob_entry,
1135 : : prob_entry.invert (),
1136 : : prob_entry,
1137 : : /* We will later redirect exit from vectorized
1138 : : loop to new_loop. */
1139 : : profile_probability::always (),
1140 : : true);
1141 : 687 : gcc_assert (new_loop != NULL);
1142 : 687 : update_ssa (TODO_update_ssa_no_phi);
1143 : :
1144 : : /* Prepare the cfg and update the phi nodes. Move the loop exit to the
1145 : : loop latch (and make its condition dummy, for the moment). */
1146 : 687 : basic_block rest = loop_preheader_edge (new_loop)->src;
1147 : 687 : edge precond_edge = single_pred_edge (rest);
1148 : 687 : split_edge (loop_latch_edge (loop));
1149 : 687 : basic_block exit_bb = single_pred (loop->latch);
1150 : 687 : edge exit = single_dom_exit (loop);
1151 : :
1152 : : /* Since the exit edge will be removed, the frequency of all the blocks
1153 : : in the loop that are dominated by it must be scaled. */
1154 : 687 : if (exit->probability.initialized_p ())
1155 : 687 : scale_dominated_blocks_in_loop (loop, exit->src,
1156 : : /* We are scaling up here so
1157 : : probability does not fit. */
1158 : 687 : exit->src->count,
1159 : 1374 : exit->src->count - exit->count ());
1160 : :
1161 : 687 : gimple_stmt_iterator bsi = gsi_last_bb (exit_bb);
1162 : 687 : exit_if = gimple_build_cond (EQ_EXPR, integer_zero_node,
1163 : : integer_zero_node,
1164 : : NULL_TREE, NULL_TREE);
1165 : :
1166 : 687 : gsi_insert_after (&bsi, exit_if, GSI_NEW_STMT);
1167 : 687 : new_exit = make_edge (exit_bb, rest, EDGE_FALSE_VALUE | irr);
1168 : 687 : rescan_loop_exit (new_exit, true, false);
1169 : :
1170 : : /* Set the probability of new exit to the same of the old one. Fix
1171 : : the count of the latch block. */
1172 : 687 : new_exit->probability = exit->probability;
1173 : 687 : edge new_nonexit = single_pred_edge (loop->latch);
1174 : 687 : new_nonexit->probability = exit->probability.invert ();
1175 : 687 : new_nonexit->flags = EDGE_TRUE_VALUE;
1176 : 687 : set_edge_probability_and_rescale_others
1177 : 687 : (exit, profile_probability::never ());
1178 : 687 : loop->latch->count = new_nonexit->count ();
1179 : :
1180 : 687 : edge old_entry = loop_preheader_edge (loop);
1181 : 687 : edge new_entry = loop_preheader_edge (new_loop);
1182 : 687 : edge old_latch = loop_latch_edge (loop);
1183 : 687 : for (gphi_iterator psi_old_loop = gsi_start_phis (loop->header),
1184 : 687 : psi_new_loop = gsi_start_phis (new_loop->header);
1185 : 2160 : !gsi_end_p (psi_old_loop);
1186 : 1473 : gsi_next (&psi_old_loop), gsi_next (&psi_new_loop))
1187 : : {
1188 : 1473 : gphi *phi_old_loop = psi_old_loop.phi ();
1189 : 1473 : gphi *phi_new_loop = psi_new_loop.phi ();
1190 : :
1191 : 1473 : tree init = PHI_ARG_DEF_FROM_EDGE (phi_old_loop, old_entry);
1192 : 1473 : use_operand_p op
1193 : 1473 : = PHI_ARG_DEF_PTR_FROM_EDGE (phi_new_loop, new_entry);
1194 : 1473 : gcc_assert (operand_equal_for_phi_arg_p (init, USE_FROM_PTR (op)));
1195 : 1473 : tree next = PHI_ARG_DEF_FROM_EDGE (phi_old_loop, old_latch);
1196 : :
1197 : : /* Prefer using original variable as a base for the new ssa name.
1198 : : This is necessary for virtual ops, and useful in order to avoid
1199 : : losing debug info for real ops. */
1200 : 1473 : tree new_init;
1201 : 1473 : if (TREE_CODE (next) == SSA_NAME
1202 : 2946 : && useless_type_conversion_p (TREE_TYPE (next),
1203 : 1473 : TREE_TYPE (init)))
1204 : 1473 : new_init = copy_ssa_name (next);
1205 : 0 : else if (TREE_CODE (init) == SSA_NAME
1206 : 0 : && useless_type_conversion_p (TREE_TYPE (init),
1207 : 0 : TREE_TYPE (next)))
1208 : 0 : new_init = copy_ssa_name (init);
1209 : 0 : else if (useless_type_conversion_p (TREE_TYPE (next),
1210 : 0 : TREE_TYPE (init)))
1211 : 0 : new_init = make_temp_ssa_name (TREE_TYPE (next), NULL,
1212 : : "unrinittmp");
1213 : : else
1214 : 0 : new_init = make_temp_ssa_name (TREE_TYPE (init), NULL,
1215 : : "unrinittmp");
1216 : :
1217 : 1473 : gphi *phi_rest = create_phi_node (new_init, rest);
1218 : 1473 : add_phi_arg (phi_rest, init, precond_edge, UNKNOWN_LOCATION);
1219 : 1473 : add_phi_arg (phi_rest, next, new_exit, UNKNOWN_LOCATION);
1220 : 1473 : SET_USE (op, new_init);
1221 : : }
1222 : :
1223 : 687 : remove_path (exit);
1224 : : /* We will later redirect exit from vectorized loop to new_loop. */
1225 : 687 : loop_preheader_edge (new_loop)->src->count = entry_count;
1226 : :
1227 : : /* The epilog loop latch executes at most factor - 1 times.
1228 : : Since the epilog is entered unconditionally it will need to handle
1229 : : up to factor executions of its body. */
1230 : 687 : new_loop->any_upper_bound = true;
1231 : 687 : new_loop->nb_iterations_upper_bound = factor - 1;
1232 : : /* We do not really know estimate on number of iterations, since we do not
1233 : : track any estimates modulo unroll factor.
1234 : : Drop estimate from loop_info and scale loop profile.
1235 : : It may be more realistic to scale loop profile to factor / 2 - 1,
1236 : : but vectorizer also uses factor - 1. */
1237 : 687 : new_loop->any_estimate = false;
1238 : 687 : scale_loop_profile (new_loop, profile_probability::always (), factor - 1);
1239 : : }
1240 : : else
1241 : 25 : new_exit = single_dom_exit (loop);
1242 : :
1243 : : /* Transform the loop. */
1244 : 712 : if (transform)
1245 : 608 : (*transform) (loop, data);
1246 : :
1247 : : /* Unroll the loop and remove the exits in all iterations except for the
1248 : : last one. */
1249 : 712 : auto_sbitmap wont_exit (factor);
1250 : 712 : bitmap_ones (wont_exit);
1251 : 712 : bitmap_clear_bit (wont_exit, factor - 1);
1252 : :
1253 : 712 : auto_vec<edge> to_remove;
1254 : 712 : bool ok
1255 : : = gimple_duplicate_loop_body_to_header_edge
1256 : 773 : (loop, loop_latch_edge (loop), factor - 1, wont_exit,
1257 : : new_exit, &to_remove,
1258 : : DLTHE_FLAG_UPDATE_FREQ | (flat ? DLTHE_FLAG_FLAT_PROFILE : 0));
1259 : 712 : gcc_assert (ok);
1260 : :
1261 : 3095 : for (edge e : to_remove)
1262 : : {
1263 : 959 : ok = remove_path (e);
1264 : 959 : gcc_assert (ok);
1265 : : }
1266 : 712 : update_ssa (TODO_update_ssa);
1267 : :
1268 : 712 : new_exit = single_dom_exit (loop);
1269 : : /* gimple_duplicate_loop_body_to_header_edge depending on
1270 : : DLTHE_FLAG_UPDATE_FREQ either keeps original frequency of the loop header
1271 : : or scales it down accordingly.
1272 : : However exit edge probability is kept as original. Fix it if needed
1273 : : and compensate. */
1274 : 712 : update_loop_exit_probability_scale_dom_bbs (loop, new_exit);
1275 : 712 : if (!single_loop_p)
1276 : : {
1277 : : /* Finally create the new counter for number of iterations and add
1278 : : the new exit instruction. */
1279 : 687 : tree ctr_before, ctr_after;
1280 : 687 : gimple_stmt_iterator bsi = gsi_last_nondebug_bb (new_exit->src);
1281 : 687 : exit_if = as_a <gcond *> (gsi_stmt (bsi));
1282 : 687 : create_iv (exit_base, PLUS_EXPR, exit_step, NULL_TREE, loop,
1283 : : &bsi, false, &ctr_before, &ctr_after);
1284 : 687 : gimple_cond_set_code (exit_if, exit_cmp);
1285 : 687 : gimple_cond_set_lhs (exit_if, ctr_after);
1286 : 687 : gimple_cond_set_rhs (exit_if, exit_bound);
1287 : 687 : update_stmt (exit_if);
1288 : : }
1289 : 712 : if (loop->any_upper_bound)
1290 : 1400 : loop->nb_iterations_upper_bound = wi::udiv_floor
1291 : 700 : (loop->nb_iterations_upper_bound + 1, factor) - 1;
1292 : 712 : if (loop->any_likely_upper_bound)
1293 : 1400 : loop->nb_iterations_likely_upper_bound = wi::udiv_floor
1294 : 700 : (loop->nb_iterations_likely_upper_bound + 1, factor) - 1;
1295 : 712 : if (loop->any_estimate)
1296 : 142 : loop->nb_iterations_estimate = wi::udiv_floor
1297 : 71 : (loop->nb_iterations_estimate + 1, factor) - 1;
1298 : :
1299 : 712 : checking_verify_flow_info ();
1300 : 712 : checking_verify_loop_structure ();
1301 : 712 : checking_verify_loop_closed_ssa (true, loop);
1302 : 712 : if (new_loop)
1303 : 1399 : checking_verify_loop_closed_ssa (true, new_loop);
1304 : 712 : }
1305 : :
1306 : : /* Wrapper over tree_transform_and_unroll_loop for case we do not
1307 : : want to transform the loop before unrolling. The meaning
1308 : : of the arguments is the same as for tree_transform_and_unroll_loop. */
1309 : :
1310 : : void
1311 : 104 : tree_unroll_loop (class loop *loop, unsigned factor,
1312 : : class tree_niter_desc *desc)
1313 : : {
1314 : 104 : tree_transform_and_unroll_loop (loop, factor, desc, NULL, NULL);
1315 : 104 : }
1316 : :
1317 : : /* Rewrite the phi node at position PSI in function of the main
1318 : : induction variable MAIN_IV and insert the generated code at GSI. */
1319 : :
1320 : : static void
1321 : 2074 : rewrite_phi_with_iv (loop_p loop,
1322 : : gphi_iterator *psi,
1323 : : gimple_stmt_iterator *gsi,
1324 : : tree main_iv)
1325 : : {
1326 : 2074 : affine_iv iv;
1327 : 2074 : gassign *stmt;
1328 : 2074 : gphi *phi = psi->phi ();
1329 : 2074 : tree atype, mtype, val, res = PHI_RESULT (phi);
1330 : :
1331 : 4148 : if (virtual_operand_p (res) || res == main_iv)
1332 : : {
1333 : 1178 : gsi_next (psi);
1334 : 1269 : return;
1335 : : }
1336 : :
1337 : 896 : if (!simple_iv (loop, loop, res, &iv, true))
1338 : : {
1339 : 91 : gsi_next (psi);
1340 : 91 : return;
1341 : : }
1342 : :
1343 : 805 : remove_phi_node (psi, false);
1344 : :
1345 : 805 : atype = TREE_TYPE (res);
1346 : 805 : mtype = POINTER_TYPE_P (atype) ? sizetype : atype;
1347 : 805 : val = fold_build2 (MULT_EXPR, mtype, unshare_expr (iv.step),
1348 : : fold_convert (mtype, main_iv));
1349 : 1610 : val = fold_build2 (POINTER_TYPE_P (atype)
1350 : : ? POINTER_PLUS_EXPR : PLUS_EXPR,
1351 : : atype, unshare_expr (iv.base), val);
1352 : 805 : val = force_gimple_operand_gsi (gsi, val, false, NULL_TREE, true,
1353 : : GSI_SAME_STMT);
1354 : 805 : stmt = gimple_build_assign (res, val);
1355 : 805 : gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
1356 : : }
1357 : :
1358 : : /* Rewrite all the phi nodes of LOOP in function of the main induction
1359 : : variable MAIN_IV. */
1360 : :
1361 : : static void
1362 : 592 : rewrite_all_phi_nodes_with_iv (loop_p loop, tree main_iv)
1363 : : {
1364 : 592 : unsigned i;
1365 : 592 : basic_block *bbs = get_loop_body_in_dom_order (loop);
1366 : 592 : gphi_iterator psi;
1367 : :
1368 : 2088 : for (i = 0; i < loop->num_nodes; i++)
1369 : : {
1370 : 1496 : basic_block bb = bbs[i];
1371 : 1496 : gimple_stmt_iterator gsi = gsi_after_labels (bb);
1372 : :
1373 : 1496 : if (bb->loop_father != loop)
1374 : 97 : continue;
1375 : :
1376 : 3473 : for (psi = gsi_start_phis (bb); !gsi_end_p (psi); )
1377 : 2074 : rewrite_phi_with_iv (loop, &psi, &gsi, main_iv);
1378 : : }
1379 : :
1380 : 592 : free (bbs);
1381 : 592 : }
1382 : :
1383 : : /* Bases all the induction variables in LOOP on a single induction variable
1384 : : (with base 0 and step 1), whose final value is compared with *NIT. When the
1385 : : IV type precision has to be larger than *NIT type precision, *NIT is
1386 : : converted to the larger type, the conversion code is inserted before the
1387 : : loop, and *NIT is updated to the new definition. When BUMP_IN_LATCH is true,
1388 : : the induction variable is incremented in the loop latch, otherwise it is
1389 : : incremented in the loop header. Return the induction variable that was
1390 : : created. */
1391 : :
1392 : : tree
1393 : 592 : canonicalize_loop_ivs (class loop *loop, tree *nit, bool bump_in_latch)
1394 : : {
1395 : 592 : unsigned precision = TYPE_PRECISION (TREE_TYPE (*nit));
1396 : 592 : unsigned original_precision = precision;
1397 : 592 : tree type, var_before;
1398 : 592 : gimple_stmt_iterator gsi;
1399 : 592 : gphi_iterator psi;
1400 : 592 : gcond *stmt;
1401 : 592 : edge exit = single_dom_exit (loop);
1402 : 592 : gimple_seq stmts;
1403 : 592 : bool unsigned_p = false;
1404 : :
1405 : 592 : for (psi = gsi_start_phis (loop->header);
1406 : 1969 : !gsi_end_p (psi); gsi_next (&psi))
1407 : : {
1408 : 1377 : gphi *phi = psi.phi ();
1409 : 1377 : tree res = PHI_RESULT (phi);
1410 : 1377 : bool uns;
1411 : :
1412 : 1377 : type = TREE_TYPE (res);
1413 : 1377 : if (virtual_operand_p (res)
1414 : 877 : || (!INTEGRAL_TYPE_P (type)
1415 : 29 : && !POINTER_TYPE_P (type))
1416 : 2229 : || TYPE_PRECISION (type) < precision)
1417 : 547 : continue;
1418 : :
1419 : 830 : uns = POINTER_TYPE_P (type) | TYPE_UNSIGNED (type);
1420 : :
1421 : 830 : if (TYPE_PRECISION (type) > precision)
1422 : : unsigned_p = uns;
1423 : : else
1424 : 825 : unsigned_p |= uns;
1425 : :
1426 : 830 : precision = TYPE_PRECISION (type);
1427 : : }
1428 : :
1429 : 592 : scalar_int_mode mode = smallest_int_mode_for_size (precision).require ();
1430 : 592 : precision = GET_MODE_PRECISION (mode);
1431 : 592 : type = build_nonstandard_integer_type (precision, unsigned_p);
1432 : :
1433 : 592 : if (original_precision != precision
1434 : 592 : || TYPE_UNSIGNED (TREE_TYPE (*nit)) != unsigned_p)
1435 : : {
1436 : 313 : *nit = fold_convert (type, *nit);
1437 : 313 : *nit = force_gimple_operand (*nit, &stmts, true, NULL_TREE);
1438 : 313 : if (stmts)
1439 : 125 : gsi_insert_seq_on_edge_immediate (loop_preheader_edge (loop), stmts);
1440 : : }
1441 : :
1442 : 592 : if (bump_in_latch)
1443 : 1184 : gsi = gsi_last_bb (loop->latch);
1444 : : else
1445 : 0 : gsi = gsi_last_nondebug_bb (loop->header);
1446 : 592 : create_iv (build_int_cst_type (type, 0), PLUS_EXPR, build_int_cst (type, 1),
1447 : : NULL_TREE, loop, &gsi, bump_in_latch, &var_before, NULL);
1448 : :
1449 : 592 : rewrite_all_phi_nodes_with_iv (loop, var_before);
1450 : :
1451 : 1184 : stmt = as_a <gcond *> (*gsi_last_bb (exit->src));
1452 : : /* Make the loop exit if the control condition is not satisfied. */
1453 : 592 : if (exit->flags & EDGE_TRUE_VALUE)
1454 : : {
1455 : 113 : edge te, fe;
1456 : :
1457 : 113 : extract_true_false_edges_from_block (exit->src, &te, &fe);
1458 : 113 : te->flags = EDGE_FALSE_VALUE;
1459 : 113 : fe->flags = EDGE_TRUE_VALUE;
1460 : : }
1461 : 592 : gimple_cond_set_code (stmt, LT_EXPR);
1462 : 592 : gimple_cond_set_lhs (stmt, var_before);
1463 : 592 : gimple_cond_set_rhs (stmt, *nit);
1464 : 592 : update_stmt (stmt);
1465 : :
1466 : 592 : return var_before;
1467 : : }
|
