legoOprd.H

Go to the documentation of this file.

/*
 *   Name:        legoOprd.H
 *
 *   Designer:    Willie Glover
 *
 *   Created:     4/10/96
 *
 *   Description: This file contains the hesder file for the LEGO operand
 *                base class used for the LEGO IR.
 *
 *   Location:    /ncsu/tinker/LEGO/src/base/legoOprd.H
 *
 *   Methods:     /ncsu/tinker/LEGO/src/base/legoOprd.C
 *
 *   05/09/96  WTG: Tested inlining (for usage)
 *   05/11/96  WTG: Completed inlining of LegoOprd
 *                  Renamed member functions using longer names.
 *                  Changed RegSpec to regSpec, Data to data
 *                  Combined CpyOprdLit() and CpyOprdReg() into single
 *                     function called CopyOperand(). See comments
 *   12/05/96  WAH: Added copy constructor.
 *    5/01/97  WAH: GetOprdRegNum returns booleanVal for BOOLEAN
 *                  operands; SetOprdRegNum sets booleanVal likewise.
 *    9/04/97  WAH: Removed private enumerations; switched to using
 *                  globals.H instead; removed SetOperand; added
 *                  Set[Prev|Next]OprdPtr.
 *    9/23/97  WAH: Added addrStyle field and associated methods;
 *                  added new literals and data types; reworked
 *                  OT_BOOLEAN to OT_LITERAL_P.
 *   10/10/97  WAH: Added parentPtr and associated methods.
 *   10/22/97  WAH: Added oprdList class (moved from analysis library).
 *   10/31/97  WAH: Added valid field and associated methods to legoOprd.
 *   1/9/98    WAH: Fixed SetLiteralString and SetLiteralLabel to handle NULL.
 *   4/22/98   WAH: Changed parentPtr to parentOpPtr; added parentAttrPtr.
 *   11/20/98  MDJ: Changed GegOprdRegNum to return intVal if RT_BR. intVal
 *                  is being used for bounded register numbers. 
 */

#ifndef LEGOOPRD_H
#define LEGOOPRD_H

#include <stdio.h>
#include <stdlib.h>

/* added include for globals.h -8/22/96- */

#include "globals.H"

class HppaTxOp;
// wah 4/22/98 Added forward declaration of legoOp and attrs.
class legoOp;
class attrs;

class legoOprd {
  friend class legoOp;
  friend class HppaTxOp;

  enum oprdTypes oprdType;      // literal, reg, undefined, or vacant

  union operandData {
    union literalType {
      char               booleanLit;
      char               charLit;
      unsigned char      uCharLit;
      short              shortLit;
      unsigned short     uShortLit;
      int                integerLit;
      unsigned           uIntegerLit;
      long               longLit;
      unsigned long      uLongLit;
      long long          longLongLit;
      unsigned long long uLongLongLit;
      long long          longLongLongLit;
      unsigned long long uLongLongLongLit;
      long               pointerLit;
      char*              labelLit;
      char*              stringLit;
      float              floatLit;
      double             doubleLit;
      int                cbLit;
      char               predicateLit;
    } literal;                  // literal operand data

    struct {
      enum regTypes regType;    // r, vr, fr, br, mvr
      int regNum;               // register number or macro register
      int omega;
      enum dataTypes dataType;  // i, f, d, p, or b, or others
      enum fileTypes fileType;  // gpr, fpr, pr, btr, or cr
      enum regStyles regStyle;  // static or rotating (s or r)
      int intValue;             // ?? not sure what for
    } regSpec;                  // register operand data
    //    int booleanVal;               // boolean value for predicates
  } data;                       // operand data

  enum addrStyles addrStyle;    // addressing style for label/string lits.

  int valid;                    // valid bit
  legoOprd *nextOperandPtr;     // ptr to next operand
  legoOprd *prevOperandPtr;     // ptr to prev operand
  legoOp *parentOpPtr;          // ptr to parent op of operand chain
  attrs *parentAttrPtr;         // ptr to parent attr of operand chain

public:

  legoOprd (void);              // constructor
  legoOprd (const legoOprd &);  // copy constructor
  ~legoOprd (void);             // destructor

 /* CopyOperand copies  one operand to another.  The argument is a
  * pointer to the operand you want to copy from.  The oprdType field
  * is checked to determine what type of operand is being copied.  A
  * pointer to the new operand is returned.
  */

  // wah 4/22/98 Commented out.
  //  legoOprd *CopyOperand (legoOprd*);

  /*
   *  SetOperand allows update of already existing lego operand.  Pass
   *   operand pointer & fields.  Separate function for regSpec and literal
   */

  //  void SetOperand(int, int, int, int, int, int);
  //  void SetOperand(legoOprd::operandData::literalType);

  /*
   *  AddOprd creates adds an operand of the specified type.  If no
   *   operand currently exists, one is created; -- otherwise another is
   *   linked in and the appropriate next & prev pointers are updated.
   *   Returns pointer to new operand.
   */

  legoOprd *AddOprd();

  /*
   *  The following methods allow update of individual fields of the
   *   lego operand.
   */
  void SetOprdType (enum oprdTypes oprdT) { oprdType = oprdT; }
  void SetOprdLiteral (legoOprd::operandData::literalType literalOprd)
       { data.literal = literalOprd; }
  void SetLiteralControlBlock (int litCB) { data.literal.cbLit = litCB; }
  void SetLiteralBoolean (int litBool) { data.literal.booleanLit = litBool; }
  void SetLiteralChar (int litChr) { data.literal.charLit = litChr; }
  void SetLiteralUChar (int litUChr) { data.literal.uCharLit = litUChr; }
  void SetLiteralShort (int litSh) { data.literal.shortLit = litSh; }
  void SetLiteralUShort (int litUSh) { data.literal.uShortLit = litUSh; }
  void SetLiteralInteger (int litInt) { data.literal.integerLit = litInt; }
  void SetLiteralUInteger (int litUInt) { data.literal.uIntegerLit = litUInt; }
  void SetLiteralLong (long litLong) { data.literal.longLit = litLong; }
  void SetLiteralULong (long litULong) { data.literal.uLongLit = litULong; }
  void SetLiteralLongLong (long long litLongLong)
  { data.literal.longLongLit = litLongLong; }
  void SetLiteralULongLong (long long litULongLong)
  { data.literal.uLongLongLit = litULongLong; }
  void SetLiteralLongLongLong (long long litLongLongLong)
  { data.literal.longLongLongLit = litLongLongLong; }
  void SetLiteralULongLongLong (long long litULongLongLong)
  { data.literal.uLongLongLongLit = litULongLongLong; }
  void SetLiteralPointer (long litPtr) { data.literal.pointerLit = litPtr; }
  void SetLiteralFloat (float litFlt) { data.literal.floatLit = litFlt; }
  void SetLiteralDouble (double litDbl) { data.literal.doubleLit = litDbl; }
  void SetLiteralPredicate (int litPr) { data.literal.predicateLit = litPr; }
  void SetLiteralString (char *litStr)
       {
         /* MEMORY LEAK!!!!! */
         //         delete[] data.literal.stringLit;
         if (litStr != NULL)
           {
             data.literal.stringLit = new char[strlen(litStr)+1];
             int idx2 = strlen(litStr);
             for (int idx=0; idx<idx2; idx++) {
               data.literal.stringLit[idx] = *(litStr++);
             }
             data.literal.stringLit[idx2] = '\0';
           } // end if
         else data.literal.stringLit = NULL;
       }
  void SetLiteralLabel (char *litLab)
       {
         //      delete[] data.literal.labelLit;
         if (litLab != NULL)
           {
             data.literal.labelLit = new char[strlen(litLab)+1];
             int idx2 = strlen(litLab);
             for (int idx=0; idx<idx2; idx++) {
               data.literal.labelLit[idx] = *(litLab++);
             }
             data.literal.labelLit[idx2] = '\0';
           } // end if
         else data.literal.labelLit = NULL;
       }
  void SetLiteralAddrStyle (enum addrStyles addrS) { addrStyle = addrS; }
  void SetOprdRegType (enum regTypes regT) { data.regSpec.regType = regT; }
  void SetOprdRegNum (int regN)
  {
    if (oprdType != OT_LITERAL_P)
      data.regSpec.regNum = regN;
    else
      data.literal.predicateLit = regN;
  }
  void SetOprdOmega  (int omeg){ data.regSpec.omega = omeg; }
  void SetOprdDataType (enum dataTypes datT) { data.regSpec.dataType = datT; }
  void SetOprdFileType (enum fileTypes filT) { data.regSpec.fileType = filT; }
  void SetOprdRegStyle (enum regStyles regS) { data.regSpec.regStyle = regS; }
  void SetIntValue  (int intV) { data.regSpec.intValue = intV; }
  void SetBooleanVal  (int bVal) { data.literal.predicateLit = bVal; }
  void SetValid (int v) { valid = v; }
  void SetNextOprdPtr (legoOprd *noprd) { nextOperandPtr = noprd; }
  void SetPrevOprdPtr (legoOprd *poprd) { prevOperandPtr = poprd; }
  void SetParentOpPtr (legoOp *pptr) { parentOpPtr = pptr; }
  void SetParentAttrPtr (attrs *pptr) { parentAttrPtr = pptr; }

  /*
   *  The following methods provide reading of individual fields of the
   *   lego operand.
   */
  enum oprdTypes GetOprdType (void) { return oprdType; }
  int  GetLiteralControlBlock (void) { return data.literal.cbLit; }
  char GetLiteralBoolean (void) { return data.literal.booleanLit; }
  int  GetLiteralChar (void) { return data.literal.charLit; }
  unsigned GetLiteralUChar (void) { return data.literal.uCharLit; }
  int  GetLiteralShort (void) { return data.literal.shortLit; }
  unsigned GetLiteralUShort (void) { return data.literal.uShortLit; }
  int  GetLiteralInteger (void) { return data.literal.integerLit; }
  unsigned GetLiteralUInteger (void) { return data.literal.uIntegerLit; }
  long GetLiteralLong (void) { return data.literal.longLit; }
  unsigned long GetLiteralULong (void) { return data.literal.uLongLit; }
  long long GetLiteralLongLong (void) { return data.literal.longLongLit; }
  unsigned long long GetLiteralULongLong (void)
  { return data.literal.uLongLongLit; }
  long long GetLiteralLongLongLong (void)
  { return data.literal.longLongLongLit; }
  unsigned long long GetLiteralULongLongLong (void)
  { return data.literal.uLongLongLongLit; }
  long GetLiteralPointer (void) { return data.literal.pointerLit; }
  float GetLiteralFloat (void) { return data.literal.floatLit; }
  double GetLiteralDouble (void) { return data.literal.doubleLit; }
  char GetLiteralPredicate (void) { return data.literal.predicateLit; }
  char *GetLiteralString (void) { return data.literal.stringLit; }
  char *GetLiteralLabel (void) { return data.literal.labelLit; }
  enum addrStyles GetLiteralAddrStyle (void)
  {
    if (oprdType != OT_LITERAL_L && oprdType != OT_LITERAL_S)
      return AS_UNDEF;
    else
      return addrStyle;
  }
  enum regTypes GetOprdRegType (void) { return data.regSpec.regType; }
  int  GetOprdRegNum (void)
  {
    if (oprdType == OT_LITERAL_P)
      return data.literal.predicateLit;
    else if (data.regSpec.regType == RT_BR)
      return data.regSpec.intValue;
    else 
      return data.regSpec.regNum;
  }
  int  GetOprdOmega (void) { return data.regSpec.omega; }
  enum dataTypes GetOprdDataType (void) { return data.regSpec.dataType; }
  enum fileTypes GetOprdFileType (void) { return data.regSpec.fileType; }
  enum regStyles GetOprdRegStyle (void) { return data.regSpec.regStyle; }
  int  GetBooleanVal  (void) { return data.literal.predicateLit; }
  int  GetOprdIntValue  (void) { return data.regSpec.intValue; }
  int  GetValid (void) { return valid; }
  legoOprd *GetNextOprdPtr (void) { return nextOperandPtr; }
  legoOprd *GetPrevOprdPtr (void) { return prevOperandPtr; }
  legoOp *GetParentOpPtr (void)
  {
    legoOprd *oprd;

    for (oprd = this; oprd->prevOperandPtr != NULL;
         oprd = oprd->prevOperandPtr) ;
    return oprd->parentOpPtr;
  }
  attrs *GetParentAttrPtr (void)
  {
    legoOprd *oprd;

    for (oprd = this; oprd->prevOperandPtr != NULL;
         oprd = oprd->prevOperandPtr) ;
    return oprd->parentAttrPtr;
  }
};

class oprdList
{
  legoOprd *oprdPtr;
  oprdList *nextListPtr;

public:
  oprdList (void) { oprdPtr = NULL; nextListPtr = NULL; }
  ~oprdList (void)
  {
    oprdList *tmpOprdListPtr;
    while (nextListPtr != NULL) {
      tmpOprdListPtr = nextListPtr;
      nextListPtr = tmpOprdListPtr->nextListPtr;
      tmpOprdListPtr->nextListPtr = NULL;
      delete tmpOprdListPtr;
    }
  }

  legoOprd *GetOprdPtr (void) { return oprdPtr; }
  void SetOprdPtr (legoOprd *o) { oprdPtr = o; }

  oprdList *GetNextListPtr (void) { return nextListPtr; }
  void SetNextListPtr (oprdList *n) { nextListPtr = n; }
}; // end class oprdList

#endif

---