InterSideEffectStandard.hpp

Go to the documentation of this file.

#ifndef InterSideEffectStandard_hpp
#define InterSideEffectStandard_hpp

#include <set>
#include <map>
#include <OpenAnalysis/Utils/OA_ptr.hpp>
#include <OpenAnalysis/IRInterface/IRHandles.hpp>
#include <OpenAnalysis/SideEffect/InterSideEffectInterface.hpp>
#include <OpenAnalysis/SideEffect/SideEffectStandard.hpp>
#include <OpenAnalysis/OABase/Annotation.hpp>
#include <OpenAnalysis/Utils/GenOutputTool.hpp>


namespace OA {
  namespace SideEffect {

/* 
   
*/
class InterSideEffectStandard : public InterSideEffectInterface,
                                public virtual Annotation
{
  public:
    InterSideEffectStandard();
    ~InterSideEffectStandard() {}

    //*****************************************************************
    // Interface Implementation
    //*****************************************************************
    
    OA_ptr<ProcIterator> getKnownProcIterator();
    
    //*************************************************************************

    OA_ptr<LocIterator> getLMODIterator(CallHandle call);

    OA_ptr<LocIterator> getMODIterator(CallHandle call);

    OA_ptr<LocIterator> getLDEFIterator(CallHandle call);

    OA_ptr<LocIterator> getDEFIterator(CallHandle call);

    OA_ptr<LocIterator> getLUSEIterator(CallHandle call);

    OA_ptr<LocIterator> getUSEIterator(CallHandle call);

    OA_ptr<LocIterator> getLREFIterator(CallHandle call);

    OA_ptr<LocIterator> getREFIterator(CallHandle call);

    //************************************************************************
    
    OA_ptr<LocIterator> getLMODIterator(ProcHandle p);

    OA_ptr<LocIterator> getMODIterator(ProcHandle p);

    OA_ptr<LocIterator> getLDEFIterator(ProcHandle p);

    OA_ptr<LocIterator> getDEFIterator(ProcHandle p);

    OA_ptr<LocIterator> getLUSEIterator(ProcHandle p);

    OA_ptr<LocIterator> getUSEIterator(ProcHandle p);

    OA_ptr<LocIterator> getLREFIterator(ProcHandle p);

    OA_ptr<LocIterator> getREFIterator(ProcHandle p);

    //*****************************************************************
    // Construction methods
    //*****************************************************************
    
    void mapProcToSideEffect(ProcHandle proc, 
                         OA_ptr<OA::SideEffect::SideEffectStandard> sideEffect);
    
    OA_ptr<OA::SideEffect::SideEffectStandard> 
        getSideEffectResults(ProcHandle proc);

    void mapCallToSideEffect(CallHandle call, 
                         OA_ptr<OA::SideEffect::SideEffectStandard> sideEffect);
    
    
    int getLocCount(ProcHandle proc);
    
    void insertLMOD(CallHandle call, OA_ptr<Location> loc);
    
    void insertMOD(CallHandle call, OA_ptr<Location> loc);
    
    void insertLDEF(CallHandle call, OA_ptr<Location> loc);
    
    void insertDEF(CallHandle call, OA_ptr<Location> loc);
    
    void insertLUSE(CallHandle call, OA_ptr<Location> loc);
    
    void insertUSE(CallHandle call, OA_ptr<Location> loc);
    
    void insertLREF(CallHandle call, OA_ptr<Location> loc);
    
    void insertREF(CallHandle call, OA_ptr<Location> loc);

    void initCallSideEffect(CallHandle call);

   
    //*****************************************************************
    // Output
    //*****************************************************************
  public:

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

  private:

    OUTPUT 
    
    GENOUT typedef std::map<ProcHandle,OA_ptr<OA::SideEffect::SideEffectStandard> >  
            ProcToSideEffectMap;
    GENOUT typedef std::map<CallHandle,OA_ptr<OA::SideEffect::SideEffectStandard> >  
            CallToSideEffectMap;

    // mappings of procedures to various sets
    GENOUT ProcToSideEffectMap mProcToSideEffectMap;

    // mapping function calls to various sets
    GENOUT CallToSideEffectMap mCallToSideEffectMap;

    // default SideEffect results
    OA_ptr<OA::SideEffect::Interface> mDefaultSideEffect;

    class InterSideEffectProcIter : public virtual ProcIterator,
                                    public IRHandleSetIterator<ProcHandle>
    {
      public:
        InterSideEffectProcIter(OA_ptr<std::set<ProcHandle> > pSet )
            : IRHandleSetIterator<ProcHandle>(pSet) {}
        ~InterSideEffectProcIter() { }

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


};


  } // end of SideEffect namespace
} // end of OA namespace

#endif