AliasMap.hpp

Go to the documentation of this file.

#ifndef AliasMap_H
#define AliasMap_H

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

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

namespace OA {
  namespace Alias {

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

class AliasMapMemRefIter : public virtual MemRefIterator,
                           public IRHandleSetIterator<MemRefHandle>
{
  public:
    AliasMapMemRefIter(OA_ptr<std::set<MemRefHandle> > pSet) 
        : IRHandleSetIterator<MemRefHandle>(pSet) {}
    ~AliasMapMemRefIter() {}

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

class IdIterator {
  public:
    IdIterator(std::map<int, OA_ptr<LocSet> >& aMap)
      {
        // iterate through ids and put them in a set
        std::map<int,OA_ptr<LocSet> >::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 AliasMap : public virtual Alias::Interface,
                 public virtual Annotation 
{
  public:
    AliasMap();
    AliasMap(ProcHandle p);
    AliasMap(AliasMap& other);
    ~AliasMap() {}

    static const int SET_ID_NONE; 

    //*****************************************************************
    // Alias::Interface 
    //*****************************************************************
    
    AliasResultType alias(MemRefHandle ref1, MemRefHandle ref2);
    
    OA_ptr<LocIterator> getMayLocs(MemRefHandle ref);

    OA_ptr<LocIterator> getMustLocs(MemRefHandle ref);

    OA_ptr<LocIterator> getMayLocs(MemRefExpr &ref, ProcHandle proc);

    OA_ptr<LocIterator> getMustLocs(MemRefExpr &ref, ProcHandle proc);

    OA_ptr<MemRefIterator> getMustAliases(MemRefHandle ref);

    OA_ptr<MemRefIterator> getMayAliases(MemRefHandle ref);

    OA_ptr<MemRefIterator> getMustAliases(OA_ptr<Location> loc);

    OA_ptr<MemRefIterator> getMayAliases(OA_ptr<Location> loc);

    OA_ptr<MemRefIterator> getMemRefIter();

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

    OA_ptr<std::set<int> > getMapSetIds(MemRefHandle ref);
     
    int getMapSetId(OA_ptr<MemRefExpr> mre); 
    
    int getMapSetId(OA_ptr<OA::Location> pLoc); 
     
    int getMapSetId(LocSet pLocSet); 

    OA_ptr<IdIterator> getIdIterator();
 
    //OA_ptr<Location> getLocForSym(SymHandle sym);

    OA_ptr<LocIterator> getLocIterator(int setId); 

  /*
    bool isMust(int setId)
    { return mIdToSetStatusMap[setId]; }
  */

    bool isMust(int setId)
    { return (mIdToSetStatusMap[setId] == MUSTALIAS); }

    //*****************************************************************
    // Construction methods 
    //*****************************************************************
    
    //void setStartId(int s) { mStartId = s; }

    int getUnknownLocSetId() { return 0; }

    int getNextId() { return mStartId + mNumSets; }

    int makeEmptySet();
 
    void mapMemRefToMapSet(MemRefHandle ref, int setId);

    void mapMemRefToMapSet(OA_ptr<MemRefExpr> ref, int setId);

    void addLocation(OA_ptr<Location> loc, int setId);

    OA_ptr<std::map<int,OA_ptr<LocSet> > > getIdToLocSetMap();

    void aliasLocs(OA_ptr<Location> loc1, OA_ptr<Location> loc2);

    void remapMemRefs(int oldSetId, int newSetId);

    void mapToUnknown(int setId);

    void removeInvisibleLocs(int setId);

    void removeInvisibleLocs(int setId, OA_ptr<MemRefExpr> inv_memref);

    void removeBaseLoc(OA_ptr<Location> baseLoc, int setId);

    bool isPartial(int setId, OA_ptr<MemRefExpr> invloc);

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

    void output(IRHandlesIRInterface& pIR);

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

  private:

    OUTPUT

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

    // keep track of id mapping to location sets and status with a map
    GENOUT int mNumSets; 
    GENOUT int mStartId;
    GENOUT std::map<int,OA_ptr<LocSet> > mIdToLocSetMap; 
    GENOUT std::map<int,AliasResultType> mIdToSetStatusMap;

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

    // what memory reference expressions map to this alias map set
    GENOUT std::map<int,MemRefExprSet> mIdToMRESetMap;

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

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

    // the location set a MemRefExpr maps to
    GENOUT std::map<OA_ptr<MemRefExpr>,int> mMREToIdMap;  

    // the location set a Location belongs to
    GENOUT std::map<OA_ptr<Location>,int> mLocToIdMap;    

};


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

#endif