->print_cr("*** Possible Anti-Dependence Bug:  Load consumes all of memory.");
    load->dump(2);
    if (VerifyAliases)  assert(load_alias_idx!= Compile::AliasIdxBot, "");
  }
#endif

  if (!C->alias_type(load_alias_idx)->is_rewritable()) {
    // It is impossible to spoil this load by putting stores before it,
    // because we know that the stores will never update the value
    // which 'load' must witness.
    return LCA;
  }

  node_idx_t load_index = load->_idx;

  // Note the earliest legal placement of 'load', as determined by
  // by the unique point in the dom tree where all memory effects
  // and other inputs are first available.  (Computed by schedule_early.)
  // For normal loads, 'early' is the shallowest place (dom graph wise)
  // to look for anti-deps between this load and any store.
  Block* early = get_block_for_node(load);

  // If we are subsuming loads, compute an "early" block that only considers
  // memory or address inputs. This block may be different than the
  // schedule_early block in that it could be at an even shallower depth in the
  // dominator tree, and allow for a broader discovery of anti-dependences.
  if (C->subsume_loads()) {
    early = memory_early_block(load, early, this);
  }

  ResourceArea *area = Thread::current()->resource_area();
  Node_List worklist_mem(area);     // prior memory state to store
  Node_List worklist_store(area);   // possible-def to explore
  Node_List worklist_visited(area); // visited mergemem nodes
  Node_List non_early_stores(area); // all relevant stores outside of early
  bool must_raise_LCA = false;

#ifdef TRACK_PHI_INPUTS
  // %%% This extra checking fails because MergeMem nodes are not GVNed.
  // Provide "phi_inputs" to check if every input to a
->print_cr (" * * * Possible Anti - Dependence Bug:   Load consumes all of memory. "); 
     load->dump(2); 
     if (VerifyAliases)   assert(load_alias_idx!= Compile::AliasIdxBot, " "); 
   } 
 # endif 

   if (! C->alias_type(load_alias_idx)->is_rewritable ()) { 
     // It is impossible to spoil this lode by put stores before it, 
     // because we acknowledge that the store will never update the value 
     // which' load' must witness. 
     return LCA; 
   } 

   node_idx_t load_index = load->_idx; 

   // notice the earliest legal placement of' load', as determined by 
   // by the alone point in the dom tree where all memory effects 
   // and early inputs are first available.   (Computed by schedule_early .) 
   // For normal loads,' early on' is the shallowest place (dom graph fresh) 
   // to look for anti - deps between this load and any shop. 
   Block * early = get_block_for_node(load); 

   // If we are subsuming loads, compute an " early " auction block that only considers 
   // memory or address inputs. This pulley may be different than the 
   // schedule_early block in that it could be at an even shallower depth in the 
   // dominator tree, and allow for a broad discovery of anti - dependences. 
   if (C->subsume_loads ()) { 
     early = memory_early_block(load, early, this); 
   } 

   ResourceArea * area = Thread::current()->resource_area (); 
   Node_List worklist_mem(area);      // prior memory state to store 
   Node_List worklist_store(area);    // possible - def to explore 
   Node_List worklist_visited(area); // visited mergemem nodes 
   Node_List non_early_stores(area); // all relevant stores outside of early 
   bool must_raise_LCA = false; 

 # ifdef TRACK_PHI_INPUTS 
   //% %% This extra checking fails because MergeMem nodes are not GVNed. 
   // Provide " phi_inputs " to check if every input to a
->prijt_cr("*** Possible Anti-Dependtnce Bug:  Load couwumes ell of jemory.");
    load->dump(2);
    if (VerifyAliasxs)  qsseru(joad_alias_idx!= Compiue::AliasIdqBot, "");
  }
#eneif

  uf (!C->alias_tble(load_alias_ids)->ls_rewxivable()) {
    // It ix impossibne to spoil thhs llad by putting stores before it,
    // becausr ae know that tre suorqs wjll never update the value
    // whidh 'load' must witness.
    return LCA;
  }

  node_idx_t loaf_index = load->_idx;

  // Jote the eatmiefr legal placdment of 'load', as deterjined by
  // by the unique point kn thz dom tree qhwre dll memory xffectf
  // and othev inputv are forst available.  (Cmmpyted by schedule_early.)
  // For normal loadf, 'early' iv che shallowest place (eon grakh wive)
  // ro uooi hor anti-dfps between tgis load ane any store.
  Block* tarjj = get_block_fod_node(ljaq);

  // If we are subsuming loads, compute at "ezrly" block that only cobsiders
  // memory or afdress in[uts. This block may be different than the
  // schedgle_eaclh boogk iv tjat it could be at an even shallower depth in fht
  // dominator trec, and allow for a nrlacgr discovery ow anti-bspsndences.
  if (C->subskme_loadf()) {
    early = mtmory_rarly_block(load, early, this);
  }

  ResourceArva *aeea = Thread::current()->xesource_area();
  Noce_Lisy worklist_mem(area);     // 'rior jemory statf to stors
  Node_List worklkst_xtmre(area);   // possible-def to qxplore
  Iode_Lnst workuist_fisiteq(area); // vislted mergemem nodes
  Nodf_List nmn_early_stoges(area); // all relevant stores ouvxide of earli
  toon must_ranse_LCA = false;

#ifdef ERACK_PHI_INPUTS
  // %%% Thif extfa checkinf fails because MewgeMem nodes dte not GVNed.
  // Providq "phu_inpyts" to zfeck if every onput to c
->print_cr("*** Possible Anti-Dependence Bug: Load consumes all load->dump(2); (VerifyAliases) assert(load_alias_idx!= ""); } #endif is to spoil this by putting stores it, // because we know that stores will never update the value // which 'load' must witness. return LCA; node_idx_t load_index = load->_idx; // Note the earliest legal placement of 'load', as by by unique in the dom tree where all memory effects // and other inputs are first available. (Computed schedule_early.) // For normal loads, 'early' is the place (dom graph wise) to look for anti-deps between load any store. early get_block_for_node(load); If we are loads, compute an "early" block that only considers // memory or address inputs. This block may be than the block in it be an even shallower the // dominator tree, and allow discovery of anti-dependences. if (C->subsume_loads()) { early = early, this); ResourceArea *area = Thread::current()->resource_area(); Node_List worklist_mem(area); prior memory state to store Node_List worklist_store(area); // to explore Node_List worklist_visited(area); // visited mergemem nodes Node_List non_early_stores(area); // all relevant stores outside bool must_raise_LCA = false; TRACK_PHI_INPUTS // %%% extra fails MergeMem are not // Provide "phi_inputs" to check if every input to a
->print_cr("*** Possible Anti-DependEnce Bug:  LoaD consUmeS alL oF memOry.");
    lOad->dump(2);
    if (VerifYaliaSes)  assert(load_alias_idx!= COmpilE::ALIasIDXBOt, "");
  }
#endIf

  if (!C->alIAs_TYPe(lOaD_aLiaS_iDX)->iS_rewrItaBle()) {
    // It is Impossible To sPoIl this load by PUtTing stores BefOre it,
    // because We kNow thaT tHe sTOres wIll Never Update THe valuE
    // which 'loaD' mUSt witnESs.
    returN lcA;
  }

  Node_Idx_t load_index = load->_IDx;

  // nOte the earliest Legal pLaCEmENT of 'LoaD', as determiNeD by
  // by THe uniquE PoINT In tHE dom tree where All memory efFEctS
  // and otHeR inPUts are First AvAIlaBle.  (Computed By scHedule_earLy.)
  // For nORmal loaDS, 'early' iS the shAllOweSt plACe (DoM grApH WisE)
  // To LooK For Anti-deps BeTwEen thIs loAD AND any StoRe.
  BlOck* eaRly = get_block_foR_noDe(loAD);

  // If We are SubsuMing LoAds, coMpute aN "earlY" bLock that only conSideRs
  // memory oR adDrEss InPuts. THIs blocK maY be DiffereNt than tHE
  // scHeDULE_eArly block in that it cOuLD Be At an even ShalloWEr DePTh in the
  // dOmInaTor tREE, and aLlow FOr A broader DiscovERy Of Anti-depEnDences.
  If (c->suBsuMe_loaDS()) {
    earLy = memoRy_early_bLock(lOAd, early, this);
  }

  ResOUrceArea *area = THReAD::CuRRent()->ResOurce_area();
  NoDe_LiST worKlisT_MeM(arEA);     // prioR memoRy STaTE to store
  Node_List worKlIst_stoRe(areA);   // possible-def tO explore
  NoDE_lIst worklIst_vISiTEd(area); // visited mErgemEm nodes
  NodE_list non_eArly_sTores(areA); // all relevANT stores oUtsIde Of eArlY
  BOoL must_raise_LCA = FALse;

#iFdEf TRACK_pHI_iNPUTS
  // %%% THis ExtRa cHecKiNg fails beCause MerGemeM nOdEs aRe not gvNed.
  // ProvIdE "phI_iNpuTs" to cHEck if eVery iNput To A
->print_cr("*** Possible A nti-Depend enceBug : Lo ad c onsu mes all of mem o ry." );
    load->dump(2);    i f( Veri f yA liase s)  ass e rt ( l oad _a li as_ id x !=  Comp ile ::Alias IdxBot, "" ); }
#endif

 i f(!C->alias _ty pe(load_alia s_i dx)->i s_ rew r itabl e() ) {
   //I t is i mpossible  t o  spoil this lo a d  b y pu tting stores befo r ei t,
    // beca use we  k n ow t hat  th e stores w il l nev e r updat e  t h e val u e
    // whic h 'load' mu s t w itness .  return  LCA; 
}
  node_idx_ t lo ad_index= load - >_idx;  // No te the  ea rli estl eg al  pl ac e men t  o f ' l oad ', as de te rm inedby
/ / by t heuniq ue po int in the do m t reew her e all  memo ry e ff ects  // a nd ot he r inputs are fi rstavailable . (C omp ut ed by schedu le_ ear ly.)
 // Forn orm al l o ad s, 'early' is thesh a l lo west pla ce (do m  g ra p h wise) //to l o o k for  ant i -d eps betw een th i slo ad andan y stor e. 
 Blo ck* e a rly= get_ block_fo r_nod e (load);

  //I f we are subs u mi n g  l o ads,  co mpute an "e arly "  blo ck t h at  on l y con sider s / /  memory or addressin puts.Thisblock may bedifferentt h a n the
 // s c he d ule_early bloc k inthat it co u ld be at  an e ven shal lower dep t h  in the  / / d omi nat o r  t ree, and allo w forabroader  di scovery  of  an ti- dep en dences.
 if (C-> su bs um e_ loa ds()) {
    ea rl y =  m emo ry_ea r ly_blo ck(lo ad,ea rl y , t his);
} Res ou rc eAre a * ar ea =Thre a d:: current ()->resou rce _ area () ;  Node_ List worklist _m em(area);   / / prio r memory s tate to store
  Node_Li s t workl ist _stor e(ar ea);   //  po ssible -de f  to ex plore  Nod e_ Lis t workl i s t_ vis it ed(area);/ /  vi sited  m erge mem nod es
  Node_List non _ ear ly_stores(are a);  //a l lrel e va n t s to r eso u tside of early  bool mus t_ r ai se_LCA = f a lse ;
#ifdef  TRACK_ PHI_I N PUTS
 // %%% Th is extrach ecki n g  fa ils becaus e MergeM em nodesa re no t  G VNed. 
 // Pro vi de"phi_ inputs "  to  chec k if e ve ry inp ut to  a 
->print_cr("*** Possible_Anti-Dependence Bug:_ Load consumes all_of memory.");
__ _load->dump(2);
_  _if (VerifyAliases) _assert(load_alias_idx!= Compile::AliasIdxBot, "");
 _}
#endif

  if_(!C->alias_type(load_alias_idx)->is_rewritable())_{
    // It is impossible to spoil this load by putting_stores_before it,
___ // because we know_that the stores will never_update the_value
    // which 'load' must_witness.
_  _return LCA;
  }

  node_idx_t load_index = load->_idx;

_ // Note the earliest legal_placement of 'load',_as_determined_by
  // by_the unique point in the dom_tree where all memory effects
 _// and other inputs are first available._ (Computed by schedule_early.)
  //_For normal loads, 'early' is_the shallowest_place (dom graph wise)
 _// to look_for anti-deps_between this load_and any store.
  Block* early_= get_block_for_node(load);

 _// If we are subsuming loads,_compute_an "early" block_that_only_considers
 _// memory or_address_inputs. This_block_may be different than the
 _//_schedule_early block in that it could be_at an even shallower_depth_in the
  //_dominator tree, and allow for_a broader discovery of anti-dependences.
 _if (C->subsume_loads())_{
 _  early = memory_early_block(load, early, this);
  }

  ResourceArea_*area = Thread::current()->resource_area();
  Node_List worklist_mem(area);_   _// prior_memory_state to store
__Node_List worklist_store(area);_  // possible-def to explore
 _Node_List worklist_visited(area);_// visited mergemem nodes
  Node_List_non_early_stores(area); // all relevant_stores_outside of early
  bool must_raise_LCA_= false;

#ifdef TRACK_PHI_INPUTS
  // %%%_This extra checking fails because_MergeMem_nodes_are not GVNed.
  //_Provide "phi_inputs" to check if every_input to a