CalleeToCallerVisitor.cpp

Go to the documentation of this file.

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


namespace OA {
 namespace DataFlow {

static bool debug = false;


 
CalleeToCallerVisitor::CalleeToCallerVisitor(
 ProcHandle callee, CallHandle call, ProcHandle caller,
 OA_ptr<Alias::InterAliasInterface> interAlias,
 OA_ptr<DataFlow::ParamBindings> paramBind,
 OA_ptr<CalleeToCallerVisitorIRInterface> _ir)
 : mIR(_ir),mCall(call), mCaller(caller), 
 mInterAlias(interAlias), mParamBind(paramBind), mCallee(callee)
{
 OA_DEBUG_CTRL_MACRO("DEBUG_CalleeToCallerVisitor:ALL", debug);

 mCallerAlias = mInterAlias->getAliasResults(caller);
}

OA_ptr<LocIterator> CalleeToCallerVisitor::getCallerLocIterator()
{

 OA_ptr<LocSetIterator> retval;
 retval = new LocSetIterator(mLocSet);
 return retval;
}


void CalleeToCallerVisitor::visitNamedLoc(NamedLoc& loc) 
{
 // should start newly empty each time
 mLocSet = new LocSet;

 // if the location is not local then just return it
 if (loc.isLocal()==false) {
 OA_ptr<Location> locCopy; locCopy = new NamedLoc(loc);
 mLocSet->insert(locCopy);
 if (debug) {
 std::cout << "CalleeToCallerVisitor: loc is not local, loc = ";
 loc.dump(std::cout);
 std::cout << std::endl;
 }
 
 }
 /*
 } else {
 // assume it is a parameter and try to get corresponding memref
 SymHandle formal = loc.getSymHandle();
 if (debug) {
 std::cout << "CalleeToCallerVisitor: formal = " << formal.hval();
 std::cout << std::endl;
 }
 
 // get the memory reference in the caller
 MemRefHandle memref = mParamBind->getCallerMemRef(mCall,formal);
 
 // only do the conversion if actual parameter is a memory reference
 if (memref!=MemRefHandle(0)) {
 // get all the may locs for the mem ref in caller
 // and insert them into the caller locs for this reference
 OA_ptr<LocIterator> mayLocIter = mCallerAlias->getMayLocs(memref);
 for ( ; mayLocIter->isValid(); (*mayLocIter)++ ) {
 if (debug) {
 std::cout << "\tmemref = " << memref.hval()
 << " has mayLoc ";
 mayLocIter->current()->dump(std::cout);
 std::cout << std::endl;
 }
 mLocSet->insert(mayLocIter->current());
 }
 }
 }
 */
}

void CalleeToCallerVisitor::visitUnnamedLoc(UnnamedLoc& loc)
{
 mLocSet = new LocSet;
 OA_ptr<Location> locptr;
 locptr = new UnnamedLoc(loc);
 mLocSet->insert(locptr);
}


class ConstructMREVisitor : public virtual MemRefExprVisitor{

public:

 OA_ptr<MemRefExpr> getMemRefExpr() {
 return mNewMRE;
 }

 ConstructMREVisitor(OA_ptr<MemRefExpr> actualMRE, 
 OA_ptr<CalleeToCallerVisitorIRInterface> _ir) 
 : mActualMRE(actualMRE), mIR(_ir)
 {
 }

 void visitNamedRef(NamedRef& ref) {
 // should never get here because will stop at RefOp that 
 // points at the base NamedRef
 }

 void visitUnnamedRef(UnnamedRef& ref) {
 // should never get here because the base ref in an InvisibleLoc 
 // is always a NamedRef
 }

 void visitUnknownRef(UnknownRef& ref) {
 // should never get here because the base ref in an InvisibleLoc is 
 // always a NamedRef
 }

 void visitAddressOf(AddressOf& ref) {


 OA_ptr<AddressOf> refOp;

 refOp = new AddressOf(ref);

 mRefOpStack.push(refOp);

 // see if this is the last RefOp before the NamedRef to the formal parameter
 OA_ptr<MemRefExpr> mre = ref.getMemRefExpr();
 if (mre->isaNamed()) {

 // if it is then call the method that will create the newMRE
 createNewMRE();

 if (debug) {
 std::cout << "\t Immediately after mActualMRE = ";
 mActualMRE->output(*mIR);
 }
 if (debug) {
 std::cout << "\t Immediately after mNewMRE = ";
 mNewMRE->output(*mIR);
 }

 } else {
 mre->acceptVisitor(*this);
 }

 if (debug) {
 std::cout << "\t Inside (end) of visitAddressOf mNewMRE = ";
 mNewMRE->output(*mIR);
 }
 
 }


 void visitDeref(Deref& ref) {
 // push empty version of this kind of RefOp onto stack
 OA_ptr<MemRefExpr> nullMRE;
 // will need to write getMRType()

 /* PLM 1/23/07 deprecated accuracy field 
 OA_ptr<Deref> refOp;

 refOp = 
 new Deref(ref.hasFullAccuracy(), ref.getMRType(), 
 nullMRE, ref.getNumDerefs()) ;
 */

 
 
 OA_ptr<Deref> refOp;
 
 refOp =
 new Deref(ref.getMRType(), nullMRE, ref.getNumDerefs()) ;
 

 mRefOpStack.push(refOp);

 // see if this is the last RefOp before the NamedRef to the formal parameter
 OA_ptr<MemRefExpr> mre = ref.getMemRefExpr();
 if (mre->isaNamed()) {

 // if it is then call the method that will create the newMRE
 createNewMRE();
 
 if (debug) {
 std::cout << "\t Immediately after mActualMRE = ";
 mActualMRE->output(*mIR);
 }
 if (debug) {
 std::cout << "\t Immediately after mNewMRE = ";
 mNewMRE->output(*mIR);
 }
 
 } else {
 mre->acceptVisitor(*this);
 }
 
 if (debug) {
 std::cout << "\t Inside visiDeref mNewMRE = ";
 mNewMRE->output(*mIR);
 }
 }

 void visitSubSetRef(SubSetRef& ref) {
 //assert(0); // not implemented yet, MMS
 
 OA::OA_ptr<OA::SubSetRef> subset_mre;
 OA::OA_ptr<OA::MemRefExpr> nullMRE;

 subset_mre = new OA::SubSetRef(
 OA::MemRefExpr::USE,
 nullMRE
 );

 mRefOpStack.push(subset_mre);

 // see if this is the last RefOp before the NamedRef to the formal parameter
 OA_ptr<MemRefExpr> mre = ref.getMemRefExpr();
 if (mre->isaNamed()) {
 // if it is then call the method that will create the newMRE
 createNewMRE();
 } else {
 mre->acceptVisitor(*this);
 }
 }

private:

 void createNewMRE()
 {
 mNewMRE = mActualMRE;


 // pop things on the list one at a time, 
 // for each RefOp, create one of the same kind but have 
 // it point to mNewMRE and then assign newly constructed MRE to mNewMRE
 while(!mRefOpStack.empty())
 { 
 OA_ptr<RefOp> refop = mRefOpStack.top(); 
 mRefOpStack.pop(); 
 

 mNewMRE = refop->composeWith(mNewMRE);

 
 if (debug) {
 std::cout << "\t Inside createNewMRE mNewMRE = ";
 mNewMRE->output(*mIR);
 }
 }
 }

private:
 std::stack<OA_ptr<RefOp> > mRefOpStack;
 OA_ptr<MemRefExpr> mActualMRE;
 OA_ptr<MemRefExpr> mNewMRE;
 OA_ptr<CalleeToCallerVisitorIRInterface> mIR; 


};


void CalleeToCallerVisitor::visitInvisibleLoc(InvisibleLoc& loc)
{
 
 if (debug) {
 std::cout << "In CalleeToCallerVisitor::visitInvisibleLoc" << std::endl;
 }
 mLocSet = new LocSet;
 
 // if base symbols is not local
 // InvisibleLoc
 
 
 SymHandle baseSym = loc.getBaseSym();
 
 
 OA_ptr<Location> baseSymLoc = mIR->getLocation(mCallee, baseSym); 
 if (!baseSymLoc->isLocal()) 
 { 
 // pull out the MRE
 OA_ptr<MemRefExpr> memref = loc.getMemRefExpr(); 
 if (debug) {
 std::cout << "\tBaseSymLoc is NOT local = ";
 memref->output(*mIR);
 }
 
 // ask caller alias analysis to getMayLocs
 // insert each of the may locs into mLocSet
 OA_ptr<LocIterator> mayLocIter = mCallerAlias->getMayLocs(*memref, mCaller);

 for ( ; mayLocIter->isValid(); (*mayLocIter)++ ) {
 mLocSet->insert(mayLocIter->current());
 }

 // base symbol is local
 // the base symbol should be a parameter
 } else {
 OA_ptr<MemRefExpr> mre = loc.getMemRefExpr();
 if (debug) {
 std::cout << "\tBaseSymLoc IS local = ";
 mre->output(*mIR);
 }
 
 // get the base symbol for the mre within the invisible location
 // it should be a formal
 OA_ptr<RefOp> refop;
 if (mre->isaRefOp()) {
 refop = mre.convert<RefOp>();
 } else { 
 assert(0); // should not have an MRE in InvLoc that isn't a RefOp
 }
 SymHandle formal = refop->getBaseSym();
 
 // get the memory reference in the caller
 MemRefHandle memref = mParamBind->getCallerMemRef(mCall,formal);

 // iterate over all mres for the actual memory reference in caller
 OA_ptr<MemRefExprIterator> mreIterPtr
 = mIR->getMemRefExprIterator(memref);
 for (; mreIterPtr->isValid(); (*mreIterPtr)++) {
 OA_ptr<OA::MemRefExpr> actual_mre = mreIterPtr->current();

 // create a visitor parameterized with mre in caller 
 ConstructMREVisitor visitor(actual_mre, mIR); 

 if (debug) {
 std::cout << "\tActual mre = ";
 actual_mre->output(*mIR);
 }
 
 // visit the mre in the callee
 mre->acceptVisitor(visitor);
 OA_ptr<MemRefExpr> composed_mre = visitor.getMemRefExpr();

 if (debug) {
 std::cout << "\tComposed mre = ";
 composed_mre->output(*mIR);
 }
 
 
 // visit the may locs for resulting mre
 OA_ptr<LocIterator> mayLocIter 
 = mCallerAlias->getMayLocs(*composed_mre, mCaller);
 if (debug) {
 std::cout << "\tConstructing mayLocs from Caller Proc " << mIR->toString(mCaller)
 << " for Composed mre:\n";
 }
 for ( ; mayLocIter->isValid(); (*mayLocIter)++ ) { 
 mLocSet->insert(mayLocIter->current());
 if (debug) {
 std::cout << "\t\tinserted==> ";
 (mayLocIter->current())->output(*mIR);
 }
 } 
 }
 }
}

void CalleeToCallerVisitor::visitUnknownLoc(UnknownLoc& loc)
{
 mLocSet = new LocSet;
 OA_ptr<Location> locptr;
 locptr = new UnknownLoc();
 mLocSet->insert(locptr);
}

void CalleeToCallerVisitor::visitLocSubSet(LocSubSet& loc)
{
 // not handling any of the more precise LocSubSet classes
 // just going to make a generic LocSubSet to wrap around
 // all the NamedLoc's the underlying location maps to
 OA_ptr<Location> baseLoc = loc.getLoc();
 if (debug) {
 std::cout << "CalleeToCallerVisitor::visitLocSubSet" << std::endl;
 std::cout << "\tbaseLoc = ";
 baseLoc->dump(std::cout);
 }
 baseLoc->acceptVisitor(*this);
 OA_ptr<LocSet> temp = mLocSet;
 mLocSet = new LocSet;
 OA_ptr<LocIterator> locIter; locIter = new LocSetIterator(temp);
 for ( ; locIter->isValid(); (*locIter)++ ) {
 OA_ptr<Location> mayLoc = locIter->current();
 if (debug) {
 std::cout << "\t\tmayLoc = ";
 mayLoc->dump(std::cout);
 }
 
 // the constructor for LocSubSet handles various mayLoc
 // subclasses
 OA_ptr<Location> subLoc;
 subLoc = new LocSubSet(mayLoc);
 mLocSet->insert(subLoc);
 }

}


 } // end of DataFlow namespace
} // end of OA namespace








/*
class ConstructMREVisitor {

public:

 ConstructMREVisitor(OA_ptr<MemRefExpr> actualMRE) : mActualMRE(actualMRE)
 {
 mMREStack = new std::stack<OA_ptr<MemRefExpr> >;
 }
 
 void visitNamedRef(NamedRef& ref) {
 // should never get here because will stop at RefOp that points at the base NamedRef
 }
 
 void visitUnnamedRef(UnnamedRef& ref) {
 // should never get here because the base ref in an InvisibleLoc is always a NamedRef
 }
 
 void visitUnknownRef(UnknownRef& ref) {
 // should never get here because the base ref in an InvisibleLoc is always a NamedRef
 }

 void visitDeref(Deref& ref)
 {
 // push empty version of this kind of RefOp onto stack
 OA_ptr<MemRefExpr> nullMRE;
 // will need to write getMRType()
 OA_ptr<MemRefExpr> refOp = new RefOp(ref.hasAddressTaken(), ref.hasFullAccuracy(), ref.getMRType(), nullMRE );
 mRefOpStack.push(refOp);

 // see if this is the last RefOp before the NamedRef to the formal parameter
 OA_ptr<MemRefExpr> mre = ref.getMemRefExpr();
 if (mre->isaNamed()) {

 // if it is then call the method that will create the newMRE 
 // createNewMRE();
 }else {
 mre->acceptVisitor(*this);
 }
 }

 void visitSubSetRef(SubSetRef& ref) { 

 } 

private:


 void createNewMRE()
 {
 OA_ptr<MemRefExpr>mNewMRE = mActualMRE;
 // pop things on the list one at a time, for each RefOp, create one of the same kind but have it point to mNewMRE and then assign newly constructed MRE to mNewMRE 

 OA_ptr<MemRefExprIterator> mreIterPtr
 = mIR->getMemRefExprIterator(mRefOpStack);

 OA_ptr<OA::MemRefExpr> mre;
 for (; mreIterPtr->isValid(); (*mreIterPtr)++) {
 mre = mreIterPtr->current();
 mre.push(mNewMRE);
 mNewMRE = mre; 
 }



 if (mre->isaDeref()) {

 MRE = new Deref(mre->hasAddressTaken, ..., mNewMRE);

 } else if isaSubsetRef {

 MRE = new Deref(mre->hasAddressTaken, ..., mNewMRE);
 }

 }
private:

 std::stack<OA_ptr<MemRefExpr> > mRefOpStack;
 OA_ptr<MemRefExpr>mActualMRE;
 OA_ptr<MemRefExpr> mNewMRE;

} */