ActiveStandard.hpp

Go to the documentation of this file.

#ifndef ActiveStandard_hpp
#define ActiveStandard_hpp

#include <cassert>
#include <iostream>
#include <list>
#include <OpenAnalysis/Utils/OA_ptr.hpp>
#include <OpenAnalysis/IRInterface/IRHandles.hpp>
#include <OpenAnalysis/ReachDefs/Interface.hpp>
#include <OpenAnalysis/DataFlow/LocDFSet.hpp>

namespace OA {
  namespace Activity {


class ActiveStandard {
  public:
    ActiveStandard(ProcHandle p);
    ~ActiveStandard() {}

    OA_ptr<SymHandleIterator> getActiveSymIterator();

    //getActiveUnnamedIterator

    bool isActive(SymHandle sym);

    bool isActive(StmtHandle stmt);

    bool isActive(MemRefHandle memref);
    
    OA_ptr<StmtHandleIterator> getActiveStmtIterator();

    OA_ptr<MemRefHandleIterator> getActiveMemRefIterator();

    OA_ptr<LocIterator> getActiveLocsIterator();


    //*****************************************************************
    // Construction methods 
    //*****************************************************************

    void insertLoc(OA_ptr<Location> loc);

    void insertStmt(StmtHandle stmt); 

    void insertMemRef(MemRefHandle memref);
    
    bool getUnknownLocActive() { return mUnknownLocActive; }

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

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

  private:
    // data members
    OA_ptr<DataFlow::LocDFSet>  mActiveLocSet;
    OA_ptr<std::set<SymHandle> > mActiveSymSet;
    bool mUnknownLocActive;

    OA_ptr<std::set<StmtHandle> > mActiveStmtSet;
    OA_ptr<std::set<MemRefHandle> > mActiveMemRefSet;

};

class ActiveSymIterator : public virtual OA::SymHandleIterator,
                          public OA::IRHandleSetIterator<OA::SymHandle>
{
public:
  ActiveSymIterator(OA::OA_ptr<std::set<OA::SymHandle> > pList) 
    : OA::IRHandleSetIterator<OA::SymHandle>(pList) {}
  ~ActiveSymIterator() {}

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


class ActiveMemRefIterator : public virtual OA::MemRefHandleIterator,
                             public OA::IRHandleSetIterator<OA::MemRefHandle>
{
public:
  ActiveMemRefIterator(OA::OA_ptr<std::set<OA::MemRefHandle> > pList) 
    : OA::IRHandleSetIterator<OA::MemRefHandle>(pList) {}
  ~ActiveMemRefIterator() {}

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


class ActiveStmtIterator : public virtual OA::IRStmtIterator,
                           public OA::IRHandleSetIterator<OA::StmtHandle>
{
public:
  ActiveStmtIterator(OA::OA_ptr<std::set<OA::StmtHandle> > pList) 
    : OA::IRHandleSetIterator<OA::StmtHandle>(pList) {}
  ~ActiveStmtIterator() {}

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



  } // end of Activity namespace
} // end of OA namespace

#endif