static bool graphite_initialize (isl_ctx *ctx) { if (number_of_loops (cfun) <= 1 /* FIXME: This limit on the number of basic blocks of a function should be removed when the SCOP detection is faster. */ || n_basic_blocks > PARAM_VALUE (PARAM_GRAPHITE_MAX_BBS_PER_FUNCTION)) { if (dump_file && (dump_flags & TDF_DETAILS)) print_global_statistics (dump_file); isl_ctx_free (ctx); return false; } scev_reset (); recompute_all_dominators (); initialize_original_copy_tables (); cloog_state = cloog_isl_state_malloc (ctx); if (dump_file && dump_flags) dump_function_to_file (current_function_decl, dump_file, dump_flags); return true; }
static unsigned int tree_vectorize (void) { if (number_of_loops () <= 1) return 0; return vectorize_loops (); }
static unsigned int tree_ssa_loop_unswitch (void) { if (number_of_loops () <= 1) return 0; return tree_ssa_unswitch_loops (); }
static unsigned int tree_ssa_loop_im (void) { if (number_of_loops () <= 1) return 0; return tree_ssa_lim (); }
static unsigned int tree_ssa_loop_prefetch (void) { if (number_of_loops () <= 1) return 0; return tree_ssa_prefetch_arrays (); }
static unsigned int tree_ssa_loop_ivcanon (void) { if (number_of_loops () <= 1) return 0; return canonicalize_induction_variables (); }
static unsigned int check_data_deps (void) { if (number_of_loops () <= 1) return 0; tree_check_data_deps (); return 0; }
static unsigned int tree_ssa_loop_ivopts (void) { if (number_of_loops () <= 1) return 0; tree_ssa_iv_optimize (); return 0; }
static unsigned int tree_linear_transform (void) { if (number_of_loops () <= 1) return 0; linear_transform_loops (); return 0; }
static unsigned int tree_ssa_loop_bounds (void) { if (number_of_loops () <= 1) return 0; estimate_numbers_of_iterations (); scev_reset (); return 0; }
static unsigned tree_parallelize_loops (void) { if (number_of_loops () <= 1) return 0; if (parallelize_loops ()) return TODO_cleanup_cfg | TODO_rebuild_alias; return 0; }
static unsigned int tree_complete_unroll (void) { if (number_of_loops () <= 1) return 0; return tree_unroll_loops_completely (flag_unroll_loops || flag_peel_loops || optimize >= 3, true); }
static bool gate_loop (function *fn) { if (!flag_tree_loop_optimize) return false; /* For -fdump-passes which runs before loop discovery print the state of -ftree-loop-optimize. */ if (!loops_for_fn (fn)) return true; return number_of_loops (fn) > 1; }
static unsigned int tree_ssa_loop_init (void) { loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS); rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa); if (number_of_loops () <= 1) return 0; scev_initialize (); return 0; }
static unsigned int tree_ssa_loop_init (void) { loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS); rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa); /* We might discover new loops, e.g. when turning irreducible regions into reducible. */ scev_initialize (); if (number_of_loops (cfun) <= 1) return 0; return 0; }
static unsigned int tree_complete_unroll_inner (void) { unsigned ret = 0; loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS); if (number_of_loops () > 1) { scev_initialize (); ret = tree_unroll_loops_completely (optimize >= 3, false); free_numbers_of_iterations_estimates (); scev_finalize (); } loop_optimizer_finalize (); return ret; }
unsigned vectorize_loops (void) { unsigned int i; unsigned int num_vectorized_loops = 0; unsigned int vect_loops_num; loop_iterator li; struct loop *loop; vect_loops_num = number_of_loops (cfun); /* Bail out if there are no loops. */ if (vect_loops_num <= 1) return 0; init_stmt_vec_info_vec (); /* ----------- Analyze loops. ----------- */ /* If some loop was duplicated, it gets bigger number than all previously defined loops. This fact allows us to run only over initial loops skipping newly generated ones. */ FOR_EACH_LOOP (li, loop, 0) if (optimize_loop_nest_for_speed_p (loop)) { loop_vec_info loop_vinfo; vect_location = find_loop_location (loop); if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOC && dump_enabled_p ()) dump_printf (MSG_NOTE, "\nAnalyzing loop at %s:%d\n", LOC_FILE (vect_location), LOC_LINE (vect_location)); loop_vinfo = vect_analyze_loop (loop); loop->aux = loop_vinfo; if (!loop_vinfo || !LOOP_VINFO_VECTORIZABLE_P (loop_vinfo)) continue; if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOC && dump_enabled_p ()) dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location, "Vectorized loop\n"); vect_transform_loop (loop_vinfo); num_vectorized_loops++; } vect_location = UNKNOWN_LOC; statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops); if (dump_enabled_p () || (num_vectorized_loops > 0 && dump_enabled_p ())) dump_printf_loc (MSG_NOTE, vect_location, "vectorized %u loops in function.\n", num_vectorized_loops); /* ----------- Finalize. ----------- */ for (i = 1; i < vect_loops_num; i++) { loop_vec_info loop_vinfo; loop = get_loop (cfun, i); if (!loop) continue; loop_vinfo = (loop_vec_info) loop->aux; destroy_loop_vec_info (loop_vinfo, true); loop->aux = NULL; } free_stmt_vec_info_vec (); if (num_vectorized_loops > 0) { /* If we vectorized any loop only virtual SSA form needs to be updated. ??? Also while we try hard to update loop-closed SSA form we fail to properly do this in some corner-cases (see PR56286). */ rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa_only_virtuals); return TODO_cleanup_cfg; } return 0; }
unsigned vectorize_loops (void) { unsigned int i; unsigned int num_vectorized_loops = 0; unsigned int vect_loops_num; loop_iterator li; struct loop *loop; vect_loops_num = number_of_loops (); /* Bail out if there are no loops. */ if (vect_loops_num <= 1) return 0; /* Fix the verbosity level if not defined explicitly by the user. */ vect_set_dump_settings (false); init_stmt_vec_info_vec (); /* ----------- Analyze loops. ----------- */ /* If some loop was duplicated, it gets bigger number than all previously defined loops. This fact allows us to run only over initial loops skipping newly generated ones. */ FOR_EACH_LOOP (li, loop, 0) if (optimize_loop_nest_for_speed_p (loop)) { loop_vec_info loop_vinfo; vect_location = find_loop_location (loop); if (vect_location != UNKNOWN_LOC && vect_verbosity_level > REPORT_NONE) fprintf (vect_dump, "\nAnalyzing loop at %s:%d\n", LOC_FILE (vect_location), LOC_LINE (vect_location)); loop_vinfo = vect_analyze_loop (loop); loop->aux = loop_vinfo; if (!loop_vinfo || !LOOP_VINFO_VECTORIZABLE_P (loop_vinfo)) continue; if (vect_location != UNKNOWN_LOC && vect_verbosity_level > REPORT_NONE) fprintf (vect_dump, "\n\nVectorizing loop at %s:%d\n", LOC_FILE (vect_location), LOC_LINE (vect_location)); vect_transform_loop (loop_vinfo); num_vectorized_loops++; } vect_location = UNKNOWN_LOC; statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops); if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS) || (num_vectorized_loops > 0 && vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))) fprintf (vect_dump, "vectorized %u loops in function.\n", num_vectorized_loops); /* ----------- Finalize. ----------- */ mark_sym_for_renaming (gimple_vop (cfun)); for (i = 1; i < vect_loops_num; i++) { loop_vec_info loop_vinfo; loop = get_loop (i); if (!loop) continue; loop_vinfo = (loop_vec_info) loop->aux; destroy_loop_vec_info (loop_vinfo, true); loop->aux = NULL; } free_stmt_vec_info_vec (); return num_vectorized_loops > 0 ? TODO_cleanup_cfg : 0; }
unsigned vectorize_loops (void) { unsigned int i; unsigned int num_vectorized_loops = 0; unsigned int vect_loops_num; loop_iterator li; struct loop *loop; vect_loops_num = number_of_loops (); /* Bail out if there are no loops. */ if (vect_loops_num <= 1) return 0; init_stmt_vec_info_vec (); /* ----------- Analyze loops. ----------- */ /* If some loop was duplicated, it gets bigger number than all previously defined loops. This fact allows us to run only over initial loops skipping newly generated ones. */ FOR_EACH_LOOP (li, loop, 0) if (optimize_loop_nest_for_speed_p (loop)) { loop_vec_info loop_vinfo; vect_location = find_loop_location (loop); if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOC && dump_enabled_p ()) dump_printf (MSG_ALL, "\nAnalyzing loop at %s:%d\n", LOC_FILE (vect_location), LOC_LINE (vect_location)); loop_vinfo = vect_analyze_loop (loop); loop->aux = loop_vinfo; if (!loop_vinfo || !LOOP_VINFO_VECTORIZABLE_P (loop_vinfo)) continue; if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOC && dump_enabled_p ()) dump_printf (MSG_ALL, "\n\nVectorizing loop at %s:%d\n", LOC_FILE (vect_location), LOC_LINE (vect_location)); vect_transform_loop (loop_vinfo); num_vectorized_loops++; } vect_location = UNKNOWN_LOC; statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops); if (dump_enabled_p () || (num_vectorized_loops > 0 && dump_enabled_p ())) dump_printf_loc (MSG_ALL, vect_location, "vectorized %u loops in function.\n", num_vectorized_loops); /* ----------- Finalize. ----------- */ for (i = 1; i < vect_loops_num; i++) { loop_vec_info loop_vinfo; loop = get_loop (i); if (!loop) continue; loop_vinfo = (loop_vec_info) loop->aux; destroy_loop_vec_info (loop_vinfo, true); loop->aux = NULL; } free_stmt_vec_info_vec (); return num_vectorized_loops > 0 ? TODO_cleanup_cfg : 0; }
unsigned fix_loop_structure (bitmap changed_bbs) { basic_block bb; int record_exits = 0; struct loop *loop; unsigned old_nloops, i; timevar_push (TV_LOOP_INIT); if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "fix_loop_structure: fixing up loops for function\n"); /* We need exact and fast dominance info to be available. */ gcc_assert (dom_info_state (CDI_DOMINATORS) == DOM_OK); if (loops_state_satisfies_p (LOOPS_HAVE_RECORDED_EXITS)) { release_recorded_exits (cfun); record_exits = LOOPS_HAVE_RECORDED_EXITS; } /* Remember the depth of the blocks in the loop hierarchy, so that we can recognize blocks whose loop nesting relationship has changed. */ if (changed_bbs) FOR_EACH_BB_FN (bb, cfun) bb->aux = (void *) (size_t) loop_depth (bb->loop_father); /* Remove the dead loops from structures. We start from the innermost loops, so that when we remove the loops, we know that the loops inside are preserved, and do not waste time relinking loops that will be removed later. */ FOR_EACH_LOOP (loop, LI_FROM_INNERMOST) { /* Detect the case that the loop is no longer present even though it wasn't marked for removal. ??? If we do that we can get away with not marking loops for removal at all. And possibly avoid some spurious removals. */ if (loop->header && bb_loop_header_p (loop->header)) continue; if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "fix_loop_structure: removing loop %d\n", loop->num); while (loop->inner) { struct loop *ploop = loop->inner; flow_loop_tree_node_remove (ploop); flow_loop_tree_node_add (loop_outer (loop), ploop); } /* Remove the loop. */ if (loop->header) loop->former_header = loop->header; else gcc_assert (loop->former_header != NULL); loop->header = NULL; flow_loop_tree_node_remove (loop); } /* Remember the number of loops so we can return how many new loops flow_loops_find discovered. */ old_nloops = number_of_loops (cfun); /* Re-compute loop structure in-place. */ flow_loops_find (current_loops); /* Mark the blocks whose loop has changed. */ if (changed_bbs) { FOR_EACH_BB_FN (bb, cfun) { if ((void *) (size_t) loop_depth (bb->loop_father) != bb->aux) bitmap_set_bit (changed_bbs, bb->index); bb->aux = NULL; } } /* Finally free deleted loops. */ bool any_deleted = false; FOR_EACH_VEC_ELT (*get_loops (cfun), i, loop) if (loop && loop->header == NULL) { if (dump_file && ((unsigned) loop->former_header->index < basic_block_info_for_fn (cfun)->length ())) { basic_block former_header = BASIC_BLOCK_FOR_FN (cfun, loop->former_header->index); /* If the old header still exists we want to check if the original loop is re-discovered or the old header is now part of a newly discovered loop. In both cases we should have avoided removing the loop. */ if (former_header == loop->former_header) { if (former_header->loop_father->header == former_header) fprintf (dump_file, "fix_loop_structure: rediscovered " "removed loop %d as loop %d with old header %d\n", loop->num, former_header->loop_father->num, former_header->index); else if ((unsigned) former_header->loop_father->num >= old_nloops) fprintf (dump_file, "fix_loop_structure: header %d of " "removed loop %d is part of the newly " "discovered loop %d with header %d\n", former_header->index, loop->num, former_header->loop_father->num, former_header->loop_father->header->index); } } (*get_loops (cfun))[i] = NULL; flow_loop_free (loop); any_deleted = true; } /* If we deleted loops then the cached scalar evolutions refering to those loops become invalid. */ if (any_deleted && scev_initialized_p ()) scev_reset_htab (); loops_state_clear (LOOPS_NEED_FIXUP); /* Apply flags to loops. */ apply_loop_flags (current_loops->state | record_exits); checking_verify_loop_structure (); timevar_pop (TV_LOOP_INIT); return number_of_loops (cfun) - old_nloops; }