8209686: cleanup arguments to PhaseIdealLoop() constructor

Reviewed-by: thartmann, kvn, pliden
This commit is contained in:
Roland Westrelin 2018-08-22 10:36:39 +02:00
parent 2ffded2a4b
commit 40af989884
5 changed files with 46 additions and 27 deletions

@ -128,7 +128,7 @@ void ZBarrierSetC2::find_dominating_barriers(PhaseIterGVN& igvn) {
ZBarrierSetC2State* s = bs->state();
if (s->load_barrier_count() >= 2) {
Compile::TracePhase tp("idealLoop", &C->timers[Phase::_t_idealLoop]);
PhaseIdealLoop ideal_loop(igvn, true, false, true);
PhaseIdealLoop ideal_loop(igvn, LoopOptsLastRound);
if (C->major_progress()) C->print_method(PHASE_PHASEIDEALLOOP_ITERATIONS, 2);
}
}

@ -2113,7 +2113,7 @@ void Compile::inline_incrementally(PhaseIterGVN& igvn) {
// PhaseIdealLoop is expensive so we only try it once we are
// out of live nodes and we only try it again if the previous
// helped got the number of nodes down significantly
PhaseIdealLoop ideal_loop( igvn, false, true );
PhaseIdealLoop ideal_loop(igvn, LoopOptsNone);
if (failing()) return;
low_live_nodes = live_nodes();
_major_progress = true;
@ -2164,6 +2164,21 @@ void Compile::inline_incrementally(PhaseIterGVN& igvn) {
}
bool Compile::optimize_loops(int& loop_opts_cnt, PhaseIterGVN& igvn, LoopOptsMode mode) {
if(loop_opts_cnt > 0) {
debug_only( int cnt = 0; );
while(major_progress() && (loop_opts_cnt > 0)) {
TracePhase tp("idealLoop", &timers[_t_idealLoop]);
assert( cnt++ < 40, "infinite cycle in loop optimization" );
PhaseIdealLoop ideal_loop(igvn, mode);
loop_opts_cnt--;
if (failing()) return false;
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP_ITERATIONS, 2);
}
}
return true;
}
//------------------------------Optimize---------------------------------------
// Given a graph, optimize it.
void Compile::Optimize() {
@ -2202,10 +2217,10 @@ void Compile::Optimize() {
igvn.optimize();
}
print_method(PHASE_ITER_GVN1, 2);
if (failing()) return;
print_method(PHASE_ITER_GVN1, 2);
inline_incrementally(igvn);
print_method(PHASE_INCREMENTAL_INLINE, 2);
@ -2254,7 +2269,7 @@ void Compile::Optimize() {
if (has_loops()) {
// Cleanup graph (remove dead nodes).
TracePhase tp("idealLoop", &timers[_t_idealLoop]);
PhaseIdealLoop ideal_loop( igvn, false, true );
PhaseIdealLoop ideal_loop(igvn, LoopOptsNone);
if (major_progress()) print_method(PHASE_PHASEIDEAL_BEFORE_EA, 2);
if (failing()) return;
}
@ -2289,7 +2304,7 @@ void Compile::Optimize() {
if((loop_opts_cnt > 0) && (has_loops() || has_split_ifs())) {
{
TracePhase tp("idealLoop", &timers[_t_idealLoop]);
PhaseIdealLoop ideal_loop( igvn, true );
PhaseIdealLoop ideal_loop(igvn, LoopOptsDefault);
loop_opts_cnt--;
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP1, 2);
if (failing()) return;
@ -2297,7 +2312,7 @@ void Compile::Optimize() {
// Loop opts pass if partial peeling occurred in previous pass
if(PartialPeelLoop && major_progress() && (loop_opts_cnt > 0)) {
TracePhase tp("idealLoop", &timers[_t_idealLoop]);
PhaseIdealLoop ideal_loop( igvn, false );
PhaseIdealLoop ideal_loop(igvn, LoopOptsSkipSplitIf);
loop_opts_cnt--;
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP2, 2);
if (failing()) return;
@ -2305,7 +2320,7 @@ void Compile::Optimize() {
// Loop opts pass for loop-unrolling before CCP
if(major_progress() && (loop_opts_cnt > 0)) {
TracePhase tp("idealLoop", &timers[_t_idealLoop]);
PhaseIdealLoop ideal_loop( igvn, false );
PhaseIdealLoop ideal_loop(igvn, LoopOptsSkipSplitIf);
loop_opts_cnt--;
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP3, 2);
}
@ -2341,16 +2356,8 @@ void Compile::Optimize() {
// Loop transforms on the ideal graph. Range Check Elimination,
// peeling, unrolling, etc.
if(loop_opts_cnt > 0) {
debug_only( int cnt = 0; );
while(major_progress() && (loop_opts_cnt > 0)) {
TracePhase tp("idealLoop", &timers[_t_idealLoop]);
assert( cnt++ < 40, "infinite cycle in loop optimization" );
PhaseIdealLoop ideal_loop( igvn, true);
loop_opts_cnt--;
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP_ITERATIONS, 2);
if (failing()) return;
}
if (!optimize_loops(loop_opts_cnt, igvn, LoopOptsDefault)) {
return;
}
#if INCLUDE_ZGC

@ -90,6 +90,14 @@ class WarmCallInfo;
class Node_Stack;
struct Final_Reshape_Counts;
enum LoopOptsMode {
LoopOptsDefault,
LoopOptsNone,
LoopOptsSkipSplitIf,
LoopOptsVerify,
LoopOptsLastRound
};
typedef unsigned int node_idx_t;
class NodeCloneInfo {
private:
@ -1079,6 +1087,7 @@ class Compile : public Phase {
void inline_incrementally(PhaseIterGVN& igvn);
void inline_string_calls(bool parse_time);
void inline_boxing_calls(PhaseIterGVN& igvn);
bool optimize_loops(int& loop_opts_cnt, PhaseIterGVN& igvn, LoopOptsMode mode);
// Matching, CFG layout, allocation, code generation
PhaseCFG* cfg() { return _cfg; }

@ -2662,7 +2662,10 @@ bool PhaseIdealLoop::process_expensive_nodes() {
//----------------------------build_and_optimize-------------------------------
// Create a PhaseLoop. Build the ideal Loop tree. Map each Ideal Node to
// its corresponding LoopNode. If 'optimize' is true, do some loop cleanups.
void PhaseIdealLoop::build_and_optimize(bool do_split_ifs, bool skip_loop_opts, bool last_round) {
void PhaseIdealLoop::build_and_optimize(LoopOptsMode mode) {
bool do_split_ifs = (mode == LoopOptsDefault || mode == LoopOptsLastRound);
bool skip_loop_opts = (mode == LoopOptsNone);
ResourceMark rm;
int old_progress = C->major_progress();
@ -2904,9 +2907,9 @@ void PhaseIdealLoop::build_and_optimize(bool do_split_ifs, bool skip_loop_opts,
// that require basic-block info (like cloning through Phi's)
if( SplitIfBlocks && do_split_ifs ) {
visited.Clear();
split_if_with_blocks( visited, nstack, last_round );
split_if_with_blocks( visited, nstack, mode == LoopOptsLastRound );
NOT_PRODUCT( if( VerifyLoopOptimizations ) verify(); );
if (last_round) {
if (mode == LoopOptsLastRound) {
C->set_major_progress();
}
}

@ -922,11 +922,11 @@ public:
_verify_me(NULL),
_verify_only(true),
_dom_lca_tags(arena()) { // Thread::resource_area
build_and_optimize(false, false);
build_and_optimize(LoopOptsVerify);
}
// build the loop tree and perform any requested optimizations
void build_and_optimize(bool do_split_if, bool skip_loop_opts, bool last_round = false);
void build_and_optimize(LoopOptsMode mode);
// Dominators for the sea of nodes
void Dominators();
@ -936,23 +936,23 @@ public:
Node *dom_lca_internal( Node *n1, Node *n2 ) const;
// Compute the Ideal Node to Loop mapping
PhaseIdealLoop( PhaseIterGVN &igvn, bool do_split_ifs, bool skip_loop_opts = false, bool last_round = false) :
PhaseIdealLoop(PhaseIterGVN &igvn, LoopOptsMode mode) :
PhaseTransform(Ideal_Loop),
_igvn(igvn),
_verify_me(NULL),
_verify_only(false),
_dom_lca_tags(arena()) { // Thread::resource_area
build_and_optimize(do_split_ifs, skip_loop_opts, last_round);
build_and_optimize(mode);
}
// Verify that verify_me made the same decisions as a fresh run.
PhaseIdealLoop( PhaseIterGVN &igvn, const PhaseIdealLoop *verify_me) :
PhaseIdealLoop(PhaseIterGVN &igvn, const PhaseIdealLoop *verify_me) :
PhaseTransform(Ideal_Loop),
_igvn(igvn),
_verify_me(verify_me),
_verify_only(false),
_dom_lca_tags(arena()) { // Thread::resource_area
build_and_optimize(false, false);
build_and_optimize(LoopOptsVerify);
}
// Build and verify the loop tree without modifying the graph. This