region.H

Go to the documentation of this file.

/*--------------------------------------------------------------------
 *   Name:        region.H
 *
 *   Designer:    Willie Glover
 *
 *   Created:     5/15/96
 *
 *   Description: This file contains the LEGO header file which
 *                defines the region base class used for the LEGO IR.
 *
 *   Location:    /ncsu/tinker/LEGO/src/derived/region.H
 *
 *   Methods:     /ncsu/tinker/LEGO/src/derived/region.C
 ---------------------------------------------------------------------
 *
 * 5/15/96 WTG: Created this file.
 * 11/7/96 SSW: added the region type TREE
 * 11/16/96 WAH:  Added legoRegionRef class.
 * 12/5/96 WAH: Added copy constructor.
 * 12/9/96 WAH: Added tail duplication method.
 * 12/11/96 WAH:  Added allListPtr.
 * 12/13/96 WAH:  Added detect method to legoRegionRef.
 * 2/13/97 WAH: Made name change from legoRegionRef to regionList et al.
 * 2/17/97 WAH: Added FindMaxRegionId method.
 * 2/26/97 WAH: Made regionList::Detect nonrecursive.
 * 3/20/97 WAH: Added markfield to legoRegion.
 * 3/22/97 WAH: Added RefreshOps method et al, IsContainedIn, Contains.
 * 4/9/97 WAH: Added IsOwner, OpKiller and RegionKiller methods.
 * 4/11/97 WAH: Added kissofdeath mark.
 * 4/18/97 WAH: Added sb mark.
 * 4/25/97 WAH: Added nestingLevel field and associated methods.
 * 4/29/97 WAH: Added dominators field and associated methods; added
 *              regionList::Intersect.
 * 5/14/97 WAH: Added RefreshAll method.
 * 6/3/97 WAH:  Changed TailDuplicate to take in an edge, not an op.
 * 6/11/97 WAH: Added GetOpCount method.
 * 8/1/97 WAH:  Added loopheader mark.
 * 9/9/97 WAH:  Added inner and outer marks.
 * 11/8/97 WAH: Added valid field to regionList.
 * 1/16/98 WAH: Changed SetParents and SetChildren to delete old lists;
 *              added hammock mark.
 * 5/14/98 WAH: Removed TailDuplicate (moved to LEGO Util).
 */

#ifndef LEGOREGION_H
#define LEGOREGION_H

#include <stdio.h>
#include "legoErr.H"
#include "edgeList.H"
#include "legoOp.H"
#include "legoPSet.H"

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

class regionList;
class legoOp;

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

enum regionTypes {
RT_PROC=0,
RT_BB,
RT_HB,
RT_SB,
RT_LOOP,
RT_LOOPBODY,
RT_TRACE,
RT_MODULE,
RT_TREE
};

#define IS_BLOCK(t) (((t) == RT_BB) || ((t) == RT_SB) || ((t) == RT_HB))

// The following #defines are used to mark a region as visited or
// whatever. To mark a region, call Mark with one of the following
// parameters. To unmark it, call Unmark. To clear all marks,
// call UnmarkAll. To check a mark, call IsMarked.
#define RM_GENERAL ((long long) 0x1)
#define RM_TRACE ((long long) 0x2)
#define RM_TREE ((long long) 0x4)
#define RM_SB ((long long) 0x8)
#define RM_LOOPHEADER ((long long) 0x10)
#define RM_INNER ((long long) 0x20)
#define RM_OUTER ((long long) 0x40)
#define RM_HAMMOCK ((long long) 0x80)
#define RM_KISSOFDEATH (((long long) 1) << 63)

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

class legoRegion
  : public legoPSet<void*>
{

  int regionId;                         // unigue sequence number for this region
  enum regionTypes regionType;          // identifies this region type.  used to
                                        //    determine whether legoSet points to
                                        //    a set of ops or regions

  edgeList      *inEdgesPtr;            // ptr to list of (edge ID, edge pointer)
  edgeList      *outEdgesPtr;           // ptr to list of (edge ID, edge pointer)
  flags         *flagPtr;               // ptr to list of region flags
  opList        *entryOpsPtr;           // ptr to list of entry ops
  opList        *exitOpsPtr;            // ptr to list of exit ops
  attrList      *regionAttrListPtr;     // ptr to attribute list

  double        weight;                 // weight assigned to region
  legoRegion    *parentPtr;             // ptr to parent region

  regionList    *parents;               // parents in control flow
  regionList    *children;              // children in control flow
  regionList    *dominators;            // dominators in control flow
  legoOp        *allListPtr;            // pointer to list of all ops

  long long     markfield;              // array of 64 mark bits
  int           nestingLevel;           // level of loop nesting

  void          *DAG;                   // ptr to DAG (arbitrary structure)

public:

  legoRegion ();
  legoRegion (const legoRegion &orig);
  legoRegion (enum regionTypes rType, unsigned rId);
  virtual ~legoRegion (void);

//  Get functions for legoRegion

    int    GetRegionId(void) { return regionId; }

    enum regionTypes GetRegionType(void) { return regionType; }

    edgeList *GetInEdgesPtr(void) { return inEdgesPtr; }

    edgeList *GetOutEdgesPtr(void) { return outEdgesPtr; }

    flags  *GetFlagPtr(void) { return flagPtr; }

    opList *GetEntryOpsPtr(void) { return entryOpsPtr; }

    opList *GetExitOpsPtr(void) { return exitOpsPtr; }

    attrList *GetRegionAttrListPtr(void) { return regionAttrListPtr; }

    double GetWeight(void) { return weight; }

    legoRegion *GetParentPtr(void) { return parentPtr; }

    regionList *GetDominators(void) { return dominators; }

    legoOp* GetListOpPtr(void) { return allListPtr; }

    int         GetNestingLevel(void)   { return nestingLevel; }
    void        *GetDAG(void)           { return DAG; }

//  Set functions for legoRegion

    void   SetRegionId(int id)                  { regionId      = id; }
    void   SetRegionType(enum regionTypes rType){ regionType    = rType; }
    void   SetInEdgesPtr(edgeList* iEdgePtr)    { inEdgesPtr    = iEdgePtr; }
    void   SetOutEdgesPtr(edgeList* oEdgePtr)   { outEdgesPtr   = oEdgePtr; }
    void   SetFlagPtr(flags* fPtr)              { flagPtr       = fPtr; }
    void   SetEntryOpsPtr(opList* entPtr)       { entryOpsPtr   = entPtr; }
    void   SetExitOpsPtr(opList* extPtr)        { exitOpsPtr    = extPtr; }
    void   SetRegionAttrListPtr(attrList *newAttrListPtr)
                                                { regionAttrListPtr = newAttrListPtr; }
    void   SetWeight(double regWeight)          { weight        = regWeight; }
    void   SetParentPtr(legoRegion *regionPtr)  { parentPtr     = regionPtr; }
    void   SetDominators(regionList *doms)      { dominators    = doms; }
    void   SetListOpPtr(legoOp *newListPtr)     { allListPtr    = newListPtr; }
    void   SetNestingLevel (int nl)             { nestingLevel  = nl; }
    void   SetDAG(void* D)                      { DAG           = D; }

//  other region methods

  legoOp *FindOpId(int);
  legoRegion *FindMaxRegionId(void);  // see region.taildup.C
  virtual int GetOpCount (void)
  {
    LegoNonFatal ("legoRegion::GetOpCount",
                  "Cannot get op count of legoRegion.");
    return 0;
  };
  //  legoRegion *TailDuplicate (opEdges *);
  int IsContainedIn (legoRegion *);
  int Contains (legoRegion *);

  class regionList *GetParents(void);
  void SetParents (regionList *);

  class regionList *GetChildren(void);
  void SetChildren (regionList *);

  void Mark (long long m) {markfield |= m; return;}
  void Unmark (long long m) {markfield &= (~m); return;}
  void UnmarkAll (void) {markfield = (long long) 0; return;}
  int IsMarked (long long m) {return ((markfield & m) != (long long) 0);}

  void RefreshOpsAndEdges (void)
  {
    RefreshOps(); 
    RefreshEdges();
  } // end RefreshOpsAndEdges
  virtual void RefreshOps (void)
    {
      LegoNonFatal ("legoRegion::RefreshOps",
                    "Cannot refresh ops of legoRegion.");
    } // end RefreshOps
  virtual void RefreshEdges (void)
    {
      LegoNonFatal ("legoRegion::RefreshEdges",
                    "Cannot refresh edges of legoRegion.");
    } // end RefreshEdges
  void RefreshAll (void);

  int IsOwner (void) {return (Data.IsOwner());}
  void OpKiller (void);
  void RegionKiller (void);
};

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

class regionList
{
  legoRegion *regionPtr;
  int valid;
  class regionList *nextListPtr;

public:
  regionList()
  {
    //    fprintf(stderr,"Creating REGIONLIST %p\n",this);
    regionPtr = NULL; valid = 1; nextListPtr = NULL;
  }
  regionList(const regionList &orig)
  {
    //    fprintf(stderr,"Creating REGIONLIST %p\n",this);
    regionPtr = orig.regionPtr;
    valid = orig.valid;
    if (orig.nextListPtr != NULL)
      nextListPtr = new regionList (*(orig.nextListPtr));
    else
      nextListPtr = NULL;
  } // end copy constructor
  regionList (legoRegion *it, class regionList *n = NULL)
  {
    //    fprintf(stderr,"Creating REGIONLIST %p\n",this);
    regionPtr = it;
    valid = 1;
    nextListPtr = n;
  } // end constructor (legoRegion *, regionList *)
  ~regionList()
  {
    regionList *temp;

    while (nextListPtr != NULL)
      {
        temp = nextListPtr;
        nextListPtr = temp->nextListPtr;
        temp->nextListPtr = NULL;
        delete temp;
      } // end while
    //    fprintf(stderr,"Deleting REGIONLIST %p\n",this);
  }
  void SetRegionPtr (legoRegion *it) {regionPtr = it;}
  legoRegion *GetRegionPtr (void) {return regionPtr;}

  void SetValid (int v) {valid = v;}
  int GetValid (void) {return valid;}
  
  void SetNextListPtr (class regionList *n) {nextListPtr = n;}
  class regionList *GetNextListPtr (void) {return nextListPtr;}
  
  void Prepend (class regionList *p)
  {
    p->Append (this);
  } // end Prepend
  void Append (class regionList *n)
  {
    nextListPtr = n;
  } // end Append
  regionList *Detect (legoRegion *r)
  {
    regionList *candidate;

    for (candidate = this; candidate != NULL;
         candidate = candidate->nextListPtr)
      {
        if (candidate->regionPtr == r)
          return candidate;
      } // end for
    return NULL;
  } // end Detect
  void Concatenate (class regionList *);
  regionList *Intersect (class regionList *);
}; // end class regionList

#endif // LEGOREGION_H

---