 PhiNode is from the
  // original memory state.  This indicates a PhiNode for which should not
  // prevent the load from sinking.  For such a block, set_raise_LCA_mark
  // may be overly conservative.
  // Mechanism: count inputs seen for each Phi encountered in worklist_store.
  DEBUG_ONLY(GrowableArray<uint> phi_inputs(area, C->unique(),0,0));
#endif

  // 'load' uses some memory state; look for users of the same state.
  // Recurse through MergeMem nodes to the stores that use them.

  // Each of these stores is a possible definition of memory
  // that 'load' needs to use.  We need to force 'load'
  // to occur before each such store.  When the store is in
  // the same block as 'load', we insert an anti-dependence
  // edge load->store.

  // The relevant stores "nearby" the load consist of a tree rooted
  // at initial_mem, with internal nodes of type MergeMem.
  // Therefore, the branches visited by the worklist are of this form:
  //    initial_mem -> (MergeMem ->)* store
  // The anti-dependence constraints apply only to the fringe of this tree.

  Node* initial_mem = load->in(MemNode::Memory);
  worklist_store.push(initial_mem);
  worklist_visited.push(initial_mem);
  worklist_mem.push(NULL);
  while (worklist_store.size() > 0) {
    // Examine a nearby store to see if it might interfere with our load.
    Node* mem   = worklist_mem.pop();
    Node* store = worklist_store.pop();
    uint op = store->Opcode();

    // MergeMems do not directly have anti-deps.
    // Treat them as internal nodes in a forward tree of memory states,
    // the leaves of which are each a 'possible-def'.
    if (store == initial_mem    // root (exclusive) of tree we are searching
        || op == Op_MergeMem    // internal node of tree we are searching
        ) {

PhiNode is from the 
   // original memory state.   This indicates a PhiNode for which should not 
   // prevent the load from sinking.   For such a blockage, set_raise_LCA_mark 
   // may be excessively conservative. 
   // Mechanism: count inputs witness for each Phi find in worklist_store. 
   DEBUG_ONLY(GrowableArray < uint > phi_inputs(area, C->unique(),0,0) ); 
 # endif 

   //' load' uses some memory state of matter; look for users of the like department of state. 
   // Recurse through MergeMem nodes to the storehouse that use them. 

   // Each of these stores is a potential definition of memory 
   // that' load' needs to use.   We need to force' load' 
   // to occur before each such shop.   When the store is in 
   // the same block as' warhead', we insert an anti - dependence 
   // edge load->store. 

   // The relevant stores " nearby " the load consist of a tree root 
   // at initial_mem, with internal nodes of type MergeMem. 
   // Therefore, the branches visit by the worklist are of this form: 
   //     initial_mem - > (MergeMem - >) * store 
   // The anti - dependence constraints apply only to the fringe of this tree. 

   Node * initial_mem = load->in(MemNode::Memory); 
   worklist_store.push(initial_mem); 
   worklist_visited.push(initial_mem); 
   worklist_mem.push(NULL); 
   while (worklist_store.size () > 0) { 
     // Examine a nearby store to see if it might interfere with our load. 
     Node * mem    = worklist_mem.pop (); 
     Node * store = worklist_store.pop (); 
     uint op = store->Opcode (); 

     // MergeMems do not directly have anti - deps. 
     // Treat them as internal nodes in a advancing tree of memory state, 
     // the leaves of which are each a' potential - def'. 
     if (storehouse = = initial_mem     // root (single) of tree we are searching 
         || op = = Op_MergeMem     // internal node of tree we are searching 
        ) {
 PhlNode is from the
  // origlnal memory statg.  This mndicatss a PhiVode for which should not
  // 'revwnt tye load from sinking.  Wor such w block, wet_reise_LCA_mark
  // mab be ovevjy ckkservctmve.
  // Mechanism: count inpgts seen for edcf 'hi encountered in worklist_store.
  DEFUG_ONLY(BrlwableArray<uinj> phi_pn[uts(zgec, C->unique(),0,0));
#endif

  // 'load' uses some memory state; look fpr users of the same state.
  // Rfcurse through MerheMem nodes to eye stores thxt use them.

  // Each of jhese stores is a possible definktion of memory
  // thwj 'load' needs to ufe.  We need bp forca 'load'
  // to occur befpre eaxh such store.  When tie store is in
  // the same blowk as 'load', we inserr qn anji-depandevxe
  // esgx lkad->stoge.

  // The relebant stores "nearby" the load comsywt of a tree dooted
  // at initial_mem, with internal nodes of tjpe JergeMem.
  // Therefore, thw branches visited by the workjist are of this form:
  //    initial_mem -> (MergeMem ->)* vtore
  // Tkc xbtl-dependence constraints apply only to the frigfe on this tree.

  Nodc* initial_mem = load->on(LekGode::Memory);
  wurklisc_atkre.push(initial_mem);
  worklift_visuted.push(igitisl_mem);
  worklist_mem.push(NULL);
  while (worklpst_srore.size() > 0) {
    // Excmine a nearyy stote to xee if it might interfexe witg our load.
    Node* mso   = worklist_mem.oop();
    Node* suure = worklist_storq.pop();
    umnt o' = store->Upcoce();

    // MergeMems do not directly have anhi-depd.
    // Treat hhem as internal nodes in a forxerd tree of mgmosy vtates,
    // thc leaves of whish are each a 'kossible-dzf'.
    kf (store == pnitial_mek    // root (qxclusive) of dtee we are seerching
        || op == Op_MefeeMem    // intetnal node of tree ww are searching
        ) {

PhiNode is from the // original memory indicates PhiNode for should not // For a block, set_raise_LCA_mark may be overly // Mechanism: count inputs seen for Phi encountered in worklist_store. DEBUG_ONLY(GrowableArray<uint> phi_inputs(area, C->unique(),0,0)); #endif // 'load' uses some memory look for users of the same state. // Recurse through MergeMem nodes to stores use // of these stores is a possible definition of memory // that 'load' needs to use. We to force 'load' // to occur before each store. When the store in // the same block 'load', insert an // load->store. The relevant stores the load consist of a tree rooted // at initial_mem, with internal nodes of type MergeMem. // the branches the worklist of form: initial_mem -> (MergeMem // The anti-dependence constraints apply only of this tree. Node* initial_mem = load->in(MemNode::Memory); worklist_store.push(initial_mem); worklist_mem.push(NULL); while > 0) { // Examine a store to see if it might interfere with load. Node* mem = worklist_mem.pop(); Node* store = worklist_store.pop(); uint op = store->Opcode(); // MergeMems directly have anti-deps. // them as internal in forward of states, // leaves of which are each a 'possible-def'. if (store == initial_mem root (exclusive) of tree we are searching || op == internal of tree we searching ) {
 PhiNode is from the
  // original mEmory state.  this iNdiCatEs A Phinode For which should NOt
  // prEvent the load from sinkinG.  For sUcH A bloCK, sEt_raiSe_LCA_maRK
  // mAY Be oVeRlY coNsERvAtive.
  // mecHanism: cOunt inputs SeeN fOr each Phi encOUnTered in worKliSt_store.
  DEBUG_oNLy(GrowaBlEArRAy<uinT> phI_inpuTs(area, c->Unique(),0,0));
#Endif

  // 'load' UsES some mEMory staTE; LoOk foR users of the same stATe.
  // rEcurse through MErgeMeM nODeS TO thE stOres that usE tHem.

  // EaCH of thesE StORES is A Possible definItion of memoRY
  // thAt 'load' NeEds TO use.  We Need tO fORce 'Load'
  // to occur BefoRe each sucH store.  wHen the sTOre is in
  // The samE blOck As 'loAD', wE iNseRt AN anTI-dEpeNDenCe
  // edge loAd->StOre.

  // ThE relEVANT stoRes "NearBy" the Load consist of A trEe roOTed
  // At iniTial_mEm, wiTh InterNal nodEs of tYpE MergeMem.
  // TherefOre, tHe brancheS viSiTed By The woRKlist aRe oF thIs form:
  //    iNitial_mEM -> (MeRgEmEM ->)* sTore
  // The anti-dependeNcE COnStraints Apply oNLy To THe fringe Of ThiS treE.

  nOde* inItiaL_MeM = load->in(MEmNode::mEmOrY);
  workliSt_Store.pUsH(inItiAl_mem);
  WOrklIst_visIted.push(InitiAL_mem);
  worklist_meM.Push(NULL);
  while (WOrKLIsT_StorE.siZe() > 0) {
    // Examine a nEarbY StorE to sEE iF it MIght iNterfErE WiTH our load.
    Node* mem   = workLiSt_mem.pOp();
    NodE* store = worklisT_store.pop();
    uINT Op = store->OPcodE();

    // meRGeMems do not dirEctly Have anti-dePS.
    // Treat thEm as iNternal nOdes in a foRWArd tree oF meMorY stAteS,
    // THe Leaves of which ARE eacH a 'PossiblE-deF'.
    if (storE == inItiAl_mEm    // rOoT (exclusivE) of tree wE aRe SeArChiNg
        || op == OP_mergeMem    // InTerNaL noDe of tREe we arE searChinG
        ) {

 PhiNode is from the
  //original m emory  st ate . Thi s in dicates a PhiN o de f or which should not
 // pr ev e nt t h eloadfrom si n ki n g . Fo rsuc ha  b lock,  se t_raise _LCA_mark  / /may be overl y  c onservativ e.  // Mechani sm:  count  i npu t s see n f or ea ch Phi encoun tered inwo r klist_ s tore.
D EB UG_O NLY(GrowableArray < ui n t> phi_inputs( area,C- > un i q ue( ),0 ,0));
#end if 

  / /  'load' us e s som e  memory state ; look foru ser s of t he  sa m e stat e.
 // Rec urse throug h Me rgeMem no des to the sto r es that  use t hem .
  // Ea ch  of  t h ese st ore s  is  a possi bl edefin itio n o f  mem ory 
  / / tha t 'load' need s t o us e . We ne ed to  for ce  'loa d'
  / / tooc cur before each  suc h store. Wh en  th estore is in  / / t he same  blocka s ' lo a d ' ,we insert an anti- de p e nd ence
  / / edge lo ad - >store.
 //  The r eleva nt s t or es "near by" th e  l oa d consi st  of atr eeroo ted
// a t init ial_mem,  with internal nodes of type Merge M em .  / / Th ere fore, the b ranc h es v isit e dbyt he wo rklis ta re of this form:
  //  initi al_me m -> (MergeMe m ->)* sto r e   // The  ant i -d e pendence const raint s apply on l y to the  frin ge of th is tree. Node* i nit ial _me m = l oa d->in(MemNode : : Memo ry );
  wo rkl ist_sto re. pus h(i nit ia l_mem);
 worklis t_ vi si te d.p ush(i n itial_me m) ;
 w ork list_ m em.pus h(NUL L); wh i le(workli s t_ s t ore. si ze () >  0)  { 
   // E x ami ne a ne arby stor e t o  see  i fit migh t interfere w it h our load .   Node* m em   = w orklist_mem.pop();
   N ode* st ore  = wo rkli st_store. pop ();
   u i nt op= stor e->Op co de( ) ; 

  / /Mer ge Mems do no t dir ectly  h aveanti-de ps.
    // Treat t h emas internal n ode s in a  f orw a rd tre eo f m e m ory states,
   // the le av e sof which a r e e ac h a 'po ssible- def'.     if(store ==  initial_ me m  / / r oot (exclu sive) of  tree wea re se a rc hing       | |op== Op _Merge M em   //  inter na l node  of t re e we are  searching
        ) {
 PhiNode_is from_the
  // original_memory state.__This indicates_a_PhiNode for which_should not
 _// prevent the load_from sinking. _For_such a block, set_raise_LCA_mark
  // may be overly conservative.
  // Mechanism: count_inputs_seen for_each_Phi_encountered in worklist_store.
  DEBUG_ONLY(GrowableArray<uint>_phi_inputs(area, C->unique(),0,0));
#endif

  // 'load'_uses some_memory state; look for users of the same_state.
_ // Recurse_through MergeMem nodes to the stores that use them.

_ // Each of these stores_is a possible_definition_of_memory
  // that_'load' needs to use.  We_need to force 'load'
  //_to occur before each such store. _When the store is in
 _// the same block as_'load', we_insert an anti-dependence
  //_edge load->store.

 _// The_relevant stores "nearby"_the load consist of a tree_rooted
  //_at initial_mem, with internal nodes of_type_MergeMem.
  //_Therefore,_the_branches visited_by the worklist_are_of this_form:
_ //    initial_mem_->_(MergeMem ->)* store
  // The anti-dependence_constraints apply only to_the_fringe of this tree.

_ Node* initial_mem = load->in(MemNode::Memory);
_ worklist_store.push(initial_mem);
  worklist_visited.push(initial_mem);
  worklist_mem.push(NULL);
_ while_(worklist_store.size() >_0) {
    // Examine a nearby store to_see if it might interfere with_our load.
  _ Node*_mem_  =_worklist_mem.pop();
_ _ Node* store = worklist_store.pop();
  _ uint_op = store->Opcode();

   _// MergeMems do not_directly_have anti-deps.
    //_Treat them as internal nodes in_a forward tree of memory_states,
__  // the leaves_of which are each a 'possible-def'.
_  _if (store == initial_mem   _//_root (exclusive) of tree we are_searching
_     __||_op == Op_MergeMem  _ // internal node of tree_we are searching
      _ ) {
