ManagerSideEffectStandard.cpp

Go to the documentation of this file.

#include "ManagerSideEffectStandard.hpp"
#include <Utils/Util.hpp>


namespace OA {
 namespace SideEffect {

static bool debug = false;

/* Deprecated, replace functionality if necessary MMS 7/6/06
class RefVisitor : public virtual LocationVisitor {
 private:
 std::set<SymHandle>& mRefSymSet;
 public:
 bool mRef;

 RefVisitor(std::set<SymHandle> &pRefSymSet)
 : mRefSymSet(pRefSymSet), mRef(true) {}
 ~RefVisitor() {}
 void visitNamedLoc(NamedLoc& loc) 
 { 
 if (mRefSymSet.find(loc.getSymHandle()) != mRefSymSet.end())
 { mRef = true; } 
 else { mRef = false; }
 }
 void visitUnnamedLoc(UnnamedLoc& loc) { mRef = true; }
 void visitInvisibleLoc(InvisibleLoc& loc) { mRef = true; }
 void visitUnknownLoc(UnknownLoc& loc) { mRef = true; }
 void visitLocSubSet(LocSubSet& loc) { 
 // have this visitor visit the base location
 OA_ptr<Location> baseLoc = loc.getLoc();
 baseLoc->acceptVisitor(*this);
 }
};
*/

ManagerSideEffectStandard::ManagerSideEffectStandard(OA_ptr<SideEffectIRInterface> _ir) : mIR(_ir)
{
 OA_DEBUG_CTRL_MACRO("DEBUG_ManagerSideEffectStandard:ALL", debug);
}


OA_ptr<SideEffectStandard> 
ManagerSideEffectStandard::performAnalysis(ProcHandle proc, 
 OA_ptr<Alias::Interface> alias,
 OA_ptr<InterSideEffectInterface> inter)
{
 mProc = proc;
 if (debug) {
 std::cout << "ManagerSideEffectStandard: proc = " << mIR->toString(proc)
 << std::endl;
 }

 // create a new (waiting to be filled) SideEffectStandard as member
 OA_ptr<SideEffectStandard> retSideEffect;
 retSideEffect= new SideEffectStandard();

 //alias->dump(std::cout,mIR);

 // empty out all the sets
 retSideEffect->emptyLMOD();
 retSideEffect->emptyMOD();
 retSideEffect->emptyLDEF();
 retSideEffect->emptyDEF();
 retSideEffect->emptyLUSE();
 retSideEffect->emptyUSE();
 retSideEffect->emptyLREF();
 retSideEffect->emptyREF();
 
 // loop through statements
 OA_ptr<OA::IRStmtIterator> sIt = mIR->getStmtIterator(proc);
 for ( ; sIt->isValid(); (*sIt)++) {
 OA::StmtHandle stmt = sIt->current();
 if (debug) {
 std::cout << "\tstmt = ";
 mIR->dump(stmt,std::cout);
 }

 // for each use memory reference in the stmt
 OA_ptr<MemRefHandleIterator> mrIterPtr = mIR->getUseMemRefs(stmt);
 for (; mrIterPtr->isValid(); (*mrIterPtr)++ )
 {
 MemRefHandle memref = mrIterPtr->current();
 if (debug) {
 std::cout << "\tmemref = ";
 mIR->dump(memref,std::cout);
 }

 // each location the memory reference may reference
 OA_ptr<LocIterator> locIterPtr = alias->getMayLocs(memref);
 for (; locIterPtr->isValid(); ++(*locIterPtr)) {

 OA_ptr<Location> useLoc = locIterPtr->current();
 if (debug) {
 std::cout << "useLoc = ";
 useLoc->dump(std::cout, mIR);
 }

 // DEPRECATED, no longer necessary, alias analysis only maps
 // to locations visible within the procedure, MMS 7/6/06
 // will only put into these sets if the location is referenced
 // in the procedure
 //useLoc->acceptVisitor(refVisitor);
 //if (refVisitor.mRef == true) {

 // put each location used through a memory reference in LREF and REF
 retSideEffect->insertLREF( useLoc);
 retSideEffect->insertREF( useLoc);
 
 // put each location used through a memory reference in LUSE 
 // and USE if the location is not already in DEF
 // FIXME?: assuming everything is used in a statement before 
 // anything
 // is defined, is this not the case in things like short circuits?
 
 // CONSERVATIVE FIXME: just do all USEs, to do upward exposed need
 // CFG, to do only USEd, need to calc DEF first
 //if (!retSideEffect->inDEF(useLoc)) {
 
 retSideEffect->insertLUSE(useLoc);
 retSideEffect->insertUSE(useLoc);
 // }
 //}
 }
 }

 // for each def memory reference in the stmt
 mrIterPtr = mIR->getDefMemRefs(stmt);
 for (; mrIterPtr->isValid(); (*mrIterPtr)++ )
 {
 MemRefHandle memref = mrIterPtr->current();
 if (debug) {
 std::cout << "\tmemref = ";
 mIR->dump(memref,std::cout);
 }
 
 // put each location may defined into LMOD and MOD
 OA_ptr<LocIterator> locIterPtr = alias->getMayLocs(memref);
 for (; locIterPtr->isValid(); ++(*locIterPtr)) {
 OA_ptr<Location> mayDef = locIterPtr->current();
 if (debug) {
 std::cout << "mayDef = ";
 mayDef->dump(std::cout, mIR);
 }

 // AGAIN, DEPRECATED
 // will only put into these sets if the location is referenced
 // in the procedure
 //mayDef->acceptVisitor(refVisitor);
 //if (refVisitor.mRef == true) {
 retSideEffect->insertLMOD(mayDef);
 retSideEffect->insertMOD(mayDef);
 //}
 } 

 // put each location must defined into LDEF and DEF
 locIterPtr = alias->getMustLocs(memref);
 for (; locIterPtr->isValid(); ++(*locIterPtr)) {
 OA_ptr<Location> mustDef = locIterPtr->current();

 // will only put into these sets if the location is referenced
 // in the procedure
 //mustDef->acceptVisitor(refVisitor);
 //if (refVisitor.mRef == true) {
 retSideEffect->insertLDEF(mustDef);
 retSideEffect->insertDEF(mustDef);
 //}
 } 
 }
 
 // Iterate over procedure calls of a statement
 // to determine their effect
 OA_ptr<IRCallsiteIterator> callsiteItPtr = mIR->getCallsites(stmt);
 for ( ; callsiteItPtr->isValid(); ++(*callsiteItPtr)) {
 CallHandle call = callsiteItPtr->current();
 if (debug) {
 std::cout << "\tcall = " << mIR->toString(call) << std::endl;
 }

 OA_ptr<LocIterator> locIterPtr;
 
 // MOD
 locIterPtr = inter->getMODIterator(call);
 for ( ; locIterPtr->isValid(); (*locIterPtr)++) {
 retSideEffect->insertMOD(locIterPtr->current());
 if (debug) {
 std::cout << "\tinserting loc = ";
 locIterPtr->current()->dump(std::cout,mIR);
 std::cout << "\tinto MOD" << std::endl;
 }
 } 
 // DEF
 locIterPtr = inter->getDEFIterator(call);
 for ( ; locIterPtr->isValid(); (*locIterPtr)++) {
 retSideEffect->insertDEF(locIterPtr->current());
 } 
 // USE
 locIterPtr = inter->getUSEIterator(call);
 for ( ; locIterPtr->isValid(); (*locIterPtr)++) {
 //if (!retSideEffect->inDEF(locIterPtr->current())) {
 //FIXME: don't know order of use vs def in func call
 OA_ptr<Location> Loc = locIterPtr->current();
 if (debug) {
 std::cout << "SideEffectStandard USE retSideEffect = ";
 Loc->dump(std::cout);
 std::cout << std::endl;
 }
 retSideEffect->insertUSE(Loc); 
 // retSideEffect->insertUSE(locIterPtr->current());
 //}
 } 
 // REF
 locIterPtr = inter->getREFIterator(call);
 for ( ; locIterPtr->isValid(); (*locIterPtr)++) {
 retSideEffect->insertREF(locIterPtr->current());
 } 
 }
 
 } // end of loop over statements

 return retSideEffect;
}
 } // end of namespace SideEffect
} // end of namespace OA