ManagerLivenessStandard.cpp

Go to the documentation of this file.

// ManagerLivenessStandard.cpp


#include "ManagerLivenessStandard.hpp"


namespace OA {
  namespace Liveness {

static bool debug = false;


ManagerLivenessStandard::ManagerLivenessStandard(OA_ptr<LivenessIRInterface> _ir) 
    : mIR(_ir)
{
   OA_DEBUG_CTRL_MACRO("DEBUG_ManagerLivenessStandard:ALL", debug);
   mSolver = new DataFlow::CFGDFSolver(DataFlow::CFGDFSolver::Backward,*this);
}

OA_ptr<DataFlow::DataFlowSet> ManagerLivenessStandard::initializeTop()
{
    OA_ptr<DataFlow::LocDFSet>  retval;
    retval = new DataFlow::LocDFSet;
    return retval;
}

OA_ptr<DataFlow::DataFlowSet> ManagerLivenessStandard::initializeBottom()
{
    OA_ptr<DataFlow::LocDFSet> retval;
    retval = new DataFlow::LocDFSet;
    return retval;
}

OA_ptr<LivenessStandard> ManagerLivenessStandard::performAnalysis(ProcHandle proc, 
    OA_ptr<CFG::CFGInterface> cfg, OA_ptr<Alias::Interface> alias,
    OA_ptr<SideEffect::InterSideEffectInterface> interSE,
    DataFlow::DFPImplement algorithm)
{
  if (debug) {
    std::cout << "In Liveness::ManagerLivenessStandard::performAnalysis" << std::endl;
  }
  mLiveMap = new LivenessStandard(proc);

  // store Alias information for use within the transfer function
  mAlias = alias;

  // get mapping of statements to locations they may and must define
  OA_ptr<OA::IRStmtIterator> sIt = mIR->getStmtIterator(proc);
  for ( ; sIt->isValid(); (*sIt)++) {
    OA::StmtHandle stmt = sIt->current();
    if (debug) {
      std::cout<< "\tstmt (" << stmt.hval() << ") = ";
      mIR->dump(stmt,std::cout);
    } 
    
    // initialize each stmt to define an empty set of locations
    mStmtMustDefMap[stmt];
    mStmtMayUseMap[stmt];

   // locations that each statement may or must def
    OA_ptr<MemRefHandleIterator> defIterPtr = mIR->getDefMemRefs(stmt);
    for (; defIterPtr->isValid(); (*defIterPtr)++) {
        MemRefHandle ref = defIterPtr->current();
        if (debug) {
          std::cout << "\t\tdef ref (" << ref.hval() << ") = ";
          mIR->dump(ref,std::cout);
        }

        OA_ptr<LocIterator> locIterPtr = alias->getMustLocs(ref);
        for (; locIterPtr->isValid(); ++(*locIterPtr)) {
            mStmtMustDefMap[stmt].insert(locIterPtr->current());
        }

    }
 
    // must or may defines from procedure calls
    OA_ptr<IRCallsiteIterator> callsiteItPtr = mIR->getCallsites(stmt);
    for ( ; callsiteItPtr->isValid(); ++(*callsiteItPtr)) {
      CallHandle expr = callsiteItPtr->current();

      OA_ptr<LocIterator> locIterPtr;
      
      // DEF
      locIterPtr = interSE->getDEFIterator(expr);
      for ( ; locIterPtr->isValid(); (*locIterPtr)++) {
          OA_ptr<Location> defLocPtr = locIterPtr->current();
          mStmtMustDefMap[stmt].insert(defLocPtr);
      }
    }

   
   OA_ptr<MemRefHandleIterator> useIterPtr = mIR->getUseMemRefs(stmt);
    for (; useIterPtr->isValid(); (*useIterPtr)++) {
        MemRefHandle useref = useIterPtr->current();
        if (debug) {
          std::cout << "\t\tuse ref (" << useref.hval() << ") = ";
          mIR->dump(useref,std::cout);
        }

        OA_ptr<LocIterator> uselocIterPtr = alias->getMayLocs(useref);
        for (; uselocIterPtr->isValid(); ++(*uselocIterPtr)) {
            mStmtMayUseMap[stmt].insert(uselocIterPtr->current());
        }

    }

  
  }//loop over statements

  // use the dataflow solver to get the In and Out sets for the BBs
  //DataFlow::CFGDFProblem::solve(cfg);
  //

  mSolver->solve(cfg,algorithm);  
  
  // get exit node for CFG and determine what definitions reach that node
  OA_ptr<CFG::NodeInterface> node;
  
  node = cfg->getExit();

  OA_ptr<DataFlow::DataFlowSet> x = mSolver->getOutSet(node);

  OA_ptr<DataFlow::LocDFSet> inSet
    = x.convert<DataFlow::LocDFSet >();

   
  return mLiveMap;

}

OA_ptr<DataFlow::DataFlowSet>
ManagerLivenessStandard::initializeNodeIN(OA_ptr<CFG::NodeInterface> n)
{
     OA_ptr<DataFlow::LocDFSet>  retval;
     retval = new DataFlow::LocDFSet;
     return retval;
}

OA_ptr<DataFlow::DataFlowSet>
ManagerLivenessStandard::initializeNodeOUT(OA_ptr<CFG::NodeInterface> n)
{
     OA_ptr<DataFlow::LocDFSet>  retval;
     retval = new DataFlow::LocDFSet;
     return retval;
}



OA_ptr<DataFlow::DataFlowSet> 
ManagerLivenessStandard::meet (OA_ptr<DataFlow::DataFlowSet> set1orig, 
                       OA_ptr<DataFlow::DataFlowSet> set2orig)
{
    OA_ptr<DataFlow::LocDFSet> set1
        = set1orig.convert<DataFlow::LocDFSet>();
    if (debug) {
        std::cout << "ManagerLivenessStandard::meet" << std::endl;
        std::cout << "\tset1 = ";
        set1->dump(std::cout,mIR);
        std::cout << ", set2 = ";
        set2orig->dump(std::cout,mIR);
    }
       
    DataFlow::LocDFSet retval 
        = set1->setUnion(*set2orig);
    if (debug) {
        std::cout << std::endl << "\tretval set = ";
        retval.dump(std::cout,mIR);
        std::cout << std::endl;
    }
       
    return retval.clone();
}


OA_ptr<DataFlow::DataFlowSet> 
ManagerLivenessStandard::transfer(OA_ptr<DataFlow::DataFlowSet> in, OA::StmtHandle stmt) 
{
    OA_ptr<DataFlow::LocDFSet> inRecast 
        = in.convert<DataFlow::LocDFSet>();

    if (debug) {
        std::cout << "In transfer, stmt(hval=" << stmt.hval() << ")= ";
        mIR->dump(stmt,std::cout);
    }


    DataFlow::LocDFSetIterator inIter(*inRecast);
    for (; inIter.isValid(); ++inIter) {
        OA_ptr<Location> livevar = inIter.current();
        if (debug) {
          std::cout << "\tlivevar in Inset = ";
          livevar->dump(std::cout,mIR);
        }
   
       mLiveMap->insertLive(stmt,livevar);
  }
         LocSet::iterator setIter;
         for (setIter=mStmtMustDefMap[stmt].begin(); setIter!=mStmtMustDefMap[stmt].end(); setIter++) {
                       OA_ptr<Location> loc = *setIter;
                       inRecast->remove(loc);
                       mLiveMap->removeLive(stmt,loc);
 
    }

         LocSet::iterator gensetIter;
         for (gensetIter=mStmtMayUseMap[stmt].begin(); gensetIter!=mStmtMayUseMap[stmt].end(); gensetIter++) {
                       OA_ptr<Location> loc = *gensetIter;
                       inRecast->insert(loc);
                       mLiveMap->insertLive(stmt,loc);

    }

    return inRecast;
 }

  } // end of namespace Liveness
} // end of namespace OA