ParamBindings.hpp

Go to the documentation of this file.

#ifndef ParamBindings_h
#define ParamBindings_h

#include <iostream>
#include <map>

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

namespace OA {
  namespace DataFlow {

class ParamBindings : public virtual Annotation {
public:
  ParamBindings() { }
  ~ParamBindings() {}

  MemRefHandle getCallerMemRef(CallHandle call, SymHandle calleeFormal);

  OA_ptr<MemRefHandleIterator> getActualIterator(CallHandle call);

  SymHandle getCalleeFormal(CallHandle call, MemRefHandle callerRef,
                            ProcHandle callee);

  OA_ptr<SymHandleIterator> getFormalIterator(ProcHandle proc);

  //bool isRefParam(SymHandle formal);

  OA_ptr<ExprHandleIterator> getActualExprHandleIterator(CallHandle call);

  OA_ptr<ExprTree> getActualExprTree(ExprHandle expr);

  ExprHandle getActualExprHandle(CallHandle call, SymHandle formal);

  //*****************************************************************
  // Output
  //*****************************************************************
  void output(IRHandlesIRInterface& ir);

  void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);
  
  //*****************************************************************
  // Construction methods 
  //*****************************************************************
  void mapMemRefToFormal(CallHandle call, MemRefHandle ref, 
                         ProcHandle callee, SymHandle sym);
  //void setRefParam(SymHandle sym);
  void mapFormalToProc(SymHandle formal, ProcHandle proc);
  //void mapActualToCall(MemRefHandle actual, CallHandle call);

  void mapCallToExprList(CallHandle call,OA_ptr<std::list<ExprHandle> > elist);
  void mapExprToTree(ExprHandle act_expr, OA_ptr<ExprTree> etree);
  void mapFormalToExpr(CallHandle call, SymHandle formal, ExprHandle act_expr);

private:
  OUTPUT

  GENOUT std::map<CallHandle,std::map<ProcHandle,std::map<MemRefHandle,SymHandle> > > 
      mCallerToCalleeMap;
  GENOUT std::map<CallHandle,std::map<SymHandle,MemRefHandle> > mCalleeToCallerMap;
  std::map<ProcHandle,OA_ptr<std::set<SymHandle> > > mProcToFormalSetMap;
  std::map<CallHandle,OA_ptr<std::set<MemRefHandle> > > mCallToActualSetMap;
  //std::map<SymHandle,bool> mIsRefParam;

  GENOUT std::map<CallHandle,OA_ptr<std::list<ExprHandle> > > mCallToExprListMap;
  GENOUT std::map<ExprHandle,OA_ptr<ExprTree> > mExprToTreeMap;
  GENOUT std::map<CallHandle,std::map<SymHandle,ExprHandle> > mCallToFormalToActualMap;
  

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

    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>::reset(); }
  };
  
  class MemRefIterator : public virtual OA::MemRefHandleIterator,
                         public OA::IRHandleSetIterator<OA::MemRefHandle>
  {
  public:
    MemRefIterator(OA::OA_ptr<std::set<OA::MemRefHandle> > pList) 
      : OA::IRHandleSetIterator<OA::MemRefHandle>(pList) {}
    ~MemRefIterator() {}

    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>::reset(); }
  };

  class ExprIterator : public virtual OA::ExprHandleIterator,
                      public OA::IRHandleListIterator<OA::ExprHandle>
  {
  public:
    ExprIterator(OA::OA_ptr<std::list<OA::ExprHandle> > eList) 
      : OA::IRHandleListIterator<OA::ExprHandle>(eList) {}
    ~ExprIterator() {}

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


};

  } // end of DataFlow namespace
} // end of OA namespace

#endif