AliasMapXAIF.hpp

Go to the documentation of this file.

#ifndef AliasMapXAIF_H
#define AliasMapXAIF_H

#include <cassert>
#include <iostream>
#include <map>
#include <set>
#include <vector>
#include <OpenAnalysis/Utils/OA_ptr.hpp>
#include <OpenAnalysis/Alias/Interface.hpp>
#include <OpenAnalysis/Alias/AliasMap.hpp>
#include <OpenAnalysis/MemRefExpr/MemRefExpr.hpp>
#include <OpenAnalysis/Location/Locations.hpp>

#include <OpenAnalysis/IRInterface/IRHandles.hpp>
#include <OpenAnalysis/OABase/Annotation.hpp>

namespace OA {
  namespace XAIF {

typedef std::set<MemRefHandle> MemRefSet;
//typedef std::set<OA_ptr<Location::Location> > LocSet;

class LocRange : public virtual Annotation {
  public:
    LocRange(int start, int end) : mStart(start), mEnd(end) {}
    ~LocRange() {}

    int getStart() const { return mStart; }
    int getEnd() const { return mEnd; }

    void output(IRHandlesIRInterface& ir)
    {
        sOutBuild->objStart("LocRange");
        sOutBuild->field("mStart", OA::int2string(mStart) );
        sOutBuild->field("mEnd", OA::int2string(mEnd) );
        sOutBuild->objEnd("LocRange");
    }
  private:
    int mStart, mEnd;
};

class LocTuple : public virtual Annotation {
  public:
    LocTuple() : mRange(0,0), mFullOverlap(false) {}
    LocTuple(int start, int end, bool fullOverlap) 
        : mRange(start,end), mFullOverlap(fullOverlap) {}
    ~LocTuple() {}

    LocRange getLocRange() const { return mRange; }
    bool isFull() const { return mFullOverlap; }

    bool operator==(const LocTuple& other) const
    { if (mRange.getStart() == other.getLocRange().getStart()
          && mRange.getEnd() == other.getLocRange().getEnd()
          && mFullOverlap == other.mFullOverlap) 
      { return true;} else { return false; }
    }

    bool operator!=(const LocTuple& other) const 
    { return !(*this == other); }

    bool operator<(const LocTuple& other) const
    { if (*this == other)  { return false; }
      else if (mRange.getStart() < other.mRange.getStart()) { return true; }
      else if (mRange.getStart() > other.mRange.getStart()) { return false; }
      else if (mRange.getEnd() < other.mRange.getEnd()) { return true; }
      else if (mRange.getEnd() > other.mRange.getEnd()) { return false; }
      else if (mFullOverlap == true) { return true; }
      else { return false; }
    }

    void output(IRHandlesIRInterface& ir) 
    {
        sOutBuild->objStart("LocTuple");
        sOutBuild->fieldStart("mRange");
        mRange.output(ir);
        sOutBuild->fieldEnd("mRange");
        sOutBuild->field("mFullOverlap",OA::bool2string(mFullOverlap));
        sOutBuild->objEnd("LocTuple");
    }
       
  private:
    LocRange mRange;
    bool mFullOverlap;
};


class IdIterator{
  public:
    IdIterator(std::map<int,OA_ptr<std::set<LocTuple> > >& aMap)
      {
        // iterate through ids and put them in a set
        std::map<int,OA_ptr<std::set<LocTuple> > >::iterator mapIter;
        for (mapIter=aMap.begin(); mapIter!=aMap.end(); mapIter++) {
            mSet.insert(mapIter->first);
        }
        reset();
      }
    ~IdIterator() {}

    void operator++() { if (isValid()) mIter++; }
    bool isValid() const  { return mIter!=mSet.end(); }
    int current() const  { return *mIter; }
    void reset() { mIter = mSet.begin(); }
  private:
    std::set<int> mSet;
    std::set<int>::iterator mIter;
};

class LocTupleIterator {
  public:
    LocTupleIterator(std::set<LocTuple>& pSet)
      {
        // copy the set so we don't depend on aSet hanging around in memory
        mSet = pSet;
        reset();
      }
    ~LocTupleIterator() {}

    void operator++() { if (isValid()) mIter++; }
    bool isValid() const  { return mIter!=mSet.end(); }
    LocTuple current() const  { return *mIter; }
    void reset() { mIter = mSet.begin(); }
  private:
    std::set<LocTuple> mSet;
    std::set<LocTuple>::iterator  mIter;
};


class AliasMapXAIF : public virtual Annotation {
  public:
    AliasMapXAIF(ProcHandle p);
    ~AliasMapXAIF() {}

    static const int SET_ID_NONE = -1; 

    OA_ptr<MemRefHandleIterator> getMemRefIter();

    //*****************************************************************
    // Info methods unique to Alias::AliasMapXAIF
    //*****************************************************************

    int getMapSetId(MemRefHandle ref); 
     
    int findMapSet(MemRefHandle ref);

    int findMapSet(OA_ptr<std::set<LocTuple> > pLocTupleSet);

    OA_ptr<IdIterator> getIdIterator();

    OA_ptr<LocTupleIterator> getLocIterator(int setId); 

    //*****************************************************************
    // Construction methods 
    //*****************************************************************
    
    void mapLocTupleSet(OA_ptr<std::set<LocTuple> > ltSet, int setId);

    void mapMemRefToMapSet(MemRefHandle ref, int setId);

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

    void output(IRHandlesIRInterface& ir);

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

  private:
    // data members
    ProcHandle mProcHandle; // procedure these sets are associated with

    // keep track of id mapping to location sets and status with a map
    std::map<int,OA_ptr<std::set<LocTuple> > > mIdToLocTupleSetMap; 

    // what memory references map to this alias map set
    std::map<int,MemRefSet> mIdToMemRefSetMap;

    // the location set a MemRefHandle maps to
    std::map<MemRefHandle,int> mMemRefToIdMap;  

    // set of memrefexpr for a memref
    std::map<MemRefHandle,std::set<OA_ptr<MemRefExpr> > > 
        mMemRefToMRESetMap;
};


  } // end of Alias namespace
} // end of OA namespace

#endif