InvisibleLoc.cpp

Go to the documentation of this file.

#include "InvisibleLoc.hpp"
#include <OpenAnalysis/Location/LocationVisitor.hpp>

namespace OA {

static bool debug = false;

InvisibleLoc::InvisibleLoc(InvisibleLoc &other)
{
 OA_DEBUG_CTRL_MACRO("DEBUG_InvisibleLoc:ALL", debug);
 mMRE = other.mMRE;
}

SymHandle InvisibleLoc::getBaseSym()
{
 OA_ptr<MemRefExpr> m = mMRE; // Stupid Sun CC 5.4

 // if our mre is another RefOp then call recursively
 if (mMRE->isaRefOp()) {
 OA_ptr<RefOp> refOp = m.convert<RefOp>();
 return refOp->getBaseSym();
 }
 // otherwise should be a named ref
 assert(mMRE->isaNamed());
 OA_ptr<NamedRef> namedRef = m.convert<NamedRef>();
 return namedRef->getSymHandle();
}
 
void InvisibleLoc::acceptVisitor(LocationVisitor& pVisitor)
{
 pVisitor.visitInvisibleLoc(*this);
}

/* 
 The Invisible Location will just return same InvisibleLoc
 */
OA_ptr<Location> InvisibleLoc::getBaseLoc() 
{ 
 OA_ptr<Location> retval; 
 retval = new InvisibleLoc(*this);
 return retval;
}

/* some of this code can be used for InvisibleLoc::getBaseSym
 OA_ptr<Location> retval; 
 if (mMRE->isaNamed()) {
 OA_ptr<MemRefExpr> m = mMRE; // Stupid Sun CC 5.4
 OA_ptr<NamedRef> namedRef = m.convert<NamedRef>();
 retval = new NamedLoc(namedRef->getSymHandle(),false);
 } else if (mMRE->isaRefOp()) {
 OA_ptr<MemRefExpr> m = mMRE; // Stupid Sun CC 5.4
 OA_ptr<RefOp> refOp = m.convert<RefOp>();
 retval = new NamedLoc(refOp->getBaseSym(),false);
 } else {
 assert(0); // shouldn't have an invisible loc without a named base loc
 }
 return retval;
}
*/


bool InvisibleLoc::operator<(Location& other)
{
 if(getOrder() < other.getOrder()) { return true; }
 else if(getOrder() > other.getOrder()) { return false; }

 // if execution gets here then we're comparing two instances of the same
 // class
 InvisibleLoc& loc = static_cast<InvisibleLoc &>(other);

 if (getMemRefExpr() < loc.getMemRefExpr() )
 { return true; } else { return false; }
}

bool InvisibleLoc::operator==(Location& other)
{
 if(getOrder() != other.getOrder()) { return false; }

 // if execution gets here then we're comparing two instances of the same
 // class
 InvisibleLoc& loc = static_cast<InvisibleLoc &>(other);

 if ( getMemRefExpr() == loc.getMemRefExpr() ) 
 { return true; } 
 else { return false; }
} 

class equivalentMREsVisitor : public virtual MemRefExprVisitor {
 private:
 OA_ptr<MemRefExpr> innermost_mre;
 int numDerefs;
 public:
 equivalentMREsVisitor()
 {
 numDerefs=0;
 }
 ~equivalentMREsVisitor() {}
 void visitNamedRef(NamedRef& ref) {
 numDerefs=0; 
 innermost_mre = ref.clone();
 }
 void visitUnnamedRef(UnnamedRef& ref) {
 numDerefs=0;
 innermost_mre = ref.clone();
 }
 void visitUnknownRef(UnknownRef& ref) {
 assert(0);
 }
 void visitAddressOf(AddressOf& ref) {
 OA_ptr<MemRefExpr> mre = ref.getMemRefExpr();
 if (!mre.ptrEqual(0)) { mre->acceptVisitor(*this); }
 }
 void visitDeref(Deref& ref) {
 numDerefs++;
 OA_ptr<MemRefExpr> mre = ref.getMemRefExpr();
 if (!mre.ptrEqual(0)) { mre->acceptVisitor(*this); }
 }
 virtual void visitSubSetRef(SubSetRef& ref) {
 OA_ptr<MemRefExpr> mre = ref.getMemRefExpr();
 if (!mre.ptrEqual(0)) { mre->acceptVisitor(*this); }
 }
 int getnumDerefs() { return numDerefs; }
 OA_ptr<MemRefExpr> getInnermostMRE() { return innermost_mre; }
};


class InvisibleLocMayOverlapVisitor : public virtual LocationVisitor {
 private:
 InvisibleLoc& mThisLoc;
 public:
 bool mMayOverlap;

 InvisibleLocMayOverlapVisitor(InvisibleLoc& thisLoc) 
 : mThisLoc(thisLoc), mMayOverlap(true) {}
 ~InvisibleLocMayOverlapVisitor() {}
 
 // we don't overlap named locations because if we did then those
 // named memory references should have been mapped to same invisible
 // instead of being mapped to a named location
 void visitNamedLoc(NamedLoc& loc) { mMayOverlap = false; }

 // we don't overlap other unnamed locations for a similar reason
 void visitUnnamedLoc(UnnamedLoc& loc) { mMayOverlap = false; }

 // only overlap with other Invisibles that have an equivalent MemRefExpr
 // InvisibleLocs overlap if they have the same number of dereferences
 // and the same base symbol
 void visitInvisibleLoc(InvisibleLoc& loc) 
 { 

 mMayOverlap = false;

 equivalentMREsVisitor eVisitor1;
 OA_ptr<MemRefExpr> mre1 = mThisLoc.getMemRefExpr();
 mre1->acceptVisitor(eVisitor1);
 OA_ptr<MemRefExpr> inner_mre1 = eVisitor1.getInnermostMRE();
 int numderefs1 = eVisitor1.getnumDerefs();

 OA_ptr<MemRefExpr> mre2 = loc.getMemRefExpr();
 equivalentMREsVisitor eVisitor2;
 mre2->acceptVisitor(eVisitor2);
 int numderefs2 = eVisitor2.getnumDerefs();
 OA_ptr<MemRefExpr> inner_mre2 = eVisitor2.getInnermostMRE();

 if(numderefs1 == numderefs2) {
 if(inner_mre1->isaNamed() && inner_mre2->isaNamed()) {
 OA_ptr<NamedRef> named1 = inner_mre1.convert<NamedRef>();
 OA_ptr<NamedRef> named2 = inner_mre2.convert<NamedRef>();
 if(named1->getSymHandle() == named2->getSymHandle()) {
 mMayOverlap = true;
 }
 }
 }
 }

 // all locs overlap with the UnknownLoc
 void visitUnknownLoc(UnknownLoc& loc) { mMayOverlap = true; }

 // if the other location is a subset and we are not then
 // make the other location do the work
 void visitLocSubSet(LocSubSet& loc) 
 { mMayOverlap = loc.mayOverlap(mThisLoc); }
};

bool InvisibleLoc::mayOverlap(Location& other)
{
 // apply the visitor to the other location and return result
 InvisibleLocMayOverlapVisitor mayOverlapVisitor(*this);
 other.acceptVisitor(mayOverlapVisitor);
 return mayOverlapVisitor.mMayOverlap;
}

class InvisibleLocMustOverlapVisitor : public virtual LocationVisitor {
 private:
 InvisibleLoc& mThisLoc;
 public:
 bool mMustOverlap;

 InvisibleLocMustOverlapVisitor(InvisibleLoc& thisLoc) 
 : mThisLoc(thisLoc), mMustOverlap(false) {}
 ~InvisibleLocMustOverlapVisitor() {}
 
 // we don't overlap other named locations 
 void visitNamedLoc(NamedLoc& loc) { mMustOverlap = false; }

 void visitUnnamedLoc(UnnamedLoc& loc) { mMustOverlap = false; }

 // if the memory reference expression is equivalent
 // then we must overlap with another invisible location
 void visitInvisibleLoc(InvisibleLoc& loc) 
 { if ( mThisLoc.getMemRefExpr() == loc.getMemRefExpr() ) 
 { mMustOverlap = true; } else { mMustOverlap = false; }
 }

 // no locs must overlap with the UnknownLoc
 void visitUnknownLoc(UnknownLoc& loc) { mMustOverlap = false; }

 // if the other location is a subset and we are not then
 // make the other location do the work
 void visitLocSubSet(LocSubSet& loc) 
 { mMustOverlap = loc.mustOverlap(mThisLoc); }
};

bool InvisibleLoc::mustOverlap(Location& other)
{
 // apply the visitor to the other location and return result
 InvisibleLocMustOverlapVisitor mustOverlapVisitor(*this);
 other.acceptVisitor(mustOverlapVisitor);
 return mustOverlapVisitor.mMustOverlap;
}

bool InvisibleLoc::subSetOf(Location & other)
{
 return mustOverlap(other);
}

void InvisibleLoc::output(IRHandlesIRInterface& pIR)
{
 sOutBuild->objStart("InvisibleLoc");

 sOutBuild->fieldStart("mMRE");
 mMRE->output(pIR);
 sOutBuild->fieldEnd("mMRE");

 sOutBuild->objEnd("InvisibleLoc");
}

void InvisibleLoc::dump(std::ostream& os)
{
 // string for mSymHandle
 os << "InvisibleLoc(this=" << this << ", mMRE=";
 mMRE->dump(os);
 os << " )" << std::endl;
}


void InvisibleLoc::dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR)
{
 // string for mSymHandle
 os << "InvisibleLoc(this=" << this << ", mMRE=";
 mMRE->dump(os,pIR);
 os << " )" << std::endl;
}

std::string InvisibleLoc::toString(OA_ptr<IRHandlesIRInterface> pIR)
{
 std::ostringstream oss;
 // string for mSymHandle
 oss << "InvisibleLoc: ";
 mMRE->dump(oss,pIR);
 return oss.str();
}

} // end namespace