SideEffectStandard.cpp

Go to the documentation of this file.

#include "SideEffectStandard.hpp"

namespace OA {
  namespace SideEffect{

static bool debug = false;

//*****************************************************************
// Interface Implementation
//*****************************************************************


SideEffectStandard::SideEffectStandard()
        { OA_DEBUG_CTRL_MACRO("DEBUG_SideEffectStandard:ALL", debug);

          mUnknownLocSet = new LocSet;
          OA_ptr<Location> uLoc; 
          //uLoc = dynamic_cast<Location*>(new UnknownLoc());
          //MMS, even the SGI compiler shouldn't need the above
          uLoc = new UnknownLoc();
          mUnknownLocSet->insert(uLoc);
        }

OA_ptr<LocIterator> SideEffectStandard::getLMODIterator()
{ 
  OA_ptr<LocSetIterator> retval;
  if (mLMODSet.ptrEqual(0)) {
    // loc set with unknown loc
    retval = new LocSetIterator(mUnknownLocSet);  
  } else {
    retval = new LocSetIterator(mLMODSet); 
  }
  return retval;
}

OA_ptr<LocIterator> SideEffectStandard::getMODIterator()
{ 
  OA_ptr<LocSetIterator> retval;
  if (mMODSet.ptrEqual(0)) {
    // loc set with unknown loc
    retval = new LocSetIterator(mUnknownLocSet);  
  } else {
    retval = new LocSetIterator(mMODSet); 
  }
  return retval;
}

OA_ptr<LocIterator> SideEffectStandard::getLDEFIterator()
{ 
  OA_ptr<LocSetIterator> retval;
  if (mLDEFSet.ptrEqual(0)) {
    OA_ptr<LocSet> retSet;  retSet = new LocSet; // empty set
    retval = new LocSetIterator(retSet);  
  } else {
    retval = new LocSetIterator(mLDEFSet); 
  }
  return retval;
}

OA_ptr<LocIterator> SideEffectStandard::getDEFIterator()
{ 
  OA_ptr<LocSetIterator> retval;
  if (mDEFSet.ptrEqual(0)) {
    OA_ptr<LocSet> retSet;  retSet = new LocSet; // empty set
    retval = new LocSetIterator(retSet);  
  } else {
    retval = new LocSetIterator(mDEFSet); 
  }
  return retval;
}

OA_ptr<LocIterator> SideEffectStandard::getLUSEIterator()
{ 
  OA_ptr<LocSetIterator> retval;
  if (mLUSESet.ptrEqual(0)) {
    // loc set with unknown loc
    retval = new LocSetIterator(mUnknownLocSet);  
  } else {
    retval = new LocSetIterator(mLUSESet); 
  }
  return retval;
}

OA_ptr<LocIterator> SideEffectStandard::getUSEIterator()
{ 
  OA_ptr<LocSetIterator> retval;
  if (mUSESet.ptrEqual(0)) {
    // loc set with unknown loc
    retval = new LocSetIterator(mUnknownLocSet);  
  } else {
    retval = new LocSetIterator(mUSESet); 
  }
  return retval;
}

OA_ptr<LocIterator> SideEffectStandard::getLREFIterator()
{ 
  OA_ptr<LocSetIterator> retval;
  if (mLREFSet.ptrEqual(0)) {
    // loc set with unknown loc
    retval = new LocSetIterator(mUnknownLocSet);  
  } else {
    retval = new LocSetIterator(mLREFSet); 
  }
  return retval;
}

OA_ptr<LocIterator> SideEffectStandard::getREFIterator()
{ 
  OA_ptr<LocSetIterator> retval;
  if (mREFSet.ptrEqual(0)) {
    // loc set with unknown loc
    retval = new LocSetIterator(mUnknownLocSet);  
  } else {
    retval = new LocSetIterator(mREFSet); 
  }
  return retval;
}
    
//*****************************************************************
// Other informational methods
//*****************************************************************
bool SideEffectStandard::inLMOD(OA_ptr<Location> loc)
{
    if (mLMODSet.ptrEqual(0)) {
        return false;
    } else {
        LocSet::iterator pos = mLMODSet->find(loc);
        return pos != mLMODSet->end();
    }
}

bool SideEffectStandard::inMOD(OA_ptr<Location> loc)
{
    if (mMODSet.ptrEqual(0)) {
        return false;
    } else {
        LocSet::iterator pos = mMODSet->find(loc);
        return pos != mMODSet->end();
    }
}

bool SideEffectStandard::inLDEF(OA_ptr<Location> loc)
{
    if (mLDEFSet.ptrEqual(0)) {
        return false;
    } else {
        LocSet::iterator pos = mLDEFSet->find(loc);
        return pos != mLDEFSet->end();
    }
}

bool SideEffectStandard::inDEF(OA_ptr<Location> loc)
{
    if (mDEFSet.ptrEqual(0)) {
        return false;
    } else {
        LocSet::iterator pos = mDEFSet->find(loc);
        return pos != mDEFSet->end();
    }
}

bool SideEffectStandard::inLUSE(OA_ptr<Location> loc)
{
    if (mLUSESet.ptrEqual(0)) {
        return false;
    } else {
        LocSet::iterator pos = mLUSESet->find(loc);
        return pos != mLUSESet->end();
    }
}

bool SideEffectStandard::inUSE(OA_ptr<Location> loc)
{
    if (mUSESet.ptrEqual(0)) {
        return false;
    } else {
        LocSet::iterator pos = mUSESet->find(loc);
        return pos != mUSESet->end();
    }
}

bool SideEffectStandard::inLREF(OA_ptr<Location> loc)
{
    if (mLREFSet.ptrEqual(0)) {
        return false;
    } else {
        LocSet::iterator pos = mLREFSet->find(loc);
        return pos != mLREFSet->end();
    }
}

bool SideEffectStandard::inREF(OA_ptr<Location> loc)
{
    if (mREFSet.ptrEqual(0)) {
        return false;
    } else {
        LocSet::iterator pos = mREFSet->find(loc);
        return pos != mREFSet->end();
    }
}

//*****************************************************************
// Construction methods
//*****************************************************************
void SideEffectStandard::insertLMOD(OA_ptr<Location> loc)
{
    if (mLMODSet.ptrEqual(0)) {
        mLMODSet = new LocSet;
    }
    mLMODSet->insert(loc);
}
    
void SideEffectStandard::insertMOD(OA_ptr<Location> loc)
{
    if (debug) {
        std::cout << "SideEffectStandard::insertMOD: loc = ";
        loc->dump(std::cout);
    }
    if (mMODSet.ptrEqual(0)) {
        mMODSet = new LocSet;
        if (debug) {
            std::cout << "SideEffectStandard::insertMOD: creating new LocSet" 
                      << std::endl;
        }
    }
    mMODSet->insert(loc);
}
    
void SideEffectStandard::insertLDEF(OA_ptr<Location> loc)
{
    if (mLDEFSet.ptrEqual(0)) {
        mLDEFSet = new LocSet;
    }
    mLDEFSet->insert(loc);
}
    
void SideEffectStandard::insertDEF(OA_ptr<Location> loc)
{
    if (mDEFSet.ptrEqual(0)) {
        mDEFSet = new LocSet;
    }
    mDEFSet->insert(loc);
}
    
void SideEffectStandard::insertLUSE(OA_ptr<Location> loc)
{
    if (mLUSESet.ptrEqual(0)) {
        mLUSESet = new LocSet;
    }
   if (debug) {
        std::cout << "LUseLocation insert = ";
        loc->dump(std::cout);
   }
                    
   mLUSESet->insert(loc);

}
    
void SideEffectStandard::insertUSE(OA_ptr<Location> loc)
{
    if (mUSESet.ptrEqual(0)) {
        mUSESet = new LocSet;
    }
    if (debug) {
        std::cout << "UseLocation insert = ";
            loc->dump(std::cout);
    }
     
    mUSESet->insert(loc);

    if(debug)
    {
      LocSetIterator USElocIter(mUSESet);
      for (; USElocIter.isValid(); ++USElocIter) {
              OA_ptr<Location> loc = USElocIter.current();
              std::cout << "UseLocCompare";
              loc->dump(std::cout);   
              std::cout << std::endl;
      }
    }
}
    
void SideEffectStandard::insertLREF(OA_ptr<Location> loc)
{
    if (mLREFSet.ptrEqual(0)) {
        mLREFSet = new LocSet;
    }
    mLREFSet->insert(loc);
}
    
void SideEffectStandard::insertREF(OA_ptr<Location> loc)
{
    if (mREFSet.ptrEqual(0)) {
        mREFSet = new LocSet;
    }
    mREFSet->insert(loc);
}
    
//*************************************************************
void SideEffectStandard::emptyLMOD()
{
    mLMODSet = new LocSet;
}

void SideEffectStandard::emptyMOD()
{
    mMODSet = new LocSet;
}

void SideEffectStandard::emptyLDEF()
{
    mLDEFSet = new LocSet;
}
    
void SideEffectStandard::emptyDEF()
{
    mDEFSet = new LocSet;
}
    
void SideEffectStandard::emptyLUSE()
{
    mLUSESet = new LocSet;
}

void SideEffectStandard::emptyUSE()
{
    mUSESet = new LocSet;
}

void SideEffectStandard::emptyLREF()
{
    mLREFSet = new LocSet;
}

void SideEffectStandard::emptyREF()
{
    mREFSet = new LocSet;
}

//*****************************************************************
// Output
//*****************************************************************


void SideEffectStandard::dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir)
{
    std::cout << "====================== SideEffect" << std::endl;

    OA_ptr<LocIterator> locIterPtr;

    std::cout << "\tLMOD = ";
    locIterPtr = getLMODIterator();
    for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) {
      locIterPtr->current()->dump(std::cout,ir);
    }
    std::cout << "\tMOD = ";
    locIterPtr = getMODIterator();
    for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) {
      locIterPtr->current()->dump(std::cout,ir);
    }
    std::cout << std::endl;

    std::cout << "\tLDEF = ";
    locIterPtr = getLDEFIterator();
    for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) {
      locIterPtr->current()->dump(std::cout,ir);
    }
    std::cout << "\tDEF = ";
    locIterPtr = getDEFIterator();
    for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) {
      locIterPtr->current()->dump(std::cout,ir);
    }
    std::cout << std::endl;

    std::cout << "\tLUSE = ";
    locIterPtr = getLUSEIterator();
    for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) {
      locIterPtr->current()->dump(std::cout,ir);
    }
    std::cout << "\tUSE = ";
    locIterPtr = getUSEIterator();
    for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) {
      locIterPtr->current()->dump(std::cout,ir);
    }
    std::cout << std::endl;

    std::cout << "\tLREF = ";
    locIterPtr = getLREFIterator();
    for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) {
      locIterPtr->current()->dump(std::cout,ir);
    }
    std::cout << "\tREF = ";
    locIterPtr = getREFIterator();
    for ( ; locIterPtr->isValid(); (*locIterPtr)++ ) {
      locIterPtr->current()->dump(std::cout,ir);
    }
    std::cout << std::endl;

}

  } // end of UDDUChains namespace
} // end of OA namespace