UDDUChainsStandard.hpp

Go to the documentation of this file.

#ifndef UDDUChainsStandard_hpp
#define UDDUChainsStandard_hpp

#include <cassert>
#include <iostream>
#include <map>
#include <set>
#include <vector>
#include <list>
#include <OpenAnalysis/Utils/OA_ptr.hpp>
#include <OpenAnalysis/IRInterface/IRHandles.hpp>
#include <OpenAnalysis/UDDUChains/Interface.hpp>
#include <OpenAnalysis/OABase/Annotation.hpp>
#include <OpenAnalysis/Utils/GenOutputTool.hpp>



namespace OA {
  namespace UDDUChains {

//typedef std::set<StmtHandle> StmtSet;


class UDDUChainsStandard : public virtual UDDUChains::Interface, public virtual Annotation
{

public:
    UDDUChainsStandard(ProcHandle p) 
        { mUDChainForStmt = new std::map<StmtHandle,OA_ptr<StmtSet> >;
          mDUChainForStmt = new std::map<StmtHandle,OA_ptr<StmtSet> >;
          mUDChainForMemRef = new std::map<MemRefHandle,OA_ptr<StmtSet> >;
          mDUChainForMemRef = new std::map<MemRefHandle,OA_ptr<StmtSet> >;
        } 
    ~UDDUChainsStandard() {}

    //StmtHandle getStmtHandle(MemRefHandle ref)
    //{ return mMemRefToStmtMap[ref]; }
    
    OA_ptr<Interface::ChainStmtIterator> getUDChainStmtIterator(StmtHandle s);

    OA_ptr<Interface::StmtsWithUDChainIterator> getStmtsWithUDChainIterator();

    OA_ptr<Interface::ChainStmtIterator> getDUChainStmtIterator(StmtHandle s);

    OA_ptr<Interface::StmtsWithDUChainIterator> getStmtsWithDUChainIterator();

    OA_ptr<Interface::ChainStmtIterator> getUDChainStmtIterator(MemRefHandle h);

    OA_ptr<Interface::MemRefsWithUDChainIterator> 
    getMemRefsWithUDChainIterator();

    OA_ptr<Interface::ChainStmtIterator> getDUChainStmtIterator(MemRefHandle h);

    OA_ptr<Interface::MemRefsWithDUChainIterator> 
    getMemRefsWithDUChainIterator();

    //*****************************************************************
    // Construction methods 
    // FIXME: the relationships between these aren't being verified
    // or asserted
    //*****************************************************************

    void insertMemRefDef(MemRefHandle ref);
    void insertMemRefUse(MemRefHandle ref);

    void insertDefUse(StmtHandle def, StmtHandle use);

    void insertMemRefDefStmtUse(MemRefHandle def, StmtHandle use);

    void insertStmtDefMemRefUse(StmtHandle def, MemRefHandle use);

    //void insertMemRefToStmtMapping(MemRefHandle ref, StmtHandle stmt)
    //{ mMemRefToStmtMap[ref] = stmt; }

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

    void output(IRHandlesIRInterface& pIR);
    
    void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);

  private:
    // data members
    OUTPUT
    
    GENOUT OA_ptr<std::map<StmtHandle,OA_ptr<StmtSet> > > mUDChainForStmt;
    GENOUT OA_ptr<std::map<StmtHandle,OA_ptr<StmtSet> > > mDUChainForStmt;
    GENOUT OA_ptr<std::map<MemRefHandle,OA_ptr<StmtSet> > > mUDChainForMemRef;
    GENOUT OA_ptr<std::map<MemRefHandle,OA_ptr<StmtSet> > > mDUChainForMemRef;
    GENOUT std::map<MemRefHandle,StmtHandle>  mMemRefToStmtMap;

  public:

    //*****************************************************************
    // Iterators
    //*****************************************************************
    class ChainStmtIterator : public IRHandleSetIterator<StmtHandle>,
                              public Interface::ChainStmtIterator
    {
      public:
        ChainStmtIterator(OA_ptr<std::set<StmtHandle> > pSet) 
            : IRHandleSetIterator<StmtHandle>(pSet) {}
        ~ChainStmtIterator() {}

        void operator++() { IRHandleSetIterator<StmtHandle>::operator++(); }
        bool isValid() const
          { return IRHandleSetIterator<StmtHandle>::isValid(); }
        StmtHandle current() const
          { return IRHandleSetIterator<StmtHandle>::current(); }
        void reset() { IRHandleSetIterator<StmtHandle>::current(); }
    };

    class StmtsWithUDChainIterator : public Interface::StmtsWithUDChainIterator 
    {
      public:
        StmtsWithUDChainIterator(OA_ptr<std::map<StmtHandle,
                                                OA_ptr<StmtSet> > > pMap) 
            : mMap(pMap), mIter(pMap->begin()) { }
        ~StmtsWithUDChainIterator() { }

        StmtHandle current() const { return mIter->first; }
        bool isValid() const { return (mIter != mMap->end()); }
        void operator++() { if (isValid()) mIter++; }
        void reset() { mIter = mMap->begin(); }

      private:
        OA_ptr<std::map<StmtHandle,OA_ptr<StmtSet> > > mMap;
        std::map<StmtHandle,OA_ptr<StmtSet> >::iterator mIter;

    };

    typedef StmtsWithUDChainIterator StmtsWithDUChainIterator;

    class MemRefsWithUDChainIterator 
        : public Interface::MemRefsWithUDChainIterator 
    {
      public:
        MemRefsWithUDChainIterator(OA_ptr<std::map<MemRefHandle,
                                                OA_ptr<StmtSet> > > pMap) 
            : mMap(pMap), mIter(pMap->begin()) { }
        ~MemRefsWithUDChainIterator() { }

        MemRefHandle current() const { return mIter->first; }
        bool isValid() const { return (mIter != mMap->end()); }
        void operator++() { if (isValid()) mIter++; }
        void reset() { mIter = mMap->begin(); }

      private:
            
        OA_ptr<std::map<MemRefHandle,OA_ptr<StmtSet> > > mMap;
        std::map<MemRefHandle,OA_ptr<StmtSet> >::iterator mIter;
    };

    typedef MemRefsWithUDChainIterator MemRefsWithDUChainIterator;
};

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

#endif