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