legoProc.H

Go to the documentation of this file.

/*-------------------------------------------------------------------
 *   Name:        legoProc.H
 *
 *   Designer:    Willie Glover
 *
 *   Created:     5/28/96
 *
 *   Description: This file contains the LEGO header file which
 *                defines the procedure region derived class.
 *
 *   Location:    /ncsu/tinker/LEGO/src/derived/legoProc.H
 --------------------------------------------------------------------
 * 5/28/96 WTG: Initial file creation.
 * 3/22/97 WAH: Added RefreshEdges method et al.
 * 4/8/97 WAH:  Fixed default constructor to allocate 5 bytes for name.
 * 4/11/97 WAH: Added Kiss Of Death to destructor.
 * 4/29/97 WAH: Added FindDominators method.
 * 6/11/97 WAH: Added GetOpCount method.
 * 1/9/98 WAH:  Fixed SetProcName to handle NULL.
 --------------------------------------------------------------------*/

#ifndef LEGOPROC_H
#define LEGOPROC_H

#include "opEdges.H"
#include "attr.H"
#include "legoJump.H"
#include "region.H"
#include "lSymTab.H"

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

//class symbolTable;
class opEdges;
class attrs;
class jumpTable;
class memvrs;

class legoProc:
  public  legoRegion
{

  char *procName;
  
  importTypes scope; 
  char * info;

  //  symbolTable* dataPtr;
  //  symbolTable* data1Ptr;
  //  symbolTable* bssPtr;

  opEdges*     edgeDictionary;
  attrs*       attrDictionary;
  jumpTable*   jumpDictionary;
  memvrs*      memDictionary;

public:

  legoProc () : legoRegion(RT_PROC,1)
  {
    //    fprintf(stderr,"Creating LEGOPROC %p\n",this);
    procName = new char[5];
    (void)strcpy(procName,"none");
    edgeDictionary = NULL;
    attrDictionary = NULL;
    jumpDictionary = NULL;
    memDictionary = NULL;
    
    info = NULL;
    scope = LIR_LOCAL;
  }

  legoProc (char* name="none", unsigned rId = 1)
           : legoRegion(RT_PROC,rId)
  {
    //    fprintf(stderr,"Creating LEGOPROC %p\n",this);
    procName = new char[strlen(name)+1];
    (void)strcpy(procName,name);
    edgeDictionary = NULL;
    attrDictionary = NULL;
    jumpDictionary = NULL;
    memDictionary = NULL;
    
    info = NULL;
    scope = LIR_LOCAL;
  }

  legoProc (const legoProc &orig) : legoRegion ((legoRegion) orig)
  {
    //    fprintf(stderr,"Creating LEGOPROC %p\n",this);
    if (procName != NULL)
      {
        procName = new char[strlen(orig.procName)+1];
        (void)strcpy(procName,orig.procName);
      } // end if
    else
      procName = NULL;
    if (orig.edgeDictionary != NULL)
      edgeDictionary = new opEdges (*(orig.edgeDictionary));
    else
      edgeDictionary = NULL;
    if (orig.attrDictionary != NULL)
      attrDictionary = new attrs (*(orig.attrDictionary));
    else
      attrDictionary = NULL;
    if (orig.jumpDictionary != NULL)
      jumpDictionary = new jumpTable (*(orig.jumpDictionary));
    else
      jumpDictionary = NULL;
    memDictionary = NULL;
    //    if (orig.memDictionary != NULL)
      //      memDictionary = new  (*(orig.memDictionary));
    info = NULL;
    if(orig.info != NULL)
        SetInfo(orig.info);
    scope = orig.scope; 
    
  }

  ~legoProc ()
  {
      if(info != NULL)
      {
          delete [] info;
          info = NULL;
      }
      
    delete[] procName;
    delete edgeDictionary;
    delete attrDictionary;
    delete jumpDictionary;
    //    delete memDictionary;
    Mark(RM_KISSOFDEATH);  // to signify to dying regions that proc dies too
    RegionKiller();
    //    fprintf(stderr,"Deleting LEGOPROC %p\n",this);
  }
  
  void SetScope(importTypes inScope)
    {
      scope = inScope;
    }
  importTypes GetScope()
    {
      return scope;
    }
  
  void SetInfo(char * newInfo)
    { 
      if(info != NULL)
        {
          delete [] info;
          info = NULL;
        }
      if(newInfo != NULL)
        {
          info = new char[strlen(newInfo) + 1];
          strcpy(info, newInfo);
        }
    }
  
  char * GetInfo() { return info;}
  int GetOpCount (void)
  {
    int opct = 0;

    for (int i = 0; i < GetCount(); i++)
      opct += ((legoRegion *) GetItem(i))->GetOpCount();
    return opct;
  }

  void SetProcName(char *pName)
  {
    delete[] procName;
    if (pName != NULL)
      {
        procName = new char[strlen(pName)+1];
        (void)strcpy(procName,pName);
      } // end if
    else procName = NULL;
  }

/*-------------------------------------------------------------------
   Update the "data" data segment pointer.
 --------------------------------------------------------------------*/
  //  void SetDataPtr(symbolTable* newDataPtr) { dataPtr = newDataPtr; }

/*-------------------------------------------------------------------
   Update the "data1" data segment pointer.
 --------------------------------------------------------------------*/
  //  void SetData1Ptr(symbolTable* newData1Ptr) { data1Ptr = newData1Ptr; }

/*-------------------------------------------------------------------
   Update the "bss" data segment pointer.
 --------------------------------------------------------------------*/
  //  void SetBssPtr(symbolTable* newBssPtr) { bssPtr = newBssPtr; }

/*-------------------------------------------------------------------
   Update the edge dictionary pointer.
 --------------------------------------------------------------------*/
  void SetEdgeDictionary(opEdges *newEdgeDictionary)
    { edgeDictionary = newEdgeDictionary; }

/*-------------------------------------------------------------------
   Update the attribute dictionary pointer.
 --------------------------------------------------------------------*/
  void SetAttrDictionary(attrs *newAttrDictionary)
    { attrDictionary = newAttrDictionary; }

/*-------------------------------------------------------------------
   Update the jump dictionary pointer.
 --------------------------------------------------------------------*/
  void SetJumpDictionary(jumpTable *newJumpDictionary)
    { jumpDictionary = newJumpDictionary; }

/*-------------------------------------------------------------------
   Update the memvrs dictionary pointer.
 --------------------------------------------------------------------*/
  void SetMemDictionary(memvrs *newMemDictionary)
    { memDictionary = newMemDictionary; }

/*-------------------------------------------------------------------
   Get the procedure name.
 --------------------------------------------------------------------*/
  char *GetProcName(void) { return procName; }

/*-------------------------------------------------------------------
   Get the "data" data segment pointer.
 --------------------------------------------------------------------*/
  //  symbolTable* GetDataPtr(void) { return dataPtr; }

/*-------------------------------------------------------------------
   Get the "data1" data segment pointer
 --------------------------------------------------------------------*/
  //  symbolTable* GetData1Ptr(void) { return data1Ptr; }

/*-------------------------------------------------------------------
   Get the "bss" data segment pointer.
 --------------------------------------------------------------------*/
  //  symbolTable* GetBssPtr(void) { return bssPtr; }

/*-------------------------------------------------------------------
   Get the edge dictionary pointer.
 --------------------------------------------------------------------*/
  opEdges *GetEdgeDictionary(void) { return edgeDictionary; }

/*-------------------------------------------------------------------
   Get the attribute dictionary pointer.
 --------------------------------------------------------------------*/
  attrs *GetAttrDictionary(void) { return attrDictionary; }

/*-------------------------------------------------------------------
   Get the jump dictionary pointer.
 --------------------------------------------------------------------*/
  jumpTable *GetJumpDictionary(void) { return jumpDictionary; }

/*-------------------------------------------------------------------
   Get the memvrs dictionary pointer.
 --------------------------------------------------------------------*/
  memvrs *GetMemDictionary(void) { return memDictionary; }

  void RefreshOps (void);
  void RefreshEdges (void) {};  // no edges in or out of proc

  void FindDominators (void);
};

#endif // LEGOPROC_H

---