WhirlIDMaps.h

Go to the documentation of this file.

// ##########################################################
// # This file is part of OpenADFortTk. #
// # The full COPYRIGHT notice can be found in the top #
// # level directory of the OpenADFortTk source tree. #
// # For more information visit #
// # http://www.mcs.anl.gov/openad #
// ##########################################################

#ifndef WhirlIDMaps_INCLUDED_h
#define WhirlIDMaps_INCLUDED_h

#include <iostream>
#include <map> // STL
#include <set> // STL
#include <list> // STL

#include "Open64IRInterface/Open64BasicTypes.h"

#include "BaseMap.h"
#include "Diagnostics.h"


namespace fortTkSupport { 

typedef UINT SymTabId;
typedef UINT SymId;
typedef UINT PUId;
typedef UINT WNId;

// A list of ids: Should only be used with scalar id types above
template <class T>
class IdList : public std::list<T> {
public:
 IdList() { }
 ~IdList() { }

 // Returns 0 if not found
 T Find(T id) const
 {
 typename std::list<T>::iterator it;
 for (it = this->begin(); it != this->end(); ++it) {
 T val = *it;
 if (id == val) { return val; }
 }
 return 0;
 }
 
};


//***************************************************************************
// ST_TAB <-> SymTabId maps (global/interprocedural)
//***************************************************************************

class SymTabToSymTabIdMap 
 : public BaseMap<ST_TAB*, SymTabId>
{
public:
 SymTabToSymTabIdMap() { }
 SymTabToSymTabIdMap(PU_Info* pu_forest) { Create(pu_forest); }
 virtual ~SymTabToSymTabIdMap() { }
 
 void Create(PU_Info* pu_forest);
};


// SymTabIdToSymTabMap: In WHIRL, all ST_TAB* are associated with a
// specific PU_Info*, except the global ST_TAB*. Because of the way
// the symbol table is implemented, it is usually not easy to access the
// symbol table with the ST_TAB*: one needs the corresponding
// PU_Info*. Consequently, we map a SymTabId to a pair. When
// entering the global the global ST_TAB* in the map, PU_Info* should
// be NULL.
class SymTabIdToSymTabMap 
 : public std::map<SymTabId, pair<ST_TAB*, PU_Info*> > {

protected:
 typedef std::map<SymTabId, pair<ST_TAB*, PU_Info*> > BaseMap;
 
public:
 SymTabIdToSymTabMap() { }
 SymTabIdToSymTabMap(PU_Info* pu_forest) { Create(pu_forest); }
 virtual ~SymTabIdToSymTabMap() { }
 
 pair<ST_TAB*, PU_Info*>
 Find(SymTabId id, bool mustFind = false) const
 {
 pair<ST_TAB*, PU_Info*> result(NULL, NULL);
 
 const_iterator it = this->find(id);
 if (it != this->end()) {
 result = (*it).second;
 } 
 else if (mustFind) {
 FORTTK_DIE("SymTabIdToSymTabMap: Could not find entry for key '" 
 << id << "'");
 }
 
 return result;
 }

 void
 Insert(SymTabId id, ST_TAB* stab, PU_Info* pu)
 {
 this->insert(make_pair(id, make_pair(stab, pu))); // do not add duplicates!
 }

 void Create(PU_Info* pu_forest);
};


//***************************************************************************
// ST <-> SymId maps (intra-procedural)
//***************************************************************************

// Note: Instead of creating ST* <-> to SymId maps, we currently use a
// ST's index -- ST_index(ST*) -- in the symbol table as a persistent
// id. While this is correct, it would be nice to add an interface
// map, even if the map is really only the identity function without
// any state.


//***************************************************************************
// PU <-> PUId maps (global/interprocedural)
//***************************************************************************

class PUToPUIdMap 
 : public BaseMap<PU_Info*, PUId>
{
public: 
 PUToPUIdMap() { }
 PUToPUIdMap(PU_Info* pu_forest) { Create(pu_forest); }
 virtual ~PUToPUIdMap() { }

 void Create(PU_Info* pu_forest);
};


class PUIdToPUMap
 : public BaseMap<PUId, PU_Info*>
{
public:
 PUIdToPUMap() { }
 PUIdToPUMap(PU_Info* pu_forest) { Create(pu_forest); }
 virtual ~PUIdToPUMap() { }
 
 void Create(PU_Info* pu_forest);
};


//***************************************************************************
// WNId <-> WN map
//***************************************************************************

class WNToWNIdMap 
 : public BaseMap<WN*, WNId>
{
public: 
 WNToWNIdMap() { }
 WNToWNIdMap(WN* wn) { Create(wn); }
 virtual ~WNToWNIdMap() { }

 void Create(WN* wn);
};

class WNIdToWNMap 
 : public BaseMap<WNId, WN*>
{
public:
 WNIdToWNMap() { }
 WNIdToWNMap(WN* wn) { Create(wn); }
 virtual ~WNIdToWNMap() { }
 
 void Create(WN* wn);
};


// ---------------------------------------------------------
// 
// ---------------------------------------------------------

// Note: Assumes ownership of the tables it creates
class WNToWNIdTabMap 
 : public BaseMap<PU_Info*, WNToWNIdMap*> {
 
public:
 WNToWNIdTabMap() { }
 WNToWNIdTabMap(PU_Info* pu_forest) { Create(pu_forest); }
 virtual ~WNToWNIdTabMap();
 
 void Create(PU_Info* pu_forest);
 void Destroy();
};

class WNIdToWNTabMap 
 : public BaseMap<PU_Info*, WNIdToWNMap*> {
 
public:
 WNIdToWNTabMap() { }
 WNIdToWNTabMap(PU_Info* pu_forest) { Create(pu_forest); }
 virtual ~WNIdToWNTabMap();
 
 void Create(PU_Info* pu_forest);
 void Destroy();
};


//***************************************************************************
// Optional routines for map creation
//***************************************************************************

// CreateSymTabIdMaps: Given a PU forest, initialize the non-NULL
// persistent ID <-> ST_TAB* maps. STTABIds are guaranteed to be
// unique within the PU forest 'pu_forest'. (The global symbol table
// is included.)
void
CreateSymTabIdMaps(PU_Info* pu_forest, 
 SymTabToSymTabIdMap* x, SymTabIdToSymTabMap* y);

// CreatePUIdMaps: Given a PU forest, initialize the non-NULL
// persistent ID <-> PU_Info* maps. PUIds are guaranteed to be unique
// within the PU forest 'pu_forest'.
void
CreatePUIdMaps(PU_Info* pu_forest, PUToPUIdMap* x, PUIdToPUMap* y);

// CreateWhirlIDMaps: Given a WN*, initialize the non-NULL persistent
// ID <-> WN* maps. WNIds are guaranteed to be unique within the
// WHIRL tree rooted at 'wn'. (Note that 'wn' is usually the result of
// PU_Info_tree_ptr(PU_Info*).)
void
CreateWhirlIdMaps(WN* wn, WNToWNIdMap* x, WNIdToWNMap* y);


}

#endif