src/hotspot/share/opto/compile.cpp
changeset 55307 ed12027517c0
parent 55110 17f85a8780d5
child 55583 82fae48799e4
child 57582 a79a819a8218
equal deleted inserted replaced
55306:ea43db53de91 55307:ed12027517c0
  2209     BREAKPOINT;
  2209     BREAKPOINT;
  2210   }
  2210   }
  2211 
  2211 
  2212 #endif
  2212 #endif
  2213 
  2213 
       
  2214   BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
  2214 #ifdef ASSERT
  2215 #ifdef ASSERT
  2215   BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
       
  2216   bs->verify_gc_barriers(this, BarrierSetC2::BeforeOptimize);
  2216   bs->verify_gc_barriers(this, BarrierSetC2::BeforeOptimize);
  2217 #endif
  2217 #endif
  2218 
  2218 
  2219   ResourceMark rm;
  2219   ResourceMark rm;
  2220 
  2220 
  2369   {
  2369   {
  2370     TracePhase tp("iterGVN2", &timers[_t_iterGVN2]);
  2370     TracePhase tp("iterGVN2", &timers[_t_iterGVN2]);
  2371     igvn = ccp;
  2371     igvn = ccp;
  2372     igvn.optimize();
  2372     igvn.optimize();
  2373   }
  2373   }
  2374 
       
  2375   print_method(PHASE_ITER_GVN2, 2);
  2374   print_method(PHASE_ITER_GVN2, 2);
  2376 
  2375 
  2377   if (failing())  return;
  2376   if (failing())  return;
  2378 
  2377 
  2379   // Loop transforms on the ideal graph.  Range Check Elimination,
  2378   // Loop transforms on the ideal graph.  Range Check Elimination,
  2380   // peeling, unrolling, etc.
  2379   // peeling, unrolling, etc.
  2381   if (!optimize_loops(igvn, LoopOptsDefault)) {
  2380   if (!optimize_loops(igvn, LoopOptsDefault)) {
  2382     return;
  2381     return;
  2383   }
  2382   }
  2384 
       
  2385 #if INCLUDE_ZGC
       
  2386   if (UseZGC) {
       
  2387     ZBarrierSetC2::find_dominating_barriers(igvn);
       
  2388   }
       
  2389 #endif
       
  2390 
  2383 
  2391   if (failing())  return;
  2384   if (failing())  return;
  2392 
  2385 
  2393   // Ensure that major progress is now clear
  2386   // Ensure that major progress is now clear
  2394   C->clear_major_progress();
  2387   C->clear_major_progress();
  2405     C->remove_range_check_casts(igvn);
  2398     C->remove_range_check_casts(igvn);
  2406     igvn.optimize();
  2399     igvn.optimize();
  2407   }
  2400   }
  2408 
  2401 
  2409 #ifdef ASSERT
  2402 #ifdef ASSERT
  2410   BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
  2403   bs->verify_gc_barriers(this, BarrierSetC2::BeforeLateInsertion);
  2411   bs->verify_gc_barriers(this, BarrierSetC2::BeforeExpand);
  2404 #endif
       
  2405 
       
  2406   bs->barrier_insertion_phase(C, igvn);
       
  2407   if (failing())  return;
       
  2408 
       
  2409 #ifdef ASSERT
       
  2410   bs->verify_gc_barriers(this, BarrierSetC2::BeforeMacroExpand);
  2412 #endif
  2411 #endif
  2413 
  2412 
  2414   {
  2413   {
  2415     TracePhase tp("macroExpand", &timers[_t_macroExpand]);
  2414     TracePhase tp("macroExpand", &timers[_t_macroExpand]);
  2416     PhaseMacroExpand  mex(igvn);
  2415     PhaseMacroExpand  mex(igvn);
  2417     print_method(PHASE_BEFORE_MACRO_EXPANSION, 2);
       
  2418     if (mex.expand_macro_nodes()) {
  2416     if (mex.expand_macro_nodes()) {
  2419       assert(failing(), "must bail out w/ explicit message");
  2417       assert(failing(), "must bail out w/ explicit message");
  2420       return;
  2418       return;
  2421     }
  2419     }
       
  2420     print_method(PHASE_MACRO_EXPANSION, 2);
  2422   }
  2421   }
  2423 
  2422 
  2424   {
  2423   {
  2425     TracePhase tp("barrierExpand", &timers[_t_barrierExpand]);
  2424     TracePhase tp("barrierExpand", &timers[_t_barrierExpand]);
  2426     print_method(PHASE_BEFORE_BARRIER_EXPAND, 2);
       
  2427     BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
       
  2428     if (bs->expand_barriers(this, igvn)) {
  2425     if (bs->expand_barriers(this, igvn)) {
  2429       assert(failing(), "must bail out w/ explicit message");
  2426       assert(failing(), "must bail out w/ explicit message");
  2430       return;
  2427       return;
  2431     }
  2428     }
       
  2429     print_method(PHASE_BARRIER_EXPANSION, 2);
  2432   }
  2430   }
  2433 
  2431 
  2434   if (opaque4_count() > 0) {
  2432   if (opaque4_count() > 0) {
  2435     C->remove_opaque4_nodes(igvn);
  2433     C->remove_opaque4_nodes(igvn);
  2436     igvn.optimize();
  2434     igvn.optimize();
  2822   }
  2820   }
  2823   if (n->is_MemBar()) {
  2821   if (n->is_MemBar()) {
  2824     MemBarNode* mb = n->as_MemBar();
  2822     MemBarNode* mb = n->as_MemBar();
  2825     if (mb->trailing_store() || mb->trailing_load_store()) {
  2823     if (mb->trailing_store() || mb->trailing_load_store()) {
  2826       assert(mb->leading_membar()->trailing_membar() == mb, "bad membar pair");
  2824       assert(mb->leading_membar()->trailing_membar() == mb, "bad membar pair");
  2827       Node* mem = mb->in(MemBarNode::Precedent);
  2825       Node* mem = BarrierSet::barrier_set()->barrier_set_c2()->step_over_gc_barrier(mb->in(MemBarNode::Precedent));
  2828       assert((mb->trailing_store() && mem->is_Store() && mem->as_Store()->is_release()) ||
  2826       assert((mb->trailing_store() && mem->is_Store() && mem->as_Store()->is_release()) ||
  2829              (mb->trailing_load_store() && mem->is_LoadStore()), "missing mem op");
  2827              (mb->trailing_load_store() && mem->is_LoadStore()), "missing mem op");
  2830     } else if (mb->leading()) {
  2828     } else if (mb->leading()) {
  2831       assert(mb->trailing_membar()->leading_membar() == mb, "bad membar pair");
  2829       assert(mb->trailing_membar()->leading_membar() == mb, "bad membar pair");
  2832     }
  2830     }