legoOp.H

Go to the documentation of this file.

/*
 *   Name:        legoOp.H
 *
 *   Designer:    Willie Glover
 *
 *   Created:     3/19/96
 *
 *   Description: This file contains the LEGO header file which
 *                defines the op base class used for the LEGO IR.
 *
 *   Location:    /ncsu/tinker/LEGO/src/base/legoOp.H
 *
 *   Methods:     /ncsu/tinker/LEGO/src/base/legoOp.C
 */

 /*
  *  Notes:
  *
  *      Style:  The first character of object identifiers is lowercase
  *              The first character of member functions is uppercase except
  *                 in the case of constructors and destructors
  *              Pointer identifiers (other than array and string types)
  *                 end in "Ptr".
  *
  * "op" is the base region class.  All other regions types are derived
  *  from "op".
  *
  * 3/21/96 WTG: Removed type opParmList. Object added as item to op class
  * 4/02/96 WTG: Changed format of opEdges. Added function declarations.
  * 4/02/96 WTG: Added declarations for member functions to legoOprd.
  * 4/02/96 WTG: Changed opid from a char string to an int
  * 4/02/96 WTG: Added structure for relatedOps.
  * 4/02/96 WTG: Added structure for flags (flag.h).
  * 4/02/96 WTG: Added structure for attrs (attr.h).
  * 4/03/96 WTG: Changed format of legoOprd so that it does not include
  *                any references to src/dest.  This is more generic and
  *                uses less storage. Also changed op so that it has objects
  *                for both source operand and dest operand.
  * 4/03/96 WTG: Added declarations for member functions to op.  Still
  *                incomplete,
  *
  * 4/04/96 SSW, DB: Modified for testing of translation of one Hppa Insn: ADD
  *
  * 4/05/96 DB: Added opcode field to legoOp to identify the instruction
  *
  * 4/10/96 WTG: Add additional comments for clarification. Added member
  *                function prototypes needed to implement write op.  Modified
  *                legoOp enum statement for spectype to insure proper match
  *                with rebel input/output.
  * 4/26/96 WB:  Added include for legoOprd.H
  * 5/13/96 WTG: Implemented inlining of the simple Set and Get- members.
  * 8/16/96 WTG: Added attr id field.
  * 12/5/96 WAH: Added copy constructor.
  * 3/15/97 WAH: Added IsDummy method.
  * 5/1/97  WAH: Added utilityPtr field and associated methods.
  * 5/15/97 WAH: Added oldOpId and associated methods.
  * 6/2/97 WAH:  Changed oldOpId to duplicateOpsPtr, etc.
  * 1/6/98 WAH:  Removed struct declarations, redid #includes.
  * 1/9/98 WAH:  Fixed SetSchedOpcode to handle NULL.
  * 3/4/98 WAH:  Added mdesInfoPtr and ruInfoPtr fields and associated
  *              methods.
  * 03/03/02 HZ: Add Is??Op  to legoOp class. The reason
  *    is that some of the Ops can not be decided by opcode alone, e.g., IsBRUOp
  */

#ifndef LEGOOP_H
#define LEGOOP_H

#include "legoMap.H"
#include "legoOpcode.H"
#include "legoOprd.H"
#include "opEdges.H"
#include "opList.H"
//#include "bitvector.H"

class flags;

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

class HppaTxOp;
struct Mdes_Info;
struct _RU_Info;
typedef struct _RU_Info RU_Info;
class bitvector; 

class legoOp {
  friend class HppaTxOp;

  enum specTypes {
    SPECULATIVE=0,
    NONSPECULATIVE
  };

  int opId;
  legoOpcode *opCodePtr;
  int opCode;

  legoOprd *srcOprdPtr;         // ptr to src operand list
  legoOprd *destOprdPtr;        // ptr to dest operand list
  legoOprd *predOprdPtr;        // ptr to pred operand list

  char *schedOpcode;            // scheduled opcode

  opList *relatedOpsPtr;        // ptr to list of (op, flowfreq)
  opList *duplicateOpsPtr;      // ptr to list of duplicate ops

  int schedTime;                // multiop scheduled time
  
  //HZ: added to use Emre's WeldSim
  int mdestime;                 // Emre: machine slot number
  
  //HZ:
  int est_r_time;  //estimated issue time

  int oplat;                    // Emre: operation latency  

  int specflag;                 // speculative, nonspeculative

  opList *inListPtr;            // ptr to list of (op,flowfreq)
  opList *outListPtr;           // ptr to list of (op,flowfreq)

  flags *opFlagPtr;             //ptr to list of region flags

  int blockId;                  // ??? not sure how created
  void *parentBlockPtr;         // pointer to containing region
                                // use cast to legoRegion
  attrList *opAttrListPtr;      // ptr to attribute list

  void *utilityPtr;             // general use pointer
  Mdes_Info *mdesInfoPtr;       // ptr to mdes info
  RU_Info *ruInfoPtr;           // ptr to resource info

  legoOp *prevOpPtr;            // ptr to previous op in prog flow
  legoOp *nextOpPtr;            // ptr to next op in prog flow

  legoOp *allListPtr;           //pointer to next non-seq op

  bitvector *PredVector;        // used to determine dependence/independece  
                                // based on control-flow prior to if-conv

  void BuildInitialDuplicateList (void);

public:
/*
 *     *** not inlined ***
 */
  legoOp (unsigned);
  legoOp (legoOp &);
  legoOp (const legoOp &);
  ~legoOp (void);
/*-----------------------------------------------------------
 * rebel file reference number
 *-----------------------------------------------------------*/
void  SetOpId (int newOpId) { opId = newOpId; }

/*-----------------------------------------------------------
 * opcode -- hash defined in tinker.tab.h
 *-----------------------------------------------------------*/
void  SetOpcode (int newOpcode) { opCode = newOpcode; }

//Sau
void  SetOpcodePtr (legoOpcode *newOpcodePtr) { opCodePtr = newOpcodePtr; }

/*-----------------------------------------------------------
 * update schedOpcode
 *-----------------------------------------------------------*/
void  SetSchedOpcode (char* newSchedOp)
  {
    delete[] schedOpcode;
    if (newSchedOp != NULL)
      {
        schedOpcode = new char[strlen(newSchedOp)+1];
        (void) strcpy( schedOpcode, newSchedOp );
      } // end if
    else schedOpcode = NULL;
  }
  
  
void SetMdesTime(int t) {mdestime=t;} // Emre

void SetEstTime(int t) {est_r_time = t;} //HZ
int GetEstTime() {return est_r_time;}

void SetOpLatency(int l) {oplat=l;} // Emre
  

/*-----------------------------------------------------------
 * update related op info (insert)
 *-----------------------------------------------------------*/
void  SetRelatedOpsPtr (opList *newRelatedOpsPtr)
  { relatedOpsPtr = newRelatedOpsPtr; }

/*-----------------------------------------------------------
 * update duplicate op info
 *-----------------------------------------------------------*/
void  SetDuplicateOpsPtr (opList *newDuplicateOpsPtr)
  { duplicateOpsPtr = newDuplicateOpsPtr; }

/*-----------------------------------------------------------
 * update schedTime
 *-----------------------------------------------------------*/
void  SetSchedTime (int newSTime) { schedTime = newSTime; }

/*-----------------------------------------------------------
 * update speculative info
 *-----------------------------------------------------------*/
void  SetSpeculative  (int newSpecul) { specflag = newSpecul; }

/*-----------------------------------------------------------
 * update prevOpPtr
 *-----------------------------------------------------------*/
void  SetPrevLink (legoOp* fromOpPtr) { prevOpPtr = fromOpPtr; }

/*-----------------------------------------------------------
 * update nextOpPtr
 *-----------------------------------------------------------*/
void  SetNextLink (legoOp* toOpPtr) { nextOpPtr = toOpPtr; }

/*-----------------------------------------------------------
 * update nextOpPtr update allListPtr of prev op
 *-----------------------------------------------------------*/
void  SetListOpPtr (legoOp* allOpPtr) { allListPtr = allOpPtr; }

/*-----------------------------------------------------------
 * update block_id
 *-----------------------------------------------------------*/
void  SetBlockId (int newBlockId) { blockId = newBlockId; }

/*-----------------------------------------------------------
 * update in and out edges ptrs
 *-----------------------------------------------------------*/
void SetInListPtr(opList *inPtr) {inListPtr = inPtr;}
void SetOutListPtr(opList *outPtr) {outListPtr = outPtr;}

/*-------------------------------------------------------------
 * update flag pointer
 *-------------------------------------------------------------*/
void  SetFlagPtr (flags *newFlagPtr) { opFlagPtr = newFlagPtr; }

/*-------------------------------------------------------------
 * update pointer to attribute dictionary
 *-------------------------------------------------------------*/
void  SetOpAttrListPtr (attrList *newAttrListPtr) { opAttrListPtr = newAttrListPtr; }

/*-------------------------------------------------------------
 * set first lego src operand pointer
 *-----------------------------------------------------------*/
void  SetSrcOprdPtr (legoOprd *srcPtr) { srcOprdPtr = srcPtr; }

/*-------------------------------------------------------------
 * set first lego dest operand pointer
 *-----------------------------------------------------------*/
void  SetDestOprdPtr (legoOprd *destPtr) { destOprdPtr = destPtr; }

/*-------------------------------------------------------------
 * set lego predicate operand pointer
 *-------------------------------------------------------------*/
void  SetPredOprdPtr (legoOprd *predPtr) { predOprdPtr = predPtr; }

/*-------------------------------------------------------------
 * set (legoRegion) parent block pointer
 *-------------------------------------------------------------*/
void  SetParentBlockPtr (void *regionPtr)
         { parentBlockPtr = regionPtr; }

/*-------------------------------------------------------------
 * set utility pointer
 *-------------------------------------------------------------*/
void  SetUtilityPtr (void *utilPtr) { utilityPtr = utilPtr; }

/*-------------------------------------------------------------
 * set mdes info pointer
 *-------------------------------------------------------------*/
void  SetMdesInfoPtr (Mdes_Info *mdPtr) { mdesInfoPtr = mdPtr; }

/*-------------------------------------------------------------
 * set resource info pointer
 *-------------------------------------------------------------*/
void  SetRUInfoPtr (RU_Info *ruPtr) { ruInfoPtr = ruPtr; }

/*-------------------------------------------------------------
 * set PredVector pointer
 *-------------------------------------------------------------*/
void SetPredVectorPtr (bitvector *vectorPtr) { PredVector = vectorPtr; }


/*-------------------------------------------------------------
 * get op sequence number
 *-------------------------------------------------------------*/
int       GetOpId (void) { return opId; }

/*-------------------------------------------------------------
 * get opCode (intval ** see tinker.tab.h for map)
 *-------------------------------------------------------------*/
int       GetOpcode (void) { return opCode; }

//HZ: //in order to make the opcode class work for legoMach module,
// we choose to use base opcode in legoMach module (as ops with same base opcode
// and different qualifiers have the same machine resource requirement.
int GetBaseOpcode(void) 
{
    if(opCodePtr == NULL)
        return opCode;
    else
        return opCodePtr->GetBaseOpcode();
}

//Sau
legoOpcode *GetOpcodePtr (void) { return opCodePtr; }

/*-------------------------------------------------------------
 * get first lego src operand pointer
 *-------------------------------------------------------------*/
legoOprd *GetSrcOprdPtr (void) { return srcOprdPtr; }

/*-------------------------------------------------------------
 * get first lego dest operand pointer
 *-------------------------------------------------------------*/
legoOprd *GetDestOprdPtr (void) { return destOprdPtr; }

/*-------------------------------------------------------------
 * get lego oprd operand pointer
 *-------------------------------------------------------------*/
legoOprd *GetPredOprdPtr (void) { return predOprdPtr; }

/*-------------------------------------------------------------
 * get schedOpcode
 *-------------------------------------------------------------*/
char *GetSchedOpcode (void) { return schedOpcode; }

/*-------------------------------------------------------------
 * get related op pointer
 *-------------------------------------------------------------*/
opList *GetRelatedOpsPtr (void) { return relatedOpsPtr; }

/*-------------------------------------------------------------
 * get duplicate ops pointer
 *-------------------------------------------------------------*/
opList *GetDuplicateOpsPtr (void) { return duplicateOpsPtr; }

/*-------------------------------------------------------------
 * get sched_time
 *-------------------------------------------------------------*/
int      GetSchedTime (void) { return schedTime; }

int      GetMdesTime (void) {return mdestime;}    // Emre

int      GetOpLatency(void) {return oplat;}         // Emre


/*-------------------------------------------------------------
 * get speculative info
 *-------------------------------------------------------------*/
int      GetSpeculative (void) { return specflag; }

/*-------------------------------------------------------------
 * get prevOpPtr
 *-------------------------------------------------------------*/
legoOp  *GetPrevLink (void) { return prevOpPtr; }

/*
/*-------------------------------------------------------------
 * get nextOpPtr
 *-------------------------------------------------------------*/
legoOp  *GetNextLink (void) { return nextOpPtr; }

/*-------------------------------------------------------------
 * get allListPtr
 *-------------------------------------------------------------*/
legoOp  *GetListOpPtr (void) { return allListPtr; }

/*-------------------------------------------------------------
 * get blockId
 *-------------------------------------------------------------*/
int      GetBlockId (void) { return blockId; }

/*-------------------------------------------------------------
 * get parent's pointer
 *-------------------------------------------------------------*/
void    *GetParentBlockPtr (void) { return parentBlockPtr; }

/*-------------------------------------------------------------
 * get utility pointer
 *-------------------------------------------------------------*/
void    *GetUtilityPtr (void) { return utilityPtr; }

/*-------------------------------------------------------------
 * get mdes info pointer
 *-------------------------------------------------------------*/
Mdes_Info *GetMdesInfoPtr (void) { return mdesInfoPtr; }

/*-------------------------------------------------------------
 * get ru info pointer
 *-------------------------------------------------------------*/
RU_Info *GetRUInfoPtr (void) { return ruInfoPtr; }

/*-------------------------------------------------------------
 * get inital flags pointer
 *-------------------------------------------------------------*/
flags  *GetOpFlagPtr (void) { return opFlagPtr; }

/*-------------------------------------------------------------
 * get in and out edges ptrs
 *-------------------------------------------------------------*/
opList *GetInListPtr(void) {return inListPtr;}
opList *GetOutListPtr(void) {return outListPtr;}

/*-------------------------------------------------------------
 * get initial attrList pointer
 *-------------------------------------------------------------*/
attrList  *GetOpAttrListPtr (void) { return opAttrListPtr; }

/*-------------------------------------------------------------
 * get PredVector pointer
 *-------------------------------------------------------------*/
bitvector *GetPredVectorPtr (void) { return PredVector; }


/*-------------------------------------------------------------
 * other methods
 *-------------------------------------------------------------*/
int IsDummy (void);

//HZ: Is??Op
   bool IsCMERGEOp();
   bool IsDEFINEOp();
   bool IsDUMMYBROp();
   bool IsBRLOp();
   bool IsBRUOp();
   bool IsBRCONDOp();
   bool IsDIVOp(); //Divsion related ops (exception potential)
   bool IsRETOp();
   bool IsLDOp();
   bool IsSTOp();
   bool IsIntegerOp();
   bool IsFloatOp();
   bool IsCMPPOp(); //Compare to a predicate
   bool IsCompareOp(); //CMPP or CMPR (compare to a register)
   bool IsBranchOp(); 
   bool IsBranchOpButNotBRL();
   bool IsPBROp();
   bool IsPBRROp();
   bool IsADDOp();
   bool IsRealOp();
   bool IsAllocOp();
   bool IsMOVOp();
   bool IsBRLExitOp(); //br.call exit#. 
   bool IsBreakOp();
};
#endif

---