ManagerAffineExpr.cpp

Go to the documentation of this file.

#include "ManagerAffineExpr.hpp"

namespace OA {
namespace AffineExpr {

ManagerAffineExpr::ManagerAffineExpr(OA_ptr<AffineExprIRInterface> _ir)
 :
 mIR(_ir)
{
}


OA_ptr<AffineExprAbstraction> ManagerAffineExpr::analyzeMemRefExp(
 ExprHandle hExp,
 ProcHandle hProc,
 const set<OA_ptr<NamedLoc> > & indexVars,
 const set<OA_ptr<NamedLoc> > & nonConstVars,
 OA_ptr<Alias::Interface> aliasResults,
 AffineAnlState *state)
{
 OA_ptr<AffineExprAbstraction> afnExp;
 afnExp = new AffineExprAbstraction();

 // convert the expression into an expression tree
 OA_ptr<ExprTree> expTree = mIR->getExprTree(hExp);

 // an affine expression abstraction is constructed by visiting each
 // of the nodes in an expression tree and determining the expressions
 // terms and factors. The AffineExprExprTreeVisitor does this.
 AffineExprExprTreeVisitor visitor(
 afnExp, mIR, hProc, indexVars, nonConstVars, aliasResults);
 expTree->acceptVisitor(visitor);

 // the success or failure of converting the expression tree into an
 // affine expression abstraction is stored in a state variable passed
 // as an argument.
 *state = visitor.getState();

 return afnExp;
}


// Visitor class:
// ----------------------------------

void AffineExprExprTreeVisitor::visitOpNode(ExprTree::OpNode& n) {
 // don't continue when in an error state
 if(mState != VALID_AFFINE_EXP) { return; }

 // iterate over children in order to do a post-order traversal
 for(int i = 0; i < n.num_children(); i++) {
 ExprTree::ChildNodesIterator iterChildren(n);

 for(; iterChildren.isValid(); ++iterChildren) {
 OA_ptr<ExprTree::Node> child;
 child = iterChildren.current();
 child->acceptVisitor(*this);
 }
 }

 // determine what to do based on the type of operator
 OpHandle hOp = n.getHandle();
 switch(mIR->getOpType(hOp)) {
 // if it's a plus sign analyze for a term
 case OP_ADD:
 case OP_SUBTRACT:
 term();
 break;

 // if it's a multiply sign analyze for a term
 case OP_MULTIPLY:
 term();
 break;

 // in all other cases change the error state
 case OP_DIVIDE:
 case OP_MODULO:
 case OP_SHIFT_LEFT:
 case OP_SHIFT_RIGHT:
 case OP_BIT_AND:
 case OP_BIT_OR:
 case OP_BIT_XOR:
 case OP_OTHER:
 mState = INVALID_OPERATOR;
 break;
 }
}

void AffineExprExprTreeVisitor::visitCallNode(ExprTree::CallNode& n) {
 // don't continue when in an error state
 if(mState != VALID_AFFINE_EXP) { return; }

 // any time a function is called in an affine expression it is
 // assumed to be non-linear
 mState = NON_LINEAR_TERM;
}

void AffineExprExprTreeVisitor::visitMemRefNode(ExprTree::MemRefNode& n) {
 // don't continue when in an error state
 if(mState != VALID_AFFINE_EXP) { return; }

 OA_ptr<NamedLoc> var;
 // get a named location for the memory reference:

 // If we have alias information:
 // ....
 /*
 // convert the MRE into a MemRefHandle
 
 // use aliasing information to get a named location
 OA_ptr<LocIterator> locs;
 locs = mAliasResults->getMayLocs(hMemRef);
 OA_ptr<Location> loc = locs->current();*
 OA_ptr<NamedLoc> var = loc.convert<NamedLoc>();
 var->output(*mIR);
 */

 // IF we don't have alias information:
 // there should be one MRE asscociated with the MemRefNode, if this
 // is not the case than the variable is considered indirect.
 MemRefHandle hMemRef = n.getHandle();
 OA_ptr<MemRefExprIterator> iterMRE = mIR->getMemRefExprIterator(hMemRef);
 OA_ptr<MemRefExpr> mre = iterMRE->current();
 (*iterMRE)++;
 if(iterMRE->isValid()) { mState = INDIRECT_REF; return; }

 // convert the MRE to a NamedRef, use information from the
 // NamedRef class to get the location asscociated with it
 if(mre->isaNamed()) {
 OA_ptr<Location> loc;
 OA_ptr<NamedRef> namedRef;
 namedRef = mre.convert<NamedRef>();
 SymHandle hSym = namedRef->getSymHandle();
 loc = mIR->getLocation(mhProc, hSym);
 var = loc.convert<NamedLoc>();
 } else { assert(false); }

 // Now that we've got a location check to see if it's for a valid variable.
 // It's not valid if the variable has been reassigned or its not
 if(mNonConstVars.find(var) == mNonConstVars.end()) {
 mState = INVALID_VAR;
 return;
 }

 // if the variable was legal, recognize it
 pushVar(var);
}

void AffineExprExprTreeVisitor::visitConstSymNode(ExprTree::ConstSymNode& n) {
 assert(false);
}

void AffineExprExprTreeVisitor::visitConstValNode(ExprTree::ConstValNode& n) {
 int val = mIR->constValIntVal(n.getHandle());
 pushScaler(val);
}

void AffineExprExprTreeVisitor::pushVar(OA_ptr<NamedLoc> var) {
 // convert the passed var into an object encoded for the stack, then
 // push it onto the stack
 StackObj oVar;
 oVar.var = var;
 oVar.isVar = true;
 mStack.push(oVar);
}

void AffineExprExprTreeVisitor::pushScaler(int val) {
 // convert the passed int into an object encoded for the stack, then
 // push it onto the stack
 StackObj oVal;
 oVal.val = val;
 oVal.isVar = false;
 mStack.push(oVal);
}

void AffineExprExprTreeVisitor::term() {
 // don't continue when in an error state
 if(mState != VALID_AFFINE_EXP) { return; }

 // pop off the last two items added to the stack
 StackObj item1 = mStack.top(); mStack.pop();
 StackObj item2 = mStack.top(); mStack.pop();

 // if one item is a variable and the other is a scalar set it so
 // that item 1 is the scalar and item 2 is the variable
 if(item1.isVar && !item2.isVar) {
 StackObj tmp = item1;
 item1 = item2;
 item2 = tmp;
 }

 // if any variable term 

 if(item1.isVar && item2.isVar) {
 mState = NON_LINEAR_TERM;
 } else {
 if(item1.isVar) {
 mAfExp->addTerm(item1.var, item2.val);
 } else {
 mAfExp->addTerm(item2.var, item1.val);
 }
 }
}

/*
void AffineExprExprTreeVisitor::term() {
 // don't continue when in an error state
 if(mState != VALID_AFFINE_EXP) { return; }

 // check to make sure the last thing added to the stack was a val, add
 // it as the offset in the affine expression abstraction
 StackObj item = mStack.top(); mStack.pop();
 assert(item.isVar == false);
 mAfExp->setOffset(item.val);
}
*/

} } // end namespaces