legoModu.H

Go to the documentation of this file.

/*-------------------------------------------------------------------
 *   Name:        legoModu.H
 *
 *   Designer:    Willie Glover
 *
 *   Created:     5/28/96
 *
 *   Description: This file contains the LEGO header file which
 *                defines the module region derived class.
 *
 *                legoModule is derived from region class.  The
 *                container holds legoProcs. In addition to the
 *                module name,  this class also has pointers to
 *                the data segments associated with this module.
 *
 *   Location:    /ncsu/tinker/LEGO/src/derived/legoModu.H
 --------------------------------------------------------------------
 * 8/12/96 WTG:  Initial file creation.
 * 4/8/97 WAH:   Fixed default constructor to allocate 5 bytes, not 4.
 * 6/11/97 WAH:  Added GetOpCount method.
 * 12/11/97 WAH: Added comments field and associated methods.
 * 1/9/98 WAH:   Fixed constructors and SetModuleName to handle NULL name.
 --------------------------------------------------------------------*/

#ifndef LEGOMODU_H
#define LEGOMODU_H

#include <stl.h>
#include "region.H"

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

#include "lSymTab.H"
#include "opEdges.H"
#include "attr.H"
#include "legoJump.H"
class memvrs;

class legoModule:
  public  legoRegion
{

  char *moduleName;
  vector <char *> *comments;

  symbolTable* dataPtr;
  symbolTable* data1Ptr;
  symbolTable* bssPtr;
  symbolTable* textPtr;
  //HZ: 12/17/01 added the segments of SDATA (short data), SBSS (short
  // uninitialized data), COMMENT (COMMENT segment) for IA-64
  symbolTable* sdataPtr;
  symbolTable* sbssPtr;
  symbolTable* commentPtr;

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

public:

  legoModule () : legoRegion(RT_MODULE,1)
  {
    //    fprintf(stderr,"Creating LEGOMODULE %p\n",this);
    moduleName = new char[5];
    (void)strcpy(moduleName,"none");
    comments = new vector<char *>;
    //dataPtr = data1Ptr = bssPtr = textPtr = NULL;
    //HZ:
    commentPtr = sbssPtr = sdataPtr = dataPtr = data1Ptr = bssPtr = textPtr = NULL;
    edgeDictionary = NULL;
    attrDictionary = NULL;
    jumpDictionary = NULL;
    memDictionary = NULL;
  }

  legoModule (char* name, unsigned rId = 1)
           : legoRegion(RT_MODULE,rId)
  {
    //    fprintf(stderr,"Creating LEGOMODULE %p\n",this);
    if (name != NULL)
      {
        moduleName = new char[strlen(name)+1];
        (void)strcpy(moduleName,name);
      } // end if
    else moduleName = NULL;
    comments = new vector<char *>;
    //dataPtr = data1Ptr = bssPtr = textPtr = NULL;
    //HZ:
    commentPtr = sbssPtr = sdataPtr = dataPtr = data1Ptr = bssPtr = textPtr = NULL;
    
    edgeDictionary = NULL;
    attrDictionary = NULL;
    jumpDictionary = NULL;
    memDictionary = NULL;
  }

  legoModule (const legoModule &orig) : legoRegion ((legoRegion) orig)
  {
    vector<char *>::iterator comi;
    //    fprintf(stderr,"Creating LEGOMODULE %p\n",this);
    if (orig.moduleName != NULL)
      {
        moduleName = new char[strlen(orig.moduleName)+1];
        (void)strcpy(moduleName,orig.moduleName);
      } // end if
    else
      moduleName = NULL;
    comments = new vector<char *>;
    for (comi = orig.comments->begin(); comi != orig.comments->end();
         comi++)
      {
        char *temp = new char [strlen (*comi) + 1];
        strcpy (temp, *comi);
        comments->push_back (temp);
      } // end for
    //HZ: 
    if (orig.sdataPtr != NULL)
      sdataPtr = new symbolTable (*(orig.sdataPtr));
    else
      sdataPtr = NULL;
    if (orig.sbssPtr != NULL)
      sbssPtr = new symbolTable (*(orig.sbssPtr));
    else
      sbssPtr = NULL;
    if (orig.commentPtr != NULL)
      commentPtr = new symbolTable (*(orig.commentPtr));
    else
      commentPtr = NULL;
              
    if (orig.dataPtr != NULL)
      dataPtr = new symbolTable (*(orig.dataPtr));
    else
      dataPtr = NULL;
    if (orig.data1Ptr != NULL)
      data1Ptr = new symbolTable (*(orig.data1Ptr));
    else
      data1Ptr = NULL;
    if (orig.bssPtr != NULL)
      bssPtr = new symbolTable (*(orig.bssPtr));
    else
      bssPtr = NULL;
    if (orig.textPtr != NULL)
      textPtr = new symbolTable (*(orig.textPtr));
    else
      textPtr = 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));
  }


  ~legoModule ()
  {
    vector<char *>::iterator comi;
    delete[] moduleName;
    for (comi = comments->begin(); comi != comments->end(); comi++)
      delete[] *comi;
    delete comments;
    delete dataPtr;
    delete data1Ptr;
    delete bssPtr;
    delete textPtr;
    
    delete sdataPtr;
    delete sbssPtr;
    delete commentPtr;
    
    delete edgeDictionary;
    delete attrDictionary;
    delete jumpDictionary;
    //    delete memDictionary;
    RegionKiller();
    //    fprintf(stderr,"Deleting LEGOMODULE %p\n",this);
  }
  int GetOpCount (void)
  {
    int opct = 0;

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

/*-------------------------------------------------------------------
   Update the name of the module.
 --------------------------------------------------------------------*/
  void SetModuleName(char *mName)
  {
    delete[] moduleName;
    if (mName != NULL)
      {
        moduleName = new char[strlen(mName)+1];
        (void)strcpy(moduleName,mName);
      } // end if
    else moduleName = NULL;
  }

/*-------------------------------------------------------------------
   Update the comments.
 --------------------------------------------------------------------*/
  void SetComments (vector<char *> *c)
  {
    vector<char *>::iterator comi;

    for (comi = comments->begin(); comi != comments->end(); comi++)
      delete[] *comi;
    delete comments;
    comments = c;
  }

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

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

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

  //HZ:
  void SetSBssPtr(symbolTable* newSBssPtr) { sbssPtr = newSBssPtr; }
  void SetCommentPtr(symbolTable* newCommentPtr) { commentPtr = newCommentPtr; }
  
  void SetTextPtr(symbolTable* newTextPtr) { textPtr = newTextPtr; }

/*-------------------------------------------------------------------
   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 module name.
 --------------------------------------------------------------------*/
  char *GetModuleName(void) { return moduleName; }

/*-------------------------------------------------------------------
   Get the comments.
 --------------------------------------------------------------------*/
  vector<char *> *GetComments(void) { return comments; }

/*-------------------------------------------------------------------
   Get the "data" data segment pointer.
 --------------------------------------------------------------------*/
  symbolTable* GetDataPtr(void) { return dataPtr; }
  
  //HZ:
  symbolTable* GetSDataPtr(void) { return sdataPtr; }
  
/*-------------------------------------------------------------------
   Get the "data1" data segment pointer
 --------------------------------------------------------------------*/
  symbolTable* GetData1Ptr(void) { return data1Ptr; }

/*-------------------------------------------------------------------
   Get the "bss" data segment pointer.
 --------------------------------------------------------------------*/
  symbolTable* GetBssPtr(void) { return bssPtr; }
  //HZ:
  symbolTable* GetSBssPtr(void) { return sbssPtr; }  
  symbolTable* GetCommentPtr(void) { return commentPtr; }  

  symbolTable* GetTextPtr(void) { return textPtr; }

/*-------------------------------------------------------------------
   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; }
};

#endif // LEGOMODU_H

---