LegoRWrt.C

Go to the documentation of this file.

/*
 *   Name:        LegoRWrt.C
 *
 *   Designer:    Willie Glover
 *
 *   Created:     4/14/96
 *
 *   Description: Routine to write out regions and ops in REBEL.
 *
 *   Location:    /ncsu/tinker/LEGO/src/util/LegoRWrt.C
 *
 *
 * 4/14/96 WTG:  created this file to test op structure
 * ...        :  updated to write everything else out, apparently...
 * 3/16/97 WAH:  fixed LegoWrite (legoRegion *, FILE *, int) to follow
 *               legoOp linkage instead of iterating over them
 * 3/19/97 WAH:  Added trace writing.
 * 3/26/97 WAH:  now writes out edge attributes.
 * 4/2/97 WAH:   Got LegoWrite to close its file pointer.
 * 4/15/97 WAH:  Investigated writing of predicate operands, name changes.
 * 4/18/97 WAH:  Fixed writing of empty out() list for ops.
 * 7/8/97 WAH:   Adjusted blockid writing of op.
 * 9/10/97 WAH:  Repaired calling LegoWrite with legoModule * only.
 * 9/23/97 WAH:  New Rebel changes.
 * 10/1/97 WAH:  Added writing of (empty) mem_vrs dictionary; removed
 *               writing of "flags ()" if no flags in region.
 * 10/6/97 WAH:  Changed cb writing control from #define to knob.
 * 12/8/97 WAH:  Fixed usage of knobs file to ensure always created
 *               for any LegoWrite call.
 * 1/22/98 WAH:  Fixed blockId writing (not "block", it's "bb_id").
 * 3/25/98 WAH:  Changed LegoWrite #4 to default to stdout.
 * 4/28/02 HZ:   Added support for the IA64 opcodes (i.e., LegoWrt writes the
 *               Rebel version of IA64 asm generated by IA64Read.
 */
// ---------------------------------------------------------------------------

#include "lego.H"
#include <stdio.h>
#include <stdlib.h>
#include <stl.h>
#include <string.h>
#include "TinkerKnobs.H"
#include "legocompress.H"

// Comment out the following line to use the new OT_LITERAL_CB writing style.
//#define OLD_OT_LITERAL_CB

// #define stderr wwout

// extern FILE *wwout;

#define INDENT_SIZE (80)
#define INDENT_INC (2)

char *ParseMap(int);
char *RegionMap(int);
//void  LegoErr(char*);
void  LegoFree(legoOp*);
int  LegoWrite (legoRegion*, FILE *, int);
int  LegoWrite (legoRegion*, char *);
int  LegoWrite (legoRegion*);

void WriteJump(legoProc*, FILE*);
void WriteAttrs(legoProc*, FILE*);
void WriteEdges(legoProc*, FILE*);
void WriteData(legoProc*, FILE*);
void WriteData(legoModule*, FILE*);
void WriteMem(legoProc*, FILE*);

/*-----------------------------------------------------------------
 * enum rStyles { STATIC='s', ROTATING='r'};  // static or rotating registers
 *-----------------------------------------------------------------*/
  static const char * const regRTN[] = {"r","vr","mvr","fr","br"};
  static const char * const regFTN[] = {"gpr","fpr","pr","btr","cr"};
  static const char * const regDTN[] = {"vo","bo","ch","uch","sh","ush","i",
                                        "ui","lng","ulng","llng","ullng",
                                        "lllng","ulllng","ptr","f","d","p",
                                        "b"};

  int lineLength;
  knobs *K = NULL;

/*
 * WriteOprd (designed by Willie Glover)
 *   oprdPtr = pointer to legoOprd to write
 *   outfile = FILE to which to write
 *   returns: nothing
 *
 * Writes out a legoOprd in REBEL format. Does not traverse to next
 * operand automatically.
 *
 * 9/3/97 WAH:   Fixed writing of OT_LITERAL_D (%d -> %lf), OT_LITERAL_C
 *               (%s -> %c).
 * 9/23/97 WAH:  Added writing of addrStyle for OT_LITERAL_L, OT_LITERAL_S;
 *               changed OT_LITERAL_CB writing from "cb" to just "b";
 *               updated OT_BOOLEAN/OT_LITERAL_P.
 * 9/26/97 WAH:  Added new operand types (14: VO, BO, (U)CH, (U)SH, UI,
 *               (U)(L)(L)LNG, PTR.
 * 10/31/97 WAH: Added non-printing of invalid operands.
 */
void WriteOprd (legoOprd* oprdPtr, FILE *outfile)
{
  double dblLit;
  float  fltLit;
  int    intLit, chrLit, cbLit, predLit, wrtMacro;
  long long llLit;
  char *lblLit;
  char *strLit;
  int regN, regT, regS, dataT, fileT, omegaData, intV;     // register data
  enum addrStyles as;
  char newcbstyle;
  if (oprdPtr == NULL) { return; }
  if (!(oprdPtr->GetValid())) return;
  int srcOprdType = oprdPtr->GetOprdType();
  switch (srcOprdType) {
    case OT_VACANT:  // storage allocated, but not set
         lineLength += fprintf(outfile,"VACANT");
         break;
  case OT_LITERAL_VO:
    lineLength += fprintf(outfile,"vo<>");
    break;
  case OT_LITERAL_BO:
    intLit = oprdPtr->GetLiteralBoolean();
    lineLength += fprintf(outfile,"bo<%d>",intLit);
    break;
  case OT_LITERAL_CH:
    intLit = oprdPtr->GetLiteralChar();
    lineLength += fprintf(outfile,"ch<%d>",intLit);
    break;
  case OT_LITERAL_UCH:
    intLit = oprdPtr->GetLiteralChar();
    lineLength += fprintf(outfile,"uch<%d>",intLit);
    break;
  case OT_LITERAL_SH:
    intLit = oprdPtr->GetLiteralShort();
    lineLength += fprintf(outfile,"sh<%d>",intLit);
    break;
  case OT_LITERAL_USH:
    intLit = oprdPtr->GetLiteralUShort();
    lineLength += fprintf(outfile,"ush<%d>",intLit);
    break;
    case OT_LITERAL_I:
         intLit = oprdPtr->GetLiteralInteger();
         lineLength += fprintf(outfile,"i<%d>",intLit);
         break;
  case OT_LITERAL_UI:
    llLit = oprdPtr->GetLiteralUInteger();
    lineLength += fprintf(outfile,"ui<%ld>",intLit);
    break;
  case OT_LITERAL_LNG:
    intLit = oprdPtr->GetLiteralLong();
    lineLength += fprintf(outfile,"lng<%ld>",intLit);
    break;
  case OT_LITERAL_ULNG:
    intLit = oprdPtr->GetLiteralULong();
    lineLength += fprintf(outfile,"ulng<%uld>",intLit);
    break;
    // Sau. seen some serious bugs in here.
    // changing only for LONG LONG right now (02/23/02) 
  case OT_LITERAL_LLNG:
    llLit = oprdPtr->GetLiteralLongLong();
    lineLength += fprintf(outfile,"llng<%lld>",llLit);
    break;
  case OT_LITERAL_ULLNG:
    intLit = oprdPtr->GetLiteralULongLong();
    lineLength += fprintf(outfile,"ullng<%uld>",intLit);
    break;
  case OT_LITERAL_LLLNG:
    intLit = oprdPtr->GetLiteralLongLongLong();
    lineLength += fprintf(outfile,"lllng<%ld>",intLit);
    break;
  case OT_LITERAL_ULLLNG:
    intLit = oprdPtr->GetLiteralULongLongLong();
    lineLength += fprintf(outfile,"ulllng<%uld>",intLit);
    break;
  case OT_LITERAL_PTR:
    intLit = oprdPtr->GetLiteralPointer();
    lineLength += fprintf(outfile,"ptr<%ld>",intLit);
    break;
    case OT_LITERAL_F:
         fltLit = oprdPtr->GetLiteralFloat();
         lineLength += fprintf(outfile,"f<%f>",fltLit);
         break;
    case OT_LITERAL_D:
         dblLit = oprdPtr->GetLiteralDouble();
         lineLength += fprintf(outfile,"d<%.0lf>",dblLit);
         break;
    case OT_LITERAL_C:
         chrLit = oprdPtr->GetLiteralChar();
         lineLength += fprintf(outfile,"c<%c>",chrLit);
         break;
    case OT_LITERAL_L:
         lblLit = oprdPtr->GetLiteralLabel();
         as = oprdPtr->GetLiteralAddrStyle();
         if (as == AS_UNDEF)
           lineLength += fprintf(outfile,"l<%s>",lblLit);
         else
           lineLength += fprintf(outfile,"l:%s<%s>",ParseMap(as+G_ABS-1),
                                 lblLit);
         break;
    case OT_LITERAL_S:
         strLit = oprdPtr->GetLiteralString();
         as = oprdPtr->GetLiteralAddrStyle();
         if (as == AS_UNDEF)
           lineLength += fprintf(outfile,"s<\"%s\">",strLit);
         else
           lineLength += fprintf(outfile,"s:%s<\"%s\">",ParseMap(as+G_ABS-1),
                                 strLit);
         break;
    case OT_LITERAL_CB:
         cbLit = oprdPtr->GetLiteralControlBlock();
         //#ifdef OLD_OT_LITERAL_CB (inverse of if-then-else)
         K->Read ("ir:new-cb-style", newcbstyle);
         if (newcbstyle)
           lineLength += fprintf(outfile,"b<%d>",cbLit);
         //#else
         else
           lineLength += fprintf(outfile,"cb<%d>",cbLit);
         //#endif
         break;
    case OT_LITERAL_P:
         predLit = oprdPtr->GetLiteralPredicate();
         if (predLit) { lineLength += fprintf(outfile,"p<t>"); }
         else         { lineLength += fprintf(outfile,"p<f>"); }
         break;
    case OT_REG:
         regT = oprdPtr->GetOprdRegType();
         regS = oprdPtr->GetOprdRegStyle();
         dataT = oprdPtr->GetOprdDataType();
         fileT = oprdPtr->GetOprdFileType();
         regN = oprdPtr->GetOprdRegNum();
         intV = oprdPtr->GetOprdIntValue();
         omegaData = oprdPtr->GetOprdOmega();
         switch (regT) {
           case RT_R:
              lineLength += fprintf(outfile,"r<%d",regN);
              if (omegaData != 0) { lineLength += fprintf(outfile," %d",omegaData); }
              lineLength += fprintf(outfile,":%s %s>",regDTN[dataT],regFTN[fileT]);
              break;
           case RT_VR:
              lineLength += fprintf(outfile,"vr<%d",regN);
              if (omegaData != 0) { lineLength += fprintf(outfile," %d",omegaData); }
              lineLength += fprintf(outfile,":%s>",regDTN[dataT]);
              break;
           case RT_MVR:
              lineLength += fprintf(outfile,"mvr<%d",regN);
              if (omegaData != 0) { lineLength += fprintf(outfile," %d",omegaData); }
              lineLength += fprintf(outfile,">");
              break;
           case RT_FR:
              lineLength += fprintf(outfile,"fr<%d",regN);
              if (omegaData != 0) { lineLength += fprintf(outfile," %d",omegaData); }
              lineLength += fprintf(outfile,":%s %s %c>",regDTN[dataT],regFTN[fileT],regS);
              break;
           case RT_BR:
              lineLength += fprintf(outfile,"br<%d",regN);
              if (omegaData != 0) { lineLength += fprintf(outfile," %d",omegaData); }
              lineLength += fprintf(outfile,":%s %s %c %d>",
                      regDTN[dataT],regFTN[fileT],regS,intV);
              break;
           default:
              LegoNonFatal ("WriteOprd", "Reg type still not found.");
              break;
        }
         break;
    case OT_MACRO:
 //        fprintf(stderr,"LW(%p-%d)",oprdPtr,oprdPtr->GetOprdRegNum());
         wrtMacro = oprdPtr->GetOprdRegNum();
         if ( wrtMacro < 255 ) { wrtMacro = 256; }
         lineLength += fprintf(outfile,"m<%s>",ParseMap(wrtMacro));
         break;
    case OT_UNDEFINED:
         lineLength += fprintf(outfile,"u<>");
         break;
    default:
         LegoNonFatal ("WriteOprd", "Src or dest operand not found.");
         break;
  }
  return;
}

/*
 * WriteOps (designed by Willie Glover)
 *   legoOpPtr = pointer to first legoOp to write
 *   singleOp = whether to write just first op or all ops
 *   outfile = file to which to write
 *   offset = number of spaces to indent from left
 *   returns: 1 if writing successful, 0 otherwise
 *
 * Writes out a single legoOp in REBEL format if singleOp is nonzero,
 * otherwise writes out all ops from legoOpPtr until the end of the
 * encompassing region.
 *
 * 9/23/97 WAH:  Added flag writing (!); repairs to attribute writing.
 * 10/2/97 WAH:  More repairs to attribute writing.
 */
int  WriteOps (legoOp* legoOpPtr,
                        int singleOp,
                        FILE *outfile,
                        int offset=0)
{
  char indStr[INDENT_SIZE];       // string to hold record offset
  unsigned indSz;        // specifies record offset
  unsigned idx;
  for (idx = 0; idx<INDENT_SIZE; idx++) { indStr[idx] = '\0'; }
  indSz = offset;
  for (idx = 0; idx<indSz; idx++) { indStr[idx] = ' '; }

  legoOprd *nextPOprdPtr;
 //  fprintf(outfile,"\n");
  lineLength = 0;

/*-----------------------------------------------------------------
 * write opid
 *-----------------------------------------------------------------*/
  int wrtOpId = legoOpPtr->GetOpId();
  lineLength += fprintf(outfile,"%sop %d", indStr, wrtOpId);
  fflush(outfile);

/*-----------------------------------------------------------------
 * write opcode
 *-----------------------------------------------------------------*/
  if(legoOpPtr->GetOpcodePtr() == NULL)
  {
      int wrtOpcode = legoOpPtr->GetOpcode();
      lineLength += fprintf(outfile," (%s",ParseMap(wrtOpcode));
      fflush(outfile);
  }
  else
  {
      //HZ: write the base opcode and the qualifiers
     lineLength += fprintf(outfile, "(%s",
              legoOpPtr->GetOpcodePtr()->GetOpcString());
     fflush(outfile);
  }

/*-----------------------------------------------------------------
 *  write destination operands
 *
 *  Get the first destination operand and write it out.  If the
 *     first operand is not NULL, then write out any additional
 *     destination operands until the a NULL pointer is reached.
 *-----------------------------------------------------------------*/
  legoOprd *destPtr = legoOpPtr->GetDestOprdPtr();
  lineLength += fprintf(outfile," [");
  WriteOprd(destPtr,outfile);
  if (destPtr != NULL) {
     legoOprd *nextDOprdPtr = destPtr->GetNextOprdPtr();
     if (nextDOprdPtr != NULL) {
        destPtr = nextDOprdPtr;
        lineLength += fprintf(outfile," ");
        WriteOprd(destPtr,outfile);
        nextDOprdPtr = destPtr->GetNextOprdPtr();
        if (nextDOprdPtr != NULL) {
           lineLength += fprintf(outfile," ");
           WriteOprd(nextDOprdPtr,outfile);
        }
     }
  }
    lineLength += fprintf(outfile,"]");
  fflush(outfile);

/*-----------------------------------------------------------------
 * write source operands
 *
 *  Get the first source operand and write it out.  If the
 *     first operand is not NULL, then write out any additional
 *     source operands until the a NULL pointer is reached.
 *-----------------------------------------------------------------*/
  legoOprd *srcPtr = legoOpPtr->GetSrcOprdPtr();
  lineLength += fprintf(outfile," [");
  WriteOprd(srcPtr,outfile);
  if (srcPtr != NULL) {
     legoOprd *nextSOprdPtr = srcPtr->GetNextOprdPtr();
     if (nextSOprdPtr != NULL) {
        srcPtr = nextSOprdPtr;
        lineLength += fprintf(outfile," ");
        WriteOprd(srcPtr,outfile);
        nextSOprdPtr = srcPtr->GetNextOprdPtr();
        if (nextSOprdPtr != NULL) {
           lineLength += fprintf(outfile," ");
           WriteOprd(nextSOprdPtr,outfile);
           //HZ: add two more possible src oprd
           nextSOprdPtr = nextSOprdPtr->GetNextOprdPtr();
           if (nextSOprdPtr != NULL) 
           {
               lineLength += fprintf(outfile," ");
               WriteOprd(nextSOprdPtr,outfile);
               nextSOprdPtr = nextSOprdPtr->GetNextOprdPtr();
               if(nextSOprdPtr != NULL) 
               {
                   lineLength += fprintf(outfile," ");
                   WriteOprd(nextSOprdPtr,outfile);
               }
           }

        }
     }
  }
  lineLength += fprintf(outfile,"]");
  fflush(outfile);

/*-----------------------------------------------------------------
 *  write predicate operand
 *
 *  Get the first predicate operand and write it out.  If more
 *     than one predicate is specified, exit with a error.
 *-----------------------------------------------------------------*/
  legoOprd *predPtr = legoOpPtr->GetPredOprdPtr();
  if (predPtr != NULL) {
     lineLength += fprintf(outfile," ");
     WriteOprd(predPtr,outfile);
     nextPOprdPtr = predPtr->GetNextOprdPtr();
     if (nextPOprdPtr != NULL) {
        LegoNonFatal ("WriteOps", "Multiple predicate operands for op %d.",
                      legoOpPtr->GetOpId());
     }
  }
  if (lineLength > 65) { fprintf(outfile,"\n%s",indStr); lineLength = 0; }
  fflush(outfile);

/*-----------------------------------------------------------------
 * write scheduled opcode
 *-----------------------------------------------------------------*/
  if ( legoOpPtr->GetSchedOpcode() != NULL ) {
     lineLength += fprintf(outfile," s_opcode(%s)",
                                   legoOpPtr->GetSchedOpcode());
     if (lineLength > 65) { fprintf(outfile,"\n%s",indStr); lineLength = 0; }
  }
  fflush(outfile);

/*-----------------------------------------------------------------
 * write related opcodes
 *-----------------------------------------------------------------*/
  opList *chkRelOpsPtr = legoOpPtr->GetRelatedOpsPtr();
  if (chkRelOpsPtr != NULL) {
     int wrtRelOpId = (chkRelOpsPtr->GetOpPtr())->GetOpId();
     double wrtRelOpFF = chkRelOpsPtr->GetWeight();
     lineLength += fprintf(outfile," related_ops(op-%d(%f)",wrtRelOpId,wrtRelOpFF);
     opList *chkRelONPtr = chkRelOpsPtr->GetNextListPtr();
     while (chkRelONPtr != NULL) {
        chkRelOpsPtr = chkRelONPtr;
        wrtRelOpId = (chkRelOpsPtr->GetOpPtr())->GetOpId();
        wrtRelOpFF = chkRelOpsPtr->GetWeight();
        chkRelONPtr = chkRelOpsPtr->GetNextListPtr();
        lineLength += fprintf(outfile," op-%d(%d)",wrtRelOpId,wrtRelOpFF);
     }
     lineLength += fprintf(outfile,")");
  }
  if (lineLength > 65) { fprintf(outfile,"\n%s",indStr); lineLength = 0; }
  fflush(outfile);

/*-----------------------------------------------------------------
 * write scheduled time
 *-----------------------------------------------------------------*/
  int wrtSTime = legoOpPtr->GetSchedTime();
  if ( wrtSTime > 0 ) {
     lineLength += fprintf(outfile," s_time(%d)",wrtSTime);
  }
  if (lineLength > 65) { fprintf(outfile,"\n%s",indStr); lineLength = 0; }
  fflush(outfile);
/*-----------------------------------------------------------------
 * write spec
 *-----------------------------------------------------------------*/
  int wrtSpecul = legoOpPtr->GetSpeculative();
  if (wrtSpecul == 1) { lineLength += fprintf(outfile," spec"); }
  if (wrtSpecul == 0) { lineLength += fprintf(outfile," nonspec"); }
  if (lineLength > 65) { fprintf(outfile,"\n%s",indStr); lineLength = 0; }
  fflush(outfile);

/*-----------------------------------------------------------------
 * write attributes for op
 *-----------------------------------------------------------------*/
   attrList *wrtOpAttrListPtr = legoOpPtr->GetOpAttrListPtr();
   if (wrtOpAttrListPtr == NULL) { /* do nothing */ }
   else {
      lineLength += fprintf(outfile," attr(");
      while (wrtOpAttrListPtr != NULL)
        {
          switch (wrtOpAttrListPtr->GetAttrType())
            {
            case ATTR_LC:
              {
                int tmpAttrId = wrtOpAttrListPtr->GetAttrId();
                if ( tmpAttrId != 0 ) {
                  lineLength += fprintf(outfile,"lc ^%d", tmpAttrId);
                } // end if
              }
              break;
            case ATTR_LIVE:
              {
                int tmpAttrId = wrtOpAttrListPtr->GetAttrId();
                if ( tmpAttrId != 0 ) {
                  lineLength += fprintf(outfile,"live ^%d", tmpAttrId);
                } // end if
              }
              break;
            case ATTR_TBLNAME:
              lineLength += fprintf(outfile, "tbl_name(%s)",
                                    wrtOpAttrListPtr->GetTableName());
              break;
            default:
              break;
            } // end switch
          if (lineLength > 65)
            { fprintf(outfile,"\n%s",indStr); lineLength = 0; }

          wrtOpAttrListPtr = wrtOpAttrListPtr->GetNextListPtr();
          if (wrtOpAttrListPtr != NULL)
            lineLength += fprintf(outfile," ");
        }
      lineLength += fprintf(outfile,")");
   }
  if (lineLength > 65) { fprintf(outfile,"\n%s",indStr); lineLength = 0; }
  fflush(outfile);

/*-----------------------------------------------------------------
 * write flags for op
 *-----------------------------------------------------------------*/
  flags *wrtOpFlagPtr = legoOpPtr->GetOpFlagPtr();
  if (wrtOpFlagPtr == NULL) { /* do nothing */ }
  else {
    lineLength += fprintf(outfile," flags(");
    flags *tmpFlagPtr = wrtOpFlagPtr;
    while ( tmpFlagPtr != NULL ) {
      if (tmpFlagPtr->GetFlagName() == 0)  // happens if blank flags read in
        continue;
      lineLength += fprintf(outfile,"%s",ParseMap(tmpFlagPtr->GetFlagName()));
      tmpFlagPtr = tmpFlagPtr->GetNextFlagPtr();
      if ( tmpFlagPtr != NULL ) { lineLength += fprintf(outfile," "); }
    }
    lineLength += fprintf(outfile,")");    
  }
  if (lineLength > 65) { fprintf(outfile,"\n%s",indStr); lineLength = 0; }
  fflush(outfile);

/*-----------------------------------------------------------------
 * get in edge info
 *-----------------------------------------------------------------*/
  opList *wrtListPtr = legoOpPtr->GetInListPtr();
  if ( wrtListPtr != NULL ) {
    lineLength += fprintf(outfile," in_edges(");
    while ( wrtListPtr != NULL ) {
       if ( wrtListPtr->GetOpId() == 0 ) { break; }
       fprintf(outfile,"op-%d(%d)",wrtListPtr->GetOpId(),
                                  (int) wrtListPtr->GetWeight());
       wrtListPtr = wrtListPtr->GetNextListPtr();
       if ( wrtListPtr != NULL ) {
         lineLength += fprintf(outfile," ");
       }
    }
  lineLength += fprintf(outfile,")");
  }
  fflush(outfile);

/*-----------------------------------------------------------------
 * get out edge info
 *-----------------------------------------------------------------*/
  wrtListPtr = legoOpPtr->GetOutListPtr();
  if ( wrtListPtr != NULL ) {
    lineLength += fprintf(outfile," out(");
    while ( wrtListPtr != NULL ) {
       if ( wrtListPtr->GetOpId() == 0) { break; }
       fprintf(outfile,"op-%d(%d)",wrtListPtr->GetOpId(),
                                  (int) wrtListPtr->GetWeight());
       wrtListPtr = wrtListPtr->GetNextListPtr();
       if ( wrtListPtr != NULL ) {
         lineLength += fprintf(outfile," ");
       }
    }
  lineLength += fprintf(outfile,")");
  }
  fflush(outfile);

/*-----------------------------------------------------------------
 * get next op in region
 *-----------------------------------------------------------------*/
  legoOp *wrtNextOp = legoOpPtr->GetNextLink();

/*-----------------------------------------------------------------
 * write block id
 *-----------------------------------------------------------------*/
  int wrtBlockId= legoOpPtr->GetBlockId();
  if (wrtBlockId != -1) {
    lineLength += fprintf(outfile," bb_id(%d)",wrtBlockId);
  }
  fprintf(outfile,")\n");
  fflush(outfile);

/*-----------------------------------------------------------------
 * Call WriteOps recursively until NULL next op
 *-----------------------------------------------------------------*/
  if ((wrtNextOp != NULL) && (singleOp == 0)) {
     if (!WriteOps(wrtNextOp,singleOp,outfile,offset)) { return 0;}
  }

  return 1;
} // WriteOps

/*
 * DumpOps (designed by Willie Glover)
 *   legoOpPtr = pointer to first legoOp to write
 *   returns: 1 if writing successful, 0 otherwise
 *
 * Calls WriteOps to write all ops from legoOpPtr until the end of the
 * encompassing region to standard error.
 */
int  DumpOps (legoOp* legoOpPtr)
{
  return WriteOps(legoOpPtr,0,stderr);
} // DumpOps

/*
 * Note: LegoWrite is an overloaded function. Three different varieties
 * are described below; only the last two have real meat. They will be
 * referred to as #1, #2, #3, and #4.

/*
 * LegoWrite (designed by Willie Glover) #1
 *   legoRegPtr = pointer to legoRegion to write
 *   rblOutFile = name of Rebel file to create
 *   returns: 1 always
 *
 * Writes a legoRegion to the file given by calling LegoWrite #3 with
 * offset zero.
 */
int  LegoWrite (legoRegion* legoRegPtr, char *rblOutFile)
{
  FILE *rblout;

  if (legoRegPtr->GetRegionType() == RT_MODULE)
    LegoWrite ((legoModule *) legoRegPtr, rblOutFile);
  else
    {
      /*
       * get the REBEL output file
       */
      rblout = fopen(rblOutFile, "w");
      if (!rblout) {
        printf("Fatal Error: LegoWrite - output file %s open failed\n",rblOutFile);
        exit(2);
      }
      LegoWrite (legoRegPtr, rblout, 0);
      fclose (rblout);
    }
  return 1;
}

/*
 * LegoWrite (designed by Willie Glover) #2
 *  legoRegPtr = pointer to legoRegion to write
 *  returns: 1 always
 *
 * Same as LegoWrite #1, but writes to standard error.
 */
int  LegoWrite (legoRegion* legoRegPtr)
{
  if (legoRegPtr->GetRegionType() == RT_MODULE)
    LegoWrite ((legoModule *) legoRegPtr, NULL);
  else
    LegoWrite (legoRegPtr, stderr, 0);
  return 1;
}
/*
 * LegoWrite (designed by Willie Glover) #3
 *   legoRegPtr = pointer to legoRegion to write
 *   filPtr = file to which to write
 *   offset = initial number of spaces to indent from left
 *   returns: 1 always
 *
 * Writes a legoRegion to the file given. Should NOT be called with
 * a legoModule.
 *
 * 2/19/97 WAH: Fixed entry/exit opList writing.
 *----------------------------------------------------------------------*/
int  LegoWrite (legoRegion* legoRegPtr, FILE *filPtr, int offset)
{
  char indStr[INDENT_SIZE]; // string to hold record offset
  unsigned indSz;           // specifies record offset
  unsigned idx;
  legoProc* procPtr;
  legoModule* moduPtr;  // dummy statement
  for (idx = 0; idx<INDENT_SIZE; idx++) { indStr[idx] = '\0'; }
  indSz = offset;
  for (idx = 0; idx<indSz; idx++) { indStr[idx] = ' '; }
  int allocatedKnobs;

  if (K == NULL)
    {
      K = new knobs();
      allocatedKnobs = 1;
    } // end if
  else
    allocatedKnobs = 0;

/*-----------------------------------------------------------------
 * get the region type
 *-----------------------------------------------------------------*/
  enum regionTypes rType = legoRegPtr->GetRegionType();

/*-----------------------------------------------------------------
 * write region type (use map to regionTypes)
 *-----------------------------------------------------------------*/
  fprintf(filPtr,"%s",indStr);
  if (rType == RT_PROC) {
     procPtr = (legoProc*)legoRegPtr;
     if (procPtr->GetScope() == LIR_GLOBAL) {
       fprintf(filPtr,"global ");
     } 
     else if (procPtr->GetScope() == LIR_GNU_WEAK) {
       fprintf(filPtr,"gnu_weak ");
     } 
  }
  fprintf(filPtr,"%s",RegionMap((int)rType));

/*-----------------------------------------------------------------
 * if proc, write procedure name
 *-----------------------------------------------------------------*/
  if (rType == RT_PROC) {
     procPtr = (legoProc*)legoRegPtr;
     fprintf(filPtr," %s",procPtr->GetProcName());
  }

/*----------------------------------
 * write regionId
 *----------------------------------*/
   fprintf(filPtr," %d (",legoRegPtr->GetRegionId());
   indSz = indSz + INDENT_INC;
   for ( ; idx < indSz; idx++) {indStr[idx] = ' ';}
   //   indStr[idx-1] = ' ';
   fprintf(filPtr,"\n%s",indStr);
/*----------------------------------
 * write weight
 *----------------------------------*/
   //   fprintf(filPtr,"weight(%10.0f)",legoRegPtr->GetWeight());
   fprintf(filPtr,"weight(%.0f)",legoRegPtr->GetWeight());
   fprintf(filPtr,"\n%s",indStr);
/*----------------------------------
 * write entry_ops / exit_ops
 *----------------------------------*/
   fprintf(filPtr,"entry_ops(");
   if ( legoRegPtr->GetEntryOpsPtr() != NULL ) {
     opList *tmpoplist = legoRegPtr->GetEntryOpsPtr();
     while (tmpoplist != NULL)
       {
         if (tmpoplist->GetValid() == 0) break;
         fprintf(filPtr,"%d",(tmpoplist->GetOpPtr()->GetOpId()));
         tmpoplist = tmpoplist->GetNextListPtr();
         if (tmpoplist != NULL) { fprintf(filPtr," "); }
       } // end while
   } // end if
   fprintf(filPtr,") ");

   fprintf(filPtr,"exit_ops(");
   if ( legoRegPtr->GetExitOpsPtr() != NULL ) {
     opList *tmpoplist = legoRegPtr->GetExitOpsPtr();
     while (tmpoplist != NULL)
       {
         if (tmpoplist->GetValid() == 0) break;
         fprintf(filPtr,"%d",(tmpoplist->GetOpPtr()->GetOpId()));
         tmpoplist = tmpoplist->GetNextListPtr();
         if (tmpoplist != NULL) { fprintf(filPtr," "); }
       } // end while
   } // end if
   fprintf(filPtr,")");
   fprintf(filPtr,"\n%s",indStr);

/*----------------------------------
 * write entry edges  (proc edges must be purged)
 *----------------------------------*/
   fprintf(filPtr,"entry_edges(");
   edgeList *tmpListPtr = legoRegPtr->GetInEdgesPtr();
   while ( tmpListPtr != NULL ) {
     if ( tmpListPtr->GetValid() == 0 ) { break; }
     fprintf(filPtr,"ctrl ^%d",tmpListPtr->GetEdgeId());
     tmpListPtr = tmpListPtr->GetNextListPtr();
     if ( tmpListPtr != NULL ) { fprintf(filPtr," "); }
   }
   fprintf(filPtr,") ");

/*-----------------------------------------------------------------
 * write exit edges
 *-----------------------------------------------------------------*/
   fprintf(filPtr,"exit_edges(");
   tmpListPtr = legoRegPtr->GetOutEdgesPtr();
   while ( tmpListPtr != NULL ) {
     if ( tmpListPtr->GetValid() == 0 ) { break; }
     fprintf(filPtr,"ctrl ^%d",tmpListPtr->GetEdgeId());
     tmpListPtr = tmpListPtr->GetNextListPtr();
     if ( tmpListPtr != NULL ) { fprintf(filPtr," "); }
   }
   fprintf(filPtr,")");

/*-----------------------------------------------------------------
 * write end of line and record offset
 *-----------------------------------------------------------------*/
   fprintf(filPtr,"\n%s",indStr);

/*-----------------------------------------------------------------
 * write flags
 *-----------------------------------------------------------------*/
   flags *tmpFlagPtr = legoRegPtr->GetFlagPtr();
//   fprintf(stderr,"\n tmpFlagPtr =%p\n",tmpFlagPtr); 
//   fprintf(stderr,"\n tmpFlagPtr->GetFlagName()=%d\n",tmpFlagPtr->GetFlagName()); 
//   fprintf(stderr,"\n ParseMap(tmpFlagPtr->GetFlagName())=%d\n",
//                      ParseMap(tmpFlagPtr->GetFlagName())); 
   if ( tmpFlagPtr != NULL )
     {
       fprintf(filPtr,"flags(");

       while ( tmpFlagPtr != NULL ) {
         if (tmpFlagPtr->GetFlagName() == 0)  // happens if blank flags read in
           break;
         fprintf(filPtr,"%s",ParseMap(tmpFlagPtr->GetFlagName()));
         tmpFlagPtr = tmpFlagPtr->GetNextFlagPtr();
         if ( tmpFlagPtr != NULL ) { fprintf(filPtr," "); }
       }
       fprintf(filPtr,")");
     }

/*-----------------------------------------------------------------
 * write end of line and record offset
 *-----------------------------------------------------------------*/
   fprintf(filPtr,"\n%s",indStr);

/*-----------------------------------------------------------------
 * write attributes
 *-----------------------------------------------------------------*/
   fprintf(filPtr,"attr(");
   attrList *wrtRegAttrListPtr = legoRegPtr->GetRegionAttrListPtr();
   if (wrtRegAttrListPtr == NULL) { /* do nothing */ }
   else {
      int tmpAttrId = (legoRegPtr->GetRegionAttrListPtr())->GetAttrId();
      if ( tmpAttrId != 0 ) {
         fprintf(filPtr,"lc ^%d", tmpAttrId);
      }
   }
   fprintf(filPtr,")");

/*-----------------------------------------------------------------
 * write end of line and record offset
 *-----------------------------------------------------------------*/
   fprintf(filPtr,"\n%s",indStr);

/*-----------------------------------------------------------------
 * write subregion prefix
 *-----------------------------------------------------------------*/
   fprintf(filPtr,"subregions(");

/*-----------------------------------------------------------------
 * write end of line and record offset
 *-----------------------------------------------------------------*/
   //   fprintf(filPtr,"\n%s",indStr);
   fprintf(filPtr,"\n");

/*-----------------------------------------------------------------
 * Iterate through all items in set
 *-----------------------------------------------------------------*/
   int itemCount = legoRegPtr->GetCount();
//   fprintf(stderr,"IN LegoWrite(), itemCount = %d\n",itemCount);
//   fprintf(stderr,"IN LegoWrite(), rType = %d\n",rType);
   /*
    * WAH: I'll assume for sanity reasons that the first op in an
    * op-holding block is the first op in control flow for it too.
    */
   if (IS_BLOCK(rType) && itemCount > 0)
     WriteOps ((legoOp *)legoRegPtr->GetItem(0), 0,
                        filPtr, indSz+INDENT_INC);
   else
     {
       for (idx=0; idx<itemCount; idx++) {
         if ( (rType == RT_PROC) ||
              (rType == RT_LOOPBODY) ||
              (rType == RT_LOOP) ||
              (rType == RT_TREE) ||
              (rType == RT_TRACE) ) {
           LegoWrite((legoRegion*)legoRegPtr->GetItem(idx),filPtr,
                     indSz+INDENT_INC);
         }
         else {
           //         WriteOps((legoOp*)legoRegPtr->GetItem(idx),
           //                           1,filPtr,indSz+INDENT_INC);
           LegoNonFatal ("LegoWrite", "Don't know how to write region "
                         " of type %d.\n", rType);
         }
       } // end for
     } // end else

/*-----------------------------------------------------------------
 * write record offset
 *-----------------------------------------------------------------*/
   fprintf(filPtr,"%s",indStr);

/*-----------------------------------------------------------------
 * close subregions
 *-----------------------------------------------------------------*/
   indSz = indSz - INDENT_INC;
   indStr[indSz] = '\0';

   fprintf(filPtr,")\n%s",indStr);

/*-----------------------------------------------------------------
 * close region
 *-----------------------------------------------------------------*/
   //   fprintf(filPtr,")\n%s",indStr);
   fprintf(filPtr,")\n");


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

   if (allocatedKnobs)
     {
       delete K; K = NULL;
     } // end if

   return 1;
}

/*
 * LegoWrite (designed by Willie Glover) #4
 *   legoModPtr = pointer to legoModule to write
 *   rblOutFile = name of file to which to write
 *   returns: 1 always
 *
 * Writes a legoModule to the file named.
 */
int  LegoWrite (legoModule* legoModPtr, char *rblOutFile=NULL )
{
  FILE *filPtr = NULL;
  legoRegion *legoRegPtr;
  legoRegion *modRegPtr;
  int idx;
  vector<char *> *modComments;
  vector<char *>::iterator comi;
  char *cmdString;
  char usegzip;

//  K = new knobs();
//  K->SetDefaultPanel ("ir");
//  K->Read("usegzip", usegzip);
  usegzip = TRUE; 
/*
 * get the REBEL output file
 */
       if ( rblOutFile == NULL ) { filPtr = stdout; }
       //if (!filPtr) { filPtr = fopen(rblOutFile, "w"); }
       if (!filPtr)
       {
          if (usegzip) {
             // here we write a compressed file
            if ((cmdString = (char *)calloc(strlen(rblOutFile)+strlen(COMPRESS_CMD)
                                         +8,sizeof(char)))!=NULL)
            {
               sprintf(cmdString,"%s > %s",COMPRESS_CMD,rblOutFile);
               filPtr = popen(cmdString, "w");
               free(cmdString);
            }
            else
            {
               rblOutFile = NULL; // so we don't call pclose on filPtr
            }
          }
          else {
             // just write plain text file
             filPtr = fopen(rblOutFile, "w");
          }
       }
       if (!filPtr) {
           LegoNonFatal ("LegoWrite", "Output file open failed - writing "
                         "to stderr.");
           filPtr = stderr;
       }
       //  char comText[100];     // comment data
       //  FILE *comfile;

/*-----------------------------------------------------------------
 * write the comment file
 *-----------------------------------------------------------------*/
  //  if((comfile = fopen("rbl_com","r")) == NULL) {
  //     LegoNonFatal ("LegoWrite", "Can't open comment file.");
  //  }
  //  else {
  //    while ( fgets(comText,sizeof(comText),comfile) != NULL) {
  //      if ( comText[3] != '+' )
  //        { fprintf(filPtr,"%s",comText); }
  //     }
  //  }
  //  fprintf(filPtr,"\n");
  modComments = legoModPtr->GetComments();
  for (comi = modComments->begin(); comi != modComments->end(); comi++)
      //HZ: add the SMODCMT and EMODCMT to define the start and end of the 
      //comment string
    fprintf (filPtr, "SMODCMT %s EMODCMT\n", *comi);
  fprintf (filPtr, "\n");
/*----------------------------------------------------------------
 * search through the set and write all the procs.
 *----------------------------------------------------------------*/
   modRegPtr = legoModPtr;
   WriteData((legoModule*)modRegPtr, filPtr);
   int itemCount = modRegPtr->GetCount();
   for (idx=0; idx<itemCount; idx++) {
         LegoWrite((legoRegion*)modRegPtr->GetItem(idx),filPtr,0);
/*-----------------------------------------------------------------
 * Write data segment
 *-----------------------------------------------------------------*/
//         WriteData((legoProc*)modRegPtr->GetItem(idx), filPtr);

/*-----------------------------------------------------------------
 * Write edge dictionary
 *-----------------------------------------------------------------*/
         WriteEdges((legoProc*)modRegPtr->GetItem(idx), filPtr);

/*-----------------------------------------------------------------
 * Write attr dictionary
 *-----------------------------------------------------------------*/
         WriteAttrs((legoProc*)modRegPtr->GetItem(idx), filPtr);

/*-----------------------------------------------------------------
 * Write memvrs dictionary
 *-----------------------------------------------------------------*/
         WriteMem((legoProc*)modRegPtr->GetItem(idx), filPtr);

/*-----------------------------------------------------------------
 * Write jump dictionary
 *-----------------------------------------------------------------*/
         WriteJump((legoProc*)modRegPtr->GetItem(idx), filPtr);
   }

   if (usegzip) {
      if (rblOutFile != NULL) pclose (filPtr);
   }
   else {
      if (rblOutFile != NULL) fclose (filPtr);
   }
   //   fclose (comfile);
  return 1;
}

---