IRHandles.hpp

Go to the documentation of this file.

#ifndef IRHandles_H
#define IRHandles_H

//#define OA_IRHANDLETYPE_UL /* should be in CXXFLAGS */
#include <sstream>
#include <string>
#include <list>

#include <inttypes.h>

#include <OpenAnalysis/Utils/OA_ptr.hpp>

namespace OA {


//***************************************************************************
//-----------------------------------------------------------------------------
// Below are generic types for handles to relate objects to a user's IR. 0 is
// reserved as a NULL value.  There are two sets of types: 
//  1) one whose type/size is relative to the current platform, and 
//  2) one whose type/size is maximum, which is useful for cross-platform tools
//
//   OA_IRHANDLETYPE_UL:  For handles on this platform
//   OA_IRHANDLETYPE_SZ64: Maximum size for cross-platform handles 
//-----------------------------------------------------------------------------
#if defined(OA_IRHANDLETYPE_UL)
  typedef unsigned long irhandle_t;
#elif defined(OA_IRHANDLETYPE_SZ64)
  typedef uint64_t irhandle_t;
#else
# error OpenAnalysis handle type must be specified!
#endif
  
//***************************************************************************


class IRHandle {
public:
  IRHandle() : h(0) { }
  IRHandle(irhandle_t h_) : h(h_) { }
  ~IRHandle() { }

  IRHandle(const IRHandle& x) : h(x.h) { }
  IRHandle& operator=(const IRHandle& x) { h = x.h; return *this; }
  IRHandle& operator=(irhandle_t h_) { h = h_; return *this; }
  
  bool operator==(const IRHandle& x) const { return (h == x.h); }
  bool operator!=(const IRHandle& x)  const { return (h != x.h); }
  bool operator<(const IRHandle& x)  const { return (h < x.h); }
  bool operator>(const IRHandle& x)  const { return (h > x.h); }

  operator bool() { return h != 0; }
  operator std::string() { std::ostringstream oss;  oss << h; return oss.str(); }


  irhandle_t hval() const { return h; }

private:
  irhandle_t h;
};


class ProcHandle : public IRHandle {
public:
  ProcHandle() { }
  ProcHandle(irhandle_t h_) : IRHandle(h_) { }
  ~ProcHandle() { }

  ProcHandle(const ProcHandle& x) : IRHandle(x) { }
  ProcHandle& operator=(const ProcHandle& x) 
    { IRHandle::operator=(x); return *this; }
};

class StmtHandle : public IRHandle {
public:
  StmtHandle() { }
  StmtHandle(irhandle_t h_) : IRHandle(h_) { }
  ~StmtHandle() { }

  StmtHandle(const StmtHandle& x) : IRHandle(x) { }
  StmtHandle& operator=(const StmtHandle& x) 
    { IRHandle::operator=(x); return *this; }
};

class StmtLabel : public IRHandle {
public:
  StmtLabel() { }
  StmtLabel(irhandle_t h_) : IRHandle(h_) { }
  ~StmtLabel() { }

  StmtLabel(const StmtLabel& x) : IRHandle(x) { }
  StmtLabel& operator=(const StmtLabel& x) 
    { IRHandle::operator=(x); return *this; }
};

class SymHandle : public IRHandle {
public:
  SymHandle() { }
  SymHandle(irhandle_t h_) : IRHandle(h_) { }
  ~SymHandle() { }

  SymHandle(const SymHandle& x) : IRHandle(x) { }
  SymHandle& operator=(const SymHandle& x) 
    { IRHandle::operator=(x); return *this; }
};

class ExprHandle : public IRHandle {
public:
  ExprHandle() { }
  ExprHandle(irhandle_t h_) : IRHandle(h_) { }
  ~ExprHandle() { }

  ExprHandle(const ExprHandle& x) : IRHandle(x) { }
  ExprHandle& operator=(const ExprHandle& x) 
    { IRHandle::operator=(x); return *this; }
  
};

class MemRefHandle : public ExprHandle {
public:
  MemRefHandle() { }
  MemRefHandle(irhandle_t h_) : ExprHandle(h_) { }
  ~MemRefHandle() { }

  MemRefHandle(const MemRefHandle& x) : ExprHandle(x) { }
  MemRefHandle& operator=(const MemRefHandle& x) 
    { IRHandle::operator=(x); return *this; }
};

class CallHandle : public ExprHandle {
public:
  CallHandle() { }
  CallHandle(irhandle_t h_) : ExprHandle(h_) { }
  ~CallHandle() { }

  CallHandle(const CallHandle& x) : ExprHandle(x) { }
  CallHandle& operator=(const CallHandle& x) 
    { IRHandle::operator=(x); return *this; }
};

class OpHandle : public IRHandle {
public:
  OpHandle() { }
  OpHandle(irhandle_t h_) : IRHandle(h_) { }
  ~OpHandle() { }

  OpHandle(const OpHandle& x) : IRHandle(x) { }
  OpHandle& operator=(const OpHandle& x) 
    { IRHandle::operator=(x); return *this; }
  
};

class ConstSymHandle : public ExprHandle {
public:
  ConstSymHandle() { }
  ConstSymHandle(irhandle_t h_) : ExprHandle(h_) { }
  ~ConstSymHandle() { }

  ConstSymHandle(const ConstSymHandle& x) : ExprHandle(x) { }
  ConstSymHandle& operator=(const ConstSymHandle& x) 
    { IRHandle::operator=(x); return *this; }
  
};

class ConstValHandle : public ExprHandle {
public:
  ConstValHandle() { }
  ConstValHandle(irhandle_t h_) : ExprHandle(h_) { }
  ~ConstValHandle() { }

  ConstValHandle(const ConstValHandle& x) : ExprHandle(x) { }
  ConstValHandle& operator=(const ConstValHandle& x) 
    { IRHandle::operator=(x); return *this; }
  
};



// FIXME: needed?
class LeafHandle : public ExprHandle {
public:
  LeafHandle() { }
  LeafHandle(irhandle_t h_) : ExprHandle(h_) { }
  LeafHandle(ExprHandle x) : ExprHandle(x.hval()) { }
  ~LeafHandle() { }

  LeafHandle(const LeafHandle& x) : ExprHandle(x) { }
  LeafHandle& operator=(const LeafHandle& x) 
    { IRHandle::operator=(x); return *this; }
};


//********************************************** All the iterators

template <class T>
class IRHandleSetIterator {
public:
    IRHandleSetIterator (OA_ptr<std::set<T> > pSet) : mSet(pSet) 
      { mIter = mSet->begin(); }
    virtual ~IRHandleSetIterator () {}

    virtual void operator ++ () { if (mIter != mSet->end()) mIter++; }
    
    virtual bool isValid() const { return (mIter != mSet->end()); }
    
    virtual T current() const { return (*mIter); }

    virtual void reset() { mIter = mSet->begin(); }

private:
    OA_ptr<std::set<T> > mSet;
    typename std::set<T>::iterator mIter;
};
 
template <class T>
class IRHandleListIterator {
public:
    IRHandleListIterator (OA_ptr<std::list<T> > pList) : mList(pList) 
      { mIter = mList->begin(); }
    virtual ~IRHandleListIterator () {}

    virtual void operator ++ () { if (mIter != mList->end()) mIter++; }
    
    virtual bool isValid() const { return (mIter != mList->end()); }
    
    virtual T current() const { return (*mIter); }

    virtual void reset() { mIter = mList->begin(); }

private:
    OA_ptr<std::list<T> > mList;
    typename std::list<T>::iterator mIter;
};
 
class ProcHandleIterator {
public:
  ProcHandleIterator() { }
  virtual ~ProcHandleIterator() { };

  virtual ProcHandle current() const = 0;  // Returns the current item.
  virtual bool isValid() const = 0;        // False when all items are exhausted.
        
  virtual void operator++() = 0;     // prefix
  void operator++(int) { ++*this; }  // postfix
  // FIXME: doesn't seem to work, for example Open64IRProcIterator 
  // doesn't see it, however InterActive.cpp:148 does see it

  virtual void reset() = 0;
};


typedef ProcHandleIterator IRProcIterator;

/*
class IRProcIterator {
public:
  IRProcIterator() { }
  virtual ~IRProcIterator() { };

  virtual ProcHandle current() = 0;  // Returns the current item.
  virtual bool isValid() = 0;        // False when all items are exhausted.
        
  virtual void operator++() = 0;     // prefix
  void operator++(int) { ++*this; }  // postfix

  virtual void reset() = 0;
};
*/

class ExprHandleIterator {
public:
  ExprHandleIterator() { }
  virtual ~ExprHandleIterator() { };

  virtual ExprHandle current() const = 0;  // Returns the current item.
  virtual bool isValid() const = 0;   // False when all items are exhausted.
        
  virtual void operator++() = 0;     // prefix
  void operator++(int) { ++*this; }  // postfix

  virtual void reset() = 0;
};

typedef ExprHandleIterator IRCallsiteParamIterator;

class StmtHandleIterator {
public:
  StmtHandleIterator() { }
  virtual ~StmtHandleIterator() { };

  virtual StmtHandle current() const = 0;  // Returns the current item.
  virtual bool isValid()  const = 0;      // False when all items are exhausted.
        
  virtual void operator++() = 0;     // prefix
  void operator++(int) { ++*this; }  // postfix

  virtual void reset() = 0;
};


typedef StmtHandleIterator IRRegionStmtIterator;

typedef StmtHandleIterator IRStmtIterator;

class MemRefHandleIterator {
public:
  MemRefHandleIterator() { }
  virtual ~MemRefHandleIterator() { };

  virtual MemRefHandle current() const = 0;  // Returns the current item.
  virtual bool isValid() const = 0;  // False when all items are exhausted.
        
  virtual void operator++() = 0;     // prefix
  void operator++(int) { ++*this; }  // postfix

  virtual void reset() = 0;
};

class CallHandleIterator {
public:
  CallHandleIterator() { }
  virtual ~CallHandleIterator() { };

  virtual CallHandle current() const = 0;  // Returns the current item.
  virtual bool isValid() const = 0;  // False when all items are exhausted.
        
  virtual void operator++() = 0;     // prefix
  void operator++(int) { ++*this; }  // postfix

  virtual void reset() = 0;
};

typedef CallHandleIterator IRCallsiteIterator;

class SymHandleIterator {
public:
  SymHandleIterator() { }
  virtual ~SymHandleIterator() { };

  virtual SymHandle current() const = 0;  // Returns the current item.
  virtual bool isValid() const = 0; // False when all items are exhausted.
        
  virtual void operator++() = 0;     // prefix
  void operator++(int) { ++*this; }  // postfix

  virtual void reset() = 0;
};

typedef SymHandleIterator IRSymIterator;
typedef SymHandleIterator IRFormalParamIterator;


//******************************************* Used to output handle data

class IRHandlesIRInterface {

public:
  virtual ~IRHandlesIRInterface() {}

  //--------------------------------------------------------
  // create a string for the given handle, should be succinct
  // and there should be no newlines
  //--------------------------------------------------------  
  virtual std::string toString(const ProcHandle h) = 0;
  virtual std::string toString(const StmtHandle h) = 0;
  virtual std::string toString(const ExprHandle h) = 0;
  virtual std::string toString(const OpHandle h) = 0;
  virtual std::string toString(const MemRefHandle h) = 0;
  virtual std::string toString(const CallHandle h) = 0;
  virtual std::string toString(const SymHandle h) = 0;
  virtual std::string toString(const ConstSymHandle h) = 0;
  virtual std::string toString(const ConstValHandle h) = 0;

  // should deprecate this
  //virtual const std::string getName(OA::SymHandle h) = 0;

  //--------------------------------------------------------
  // dumps that do pretty prints
  //--------------------------------------------------------  

  virtual void dump(MemRefHandle h, std::ostream& os) = 0;

  virtual void dump(StmtHandle stmt, std::ostream& os) = 0;

  //virtual void currentProc(OA::ProcHandle p) = 0;

};

//***************************************************************************

/*
#include <iostream>
using std::cout;
using std::endl;

int 
main()
{
  ProcHandle p(1);
  ExprHandle e(2);
  LeafHandle l1((irhandle_t)&e);  // This is a little awkward...
  LeafHandle l2 = (irhandle_t)&e; // This is a little awkward...
  
  cout << "P: " << *p << endl;
  cout << "E: " << *e << endl;
  cout << "L1: " << *l1 << endl
       << "L2: " << *l2 << endl
       << "L1 == L2: " << ((l1 == l2) ? "true" : "false") << endl;
  
  
  ExprHandle ee1(l1);    // create expr from leaf
  ExprHandle ee2 = l1;   // assign a leaf to an expression
  ee2 = l1;              // assign a leaf to an expression
  
  LeafHandle ll1(ee1);   // create leaf from expr
  LeafHandle ll2 = ee1;  // assign expr to a leaf
  ll2 = ee1;             // assign expr to a leaf
  
  ExprHandle ee3 = *ll1; // initialize a expr with a leaf
  LeafHandle ll3 = *ee1; // initialize a leaf with an expr
  
  ExprHandle* ee4    = dynamic_cast<ExprHandle*>(&ll1); // ok
  // LeafHandle* ll4 = dynamic_cast<LeafHandle*>(&ee1); // error
  
  cout << "EE1: " << *ee1 << endl
       << "EE2: " << *ee2 << endl
       << "EE3: " << *ee3 << endl
       << "EE4: " << *(*ee4) << endl;
  cout << "LL1: " << *ll1 << endl
       << "LL2: " << *ll2 << endl
       << "LL3: " << *ll2 << endl;

  return 0;
}
*/

} // end of namespace OA

#endif