MemRefExpr.hpp

Go to the documentation of this file.

#ifndef MemRefExpr_H
#define MemRefExpr_H

#include <iostream>
#include <cassert>
#include <OpenAnalysis/Utils/OA_ptr.hpp>
#include <OpenAnalysis/IRInterface/IRHandles.hpp>
#include <OpenAnalysis/OABase/Annotation.hpp>

namespace OA {

class MemRefExpr;
class IdxExprAccess;
class MemRefExpr;
class NamedRef;
class UnnamedRef;
class UnknownRef;
class RefOp;
class Deref;
class SubSetRef;
class IdxAccess;
class IdxExprAccess;
class FieldAccess;

class MemRefExprVisitor;

// ----- Iterator classes -----
template<class T>
class MREIteratorClass {
  public:
    MREIteratorClass() { }
    virtual ~MREIteratorClass() { }

    // Returns the current item.
    virtual OA_ptr<T> current() const = 0;

    // False when all items are exhausted.;
    virtual bool isValid() const = 0;

    virtual void operator++() = 0;
    void operator++(int) { ++*this; } ;

    virtual void reset() = 0;
};

typedef MREIteratorClass<MemRefExpr>    MemRefExprIterator;
typedef MREIteratorClass<NamedRef>      NamedRefIterator;
typedef MREIteratorClass<UnnamedRef>    UnnamedRefIterator;
typedef MREIteratorClass<UnknownRef>    UnknownRefIterator;
typedef MREIteratorClass<RefOp>         RefOpIterator;
typedef MREIteratorClass<Deref>         DerefIterator;
typedef MREIteratorClass<SubSetRef>     SubSetRefIterator;
typedef MREIteratorClass<IdxAccess>     IdxAccessIterator;
typedef MREIteratorClass<IdxExprAccess> IdxExprAccessIterator;
typedef MREIteratorClass<FieldAccess>   FieldAccessIterator;

// ------ MemRefExpr classes -----

class MemRefExpr : public Annotation {
  public:
    typedef enum {
      USE,     // mem ref specifies where to find source location for use
      DEF,     // mem ref specifies where to put result of assign
      USEDEF,  // mem ref that specifies a location that will be used first
               // and then defined (eg. i++)
      DEFUSE   // mem ref that specifies a location that will be defined first
               // and then used (eg. i++)
    } MemRefType;

    MemRefExpr(MemRefType mrType) : mMemRefType(mrType) {}

    MemRefExpr(MemRefExpr &mre) : mMemRefType(mre.mMemRefType) {}

    virtual ~MemRefExpr() {}

    virtual void acceptVisitor(MemRefExprVisitor& pVisitor) = 0;

    // return a ptr to a copy of self
    virtual OA_ptr<MemRefExpr> clone() = 0;

    //*****************************************************************
    // Subclass type methods 
    //*****************************************************************
    virtual bool isaNamed() { return false; }
    virtual bool isaUnnamed() { return false; }
    virtual bool isaUnknown() { return false; }
    virtual bool isaRefOp() { return false; }
    
    virtual bool isaDeref() { return false; }
    virtual bool isaAddressOf() { return false; }

    virtual bool isaSubSetRef() { return false; }
    virtual bool isaIdxAccess() { return false; }
    virtual bool isaIdxExprAccess() { return false; }
    virtual bool isaFieldAccess() { return false; }

    //*****************************************************************
    // Info methods 
    //*****************************************************************
    
    MemRefType getMRType() { return mMemRefType; }

    bool isDef() { return (mMemRefType==DEF 
                           || mMemRefType == USEDEF || mMemRefType == DEFUSE); }

    bool isUse() { return (mMemRefType==USE 
                          || mMemRefType == USEDEF || mMemRefType == DEFUSE); }

    bool isDefUse() { return (mMemRefType==DEFUSE); }

    bool isUseDef() { return (mMemRefType==USEDEF); }

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

    void setMemRefType(MemRefExpr::MemRefType mrType) { mMemRefType = mrType; }

    //*****************************************************************
    // Relationship methods 
    //*****************************************************************

    virtual bool operator<(MemRefExpr & other);

    virtual bool operator==(MemRefExpr& other);
    
    bool operator!=(MemRefExpr& other) { return ! ((*this)==other); }
    
    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir); 

    // helper functions for output
    virtual std::string typeString() { return "MemRefExpr"; }
    std::string toString(MemRefType);

    //*****************************************************************
    // Debugging methods 
    //*****************************************************************
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR);
    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);

    virtual int getOrder() { assert(0); return sOrder; }

private:
    static const int sOrder = -100;
    MemRefType mMemRefType;
};

class NamedRef: public MemRefExpr {
  public:

    NamedRef(MemRefType mrType, SymHandle sh)
        : MemRefExpr(mrType), mSymHandle(sh) { }

    NamedRef(NamedRef &mre) : MemRefExpr(mre), mSymHandle(mre.mSymHandle) { }
    
    NamedRef(MemRefExpr &mre, SymHandle sh) : MemRefExpr(mre), mSymHandle(sh) {}

    ~NamedRef() { }

    void acceptVisitor(MemRefExprVisitor& pVisitor);

    OA_ptr<MemRefExpr> clone();

    //*****************************************************************
    // Subclass type methods 
    //*****************************************************************
    bool isaNamed() { return true; }
    
    //*****************************************************************
    // Info methods 
    //*****************************************************************
    SymHandle getSymHandle() { return mSymHandle; }
    virtual std::string typeString() { return "NamedRef"; }
    
    //*****************************************************************
    // Relationship methods 
    //*****************************************************************

    bool operator<(MemRefExpr & other);

    bool operator==(MemRefExpr& other);

    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir); 

    //*****************************************************************
    // Debugging methods 
    //*****************************************************************
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR);
    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);

    virtual int getOrder() { return sOrder; }

  private:
    static const int sOrder = 100;
    SymHandle mSymHandle;
};

class UnnamedRef: public MemRefExpr {
  public:

    UnnamedRef(MemRefType mrType, ExprHandle sh, ProcHandle proc)
        : MemRefExpr(mrType), mExprHandle(sh), mLocal(true), mProcHandle(proc) { }


    UnnamedRef(MemRefType mrType, ExprHandle sh)
        : MemRefExpr(mrType), mExprHandle(sh), mLocal(false) { }


    UnnamedRef(UnnamedRef &mre) : MemRefExpr(mre), 
                                  mExprHandle(mre.mExprHandle),
                                  mLocal(mre.mLocal),
                                  mProcHandle(mre.mProcHandle) {}
    
    UnnamedRef(MemRefExpr &mre, ExprHandle s, ProcHandle p)
        : MemRefExpr(mre), mExprHandle(s), mLocal(true), mProcHandle(p) {}


    UnnamedRef(MemRefExpr &mre, ExprHandle s)
        : MemRefExpr(mre), mExprHandle(s), mLocal(false) {}


    ~UnnamedRef() { }

    void acceptVisitor(MemRefExprVisitor& pVisitor);

    OA_ptr<MemRefExpr> clone();

    //*****************************************************************
    // Subclass type methods 
    //*****************************************************************
    bool isaUnnamed() { return true; }
    
    //*****************************************************************
    // Info methods 
    //*****************************************************************
    ExprHandle getExprHandle() { return mExprHandle; }

    bool isLocal() { return mLocal; }

    ProcHandle getProcHandle() { return mProcHandle; }
    
    //*****************************************************************
    // Relationship methods 
    //*****************************************************************

    bool operator<(MemRefExpr & other);

    bool operator==(MemRefExpr& other);
    
    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir); 
    virtual std::string typeString() { return "UnnamedRef"; }

    //*****************************************************************
    // Debugging methods 
    //*****************************************************************
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR);
    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);

    virtual int getOrder() { return sOrder; }

  private:
    static const int sOrder = 200;
    ExprHandle mExprHandle;
    bool mLocal;
    ProcHandle mProcHandle;
};

class UnknownRef: public MemRefExpr {
  public:

    UnknownRef(MemRefType mrType)
        : MemRefExpr(mrType) { }

    UnknownRef(UnknownRef &mre) : MemRefExpr(mre) {}

    ~UnknownRef() { }

    void acceptVisitor(MemRefExprVisitor& pVisitor);

    OA_ptr<MemRefExpr> clone();

    //*****************************************************************
    // Subclass type methods 
    //*****************************************************************
    bool isaUnknown() { return true; }
    
    //*****************************************************************
    // Relationship methods 
    //*****************************************************************

    bool operator<(MemRefExpr & other);

    bool operator==(MemRefExpr& other);
    
    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir); 
    virtual std::string typeString() { return "UnknownRef"; }

    //*****************************************************************
    // Debugging methods 
    //*****************************************************************
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR);
    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);

    virtual int getOrder() { return sOrder; }

  private:
    static const int sOrder = 100000000;
};


class RefOp: public MemRefExpr {
  public:

    RefOp( MemRefType mrType, OA_ptr<MemRefExpr> mre)
        : MemRefExpr(mrType), mMRE(mre) { }
 

    RefOp(RefOp & mre) : MemRefExpr(mre), mMRE(mre.mMRE) { }

    virtual ~RefOp() { }
    
    //*****************************************************************
    // MemRefExpr subclass type methods 
    //*****************************************************************
    bool isaRefOp() { return true; }

    //*****************************************************************
    // Info methods 
    //*****************************************************************
    SymHandle getBaseSym();

    virtual std::string typeString() { return "RefOp"; }

    OA_ptr<MemRefExpr> getBase();

    OA_ptr<MemRefExpr> getMemRefExpr() { return mMRE; }

    //*****************************************************************
    // Relationship methods, will be defined in subclasses 
    //*****************************************************************

    //*****************************************************************
    // Construction Method
    //*****************************************************************
    
    virtual OA_ptr<MemRefExpr> composeWith(OA_ptr<MemRefExpr> mre) = 0;
    
    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    virtual void output(IRHandlesIRInterface& ir); 


private:
    OA_ptr<MemRefExpr> mMRE;

};


/* AddressOf class: represents if MemRefExpr has AddressTaken*/
class AddressOf: public RefOp { 
  public: 

    AddressOf(MemRefType mrType, OA_ptr<MemRefExpr> mre)
        : RefOp(mrType, mre) { }
  
    AddressOf(AddressOf & mre) : RefOp(mre) { } 
 
    ~AddressOf() { } 

    void acceptVisitor(MemRefExprVisitor& pVisitor);

    OA_ptr<MemRefExpr> clone();

    virtual std::string typeString() { return "AddressOf"; }

    //*****************************************************************
    // RefOp subclass type methods
    //*****************************************************************
    bool isaAddressOf() { return true; }

    //*****************************************************************
    // Relationship methods
    //*****************************************************************

    bool operator<(MemRefExpr & other);

    bool operator==(MemRefExpr& other);

    //*****************************************************************
    // Construction Method
    //*****************************************************************
    OA_ptr<MemRefExpr> composeWith(OA_ptr<MemRefExpr> mre);

    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir);

    //*****************************************************************
    // Debugging methods
    //*****************************************************************
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR);
    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);

    virtual int getOrder() { return sOrder; }

 private: 
    static const int sOrder = 350; 
}; 


class Deref: public RefOp {
  public:

    Deref(MemRefType mrType, OA_ptr<MemRefExpr> mre,
          int numDeref)
      : RefOp(mrType, mre), mNumDeref(numDeref) { }

    
    // default values
    Deref(MemRefType mrType, OA_ptr<MemRefExpr> mre)
      : RefOp(mrType, mre), mNumDeref(1) { }

    
    Deref(Deref &mre) : RefOp(mre), mNumDeref(mre.mNumDeref) {}

    ~Deref() { }

    void acceptVisitor(MemRefExprVisitor& pVisitor);

    OA_ptr<MemRefExpr> clone();

    //*****************************************************************
    // RefOp subclass type methods 
    //*****************************************************************
    bool isaDeref() { return true; }
    
    //*****************************************************************
    // Info methods 
    //*****************************************************************
    int getNumDerefs() { return mNumDeref; }
    virtual std::string typeString() { return "Deref"; }

    //*****************************************************************
    // Relationship methods
    //*****************************************************************
    
    bool operator<(MemRefExpr & other);

    bool operator==(MemRefExpr& other);
    
    //*****************************************************************
    // Construction Method
    //*****************************************************************
    
    OA_ptr<MemRefExpr> composeWith(OA_ptr<MemRefExpr> mre);
    
    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir); 

    //*****************************************************************
    // Debugging methods 
    //*****************************************************************
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR);
    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);

    virtual int getOrder() { return sOrder; }

private:
    static const int sOrder = 300;
    int mNumDeref;
};

class SubSetRef: public RefOp {
  public:

    SubSetRef( MemRefType mrType, OA_ptr<MemRefExpr> mre)
      : RefOp(mrType, mre) {} //{ if (!mre.ptrEqual(0)) assert( ! mre->isaSubSetRef() ); }

    SubSetRef(SubSetRef & mre) : RefOp(mre) { }

    virtual ~SubSetRef() { }

    void acceptVisitor(MemRefExprVisitor& pVisitor);

    OA_ptr<MemRefExpr> clone();

    //*****************************************************************
    // RefOp subclass type methods 
    //*****************************************************************
    virtual bool isaSubSetRef() { return true; }
    virtual bool isSubClassOfSubSetRef() { return false; }
    
    //*****************************************************************
    // Relationship methods, will be defined in subclasses
    //*****************************************************************
    
    virtual bool operator<(MemRefExpr & other);

    virtual bool operator==(MemRefExpr& other);
    
    //*****************************************************************
    // Construction Method
    //*****************************************************************
    
    OA_ptr<MemRefExpr> composeWith(OA_ptr<MemRefExpr> mre);
 
    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir); 
    virtual std::string typeString() { return "SubSetRef"; }

    //*****************************************************************
    // Debugging methods    
    //****************************************************************    
    virtual void dump(std::ostream& os, 
                       OA_ptr<IRHandlesIRInterface> pIR);  

    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);
    virtual int getOrder() { return sOrder; }          

private:
    static const int sOrder = 600;

};


class IdxAccess: public SubSetRef {
  public:

    IdxAccess(MemRefType mrType, OA_ptr<MemRefExpr> mre, int idx)
      : SubSetRef(mrType,mre), mIdx(idx) { }

    IdxAccess(IdxAccess &mre) : SubSetRef(mre), mIdx(mre.mIdx) {}

    ~IdxAccess() { }

    void acceptVisitor(MemRefExprVisitor& pVisitor);

    OA_ptr<MemRefExpr> clone();

    //*****************************************************************
    // SubSetRef subclass type methods 
    //*****************************************************************
    bool isaIdxAccess() { return true; }
    bool isSubClassOfSubSetRef() { return true; }
    
    //*****************************************************************
    // Info methods 
    //*****************************************************************
    int getIdx() { return mIdx; }
    virtual std::string typeString() { return "IdxAccess"; }

    //*****************************************************************
    // Relationship methods
    //*****************************************************************
    
    bool operator<(MemRefExpr & other);

    bool operator==(MemRefExpr& other);
    
    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir); 

    //*****************************************************************
    // Debugging methods 
    //*****************************************************************
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR);
    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);

    virtual int getOrder() { return sOrder; }

private:
    static const int sOrder = 400;
    int mIdx;
};

class IdxExprAccess : public SubSetRef {
  public:

    IdxExprAccess( MemRefType mrType, OA_ptr<MemRefExpr> mre,
                   MemRefHandle hExpr)
    : SubSetRef( mrType, mre)
    {
        mhExpr = hExpr;
    }

    IdxExprAccess(IdxExprAccess &mre)
      : SubSetRef(mre),
        mhExpr(mre.mhExpr)
    {
    }

    ~IdxExprAccess() { }

    virtual void acceptVisitor(MemRefExprVisitor& pVisitor);

    OA_ptr<MemRefExpr> clone();

    //*****************************************************************
    // SubSetRef subclass type methods 
    //*****************************************************************
    bool isaIdxExprAccess() { return true; }
    bool isSubClassOfSubSetRef() { return true; }

    //*****************************************************************
    // Info methods 
    //*****************************************************************
    MemRefHandle getExpr() { return mhExpr; }
    virtual std::string typeString() { return "IdxExprAccess"; }

    //*****************************************************************
    // Relationship methods
    //*****************************************************************
    bool operator<(MemRefExpr & other);

    bool operator==(MemRefExpr& other);

    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir); 

    //*****************************************************************
    // Debugging methods
    //*****************************************************************
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR);
    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);

    virtual int getOrder() { return sOrder; }

  private:
    static const int sOrder = 450;
    MemRefHandle mhExpr;
};

class FieldAccess: public SubSetRef {
  public:

    FieldAccess( MemRefType mrType,
            OA_ptr<MemRefExpr> mre, std::string field)
      : SubSetRef(mrType,mre), mFieldName(field) { }

   
    FieldAccess(FieldAccess &mre) : SubSetRef(mre), mFieldName(mre.mFieldName) {}

    ~FieldAccess() { }

    void acceptVisitor(MemRefExprVisitor& pVisitor);

    OA_ptr<MemRefExpr> clone();

    //*****************************************************************
    // SubSetRef subclass type methods 
    //*****************************************************************
    bool isaFieldAccess() { return true; }
    bool isSubClassOfSubSetRef() { return true; }
    
    //*****************************************************************
    // Info methods 
    //*****************************************************************
    std::string getFieldName() { return mFieldName; }
    virtual std::string typeString() { return "FieldAccess"; }

    //*****************************************************************
    // Relationship methods
    //*****************************************************************
    
    bool operator<(MemRefExpr & other);

    bool operator==(MemRefExpr& other);
    
    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir); 

    //*****************************************************************
    // Debugging methods 
    //*****************************************************************
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> pIR);
    virtual void dump(std::ostream& os, IRHandlesIRInterface& pIR);
    virtual void dump(std::ostream& os);

    virtual int getOrder() { return sOrder; }

private:
    static const int sOrder = 500;
    std::string mFieldName;
};


} // end of OA namespace

#endif