hammock.C

Go to the documentation of this file.

/*
 * hammock.C
 *
 * Hammock conversion function.
 *
 * 5/13/97 WAH:  Created.
 * 6/12/97 WAH:  Modified initialization of NextPredRedNum to be
 *               next free register number over ALL registers.
 * 6/16/97 WAH:  Predicate copies also copy OprdRegType (had forgotten).
 * 10/11/97 WAH: Added setting of operand parentPtr.
 * 12/8/97 WAH:  Added explicit parameter to SweepOps call.
 * 1/16/98 WAH:  Cleaned up hammock function; added RM_HAMMOCK marking;
 *               added check for has_hb or has_sb flag before detection.
 * 1/21/98 WAH:  Fixed update of E block's incoming edge during if-conversion.
 * 1/22/98 WAH:  Changed AddWeightAttribute to make lcode attribute
 *               instead of using blockId field; proc now flagged has_hb.
 * 1/27/98 WAH:  Fixed if-conversion of hammock with sb S block.
 * 4/23/98 WAH:  Updated legoOprd::parentPtr.
 */

#include <stdio.h>
#include "lego.H"
#include "legoUtil.H"
#include "hyperform.H"
#include "chains.H"
#include "bitvector.H"

//#define _HAMMOCK_DEBUG
//#define _SHOW_VECTORS
//#define dderr(_s_)  cerr << _s_
#define dderr(_s_)  

#ifdef _HAMMOCK_DEBUG
legoModule *M = NULL;
int numnum = 0;
#define dderr(_s_)  cerr << _s_
#define dprintf(s) fprintf s
#define OUTF stderr
#else
#define dprintf(s)
#endif // _HAMMOCK_DEBUG

//#define HAMMOCK_WRITE_INTERMEDIATE_REBEL

extern chains* Chains;

//===========================================================================

/*
 * isStraight
 *   r = pointer to region in question
 *   returns: 1 if r is straight, 0 otherwise
 *
 * Determines whether a region is straight, i.e., whether it has exactly
 * one parent and exactly one child.
 */
static int isStraight (legoRegion *r)
{
  regionList *l = r->GetParents();  // check if exactly one parent
  if (l == NULL || l->GetRegionPtr() == NULL || l->GetNextListPtr() != NULL)
    return 0;

  l = r->GetChildren();  // check if exactly one child
  if (l == NULL || l->GetRegionPtr() == NULL || l->GetNextListPtr() != NULL)
    return 0;

  return 1;  
} // end isStraight

/*
 * DetectHammock
 *   S = start block of hammock
 *   returns: hammock information
 *
 * Looks for a hammock starting at S (start) and stopping at J (join).
 * The hammock may be either a diamond shape (with two blocks T (then)
 * and E (else) - an if-then-else) or a triangular "delta" shape (with
 * one block T - and if-then) in between S and J.
 */
hammock_info *DetectHammock (legoRegion *S)
{
  hammock_info *h;
  legoRegion *temp;
  regionList *l;
  int foundS, foundT, foundE;
  int notdiamond;

  h = new hammock_info;
  if (!(IS_BLOCK(S->GetRegionType())))
    return h;

  // 1. S may only have exactly two children.
  l = S->GetChildren();  // l = children of S
  if (l == NULL || l->GetRegionPtr() == NULL) return h;
  h->T = l->GetRegionPtr();  // T = first child of S
  l = l->GetNextListPtr();
  if (l == NULL || l->GetRegionPtr() == NULL) return h;
  h->E = l->GetRegionPtr();  // E = second child of S
  if (l->GetNextListPtr() != NULL) return h;

  // 2. T must be straight and between different blocks; set J to its child.
  //    If T isn't straight, try switching T and E.
  notdiamond = 0;
  if (isStraight (h->T) && h->T->GetChildren()->GetRegionPtr() != S)
    {
      // T is fine.
      h->J = h->T->GetChildren()->GetRegionPtr();
    } // end if
  else
    {
      temp = h->T; h->T = h->E; h->E = temp;
      notdiamond = 1;  // If first T won't work, can't be a diamond!
      if (isStraight (h->T) && h->T->GetChildren()->GetRegionPtr() != S)
        {
          // T is now fine.
          h->J = h->T->GetChildren()->GetRegionPtr();
        } // end if
      else
        return h;  // neither one works, so give up
    } // end if

  // 3. Try to detect a delta: if J == E, and J has no parents besides
  //    S and T, it's a delta.
  if (h->J == h->E)  // may be a delta
    {
      while (1)  // this is a kludge to allow the breaks out of the testing
        {
          foundS = foundT = 0;
          l = h->J->GetParents();  // l = parents of J
          if (l == NULL)
            {  // must have at least one parent (T)
              dprintf((OUTF, "DetectHammock: inconsistency error 1.\n"));
              return h;  // not a delta
            } // end if
          temp = l->GetRegionPtr();
          if (temp == S)
            foundS = 1;
          else if (temp == h->T)
            foundT = 1;
          else break;  // found parent not S or T => not a delta
          
          l = l->GetNextListPtr();
          if (l == NULL)
            return h;  // has only one parent => not a delta OR DIAMOND
          if (l->GetNextListPtr() != NULL)
            return h;  // J has > 2 parents => not a delta OR DIAMOND

          temp = l->GetRegionPtr();
          if (temp == S)
            foundS = 1;
          else if (temp == h->T)
            foundT = 1;
          else  // found parent not S or T => not a delta
            break;

          if (!foundS || !foundT)  // should have found S and T both
            break;

          h->S = S;
          h->E = NULL;  // flag as delta
          return h;  // IT'S A DELTA!
        } // end while
    } // end if

  // 4. Now look for a diamond. We know that T goes straight from S to
  //    J. Check that E does as well. Then make sure that J's only parents
  //    are T and E. If this is all true, it's a diamond.
  if (notdiamond) return h;  // determined when finding T in step 2
  if (!(isStraight (h->E))) return h;
  l = h->E->GetParents();  // l = parents of E
  if (l == NULL || l->GetRegionPtr() != S)
    {
      dprintf ((OUTF, "DetectHammock: inconsistency error 2.\n"));
      return h;
    } // end if

  l = h->E->GetChildren();  // l = children of E
  if (l == NULL)
    {
      dprintf ((OUTF, "DetectHammock: inconsistency error 2.\n"));
      return h;
    }
  if (l->GetRegionPtr() != h->J)  // E's child is not J => not a diamond
    return h;

  foundT = foundE = 0;
  l = h->J->GetParents();  // l = parents of J
  if (l == NULL)
    {  // must have at least one parent (T)
      dprintf((OUTF, "DetectHammock: inconsistency error 1.\n"));
      return h;  // not a delta
    } // end if
  temp = l->GetRegionPtr();
  if (temp == h->T)
    foundT = 1;
  else if (temp == h->E)
    foundE = 1;
  else return h;  // found parent not S or T => not a diamond
          
  l = l->GetNextListPtr();  // from delta
  if (l == NULL)
    return h;  // has only one parent => not a diamond
  if (l->GetNextListPtr() != NULL)
    return h;  // J has > 2 parents => not a diamond

  temp = l->GetRegionPtr();
  if (temp == h->T)
    foundT = 1;
  else if (temp == h->E)
    foundE = 1;
  else  // found parent not T or E => not a diamond
    return h;

  if (!foundT || !foundE)  // should have found T and E both
    return h;

  h->S = S;
  return h;  // IT'S A DIAMOND!
} // end DetectHammock

//===========================================================================

/*
 * RevertCodePosSuperblock
 *   sb = pointer to superblock
 *   proc = pointer to proc containing sb
 *
 * Lcode requires proper code positioning, while LEGO-style Rebel
 * doesn't. Some blocks in Lcode which could be ordinary blocks end
 * up becoming superblocks to ensure code positioning. In other
 * words, a block with a single decision at the bottom (BRCT, BRCF)
 * may be turned into a superblock if neither target block can be
 * placed immediately after the decision block as a fall-through;
 * as a superblock, the single decision branch is followed by an
 * explicit branch (BRU) to the alternate target.
 *
 * This function turns such a block back into a single-branch block.
 * It will still be a sb/hb region, but in all other respects will
 * be a basic block again.
 */
void
RevertCodePosSuperblock (legoRegion *sb, legoProc *proc)
{
  int qualifies = 1;
  opList *exits;
  legoOp *exit1, *exit2, *opscan, *fallthru, *opscanprev;
  attrList *atl1, *atl2;
  attrs *a1, *a2;
  legoOprd *attroprd;
  opEdges *edge;
  opList *opl;

  // Check whether the block qualifies.
  // 1. Must be sb or hb.
  if (sb->GetRegionType() != RT_HB &&
      sb->GetRegionType() != RT_SB) qualifies = 0;

  // 2. Must have exactly two exit ops.
  if (qualifies)
    {

      exits = sb->GetExitOpsPtr();
      if (exits == NULL || exits->GetNextListPtr() == NULL ||
          exits->GetNextListPtr()->GetNextListPtr() != NULL)
        qualifies = 0;
    } // end if

  // 3. First exit must be BRCT or BRCF and second (bottom) must be BRU.
  if (qualifies)
    {
      exit1 = exits->GetOpPtr();
      exit2 = exits->GetNextListPtr()->GetOpPtr();
      if (exit1->GetNextLink() == NULL)  // conditional must be first
        {
          legoOp *swap;

          swap = exit1; exit1 = exit2; exit2 = swap;
        } // end if

      if (!(exit1->IsBRCONDOp()) || !(exit2->IsBRUOp()))
        qualifies = 0;
    } // end if

  // 4. After exit1 must come a C_MERGE, then a PBRR/PBRA, then exit2.
  if (qualifies)
    {
      opscan = exit1->GetNextLink();
      if (opscan == NULL ||
          !(opscan->IsCMERGEOp()))
        qualifies = 0;
    } // end if
  if (qualifies)
    {
      opscan = opscan->GetNextLink();
      if (opscan == NULL || !(opscan->IsPBROp() != PBRR))
        qualifies = 0;
    } // end if
  if (qualifies && opscan->GetNextLink() != exit2)
    qualifies = 0;

  if (!qualifies)
    {
      LegoNonFatal ("RevertCodePosSuperblock",
                    "Block %d doesn't qualify for reversion.",
                    sb->GetRegionId());
      return;
    } // end if

  // First, blow away the C_MERGE and PBRR/PBRA ops and their attributes.
  RemoveMidOp (exit1->GetNextLink(), 1);  // C_MERGE
  RemoveMidOp (exit1->GetNextLink(), 1);  // PBRR/PBRA

  // Now, merge exit1 and exit2 together. This will be done clumsily
  // when it comes to lc attributes: exit1 will take on all of exit2's that
  // don't conflict.
  RemoveLiveAttribute (exit2, proc);

  // Merge lc attributes.
  atl2 = exit2->GetOpAttrListPtr();
  while (atl2 != NULL)  // don't bother if no attributes to merge
    {
      // Move attributes over one by one.
      switch (atl2->GetAttrType())
        {
        case ATTR_LC:
          // Loop through the lc attributes, copying needed ones.
          a2 = atl2->GetAttrPtr();
          if (a2 != NULL)
            {
              a1 = FindLcAttribute (a2->GetAttrString(), exit1);
              if (a1 == NULL)  // if not there, move over
                AddLcAttribute (a2->GetAttrString(), a2->GetAttrOprdPtr(),
                                exit1, proc);
              a2->SetAttrOprdPtr (NULL);  // preserve operands in new one
              RemoveLcAttribute (a2->GetAttrString(), exit2, proc);
            } // end if

          atl2 = exit2->GetOpAttrListPtr();  // start from beginning again
          break;
        default:
          atl2 = atl2->GetNextListPtr();  // skip to next attrList
          break;
        } // end switch

    } // end while

  // Redirect edge from exit2 to exit1.
  fallthru = exit2->GetOutListPtr()->GetOpPtr();
  if (fallthru == NULL)
    LegoFatal ("RevertCodePosSuperblock", "Can't find op following op %d.",
               exit2->GetOpId());
  edge = FindControlEdge (exit2, fallthru);
  if (edge == NULL)
    LegoFatal ("RevertCodePosSuperblock", "Can't find edge from "
               "op %d to op %d.", exit2->GetOpId(), fallthru->GetOpId());
  edge->SetFromOpPtr (exit1);
  edge->SetFromOpId (exit1->GetOpId());

  // Add fallthru to exit1's outlist.
  opl = exit2->GetOutListPtr();
  opl->SetNextListPtr (exit1->GetOutListPtr());
  exit1->SetOutListPtr (opl);
  exit2->SetOutListPtr (NULL);  // moved off exit2

  // Change fallthru's inlist to refer to exit1.
  opl = fallthru->GetInListPtr();
  opl->SetOpPtr (exit1);
  opl->SetOpId (exit1->GetOpId());

  // Remove edge between exit1 and exit2.
  edge = FindControlEdge (exit1, exit2);
  if (edge == NULL)
    LegoFatal ("RevertCodePosSuperblock", "Can't find edge from "
               "op %d to op %d.", exit1->GetOpId(), exit2->GetOpId());
  RemoveEdge (exit1, exit2, ET_CNTL);

  // Remove exit2 now!
  exit1->SetNextLink (NULL);
  for (opscanprev = NULL, opscan = proc->GetListOpPtr();
       opscan != exit2; opscanprev = opscan, opscan = opscan->GetListOpPtr()) ;
  if (opscanprev != NULL)
    opscanprev->SetListOpPtr (opscan->GetListOpPtr());
  else
    proc->SetListOpPtr (opscan->GetListOpPtr());
  delete exit2;

  // Cleanup.
  while (sb->GetRegionType() != RT_PROC)
    {
      sb->RefreshOps();
      sb = sb->GetParentPtr();
    } // end while

  return;
} // end RevertCodePosSuperblock


/*
 * NextPredRegNum
 *
 * Indicates the next available predicate register number. Initialize
 * this to zero before running through a proc.
 */
int NextPredRegNum = 0;

/*
 * MakeDupPred
 *   orig = pointer to original predicate
 *   returns: new duplicate of predicate
 *
 * Makes a new predicate operand the same as orig while avoiding using
 * the copy constructor.
 */
static legoOprd *
MakeDupPred (legoOprd *orig)
{
  legoOprd *newp;

  // Want to avoid copy constructor (chaining along nextOperandPtr).
  newp = new legoOprd;
  newp->SetOprdType (orig->GetOprdType());
  newp->SetOprdRegType (orig->GetOprdRegType());
  newp->SetOprdRegNum (orig->GetOprdRegNum());
  newp->SetOprdDataType (orig->GetOprdDataType());
  newp->SetOprdFileType (orig->GetOprdFileType());
  newp->SetOprdOmega (orig->GetOprdOmega());
  newp->SetOprdRegStyle (orig->GetOprdRegStyle());
  newp->SetIntValue (orig->GetOprdIntValue());

  return newp;
} // end MakeDupPred

/*
 * AddWeightAttribute
 *   op = op to annotate
 *   returns: new attr attached to op
 *
 * Attaches a new attr to the op saying what the weight of its block
 * is.
 */
static attrs *
AddWeightAttribute (legoOp *op)
{
  legoRegion *block;
  legoOprd *oprd;
  attrs *wtattr;

  block = (legoRegion *) op->GetParentBlockPtr();
  if (block == NULL) return NULL;

  oprd = new legoOprd;
  oprd->SetOprdType (OT_LITERAL_D);
  oprd->SetLiteralDouble (block->GetWeight());

  // Only update orig_wt for an op one time, as HBs may be in merged into 
  // other HBs. In this case we are only interested in the orig BB weight.
  if (FindLcAttribute( "orig_wt", op ) == NULL) {
    wtattr = AddLcAttribute ("orig_wt", oprd, op,
                             (legoProc *) FindParentRegionType (RT_PROC, op));
    return wtattr;
  }
  else {
    return NULL;
  }
  
  //  attrList *atl;
  //  intList *il;


  //  op->SetBlockId ((int) weight);
  //  return NULL;

  // for (atl = op->GetOpAttrListPtr();
  //       atl != NULL && atl->GetNextListPtr() != NULL &&
  //     atl->GetAttrType() != ATTR_FREQ;
  //       atl = atl->GetNextListPtr()) /* do nothing */;
  //  if (atl == NULL)
  //    {
  //      atl = new attrList;
  //      op->SetOpAttrListPtr (atl);
  //    } // end if
  //  else if (atl->GetAttrType() != ATTR_FREQ)
  //    {
  //      atl->SetNextListPtr (new attrList);
  //      atl = atl->GetNextListPtr();
  //    } // end else
  //  atl->SetAttrType (ATTR_FREQ);
  //  atl->SetValid(1);
  //  if (atl->GetAttrValPtr() == NULL)
  //    atl->SetAttrValPtr (new intList);
  //  il = atl->GetAttrValPtr();
  //  il->SetValid(1);
  //  il->SetAttrValue ((int) weight);
  //  return atl;
}

/*
 * AddOrthoPredAttribute
 *   op = op to annotate
 *   returns: new attr attached to op
 *
 * Attaches a new attr to the op with the predicate reg number of the 
 * orthogonal operations. For if-converted if-then-else statements, 
 * orthogonal predicates will be assigned to the then and else subblocks.
 * The dag builder will use this information so that deps are not included
 * between these orthogonal operations
 * 
 */
static attrs *
AddOrthoPredAttribute (legoOp *op, int PredRegNumb)
{
  legoRegion *block;
  legoOprd *oprd;
  attrs *wtattr;

  block = (legoRegion *) op->GetParentBlockPtr();
  if (block == NULL) return NULL;

  oprd = new legoOprd;
  oprd->SetOprdType (OT_LITERAL_I);
  oprd->SetLiteralInteger (PredRegNumb);

  wtattr = AddLcAttribute ("orthogonal_pred_reg_numb", oprd, op,
                           (legoProc *) FindParentRegionType (RT_PROC, op));
  return wtattr;

}

/*
 * AddZerosRight
 *   vector = bitvector to manipulate
 *   num_valid_bits = number of currently valid bits in bit vector, we can 
 *                    assume they are right justified (in low-order bits)
 *   num_shift_bits = number of zeros to add to the right of currently valid 
 *                    bits
 *
 * Assumes previous checking eliminates overflow possibility
 * 
 */
void
AddZerosRight (bitvector *vector, int num_valid_bits, int num_shift_bits)
{
  
  dderr ("\nAdding " << num_shift_bits << " zeros to the right of a vector with " << num_valid_bits << " valid bits\n");
#ifdef _SHOW_VECTORS
  vector->Show();
#endif // _SHOW_VECTORS
  if (num_shift_bits > 0) {
    for (int i = 0; i < num_valid_bits; i++) {
      if (vector->Read((num_valid_bits - 1) - i)) {
        vector->Set(((num_valid_bits - 1) - i) + num_shift_bits);
        vector->Reset((num_valid_bits - 1) - i);
      }
    }
  }
#ifdef _SHOW_VECTORS
  vector->Show();
#endif // _SHOW_VECTORS
}

/*
 * ReplicateBits
 *   vector = bitvector to manipulate
 *   num_valid_bits = number of currently valid bits in bit vector, we can 
 *                    assume they are right justified (in low-order bits)
 *   num_copies = Final vector should contain this many copies of the original 
 *
 * Assumes previous checking eliminates overflow possibility
 * 
 */
void
ReplicateBits (bitvector *vector, int num_valid_bits, int num_copies)
{

  dderr ("\nReplicating for " << num_copies << " copies of original vector with " << num_valid_bits << " valid bits\n");
#ifdef _SHOW_VECTORS
  vector->Show();
#endif // _SHOW_VECTORS
  for (int i = 1; i < num_copies; i++) {
    for (int j = 0; j < num_valid_bits; j++) {
      if (vector->Read((num_valid_bits - 1) - j)) {
        vector->Set(((num_valid_bits - 1) - j) + (i * num_valid_bits));
      }
    }
  }
#ifdef _SHOW_VECTORS
  vector->Show();
#endif // _SHOW_VECTORS
}

/*
 * ReplicateBitsMask
 *   vector = bitvector to manipulate
 *   num_valid_bits = number of currently valid bits in bit vector, we can 
 *                    assume they are right justified (in low-order bits)
 *   num_copies = Final vector should contain this many copies of the original 
 *
 * Assumes previous checking eliminates overflow possibility
 * 
 */
bitvector *
ReplicateBitsMask (bitvector *vector, bitvector *mask,
                    int num_valid_bits, int pattern_size, int PredVectorSize)
{

  dderr ("\nReplicating with Mask for a copy of input vector at each valid bit in mask. Mask with " << num_valid_bits << " valid bits\n");
#ifdef _SHOW_VECTORS
  cerr << "Mask Vector :\n";
  mask->Show();
  cerr << "Input Vector :\n";
  vector->Show();
#endif // _SHOW_VECTORS
  
  bitvector *new_vector = new bitvector(PredVectorSize);
  
  int new_i = 0;
  for (int i = 0; i < num_valid_bits; i++) {
    if (mask->Read(i)) {
      for (int j = 0; j < pattern_size; j++) {
        if (vector->Read(j)) {
          new_vector->Set(new_i);
        }
        new_i++; 
      }
    }  
    else {
      new_i++;
    }
  }
  
  delete vector; 

#ifdef _SHOW_VECTORS
  new_vector->Show();
#endif // _SHOW_VECTORS

  return new_vector; 
}

/*
 * MultiplyBits
 *   vector = bitvector to manipulate
 *   num_valid_bits = number of currently valid bits in bit vector, we can 
 *                    assume they are right justified (in low-order bits)
 *   num_mults = Final vector should contain this many copies of the original 
 *
 * Assumes previous checking eliminates overflow possibility
 * 
 */
void
MultiplyBits (bitvector *vector, int num_valid_bits, int num_mults)
{

  dderr ("\nMultiplying for " << num_mults << " mults of each bit in the original vector with originally " << num_valid_bits << " valid bits\n");
#ifdef _SHOW_VECTORS
  vector->Show();
#endif // _SHOW_VECTORS
  for (int i = num_valid_bits; i >= 1; i--) {
    if (vector->Read(i - 1)) {
      for (int j = num_mults; j >= 1; j--) {
        vector->Set(((i * num_mults) - j));
      }
      // Leave the very last bit alone
      if (i != 1) {
        vector->Reset(i - 1);
      }
    }  
  }
#ifdef _SHOW_VECTORS
  vector->Show();
#endif // _SHOW_VECTORS
}

/*
 * MultiplyBitsMask
 *   vector = bitvector to manipulate
 *   num_valid_bits = number of currently valid bits in bit vector, we can 
 *                    assume they are right justified (in low-order bits)
 *   num_mults = Final vector should contain this many copies of the original 
 *
 * Assumes previous checking eliminates overflow possibility
 * 
 */
bitvector *
MultiplyBitsMask (bitvector *vector, bitvector *mask, 
                   int num_valid_bits, int num_mults, int PredVectorSize)
{
  
  dderr ("\nMultiplying with Mask for " << num_mults << " mults of each bit if valid in mask. Vector with originally " << num_valid_bits << " valid bits\n");
#ifdef _SHOW_VECTORS
  cerr << "Mask Vector :\n";
  mask->Show();
  cerr << "Input Vector :\n";
  vector->Show();
#endif // _SHOW_VECTORS
  
  bitvector *new_vector = new bitvector(PredVectorSize);
  
  int new_i = 0;
  for (int i = 0; i < num_valid_bits; i++) {
    if (mask->Read(i)) {
      if (vector->Read(i)) {      
        for (int j = 0; j < num_mults; j++) {
          new_vector->Set(new_i);
          new_i++;
        }
      }
      else {
        new_i = new_i + num_mults; 
      }
    }
    else {
      if (vector->Read(i)) {      
        new_vector->Set(new_i);
      }      
      new_i++;
    }
  }

  delete vector; 
  
#ifdef _SHOW_VECTORS
  new_vector->Show();
#endif // _SHOW_VECTORS

  return new_vector; 
}

/*
 * IfConvertHammock
 *   h = pointer to hammock information
 *   returns: pointer to if-converted code (hyperblock), NULL if error
 *
 * Performs if-conversion (predication) on a hammock control structure.
 * Predicates ops in the T and E blocks appropriately, then creates a
 * hyperblock to hold the ops of S, T, E, and J, in order. This new
 * hyperblock is returned.
 *
 * This is actually rather complicated...>:P
 */
legoRegion *IfConvertHammock (hammock_info *h, knobs *K)
{
  legoRegion *hyp;
  legoProc *proc;
  legoOprd *p1, *p2, *curp, *pT = NULL, *pE = NULL, *oprd;

  opList *opl;
  legoOp *lastop, *pbrrop, *op;
  int fromopid, toopid;

  int makingnewHB, isBRCT, PBRRblock;

  bitvector *new_SorJ_vector, *new_T_vector, *new_E_vector; 
  int S_size, T_size, E_size; 
  int PredVectorSize, required_vector_size; 
  attrs *a; 
  attrList *atl;
  enum attrTypes atype;

  dprintf((OUTF, "IfConvertHammock: --- converting starting at %d ---\n",
           h->S->GetRegionId()));
  if (!(h->HammockDetected()))
    return NULL;
  if (h->T == NULL || h->J == NULL)
    return NULL;

  for (hyp = h->S; hyp->GetRegionType() != RT_PROC;
       hyp = hyp->GetParentPtr())  // just using hyp as generic pointer
    if (hyp == NULL)
      {
        dprintf((OUTF,"IfConvertHammock: can't find proc!\n"));
        return NULL;
      } // end if (for)
  proc = (legoProc *) hyp;

  if (h->S->GetRegionType() != RT_HB)
    {
      hyp = new legoHB (h->S->GetRegionId());  // make new hyperblock
      hyp->SetWeight (h->S->GetWeight());
      oprd = new legoOprd;
      oprd->SetOprdType (OT_LITERAL_I);
      oprd->SetLiteralInteger(0);
      AddLcAttribute ("use_orig_wt", oprd, hyp, proc); 
      makingnewHB = 1;
    } // end if
  else
    {
      hyp = h->S;  // use existing hyperblock
      makingnewHB = 0;
    } // end else

  // Read in knobs.
  K->SetDefaultPanel ("rform/tree");
  K->Read ("num-bits-pred-vector", PredVectorSize);

  // Determine if PredVector length requirements can be satisfied
  // by PredVectorSize
  if ( (a = FindLcAttribute( "pred_vector_size", h->S )) != NULL ) 
    S_size = a->GetAttrOprdPtr()->GetLiteralInteger();
  else 
    S_size = 1; 
  if ( (a = FindLcAttribute( "pred_vector_size", h->T )) != NULL ) 
    T_size = a->GetAttrOprdPtr()->GetLiteralInteger();
  else 
    T_size = 1; 
  if (!(h->IsDelta())) 
    if ( (a = FindLcAttribute( "pred_vector_size", h->E )) != NULL ) 
      E_size = a->GetAttrOprdPtr()->GetLiteralInteger();
    else 
      E_size = 1; 
  else 
    E_size = 1; 
  required_vector_size = ((T_size + E_size) * S_size);
  if (required_vector_size > PredVectorSize) {
    LegoNonFatal ("IfConvertHammock", "Need more PredVectorSize to continue if-conversion !!!\n.");
    return NULL;
  }
  // Update hyp's pred_vector_size attr
  oprd = new legoOprd;
  oprd->SetOprdType (OT_LITERAL_I);
  oprd->SetLiteralInteger(required_vector_size);
  AddLcAttribute ("pred_vector_size", oprd, hyp, proc); 
  // Create Prototype for Join PredVector
  new_SorJ_vector = new bitvector(PredVectorSize);   
  new_T_vector = new bitvector(PredVectorSize);   
  new_E_vector = new bitvector(PredVectorSize);   
  for (int i = 0; i < required_vector_size; i++) {
    new_SorJ_vector->Set(i);
  }
  // The following vectors are only used for BB used for the first time in 
  // a HB (they will only replace a NULL PredVector)
  new_T_vector->Set(0);
  new_E_vector->Set(T_size);
  if (S_size > 1) {
//    MultiplyBits(new_T_vector, (T_size + E_size), S_size);
//    MultiplyBits(new_E_vector, (T_size + E_size), S_size);
    ReplicateBits(new_T_vector, (T_size + E_size), S_size);
    ReplicateBits(new_E_vector, (T_size + E_size), S_size);
  }
  dderr ("S_size = " << S_size << "\n");
  dderr ("T_size = " << T_size << "\n");
  dderr ("E_size = " << E_size << "\n");
  dderr ("required_vector_size = " << required_vector_size << "\n");
#ifdef _SHOW_VECTORS
  new_SorJ_vector->Show();
  new_T_vector->Show();
  new_E_vector->Show();
#endif // _SHOW_VECTORS
  
  while (1)
    {
      for (opl = h->S->GetExitOpsPtr();  // find last op in block
           opl != NULL && opl->GetOpPtr()->GetNextLink() != NULL;
           opl = opl->GetNextListPtr()) /* do nothing */;
      if (opl == NULL)
        {
          LegoNonFatal ("IfConvertHammock", "Can't find last op in S "
                        "block %d.", h->S->GetRegionId());
          return NULL;
        }
      lastop = opl->GetOpPtr();

      // If lastop is a BRU, it's probably a pseudo-superblock, which
      // should be cleaned up now.
      if (!(lastop->IsBRUOp())) break;  // normal

      RevertCodePosSuperblock (hyp, proc);  // then get the last op again...
    } // end while

  if (lastop->GetSrcOprdPtr() == NULL ||
      lastop->GetSrcOprdPtr()->GetNextOprdPtr() == NULL)
    {
      LegoNonFatal ("IfConvertHammock", "Can't find predicate source of "
                    "branch %d.", lastop->GetOpId());  // will need it later
      return NULL;
    } // end if

  // STEP 1: Analysis and setup.

  // 1a. Determine whether branch is BRCT or BRCF.
  //if (lastop->IsBRCTOp())
    if(lastop->GetOpcode() == BRCT)
  {
      LegoNonFatal("IfConvertHammock", "BRCF is not supported yet.");
    isBRCT = 1;
  }
  else
  {
      LegoNonFatal("IfConvertHammock", "BRCF is not supported yet.");
    isBRCT = 0;
  }

  // 1b. Find the target of the branch.
  for (pbrrop = lastop;
       pbrrop != NULL && !(pbrrop->IsPBROp());
       pbrrop = pbrrop->GetPrevLink()) /* do nothing */;
  if (pbrrop == NULL)
    {
      LegoNonFatal ("IfConvertHammock", "Can't find PBRR/PBRA in block %d.",
                    h->S->GetRegionId());
      return NULL;
    } // end if
  oprd = pbrrop->GetSrcOprdPtr();
  if (oprd->GetOprdType() != OT_LITERAL_CB)
    {
      LegoNonFatal ("IfConvertHammock", "PBRR %d not to control block.",
                    pbrrop->GetOpId());
      return NULL;
    } // end if
  PBRRblock = oprd->GetLiteralControlBlock();
  if (PBRRblock != h->T->GetRegionId() &&
      PBRRblock != h->J->GetRegionId() &&
      !(!(h->IsDelta()) && PBRRblock == h->E->GetRegionId()))
    {
      LegoNonFatal ("IfConvertHammock", "Can't find block %d in hammock.",
                    PBRRblock);
      return NULL;
    } // end if

  // 1c. Find the predicate operands that are the destination of the last
  //     CMPP in S. Put the first in p1, the second in p2. If the second
  //     isn't there, take care of it.
  for (op = lastop;  // scan back to last CMPP
       op != NULL && op->IsCMPPOp();
       op = op->GetPrevLink()) /* do nothing */;

  if (op == NULL)
    {
      LegoNonFatal ("IfConvertHammock", "Can't find CMPP for branch %d.",
                    lastop->GetOpId());
      return NULL;
    } // end if

  // mdj - 4/1/99 (No April Fool's joke, this change is really needed)
  // Not guaranteed to work everytime but should for the Rebel files 
  // that I have inspected. Seems that the second dest D-action of a CMPP is 
  // 'always' the same as the first for our source from IMPACT/ELCOR. We need 
  // the second dest to be the complement of the first (increment opcode)
  // make sure that the second D-action is a complement (odd-number opcode)
  //op->SetOpcode((op->GetOpcode() + 1));
  div_t remainder = div(op->GetOpcode(), 2);
  if (remainder.rem == 0) {
    op->SetOpcode((op->GetOpcode() + 1));
  }
    
  p1 = op->GetDestOprdPtr();  // first destination!
  if (p1 == NULL || p1->GetNextOprdPtr() == NULL)
    {
      LegoNonFatal ("IfConvertHammock", "CMPP %d has bad destinations.",
                    op->GetOpId());
      return NULL;
    } // end if
  p2 = p1->GetNextOprdPtr();  // p2 is there always!
  if (p1->GetNextOprdPtr()->GetOprdType() != OT_UNDEFINED)
    /* do nothing - we have two predicates! */;
  // Nuts, there's no second destination. Before making one, it isn't
  // really required if this is a delta.
  else if (h->IsDelta())
    {
      // OK, there are four cases to consider:
      //       | branch to T      | branch to J
      //       |                  |
      //  BRCT | pT = p1          | make p2; pT = p2
      //  -----|------------------|-----------------
      //  BRCF | make p2; pT = p2 | pT = p1
      //
      // Well, I'll be damned, I find myself wishing for a logical
      // XNOR operator...
      if ((PBRRblock == h->T->GetRegionId() && isBRCT) ||
          (PBRRblock != h->T->GetRegionId() && !isBRCT))
        pT = p1;
      else
        {
          // Don't bother fixing PBRR or BRCT, since they're going
          // away anyway. We do need to add p2, since T must be
          // predicated on the complement of the CMPP.
          p2->SetOprdType (p1->GetOprdType());
          p2->SetOprdRegType (p1->GetOprdRegType());
          p2->SetOprdRegNum (p1->GetOprdRegNum());
          p2->SetOprdDataType (p1->GetOprdDataType());
          p2->SetOprdFileType (p1->GetOprdFileType());
          p2->SetOprdOmega (p1->GetOprdOmega());
          p2->SetOprdRegStyle (p1->GetOprdRegStyle());
          p2->SetIntValue (p1->GetOprdIntValue());
          p1->SetOprdRegNum (0);  // throw away other result
          pT = p2;
        } // end else
    } // end else if
  else
    {
      // We need a second destination (for the diamond). Scan through
      // every op in the proc to find the next predicate register that's
      // free.
      if (NextPredRegNum == 0)  // find it
        {
          legoOp *o;
          legoOprd *d;
          for (o = proc->GetListOpPtr(); o != NULL; o = o->GetListOpPtr())
            {
              for (d = o->GetSrcOprdPtr(); d != NULL; d = d->GetNextOprdPtr())
                if (d->GetOprdType() == OT_REG &&
                    //              (d->GetOprdDataType() == DT_P ||
                    //               d->GetOprdFileType() == FT_PR) &&
                    d->GetOprdRegNum() > NextPredRegNum)
                  NextPredRegNum = d->GetOprdRegNum();

              for (d = o->GetDestOprdPtr(); d != NULL; d = d->GetNextOprdPtr())
                if (d->GetOprdType() == OT_REG &&
                    //              (d->GetOprdDataType() == DT_P ||
                    //               d->GetOprdFileType() == FT_PR) &&
                    d->GetOprdRegNum() > NextPredRegNum)
                  NextPredRegNum = d->GetOprdRegNum();

              for (d = o->GetPredOprdPtr(); d != NULL; d = d->GetNextOprdPtr())
                if (d->GetOprdType() == OT_REG &&
                    //              (d->GetOprdDataType() == DT_P ||
                    //               d->GetOprdFileType() == FT_PR) &&
                    d->GetOprdRegNum() > NextPredRegNum)
                  NextPredRegNum = d->GetOprdRegNum();
            } // end for

          NextPredRegNum++;  // next available one
          dprintf((OUTF, "IfConvertHammock: NextPredRegNum = %d\n",
                   NextPredRegNum));
        } // end if

      // Make the new operand and plop it into the CMPP.
      p2->SetOprdType (p1->GetOprdType());
      p2->SetOprdRegNum (NextPredRegNum++);
      p2->SetOprdRegType (p1->GetOprdRegType());
      p2->SetOprdDataType (p1->GetOprdDataType());
      p2->SetOprdFileType (p1->GetOprdFileType());
      p2->SetOprdOmega (p1->GetOprdOmega());
      p2->SetOprdRegStyle (p1->GetOprdRegStyle());
      p2->SetIntValue (p1->GetOprdIntValue());
    } // end else

  // 1d. Figure out pT and pE, the predicates for T and E, if it's a diamond.
  //          | branch to T       | branch to E
  //          |                   |
  //  BRCT pX | pT = pX, pE = !pX | pT = !pX, pE = pX
  //          |                   |
  //  BRCF pX | pT = !pX, pE = pX | pT = pX, pE = !pX
  if (!(h->IsDelta()))
    {
      legoOprd *pX;

      pX = lastop->GetSrcOprdPtr()->GetNextOprdPtr();
      if (pX->GetOprdRegNum() == p1->GetOprdRegNum())
        pX = p1;  // point pX to p1
      else
        pX = p2;  // point pX to p2

      if ((PBRRblock == h->T->GetRegionId() && isBRCT) ||
          (PBRRblock == h->E->GetRegionId() && !isBRCT))
        {
          pT = pX;
          pE = (pT == p1 ? p2 : p1);
        } // end if
      else
        {
          pE = pX;
          pT = (pE == p1 ? p2 : p1);
        } // end else
    } // end if

  // STEP 2: If-Conversion

  legoOprd *Tpredicate;
  legoOprd *Epredicate;
  legoOp *prevop;

  regionList *rl;
  legoRegion *region;
  unsigned i, count;

  // 2a. Make new prototype predicate legoOprds based on pT (and pE,
  //     if needed.
  Tpredicate = MakeDupPred (pT);
  if (pE != NULL)
    Epredicate = MakeDupPred (pE);
  else
    Epredicate = NULL;

  // 2b. Invalidate children lists of parents of S, and parents lists
  //     of children of J. Also, if S is the hyperblock, remove its
  //     parents and children.
  for (rl = h->S->GetParents(); rl != NULL; rl = rl->GetNextListPtr())
    {
      region = rl->GetRegionPtr();
      if (region != NULL)
        {
          delete (region->GetChildren());
          region->SetChildren (NULL);
        } // end if
    } // end for
  for (rl = h->J->GetChildren(); rl != NULL; rl = rl->GetNextListPtr())
    {
      region = rl->GetRegionPtr();
      if (region != NULL)
        {
          delete (region->GetParents());
          region->SetParents (NULL);
        } // end if
    } // end for
  if (!makingnewHB)
    {
      delete (h->S->GetParents());
      h->S->SetParents (NULL);
      delete (h->S->GetChildren());
      h->S->SetChildren (NULL);
    } // end if
  
  // 2c. Move ops from S to hyp. Remove the PBRR op. At the end,
  //     destroy the edge not leading to T.
  count = h->S->GetCount();
  for (i = 0; i < count; i++)
    {
      if (makingnewHB)
        op = (legoOp *) h->S->GetItem(0);
      else
        op = (legoOp *) h->S->GetItem(i);
      AddWeightAttribute (op);
      // Set PredVector and orig_hammock_hb_id attribute
      if (op->GetPredVectorPtr() == NULL) { 
        op->SetPredVectorPtr(new bitvector(*new_SorJ_vector));
      }
      else {
        MultiplyBits(op->GetPredVectorPtr(), S_size, (T_size + E_size));
      }
      dderr ("OpId = " << op->GetOpId() << " (a S op)\n");
//      oprd = new legoOprd;
//      oprd->SetOprdType (OT_LITERAL_I);
//      oprd->SetLiteralInteger(hyp->GetRegionId());
//      cerr << "OpId = " << op->GetOpId() << ", orig_hammock_hb_id = " << hyp->GetRegionId() << " (a S op)\n";
//      AddLcAttribute ("orig_hammock_hb_id", oprd, op, proc);
      if ((op->IsPBROp()) &&
          op->GetSrcOprdPtr()->GetOprdType() == OT_LITERAL_CB)
        {
          dprintf((OUTF,"IfConvertHammock: removing PBRR %d from S.\n",
                   op->GetOpId()));
          if (makingnewHB)
            h->S->Detach (0);
          else
            {
              h->S->Detach (i--);  // backtrack i by one
              count--;  // count is one less now too
            } // end else
          RemoveMidOp (op);
        } // end if
      else if (makingnewHB)
        {
          dprintf((OUTF,"IfConvertHammock: moving op %d from S.\n",
                   op->GetOpId()));
          h->S->Detach (0);
          hyp->AddItem(op);
          op->SetParentBlockPtr (hyp);
        } // end if
    } // end for
  prevop = op;

  fromopid = op->GetOpId();
  if (h->IsDelta())
    toopid = h->J->GetEntryOpsPtr()->GetOpPtr()->GetOpId();  // S->J
  else
    toopid = h->E->GetEntryOpsPtr()->GetOpPtr()->GetOpId();  // S->E
  RemoveEdge (fromopid, toopid, proc, ET_CNTL);

  // 2d. Move ops from T to hyp, predicating them on Tpredicate.
  //     Remove the PBRR op.
  count = h->T->GetCount();
  for (i = 0; i < count; i++)
    {
      op = (legoOp *) h->T->GetItem(0);
      AddWeightAttribute (op);
//      if (Epredicate != NULL)
//      AddOrthoPredAttribute (op, Epredicate->GetOprdRegNum() );
      h->T->Detach (0);
      if (!(op->IsPBROp()) ||
          op->GetSrcOprdPtr()->GetOprdType() != OT_LITERAL_CB)
        {
          dprintf((OUTF,"IfConvertHammock: moving op %d from T.\n",
                   op->GetOpId()));
          hyp->AddItem(op);
          op->SetParentBlockPtr (hyp);
          // Set PredVector and orig_hammock_hb_id attribute
          if (op->GetPredVectorPtr() == NULL) { 
            op->SetPredVectorPtr(new bitvector(*new_T_vector));
          }
          else {
            // Don't need to add zeros left, already zeros
//          MultiplyBits(op->GetPredVectorPtr(), (T_size + E_size), S_size);
            ReplicateBits(op->GetPredVectorPtr(), (T_size + E_size), S_size);
          }
          dderr ("OpId = " << op->GetOpId() << " (a T op)\n");
//        oprd = new legoOprd;
//        oprd->SetOprdType (OT_LITERAL_I);
//        oprd->SetLiteralInteger(hyp->GetRegionId());
//        cerr << "OpId = " << op->GetOpId() << ", orig_hammock_hb_id = " << hyp->GetRegionId() << " (a T op)\n";
//        AddLcAttribute ("orig_hammock_hb_id", oprd, op, proc);
        } // end if
      else
        {
          dprintf((OUTF,"IfConvertHammock: removing PBRR %d from T.\n",
                   op->GetOpId()));
          RemoveMidOp (op);
        } // end else
      if (i == 0)
        {
          prevop->SetNextLink (op);
          op->SetPrevLink (prevop);
        } // end if

      oprd = op->GetPredOprdPtr();
      // mdj - 4/2/99
      // Only want to update TRUE predicates here. If the predicate is now 
      // non-TRUE, it was updated by a prior hammock conversion. Leaving 
      // these predicates alone while updating (predicating) the CMPP ops 
      // that create these predicates produces the correct predicate values
      int dont_change_pred = 0;
      if (oprd != NULL) {
        if (oprd->GetOprdType() != OT_LITERAL_P ||
            oprd->GetLiteralPredicate() != TRUE ) {
          dont_change_pred = 1;
        }
        else {
          delete oprd;
        }
      }
      if (!dont_change_pred) {
        oprd = new legoOprd (*Tpredicate);
        op->SetPredOprdPtr (oprd);
        oprd->SetParentOpPtr (op);
      }
    } // end for
  prevop = op;
  
  // 2e. If E needs to be done, move ops from E to hyp,
  //     predicating them on EPredicate. Remove the PBRR op. Get the edge
  //     coming out of T to point to E instead (i.e., get edge from last
  //     op in T to be to first op in E instead).
  if (Epredicate != NULL)
    {
      count = h->E->GetCount();
      for (i = 0; i < count; i++)
        {
          op = (legoOp *) h->E->GetItem(0);
          AddWeightAttribute (op);
//        AddOrthoPredAttribute (op, Tpredicate->GetOprdRegNum() );
          if (i == 0)
            {
              // Move that edge. It's still referenced by T.
              opEdges *fixedge = h->T->GetOutEdgesPtr()->GetEdgePtr();
              if (fixedge->GetFromOpPtr() != prevop)
                LegoFatal ("IfConvertHammock", "Out edge of block %d "
                           "does not originate from op %d.",
                           h->T->GetRegionId(), prevop->GetOpId());
              fixedge->SetToOpPtr (op);
              fixedge->SetToOpId (op->GetOpId());
              //              h->E->GetInEdgesPtr()->GetEdgePtr()->SetFromOpPtr (prevop);
              //              h->E->GetInEdgesPtr()->GetEdgePtr()->SetFromOpId
              //                (prevop->GetOpId());
            } // end if
          h->E->Detach (0);
          if (!(op->IsPBROp()) ||
              op->GetSrcOprdPtr()->GetOprdType() != OT_LITERAL_CB)
            {
              dprintf((OUTF,"IfConvertHammock: moving op %d from E.\n",
                       op->GetOpId()));
              hyp->AddItem(op);
              op->SetParentBlockPtr (hyp);
              // Set PredVector and orig_hammock_hb_id attribute
              if (op->GetPredVectorPtr() == NULL) { 
                op->SetPredVectorPtr(new bitvector(*new_E_vector));
              }
              else {
                AddZerosRight(op->GetPredVectorPtr(), E_size, T_size); 
//              MultiplyBits(op->GetPredVectorPtr(), (T_size + E_size), S_size);
                ReplicateBits(op->GetPredVectorPtr(), (T_size + E_size), S_size);
              }
              dderr ("OpId = " << op->GetOpId() << " (a E op)\n");
//            oprd = new legoOprd;
//            oprd->SetOprdType (OT_LITERAL_I);
//            oprd->SetLiteralInteger(hyp->GetRegionId());
//            cerr << "OpId = " << op->GetOpId() << ", orig_hammock_hb_id = " << hyp->GetRegionId() << " (a E op)\n";
//            AddLcAttribute ("orig_hammock_hb_id", oprd, op, proc);
            } // end if
          else
            {
              dprintf((OUTF,"IfConvertHammock: removing PBRR %d from E.\n",
                       op->GetOpId()));
              RemoveMidOp (op);
            } // end else
          if (i == 0)
            {
              prevop->SetNextLink (op);
              op->SetPrevLink (prevop);
            } // end if

          oprd = op->GetPredOprdPtr();
          // mdj - 4/2/99
          // Only want to update TRUE predicates here. If the predicate is now 
          // non-TRUE, it was updated by a prior hammock conversion. Leaving 
          // these predicates alone while updating (predicating) the CMPP ops 
          // that create these predicates produces the correct predicate values
          int dont_change_pred = 0;
          if (oprd != NULL) {
            if (oprd->GetOprdType() != OT_LITERAL_P ||
                oprd->GetLiteralPredicate() != TRUE ) {
              dont_change_pred = 1;
            }
            else {
              delete oprd;
            }
          }
          if (!dont_change_pred) {
            oprd = new legoOprd (*Epredicate);
            op->SetPredOprdPtr (oprd);
            oprd->SetParentOpPtr (op);
          }
        } // end for
      prevop = op;
    } // end if

  // 2f. Move ops from J to hyp.
  count = h->J->GetCount();
  for (i = 0; i < count; i++)
    {
      op = (legoOp *) h->J->GetItem(0);
      AddWeightAttribute (op);
      h->J->Detach (0);
      dprintf((OUTF,"IfConvertHammock: moving op %d from J.\n",
               op->GetOpId()));
      hyp->AddItem(op);
      op->SetParentBlockPtr (hyp);
      // Set PredVector and orig_hammock_hb_id attribute
      if (op->GetPredVectorPtr() == NULL) { 
        op->SetPredVectorPtr(new bitvector(*new_SorJ_vector));
      }
      else {
        MultiplyBits(op->GetPredVectorPtr(), S_size, (T_size + E_size));
      }
      dderr ("OpId = " << op->GetOpId() << " (a J op)\n");
//      oprd = new legoOprd;
//      oprd->SetOprdType (OT_LITERAL_I);
//      oprd->SetLiteralInteger(hyp->GetRegionId());
//      cerr << "OpId = " << op->GetOpId() << ", orig_hammock_hb_id = " << hyp->GetRegionId() << " (a J op)\n";
//      AddLcAttribute ("orig_hammock_hb_id", oprd, op, proc);
      if (i == 0)
        {
          prevop->SetNextLink (op);
          op->SetPrevLink (prevop);
        } // end if
    } // end for

  // 2g. Remove S, T, E, and J, and insert hyp.
  region = h->S->GetParentPtr();
  if (region == NULL)
    {
      dprintf((OUTF,"IfConvertHammock: can't find parent of S.\n"));
      return NULL;
    } // end if (for)
  if (makingnewHB)
    {
      i = region->Search (h->S);
      // Get rid of attributes before destroying h->S
      RemoveLiveAttribute (h->S, proc); 
      atl = h->S->GetRegionAttrListPtr();
      while (atl != NULL)
        {
          atype = atl->GetAttrType();
          if (atype != ATTR_LC)
            {
              atl = atl->GetNextListPtr(); continue;  // skip to first lc
            } // end if
          
          // Remove the first attribute here.
          a = atl->GetAttrPtr();
          RemoveLcAttribute (a->GetAttrString(), h->S, proc);
          
          atl = h->S->GetRegionAttrListPtr();  // reset for next scan
        } // end while
      if (i == MAX_UNSIGNED)
        {
          LegoNonFatal ("IfConvertHammock", "Can't find S block %d in its "
                        "parent region %d.", h->S->GetRegionId(),
                        region->GetRegionId());
          return NULL;
        } // end if
      if (h->S == ((legoTreegion *)region)->GetRoot())
        ((legoTreegion *)region)->SetRoot(hyp);
      // Destroying h->S, h->T, h->E, h->J blocks seems to fuck 
      // up things such as ParentBlockPtrs of Ops. So I will 
      // just leave them as orphaned blocks now and mark them. 
      // Will skip them in later in treeform()
//      h->S->Mark (RM_GENERAL);
      region->DestroyItem (i);
//      region->Insert (hyp, i);
      region->AddItem (hyp);
      hyp->SetParentPtr (region);
//      if (!(region->IsOwner())) delete h->S;
    } // end if

  region = h->T->GetParentPtr();
  if (region == NULL)
    {
      LegoNonFatal ("IfConvertHammock", "Can't find parent of T block %d.",
                    h->T->GetRegionId());
      return NULL;
    } // end if (for)
  i = region->Search (h->T);
  // Get rid of attributes before destroying h->T
  RemoveLiveAttribute (h->T, proc); 
  atl = h->T->GetRegionAttrListPtr();
  while (atl != NULL)
    {
      atype = atl->GetAttrType();
      if (atype != ATTR_LC)
        {
          atl = atl->GetNextListPtr(); continue;  // skip to first lc
        } // end if
      
      // Remove the first attribute here.
      a = atl->GetAttrPtr();
      RemoveLcAttribute (a->GetAttrString(), h->T, proc);
      
      atl = h->T->GetRegionAttrListPtr();  // reset for next scan
    } // end while
  if (i == MAX_UNSIGNED)
    {
      LegoNonFatal ("IfConvertHammock", "Can't find T block %d in its "
                    "parent region %d.", h->T->GetRegionId(),
                    region->GetRegionId());
      return NULL;
    } // end if
  // Destroying h->S, h->T, h->E, h->J blocks seems to fuck 
  // up things such as ParentBlockPtrs of Ops. So I will 
  // just leave them as orphaned blocks now and mark them. 
  // Will skip them in later in treeform()
//  h->T->Mark (RM_GENERAL);
  region->DestroyItem (i);
//  if (!(region->IsOwner())) delete h->T;

  if (!(h->IsDelta()))
    {
      region = h->E->GetParentPtr();
      if (region == NULL)
        {
          LegoNonFatal ("IfConvertHammock", "Can't find parent of E block "
                        "%d.", h->E->GetRegionId());
          return NULL;
        } // end if (for)
      i = region->Search (h->E);
      // Get rid of attributes before destroying h->E
      RemoveLiveAttribute (h->E, proc); 
      atl = h->E->GetRegionAttrListPtr();
      while (atl != NULL)
        {
          atype = atl->GetAttrType();
          if (atype != ATTR_LC)
            {
              atl = atl->GetNextListPtr(); continue;  // skip to first lc
            } // end if
          
          // Remove the first attribute here.
          a = atl->GetAttrPtr();
          RemoveLcAttribute (a->GetAttrString(), h->E, proc);
          
          atl = h->E->GetRegionAttrListPtr();  // reset for next scan
        } // end while
      if (i == MAX_UNSIGNED)
        {
          LegoNonFatal ("IfConvertHammock", "Can't find E block %d in its "
                        "parent region %d.", h->E->GetRegionId(),
                        region->GetRegionId());
          return NULL;
        } // end if
      // Destroying h->S, h->T, h->E, h->J blocks seems to fuck 
      // up things such as ParentBlockPtrs of Ops. So I will 
      // just leave them as orphaned blocks now and mark them. 
      // Will skip them in later in treeform()
//      h->E->Mark (RM_GENERAL);
      region->DestroyItem (i);
//      if (!(region->IsOwner())) delete h->E;
    } // end if

  region = h->J->GetParentPtr();
  if (region == NULL)
    {
      LegoNonFatal ("IfConvertHammock", "Can't find parent of J block %d.",
                    h->J->GetRegionId());
      return NULL;
    } // end if (for)
  i = region->Search (h->J);
  // Get rid of attributes before destroying h->J
  RemoveLiveAttribute (h->J, proc); 
  atl = h->J->GetRegionAttrListPtr();
  while (atl != NULL)
    {
      atype = atl->GetAttrType();
      if (atype != ATTR_LC)
        {
          atl = atl->GetNextListPtr(); continue;  // skip to first lc
        } // end if
      
      // Remove the first attribute here.
      a = atl->GetAttrPtr();
      RemoveLcAttribute (a->GetAttrString(), h->J, proc);
      
      atl = h->J->GetRegionAttrListPtr();  // reset for next scan
    } // end while
  if (i == MAX_UNSIGNED)
    {
      LegoNonFatal ("IfConvertHammock", "Can't find J block %d in its "
                    "parent region %d.", h->J->GetRegionId(),
                    region->GetRegionId());
      return NULL;
    } // end if
  // Destroying h->S, h->T, h->E, h->J blocks seems to fuck 
  // up things such as ParentBlockPtrs of Ops. So I will 
  // just leave them as orphaned blocks now and mark them. 
  // Will skip them in later in treeform()
//  h->J->Mark (RM_GENERAL);
  region->DestroyItem (i);
//  if (!(region->IsOwner())) delete h->J;

  // 2h. Run SweepOps on hyp to remove interior branches and C_MERGEs.
  ((legoHB *)hyp)->RefreshOps();  // need for sweeping
  //  ((legoHB *)hyp)->SweepOps (1);
  sweepops ((legoHB *) hyp, 1);

  // 2i. Refresh the op/edge lists for hyp. Other regions don't need
  //     to be altered.

  ((legoHB *) hyp)->RefreshOps();
  ((legoHB *) hyp)->RefreshEdges();
  // actually, may need to also refresh treegion
//  if (((legoRegion *)hyp->GetParentPtr())->GetRegionType() == RT_TREE) {
//    ((legoTreegion *)hyp->GetParentPtr())->RefreshOps();
//    ((legoTreegion *)hyp->GetParentPtr())->RefreshEdges();
//  }

  delete Tpredicate;
  delete Epredicate;
  delete new_SorJ_vector;
  delete new_T_vector;
  delete new_E_vector;

  return hyp;
} // end IfConvertHammock

//===========================================================================


/*
 * IfConvertTreeBranch
 *   returns: pointer to if-converted code (hyperblock), NULL if error
 *
 * Performs if-conversion (predication) on treegion based on branch profiling.
 *
 * This is actually rather complicated...>:P
 */
legoOp *IfConvertTreeBranch (legoOp *branchop, knobs *K)
{
  legoRegion *hyp;
  legoProc *proc;
  legoTreegion *tree;
  legoOprd *p1, *p2, *pX, *pTaken = NULL, *pFallThru = NULL;
  legoOprd *btroprd, *cmppoprd, *def, *use, *oprd;
  oprdList *defs, *uses;
  legoRegion *TakenBlock, *FallThruBlock, *BranchBlock; 

  opList *oplist, *oplisttoremove;
  legoOp *lastop, *pbrrop, *cmppop, *op, *fixlinkop, *return_prev_op;
  legoOp *prevop, *cmergetakenop, *cmergefallthruop;
  legoOp *FirstItem, *NextItem, *ThisItem, *listop;
  legoOp *TakenBRU, *FallThruBRU, *FallThruPBRR;
  legoOp *duplicatecmppop; 
  int fromopid, toopid;
  int opid, eaid, newregnum, count_uses;

  int makingnewHB, isBRCT, PBRRblock;
  int TreegionExit, TakenBlockInTree, FallThruBlockInTree;
  int AddCtrlEdge=FALSE, AddCtrlEdgeTaken=FALSE, AddCtrlEdgeFallThru=FALSE; 
  int AddCtrlEdgeTakenPrev=FALSE, AddCtrlEdgeFallThruPrev=FALSE;
  int AddCtrlEdgeFallThruPBRR=FALSE, AddCtrlEdgeFix=FALSE;
  legoOp *takenfromop, *takentoop, *fallthrufromop, *fallthrutoop;
  legoOp *takenprevfromop, *takenprevtoop, *fallthruprevfromop, *fallthruprevtoop;
  legoOp *fallthrupbrrfromop, *fallthrupbrrtoop;
  legoOp *fixfromop, *fixtoop;
  legoOp *removeedgefromop, *removeedgetoop;
  opEdges *edge;
  int Branch_size, Taken_size, FallThru_size; 
  int Branch_count; 
  legoOp *temp_op; 
  opList *temp_oplist;

  attrs *attrdictionary, *attrtail, *atscan, *a;
  attrList *atlscan, *atl;

  bitvector *new_true_vector, *new_taken_vector, *new_fallthru_vector, *temp_vector, *mask_vector; 
  int PredVectorSize, required_vector_size;

  enum attrTypes atype;
  
  FILE *converted_fp;

  BranchBlock = (legoRegion *) branchop->GetParentBlockPtr();

  dprintf((OUTF, "IfConvertTreeBranch: --- converting starting at %d ---\n",
           BranchBlock->GetRegionId()));

  // Determine if branch is a Treegion exit
  tree = (legoTreegion *) FindParentRegionType(RT_TREE, branchop);
  if (tree == NULL) return NULL; 
  TreegionExit = FALSE;
  for (oplist = tree->GetExitOpsPtr();
       oplist != NULL;
       oplist = oplist->GetNextListPtr()) {
    if ((op = oplist->GetOpPtr()) != NULL) 
      if (op == branchop) {
        TreegionExit = TRUE;
        break; 
      }
  }

  // Make sure that branch is a BRCT or BRCF op
  //if (branchop->IsBRCTOp())
  if(branchop->GetOpcode() == BRCT)
  {
      LegoNonFatal("IfConvertHammock", "BRCF is not supported yet.");      
    isBRCT = 1;
  }
  //else if (branchop->IsBRCFOp())
  else if(branchop->GetOpcode() == BRCF)
  {
      LegoNonFatal("IfConvertHammock", "BRCF is not supported yet.");
    isBRCT = 0;
  }
  else 
    return NULL; 

  // Make sure that the branch has only two exit ops
  oplist = branchop->GetOutListPtr();
  if (oplist == NULL || oplist->GetNextListPtr() == NULL ||
      oplist->GetNextListPtr()->GetNextListPtr() != NULL)
    return NULL;
  
  // Find the procedure
  proc = (legoProc *) FindParentRegionType(RT_PROC, branchop);
  if (proc == NULL) {
    dprintf((OUTF,"IfConvertTreeBranch: can't find proc!\n"));
    return NULL;    
  }
  
  // Make a new hyperblock if necessary
  if (BranchBlock->GetRegionType() != RT_HB)
    {
      hyp = new legoHB (BranchBlock->GetRegionId());  // make new hyperblock
      hyp->SetWeight (BranchBlock->GetWeight());
      oprd = new legoOprd;
      oprd->SetOprdType (OT_LITERAL_I);
      oprd->SetLiteralInteger(0);
      AddLcAttribute ("use_orig_wt", oprd, hyp, proc); 
      makingnewHB = 1;
    } // end if
  else
    {
      hyp = BranchBlock;  // use existing hyperblock
      makingnewHB = 0;
    } // end else

  if (branchop->GetSrcOprdPtr() == NULL ||
      branchop->GetSrcOprdPtr()->GetNextOprdPtr() == NULL)
    {
      LegoNonFatal ("IfConvertTreeBranch", "Can't find predicate source of "
                    "branch %d.", branchop->GetOpId());  // will need it later
      return NULL;
    } // end if

  // STEP 1: Analysis and setup.

  // 1a. Because I may want to IfConvertTreeBranch() after scheduling, I will 
  // use Chains to determine predecessor PBRR and CMPP. Requires 
  // ReachingDefinitions analysis to be current. 
  if (Chains == NULL) {
    LegoNonFatal ("IfConvertTreeBranch", "Chains is NULL: call ReachingDefinitions().");
    return NULL;
  } // end if

  // 1b. Find the target of the branch.
  btroprd = branchop->GetSrcOprdPtr(); // should be 1st source
  pbrrop = NULL;
  for (defs = Chains->GetUDChains()->Lookup (btroprd);
       (defs != NULL) && (Chains->GetUDChains()->NotFound() == FALSE);
       defs = defs->GetNextListPtr()) {
    def = defs->GetOprdPtr();
    pbrrop = def->GetParentOpPtr(); // only one PBRR op should reach
    break; 
  }

  dderr ("pbrrop OpId is: " << pbrrop->GetOpId() << "\n");
  dderr ("branchop OpId is: " << branchop->GetOpId() << "\n");
  
  if (pbrrop == NULL) {
    LegoNonFatal ("IfConvertTreeBranch", "Can't find PBRR/PBRA in block %d.",
                  BranchBlock->GetRegionId());
    return NULL;
  } // end if

  oprd = pbrrop->GetSrcOprdPtr();
  if (oprd->GetOprdType() != OT_LITERAL_CB) {
    LegoNonFatal ("IfConvertTreeBranch", "PBRR %d not to control block.",
                  pbrrop->GetOpId());
    return NULL;
  } // end if
  
  // Find the Taken and FallThru Blocks 
  PBRRblock = oprd->GetLiteralControlBlock();
  oplist = branchop->GetOutListPtr();
  if (((legoRegion *) oplist->GetOpPtr()->GetParentBlockPtr())
      ->GetRegionId() ==  PBRRblock) {
    dderr ("oplist Valid = " << oplist->GetValid() << "\n");
    TakenBlock = (legoRegion *) oplist->GetOpPtr()->GetParentBlockPtr();
    dderr ("oplist Valid = " << oplist->GetNextListPtr()->GetValid() << "\n");
    FallThruBlock = (legoRegion *) oplist->GetNextListPtr()->GetOpPtr()->GetParentBlockPtr();
  }
  else if (((legoRegion *) oplist->GetNextListPtr()->GetOpPtr()
            ->GetParentBlockPtr())->GetRegionId() ==  PBRRblock) {
    dderr ("oplist Valid = " << oplist->GetValid() << "\n");
    FallThruBlock = (legoRegion *) oplist->GetOpPtr()->GetParentBlockPtr();
    dderr ("oplist Valid = " << oplist->GetNextListPtr()->GetValid() << "\n");
    TakenBlock = (legoRegion *) oplist->GetNextListPtr()->GetOpPtr()->GetParentBlockPtr();
  }
  else {
    LegoNonFatal ("IfConvertTreeBranch", "Could not determine TakenBlock and FallThruBlock in block %d.", BranchBlock->GetRegionId());
    return NULL;
  } // end if

  dderr ("BranchBlock Id is: " << BranchBlock->GetRegionId() << "\n");  
  dderr ("TakenBlock Id is: " << TakenBlock->GetRegionId() << "\n");  
  dderr ("FallThruBlock Id is: " << FallThruBlock->GetRegionId() << "\n");  
  
  // If TreegionExit == TRUE, determine if TakenBlock and FallThruBlock are 
  // within the Treegion (but not a loop back to Root)
  TakenBlockInTree = TRUE;
  FallThruBlockInTree = TRUE;
  if (TreegionExit == TRUE) {
    if ((tree != 
        ((legoTreegion *) FindParentRegionType(RT_TREE, TakenBlock))) ||
        (TakenBlock == tree->GetRoot())) {
      TakenBlockInTree = FALSE;
    }
    if ((tree != 
        ((legoTreegion *) FindParentRegionType(RT_TREE, FallThruBlock))) ||
        (FallThruBlock == tree->GetRoot())) {
      FallThruBlockInTree = FALSE;
    }
  }
  
  if ((TreegionExit == 1) && (TakenBlockInTree == 1) && (FallThruBlockInTree == 1))
    cerr << "Break Here\n";

  // Read in knobs.
  K->SetDefaultPanel ("rform/tree");
  K->Read ("num-bits-pred-vector", PredVectorSize);

  // Determine if PredVector length requirements can be satisfied
  // by PredVectorSize
  if ( (a = FindLcAttribute( "pred_vector_size", BranchBlock )) != NULL ) 
    Branch_size = a->GetAttrOprdPtr()->GetLiteralInteger();
  else 
    Branch_size = 1;
  if (branchop->GetPredVectorPtr() != NULL) {
    temp_vector = branchop->GetPredVectorPtr(); 
#ifdef _SHOW_VECTORS
    dderr ("branchop vector :\n");
    temp_vector->Show();
#endif // _SHOW_VECTORS
    Branch_count = 0; 
    for (int i = 0; i < Branch_size; i++) {
      if (temp_vector->Read(i)) {
        Branch_count++; 
      }
    }
  }
  else {
    Branch_count = 1; 
  }
  if (TakenBlockInTree) {
    if ( (a = FindLcAttribute( "pred_vector_size", TakenBlock )) != NULL ) 
      Taken_size = a->GetAttrOprdPtr()->GetLiteralInteger();
    else 
      Taken_size = 1; 
  }
  else {
    Taken_size = 1; 
  }
  if (FallThruBlockInTree) {
    if ( (a = FindLcAttribute( "pred_vector_size", FallThruBlock )) != NULL ) 
      FallThru_size = a->GetAttrOprdPtr()->GetLiteralInteger();
    else 
      FallThru_size = 1; 
  }
  else {
    FallThru_size = 1; 
  }
  required_vector_size = ((Branch_count * (Taken_size + FallThru_size - 1)) + Branch_size);
  if (required_vector_size > PredVectorSize) {
    LegoNonFatal ("IfConvertTreeBranch", "Need more PredVectorSize to continue if
-conversion !!!\n.");
    return NULL;
  }
  // Update hyp's pred_vector_size attr
  oprd = new legoOprd;
  oprd->SetOprdType (OT_LITERAL_I);
  oprd->SetLiteralInteger(required_vector_size);
  AddLcAttribute ("pred_vector_size", oprd, hyp, proc); 
  // Create Prototype for Join PredVector
  new_true_vector = new bitvector(PredVectorSize);   
  new_taken_vector = new bitvector(PredVectorSize);   
  new_fallthru_vector = new bitvector(PredVectorSize); 
  if (branchop->GetPredVectorPtr() != NULL) {
    mask_vector = new bitvector(*branchop->GetPredVectorPtr()); 
  }
  else {
    mask_vector = new bitvector(PredVectorSize);
    mask_vector->Set(0);
  }
  for (int i = 0; i < required_vector_size; i++) {
    new_true_vector->Set(i);
  }
  // The following vectors are only used for BB used for the first time in 
  // a HB (they will only replace a NULL PredVector)
  new_taken_vector->Set(0);
  new_fallthru_vector->Set(Taken_size);
  new_taken_vector = ReplicateBitsMask(new_taken_vector, mask_vector, Branch_size, (Taken_size + FallThru_size), PredVectorSize);
  new_fallthru_vector = ReplicateBitsMask(new_fallthru_vector, mask_vector, Branch_size, (Taken_size + FallThru_size), PredVectorSize);
  dderr ("\nBranch_size = " << Branch_size << "\n");
  dderr ("Taken_size = " << Taken_size << "\n");
  dderr ("FallThru_size = " << FallThru_size << "\n");
  dderr ("Branch_count = " << Branch_count << "\n");
  dderr ("required_vector_size = " << required_vector_size << "\n");
#ifdef _SHOW_VECTORS
  new_true_vector->Show();
  new_taken_vector->Show();
  new_fallthru_vector->Show();
#endif // _SHOW_VECTORS
  


  // If we need new BRUs to a TakenBlock or FallThruBlock not in the Treegion, 
  // copy construct them now from orig branchop and orig pbrrop before 
  // they are removed. 
  cmergetakenop = TakenBlock->GetEntryOpsPtr()->GetOpPtr();
  cmergefallthruop = FallThruBlock->GetEntryOpsPtr()->GetOpPtr();
  if (TreegionExit == TRUE) {
    if (TakenBlockInTree == FALSE) {
      opid = (FindMaxOpId ((legoProc *) proc))->GetOpId();
      // Add weight attr now to branchop so that it is copy constructed to the 
      // new BRU
      AddWeightAttribute (branchop);
      TakenBRU = new legoOp(*branchop);
      TakenBRU->SetOpcode(BRU);
      TakenBRU->SetOpId (++opid);
//      // make sure to copy the hammockPredVector
//      if (branchop->GetHammockPredVectorPtr() != NULL) {
//      TakenBRU->SetHammockPredVectorPtr(new bitvector(*branchop->GetHammockPredVectorPtr()));
//      }
      TakenBRU->SetParentBlockPtr (hyp);
      // Add to proc allListPtr - ops are enqueued in reverse.
      TakenBRU->SetListOpPtr(proc->GetListOpPtr());
      proc->SetListOpPtr (TakenBRU);
      // Get rid of the predicate source
      oprd = TakenBRU->GetSrcOprdPtr()->GetNextOprdPtr();
      TakenBRU->GetSrcOprdPtr()->SetNextOprdPtr(NULL);
      delete oprd; 
      // Duplicate op attributes.
      attrdictionary = proc->GetAttrDictionary();
      for (attrtail = attrdictionary; attrtail->GetNextAttrPtr() != NULL;
           attrtail = attrtail->GetNextAttrPtr()) /* do nothing */;
      eaid = FindMaxEdgeAttrId (proc);
      for (atlscan = TakenBRU->GetOpAttrListPtr(); atlscan != NULL;
           atlscan = atlscan->GetNextListPtr())
        {
          if (atlscan->GetAttrPtr() == NULL)
            continue;
          atscan = new attrs (*(atlscan->GetAttrPtr()), TakenBRU, ++eaid);
          atlscan->SetAttrPtr (atscan);
          atscan->SetAttrId (eaid);
          atlscan->SetAttrId (eaid);
          attrtail->SetNextAttrPtr (atscan);
          attrtail = attrtail->GetNextAttrPtr();
        } // end for
      // Get rid of out op to FallThruBlock
      oplist = TakenBRU->GetOutListPtr();
      // FallThruBlock is either the 1st or 2nd op on oplist
      if (TakenBlock == 
          (legoRegion *) oplist->GetOpPtr()->GetParentBlockPtr()) {
        oplisttoremove = oplist->GetNextListPtr();
        oplist->SetNextListPtr(NULL);
        delete oplisttoremove;
      }
      else {
        oplisttoremove = oplist;
        oplist = oplisttoremove->GetNextListPtr();
        oplisttoremove->SetNextListPtr(NULL);
        delete oplisttoremove;
        TakenBRU->SetOutListPtr(oplist);
      }
      // Fix Out Edge
      edge = FindControlEdge (branchop, cmergetakenop, 1);
      if (edge == NULL)
        LegoFatal ("IfConvertTreeBranch", "Can't find edge from "
                   "op %d to op %d.", TakenBRU->GetOpId(), cmergetakenop->GetOpId());
      // Re-do inList for the op that this edge reaches
      for (temp_oplist = edge->GetToOpPtr()->GetInListPtr();
           temp_oplist->GetOpPtr() != branchop;
           temp_oplist = temp_oplist->GetNextListPtr())
        ; // just find the list element that needs updating
      temp_oplist->SetOpPtr(TakenBRU);
      temp_oplist->SetOpId(TakenBRU->GetOpId()); 
      edge->SetFromOpPtr (TakenBRU);
      edge->SetFromOpId (TakenBRU->GetOpId());
    }
    
    if (FallThruBlockInTree == FALSE) {
      opid = (FindMaxOpId ((legoProc *) proc))->GetOpId();
      // Add weight attr now to branchop so that it is copy constructed to the 
      // new BRUs
      AddWeightAttribute (branchop);
      FallThruBRU = new legoOp(*branchop);
      FallThruBRU->SetOpcode(BRU);
      FallThruBRU->SetOpId (++opid);
//      if (branchop->GetHammockPredVectorPtr() != NULL) {
//      FallThruBRU->SetHammockPredVectorPtr(new bitvector(*branchop->GetHammockPredVectorPtr()));
//      }
      FallThruBRU->SetParentBlockPtr (hyp);
      // Add to proc allListPtr - ops are enqueued in reverse.
      FallThruBRU->SetListOpPtr(proc->GetListOpPtr());
      proc->SetListOpPtr (FallThruBRU);
      // Get rid of the predicate source
      oprd = FallThruBRU->GetSrcOprdPtr()->GetNextOprdPtr();
      FallThruBRU->GetSrcOprdPtr()->SetNextOprdPtr(NULL);
      delete oprd; 
      // ReDo the BTR source
      oprd = FallThruBRU->GetSrcOprdPtr();
      newregnum = FindMaxRegNum (proc);
      oprd->SetOprdRegNum(++newregnum);
      //delete oprd;      
      //FallThruBRU->SetSrcOprdPtr(NULL);
      // Duplicate op attributes.
      attrdictionary = proc->GetAttrDictionary();
      for (attrtail = attrdictionary; attrtail->GetNextAttrPtr() != NULL;
           attrtail = attrtail->GetNextAttrPtr()) /* do nothing */;
      eaid = FindMaxEdgeAttrId (proc);
      for (atlscan = FallThruBRU->GetOpAttrListPtr(); atlscan != NULL;
           atlscan = atlscan->GetNextListPtr())
        {
          if (atlscan->GetAttrPtr() == NULL)
            continue;
          atscan = new attrs (*(atlscan->GetAttrPtr()), FallThruBRU, ++eaid);
          atlscan->SetAttrPtr (atscan);
          atscan->SetAttrId (eaid);
          atlscan->SetAttrId (eaid);
          attrtail->SetNextAttrPtr (atscan);
          attrtail = attrtail->GetNextAttrPtr();
        } // end for
      // Get rid of out op to TakenBlock
      oplist = FallThruBRU->GetOutListPtr();
      // TakenBlock is either the 1st or 2nd op on oplist
      if (FallThruBlock == 
          (legoRegion *) oplist->GetOpPtr()->GetParentBlockPtr()) {
        oplisttoremove = oplist->GetNextListPtr();
        oplist->SetNextListPtr(NULL);
        delete oplisttoremove;
      }
      else {
        oplisttoremove = oplist;
        oplist = oplisttoremove->GetNextListPtr();
        oplisttoremove->SetNextListPtr(NULL);
        delete oplisttoremove;
        FallThruBRU->SetOutListPtr(oplist);
      }
      // Fix Out Edge
      edge = FindControlEdge (branchop, cmergefallthruop, 1);
      if (edge == NULL)
        LegoFatal ("IfConvertTreeBranch", "Can't find edge from "
                   "op %d to op %d.", FallThruBRU->GetOpId(), cmergefallthruop->GetOpId());
      // Re-do inList for the op that this edge reaches
      for (temp_oplist = edge->GetToOpPtr()->GetInListPtr();
           temp_oplist->GetOpPtr() != branchop;
           temp_oplist = temp_oplist->GetNextListPtr())
        ; // just find the list element that needs updating
      temp_oplist->SetOpPtr(FallThruBRU);
      temp_oplist->SetOpId(FallThruBRU->GetOpId()); 
      edge->SetFromOpPtr (FallThruBRU);
      edge->SetFromOpId (FallThruBRU->GetOpId()); 
      
      // FallThruBRU also needs a new PBR
      opid = (FindMaxOpId ((legoProc *) proc))->GetOpId();
      // Add weight attr now to pbrrop so that it is copy constructed to the 
      // new PBRR
      AddWeightAttribute (pbrrop);
      FallThruPBRR = new legoOp(*pbrrop);
      FallThruPBRR->SetOpId (++opid);
//      if (pbrrop->GetHammockPredVectorPtr() != NULL) {
//      FallThruPBRR->SetHammockPredVectorPtr(new bitvector(*pbrrop->GetHammockPredVectorPtr()));
//      }
      FallThruPBRR->SetParentBlockPtr (hyp);
      // Add to proc allListPtr - ops are enqueued in reverse.
      FallThruPBRR->SetListOpPtr(proc->GetListOpPtr());
      proc->SetListOpPtr (FallThruPBRR);
      // ReDo the BTR dest
      oprd = FallThruPBRR->GetDestOprdPtr();
      oprd->SetOprdRegNum(newregnum);
      // ReDo the CB literal
      oprd = FallThruPBRR->GetSrcOprdPtr();
      oprd->SetLiteralControlBlock (FallThruBlock->GetRegionId());
      // Duplicate op attributes.
      for (attrtail = attrdictionary; attrtail->GetNextAttrPtr() != NULL;
           attrtail = attrtail->GetNextAttrPtr()) /* do nothing */;
      eaid = FindMaxEdgeAttrId (proc);
      for (atlscan = FallThruPBRR->GetOpAttrListPtr(); atlscan != NULL;
           atlscan = atlscan->GetNextListPtr())
        {
          if (atlscan->GetAttrPtr() == NULL)
            continue;
          atscan = new attrs (*(atlscan->GetAttrPtr()), FallThruPBRR, ++eaid);
          atlscan->SetAttrPtr (atscan);
          atscan->SetAttrId (eaid);
          atlscan->SetAttrId (eaid);
          attrtail->SetNextAttrPtr (atscan);
          attrtail = attrtail->GetNextAttrPtr();
        } // end for
    }
  }
    
  // Don't destroy this PBR if it reaches any other branches (possible 
  // if speculated and dominator parallel) or if TakenBlockInTree == FALSE
  int destroy = TRUE;
  if (TakenBlockInTree == TRUE) {
    for (uses = Chains->GetDUChains()->Lookup (def);
         (uses != NULL) && (Chains->GetUDChains()->NotFound() == FALSE);
         uses = uses->GetNextListPtr()) {
      use = uses->GetOprdPtr();
      if (use->GetParentOpPtr() != branchop) {
        destroy = FALSE;
        break; 
      } 
    }
  }
  else {
    destroy = FALSE;
  }

  return_prev_op = branchop->GetPrevLink(); 
  if (destroy) {
    if (pbrrop == return_prev_op) {
      return_prev_op = pbrrop->GetPrevLink(); 
    }
    RemoveMidOp(pbrrop, 1);
  }

  // 1c. Find the predicate operands that are the destination of the CMPP.
  //     Put the first in p1, the second in p2. If the second isn't there, 
  //     take care of it.
  cmppoprd = branchop->GetSrcOprdPtr()->GetNextOprdPtr(); // 2nd source
  cmppop = NULL;
  for (defs = Chains->GetUDChains()->Lookup (cmppoprd);
       (defs != NULL) && (Chains->GetUDChains()->NotFound() == FALSE);
       defs = defs->GetNextListPtr()) {
    def = defs->GetOprdPtr();
    cmppop = def->GetParentOpPtr(); // only one CMPP op should reach
    break; 
  }
  
  dderr ("cmppop OpId is: " << cmppop->GetOpId() << "\n");

  if (cmppop == NULL) {
    LegoNonFatal ("IfConvertTreeBranch", "Can't find CMPP for branch %d.",
                  BranchBlock->GetRegionId());
    return NULL;
  } // end if

  if (cmppop->IsCMPPOp()) {
    LegoNonFatal ("IfConvertTreeBranch", "Can't find CMPP for branch %d.",
                  BranchBlock->GetRegionId());
    return NULL;
  } // end if

  // make sure that the second D-action is a complement (odd-number opcode)
  div_t remainder = div(cmppop->GetOpcode(), 2);
  if (remainder.rem == 0) {
    cmppop->SetOpcode((cmppop->GetOpcode() + 1));
  }
  
  p1 = cmppop->GetDestOprdPtr();  // first destination!
  if (p1 == NULL || p1->GetNextOprdPtr() == NULL)
    {
      LegoNonFatal ("IfConvertTreeBranch", "CMPP %d has bad destinations.",
                    cmppop->GetOpId());
      return NULL;
    } // end if
  p2 = p1->GetNextOprdPtr();  // p2 is there always!
  if (p1->GetNextOprdPtr()->GetOprdType() != OT_UNDEFINED)
    /* do nothing - we have two predicates! */;
  else {   // Nuts, there's no second destination. 
    // We need a second destination. Scan through
    // every op in the proc to find the next predicate register that's
    // free.
    if (NextPredRegNum == 0) {  // find it
      legoOp *o;
      legoOprd *d;
      for (o = proc->GetListOpPtr(); o != NULL; o = o->GetListOpPtr()) {
        for (d = o->GetSrcOprdPtr(); d != NULL; d = d->GetNextOprdPtr())
          if (d->GetOprdType() == OT_REG &&
              //                    (d->GetOprdDataType() == DT_P ||
              //                     d->GetOprdFileType() == FT_PR) &&
              d->GetOprdRegNum() > NextPredRegNum)
            NextPredRegNum = d->GetOprdRegNum();
        
        for (d = o->GetDestOprdPtr(); d != NULL; d = d->GetNextOprdPtr())
          if (d->GetOprdType() == OT_REG &&
              //                    (d->GetOprdDataType() == DT_P ||
              //                     d->GetOprdFileType() == FT_PR) &&
              d->GetOprdRegNum() > NextPredRegNum)
            NextPredRegNum = d->GetOprdRegNum();
        
        for (d = o->GetPredOprdPtr(); d != NULL; d = d->GetNextOprdPtr())
          if (d->GetOprdType() == OT_REG &&
              //                    (d->GetOprdDataType() == DT_P ||
              //                     d->GetOprdFileType() == FT_PR) &&
              d->GetOprdRegNum() > NextPredRegNum)
            NextPredRegNum = d->GetOprdRegNum();
      } // end for
      
      NextPredRegNum++;  // next available one
      dprintf((OUTF, "IfConvertTreeBranch: NextPredRegNum = %d\n",
               NextPredRegNum));
    } // end if
    
    // For hyperblocks, need to make sure that all predicates start out 
    // unique, so I will also refresh p1's number. With the lack of control
    // flow within a hyperblock control flow out can get confused when more 
    // than one CMPP uses the same prednumb (especially after scheduling). 
    // TailDuplication of CMPPs is a source for this problem. Once again, 
    // learned this one the hard way. 

    // If p1 reaches more than one branch (possible if merged due to dominator
    // parallelism) copy construct a new CMPP
    for (count_uses = 0, uses = Chains->GetDUChains()->Lookup (p1);
         (uses != NULL) && (Chains->GetDUChains()->NotFound() == FALSE);
         count_uses++, uses = uses->GetNextListPtr()) 
      use = uses->GetOprdPtr();  // just count uses
    if (count_uses > 1) { // more than one use found, copy construct CMPP
  // should update RDefs somewhere around here so that I do not need to 
  // copy construct CMPPs that now only reach one use.
      dderr ("*** This part has not been debugged yet *** count = " << count_uses << "\n");
      duplicatecmppop = new legoOp(*cmppop);
      duplicatecmppop->SetOpId(FindMaxOpId((legoProc *) proc)->GetOpId() + 1);
      // Duplicate op attributes.
      attrdictionary = proc->GetAttrDictionary();
      for (attrtail = attrdictionary; attrtail->GetNextAttrPtr() != NULL;
           attrtail = attrtail->GetNextAttrPtr()) /* do nothing */;
      eaid = FindMaxEdgeAttrId (proc);
      for (atlscan = duplicatecmppop->GetOpAttrListPtr(); atlscan != NULL;
           atlscan = atlscan->GetNextListPtr())
        {
          if (atlscan->GetAttrPtr() == NULL)
            continue;
          atscan = new attrs (*(atlscan->GetAttrPtr()), duplicatecmppop, ++eaid);
          atlscan->SetAttrPtr (atscan);
          atscan->SetAttrId (eaid);
          atlscan->SetAttrId (eaid);
          attrtail->SetNextAttrPtr (atscan);
          attrtail = attrtail->GetNextAttrPtr();
        } // end for
      // make sure to copy the hammockPredVector
      if (cmppop->GetPredVectorPtr() != NULL) {
        duplicatecmppop->SetPredVectorPtr(new bitvector(*cmppop->GetPredVectorPtr()));
      }
      
      p1 = duplicatecmppop->GetDestOprdPtr();  // first destination!
      if (p1 == NULL || p1->GetNextOprdPtr() == NULL)
        {
          LegoNonFatal ("IfConvertTreeBranch", "duplicatecmppop %d has bad destinations.",
                        duplicatecmppop->GetOpId());
          return NULL;
        } // end if
      AddMidOp (duplicatecmppop, cmppop);
      p2 = p1->GetNextOprdPtr();  // p2 is there always!
      p1->SetOprdRegNum (NextPredRegNum);
      // Need the same new number for the branch that this reaches
      branchop->GetSrcOprdPtr()->GetNextOprdPtr()->SetOprdRegNum(NextPredRegNum++);
    }
    else { // just rename p1 and the branchop that it should reach
      dderr ("A-OK: count = " << count_uses << "\n");
      dderr ("branchopId = " << branchop->GetOpId() << "\n");
      dderr ("UseOpId = " << use->GetParentOpPtr()->GetOpId() << "\n");
      p1->SetOprdRegNum (NextPredRegNum);
      // Need the same new number for the branch that this reaches
      branchop->GetSrcOprdPtr()->GetNextOprdPtr()->SetOprdRegNum(NextPredRegNum++);
    }
    
    // Make the new operand and plop it into the CMPP.
    p2->SetOprdType (p1->GetOprdType());
    p2->SetOprdRegNum (NextPredRegNum++);
    p2->SetOprdRegType (p1->GetOprdRegType());
    p2->SetOprdDataType (p1->GetOprdDataType());
    p2->SetOprdFileType (p1->GetOprdFileType());
    p2->SetOprdOmega (p1->GetOprdOmega());
    p2->SetOprdRegStyle (p1->GetOprdRegStyle());
    p2->SetIntValue (p1->GetOprdIntValue());
  } // end else

  // 1d. Figure out pTaken and pFallThru, the predicates for the 
  //     Taken Block and FallThru Block
  //          |       branch to Taken        |
  //          |                              |
  //  BRCT pX | pTaken = pX, pFallThru = !pX | 
  //          |                              |
  //  BRCF pX | pTaken = !pX, pFallThru = pX | 

  pX = branchop->GetSrcOprdPtr()->GetNextOprdPtr();
  if (pX->GetOprdRegNum() == p1->GetOprdRegNum())
    pX = p1;  // point pX to p1
  else
    pX = p2;  // point pX to p2
  
  if (isBRCT)    {
    pTaken = pX;
    pFallThru = (pTaken == p1 ? p2 : p1);
  } // end if
  else {
    pFallThru = pX;
    pTaken = (pFallThru == p1 ? p2 : p1);
  } // end else
  
  // STEP 2: If-Conversion

  legoOprd *Tpredicate;
  legoOprd *Fpredicate;

  regionList *rl;
  legoRegion *region;
  unsigned i, count;
  int mapping; 

  // Output to iF_CoNVeRTeD_PT file that the mapping of this branchop 
  // will be if-converted
  converted_fp = fopen("./iF_CoNVeRTeD_PT", "a");
  if(converted_fp==NULL) {
    LegoFatal ("IfConvertTreeBranch", "Could not open iF_CoNVeRTeD_PT.");
  }
  if ( (a = FindLcAttribute( "branch_mapping", branchop )) != NULL ) {
    mapping = a->GetAttrOprdPtr()->GetLiteralInteger();
    fprintf(converted_fp,"%d\n", mapping);
    fclose(converted_fp);
  }
  else {
//    LegoNonFatal ("IfConvertTreeBranch", "No mapping for branchop Id %d\n.",
//                branchop->GetOpId());
  }

  fprintf(converted_fp,"%d\n", mapping);
  fclose(converted_fp);
  
  // 2a. Make new prototype predicate legoOprds based on pTaken and pFallThru
  Tpredicate = MakeDupPred (pTaken);
  Fpredicate = MakeDupPred (pFallThru);

  // 2b. Invalidate children lists of parents of branchop's
  //     region_ptr, and invalidate parents lists of children of branchop's 
  //     region_ptgr. Also, invalidate parents of the children of the Taken 
  //     and FallThru Blocks.

  // I'm pretty sure that I do not need all of these (especially because 
  // RefreshEdges also resets) but added them while chasing bug and it 
  // works with them now, and it NEEDs to keep working
  for (rl = BranchBlock->GetParents(); 
       rl != NULL; 
       rl = rl->GetNextListPtr())
    {
      region = rl->GetRegionPtr();
      if (region != NULL)
        {
          delete (region->GetChildren());
          region->SetChildren (NULL);
        } // end if
    } // end for
  for (rl = BranchBlock->GetChildren(); 
       rl != NULL; 
       rl = rl->GetNextListPtr())
    {
      region = rl->GetRegionPtr();
      if (region != NULL)
        {
          delete (region->GetParents());
          region->SetParents (NULL);
        } // end if
    } // end for
  for (rl = TakenBlock->GetChildren(); 
       rl != NULL; 
       rl = rl->GetNextListPtr())
    {
      region = rl->GetRegionPtr();
      if (region != NULL)
        {
          delete (region->GetParents());
          region->SetParents (NULL);
        } // end if
    } // end for
  for (rl = TakenBlock->GetParents(); 
       rl != NULL; 
       rl = rl->GetNextListPtr())
    {
      region = rl->GetRegionPtr();
      if (region != NULL)
        {
          delete (region->GetChildren());
          region->SetChildren (NULL);
        } // end if
    } // end for
  for (rl = FallThruBlock->GetChildren(); 
       rl != NULL; 
       rl = rl->GetNextListPtr())
    {
      region = rl->GetRegionPtr();
      if (region != NULL)
        {
          delete (region->GetParents());
          region->SetParents (NULL);
        } // end if
    } // end for
  for (rl = FallThruBlock->GetParents(); 
       rl != NULL; 
       rl = rl->GetNextListPtr())
    {
      region = rl->GetRegionPtr();
      if (region != NULL)
        {
          delete (region->GetChildren());
          region->SetChildren (NULL);
        } // end if
    } // end for

  fixlinkop = NULL;
  if (branchop->GetNextLink() != NULL)
    fixlinkop = branchop->GetNextLink();
  
  if (!makingnewHB) {
    // Just Update PredVector for ops already in hyp
    for (FirstItem = (legoOp *) BranchBlock->GetItem(0); 
         FirstItem->GetPrevLink() != NULL;
         FirstItem = FirstItem->GetPrevLink())
      ; // do nothing
    for (NextItem = FirstItem; NextItem != NULL; ) {
      ThisItem = NextItem; 
      NextItem = NextItem->GetNextLink();
      // Add/Update PredVector
      if (ThisItem->GetPredVectorPtr() == NULL) { 
        LegoNonFatal ("IfConvertTreeBranch", "Can't find PredVector for OpId %d  "
                      " in HBId %d.", ThisItem->GetOpId(), BranchBlock->GetRegionId());
        ThisItem->SetPredVectorPtr(new bitvector(*new_true_vector));
      }
      else {
        ThisItem->SetPredVectorPtr(MultiplyBitsMask(ThisItem->GetPredVectorPtr(), mask_vector, Branch_size, (Taken_size + FallThru_size), PredVectorSize));
      }
      dderr ("OpId = " << ThisItem->GetOpId() << " (a BranchBlock op)\n");
    } // end for
  }

  prevop = branchop->GetPrevLink();
  removeedgefromop = prevop;
  removeedgetoop = branchop;
  RemoveEdge (prevop, branchop, proc, ET_CNTL);  
  branchop->GetPrevLink()->SetNextLink (NULL);
  if (branchop->GetNextLink() != NULL) {
    RemoveEdge (branchop, branchop->GetNextLink(), proc, ET_CNTL); 
    branchop->SetNextLink(NULL); 
  }
  branchop->SetPrevLink (NULL);
  branchop->SetNextLink (NULL);
  if (TakenBlockInTree == TRUE) {
    cmergetakenop->GetNextLink()->SetPrevLink (NULL);
    RemoveEdge (cmergetakenop, cmergetakenop->GetNextLink(), proc, ET_CNTL);  
    cmergetakenop->SetPrevLink (NULL);
    cmergetakenop->SetNextLink (NULL);
    RemoveEdge (branchop, cmergetakenop, proc, ET_CNTL);  
  }
  if (FallThruBlockInTree == TRUE) {
    cmergefallthruop->GetNextLink()->SetPrevLink (NULL);
    RemoveEdge (cmergefallthruop, cmergefallthruop->GetNextLink(), proc, ET_CNTL);  
    cmergefallthruop->SetPrevLink (NULL);
    cmergefallthruop->SetNextLink (NULL);
    RemoveEdge (branchop, cmergefallthruop, proc, ET_CNTL);  
  }
  
  // remove branchop from allList, etc. 
  if ((listop = proc->GetListOpPtr()) != branchop) {
    for (;
         listop != NULL && listop->GetListOpPtr() != branchop;
         listop = listop->GetListOpPtr())
      /* do nothing */;
  }
  if (listop != NULL)
    {
      if (proc->GetListOpPtr() != branchop)
        listop->SetListOpPtr (branchop->GetListOpPtr());
      else
        proc->SetListOpPtr (branchop->GetListOpPtr());
    } // end if
  branchop->SetListOpPtr (NULL);
    
  // Detach from region.
  BranchBlock->Detach(BranchBlock->Search(branchop));
  
  RemoveLiveAttribute (branchop, proc);  // kill live attribute right off
  
  atl = branchop->GetOpAttrListPtr();
  while (atl != NULL)
    {
      atype = atl->GetAttrType();
      if (atype != ATTR_LC)
        {
          atl = atl->GetNextListPtr(); continue;  // skip to first lc
        } // end if
      
      // Remove the first attribute here.
      a = atl->GetAttrPtr();
      RemoveLcAttribute (a->GetAttrString(), branchop, proc);
      
      atl = branchop->GetOpAttrListPtr();  // reset for next scan
    } // end while
  delete branchop;
  
  // remove cmergetakenop from allList, etc. 
  if (TakenBlockInTree == TRUE) {
    if ((listop = proc->GetListOpPtr()) != cmergetakenop) {
      for (;
           listop != NULL && listop->GetListOpPtr() != cmergetakenop;
           listop = listop->GetListOpPtr())
        /* do nothing */;
    }
    if (listop != NULL)
      {
        if (proc->GetListOpPtr() != cmergetakenop)
          listop->SetListOpPtr (cmergetakenop->GetListOpPtr());
        else
          proc->SetListOpPtr (cmergetakenop->GetListOpPtr());
      } // end if
    cmergetakenop->SetListOpPtr (NULL);
    
    // Detach from region.
    TakenBlock->Detach(TakenBlock->Search(cmergetakenop));
    
    RemoveLiveAttribute (cmergetakenop, proc);  // kill live attribute right off
    
    atl = cmergetakenop->GetOpAttrListPtr();
    while (atl != NULL)
      {
        atype = atl->GetAttrType();
        if (atype != ATTR_LC)
          {
            atl = atl->GetNextListPtr(); continue;  // skip to first lc
          } // end if
        
        // Remove the first attribute here.
        a = atl->GetAttrPtr();
        RemoveLcAttribute (a->GetAttrString(), cmergetakenop, proc);
        
        atl = cmergetakenop->GetOpAttrListPtr();  // reset for next scan
      } // end while
    delete cmergetakenop;
  }
  
  // remove cmergefallthruop from allList, etc. 
  if (FallThruBlockInTree == TRUE) {
    if ((listop = proc->GetListOpPtr()) != cmergefallthruop) {
      for (;
           listop != NULL && listop->GetListOpPtr() != cmergefallthruop;
           listop = listop->GetListOpPtr())
        /* do nothing */;
    }
    if (listop != NULL)
      {
        if (proc->GetListOpPtr() != cmergefallthruop)
          listop->SetListOpPtr (cmergefallthruop->GetListOpPtr());
        else
          proc->SetListOpPtr (cmergefallthruop->GetListOpPtr());
      } // end if
    cmergefallthruop->SetListOpPtr (NULL);
    
    // Detach from region.
    FallThruBlock->Detach(FallThruBlock->Search(cmergefallthruop));
    
    RemoveLiveAttribute (cmergefallthruop, proc);  // kill live attribute right off
    
    atl = cmergefallthruop->GetOpAttrListPtr();
    while (atl != NULL)
      {
        atype = atl->GetAttrType();
        if (atype != ATTR_LC)
          {
            atl = atl->GetNextListPtr(); continue;  // skip to first lc
          } // end if
        
        // Remove the first attribute here.
        a = atl->GetAttrPtr();
        RemoveLcAttribute (a->GetAttrString(), cmergefallthruop, proc);
        
        atl = cmergefallthruop->GetOpAttrListPtr();  // reset for next scan
      } // end while
    delete cmergefallthruop;
  }
  
  // 2c. Move ops from branchop region to hyp. At the end,
  //     destroy the edge leading to FallThru Block.
  // Remove branchop in BranchBlock and C_MERGEs in 
  // TakenBlock and FallThruBlock
  if (makingnewHB) {
    for (FirstItem = (legoOp *) BranchBlock->GetItem(0); 
         FirstItem->GetPrevLink() != NULL;
         FirstItem = FirstItem->GetPrevLink())
      ; // do nothing
    for (NextItem = FirstItem; NextItem != NULL; ) {
      ThisItem = NextItem; 
      NextItem = NextItem->GetNextLink();
      AddWeightAttribute (ThisItem);
      dprintf((OUTF,"IfConvertTreeBranch: moving op %d from BranchBlock.\n",
               ThisItem->GetOpId()));
      BranchBlock->Detach(BranchBlock->Search(ThisItem));
      hyp->AddItem(ThisItem);
      ThisItem->SetParentBlockPtr (hyp);
      // Add/Update PredVector
      if (ThisItem->GetPredVectorPtr() == NULL) { 
        ThisItem->SetPredVectorPtr(new bitvector(*new_true_vector));
      }
      else {
        ThisItem->SetPredVectorPtr(MultiplyBitsMask(ThisItem->GetPredVectorPtr(), mask_vector, Branch_size, (Taken_size + FallThru_size), PredVectorSize));
      }
      dderr ("OpId = " << ThisItem->GetOpId() << " (a BranchBlock op)\n");
    } // end for
    prevop = ThisItem;
  }
  
  // 2d. Move ops from Taken Block to hyp, predicating them on Tpredicate.
  if (TakenBlockInTree == TRUE) {
    for (FirstItem = (legoOp *) TakenBlock->GetItem(0); 
         FirstItem->GetPrevLink() != NULL;
         FirstItem = FirstItem->GetPrevLink())
      ; // do nothing
    for (NextItem = FirstItem, i = 0; NextItem != NULL; i++) {
      ThisItem = NextItem; 
      NextItem = NextItem->GetNextLink();
      AddWeightAttribute (ThisItem);
      TakenBlock->Detach(TakenBlock->Search(ThisItem));
      dprintf((OUTF,"IfConvertTreeBranch: moving op %d from Taken.\n",
               ThisItem->GetOpId()));
      hyp->AddItem(ThisItem);
      ThisItem->SetParentBlockPtr (hyp);
      
      if (i == 0) {
//      if (AddCtrlEdge == TRUE) {
          AddCtrlEdgeTaken = TRUE; 
          takenfromop = prevop; 
          takentoop = ThisItem; 
//        AddCtrlEdge = FALSE;
//      }
        prevop->SetNextLink (ThisItem);
        ThisItem->SetPrevLink (prevop);
      } // end if
      
      oprd = ThisItem->GetPredOprdPtr();
      // mdj - 4/2/99
      // Only want to update TRUE predicates here. If the predicate is now 
      // non-TRUE, it was updated by a prior hammock conversion. Leaving 
      // these predicates alone while updating (predicating) the CMPP ops 
      // that create these predicates produces the correct predicate values
      int dont_change_pred = 0;
      if (oprd != NULL) {
        if (oprd->GetOprdType() != OT_LITERAL_P ||
            oprd->GetLiteralPredicate() != TRUE ) {
          dont_change_pred = 1;
        }
        else {
          delete oprd;
        }
      }
      if (!dont_change_pred) {
        oprd = new legoOprd (*Tpredicate);
        ThisItem->SetPredOprdPtr (oprd);
        oprd->SetParentOpPtr (ThisItem);
      }
      // Set PredVector and orig_tree_hb_id attribute
      if (ThisItem->GetPredVectorPtr() == NULL) { 
        ThisItem->SetPredVectorPtr(new bitvector(*new_taken_vector));
      }
      else {
        // Don't need to add zeros left for fallthru path
        ThisItem->SetPredVectorPtr(ReplicateBitsMask(ThisItem->GetPredVectorPtr(), mask_vector, Branch_size, (Taken_size + FallThru_size), PredVectorSize));
      }
      dderr ("OpId = " << ThisItem->GetOpId() << " (a TakenBlock op)\n");
//      ThisItem->SetPredVectorPtr(new bitvector(*taken_vector));
//      oprd = new legoOprd;
//      oprd->SetOprdType (OT_LITERAL_I);
//      oprd->SetLiteralInteger(hyp->GetRegionId());
//      AddLcAttribute ("orig_tree_hb_id", oprd, ThisItem, proc);
    } // end for
    prevop = ThisItem;
  }  
  else {
    dderr ("adding TakenBRU op " << TakenBRU->GetOpId() << " to hyp. \n");
    dprintf((OUTF,"IfConvertTreeBranch: adding TakenBRU op %d to hyp.\n",
             TakenBRU->GetOpId()));
    hyp->AddItem(TakenBRU);
    TakenBRU->SetParentBlockPtr (hyp);
    
    prevop->SetNextLink (TakenBRU);
    TakenBRU->SetPrevLink (prevop);
    AddCtrlEdgeTakenPrev = TRUE; 
    takenprevfromop = prevop;
    takenprevtoop = TakenBRU;
    //AddEdge(prevop, TakenBRU, ET_CNTL);
    
    // When changing conditional branches to unconditional branches, 
    // we always want to update the predicate source (not just update 
    // for TRUE predicates as before).
    oprd = TakenBRU->GetPredOprdPtr();
    delete oprd;
    oprd = new legoOprd (*Tpredicate);
    TakenBRU->SetPredOprdPtr (oprd);
    oprd->SetParentOpPtr (TakenBRU);
    // Set PredVector and orig_tree_hb_id attribute
    TakenBRU->SetPredVectorPtr(new bitvector(*new_taken_vector));
    dderr ("OpId = " << TakenBRU->GetOpId() << " (TakenBRU op)\n");
//    oprd = new legoOprd;
//    oprd->SetOprdType (OT_LITERAL_I);
//    oprd->SetLiteralInteger(hyp->GetRegionId());
//    AddLcAttribute ("orig_tree_hb_id", oprd, TakenBRU, proc);

    prevop = TakenBRU;
//    AddCtrlEdge = TRUE;
  }
  
  // 2e. Move ops from FallThru Block to hyp, predicating them on Fpredicate.
  if (FallThruBlockInTree == TRUE) {
    for (FirstItem = (legoOp *) FallThruBlock->GetItem(0); 
         FirstItem->GetPrevLink() != NULL;
         FirstItem = FirstItem->GetPrevLink())
      ; // do nothing
    for (NextItem = FirstItem, i = 0; NextItem != NULL; i++) {
      ThisItem = NextItem; 
      NextItem = NextItem->GetNextLink();
      AddWeightAttribute (ThisItem);
      FallThruBlock->Detach(FallThruBlock->Search(ThisItem));
      dprintf((OUTF,"IfConvertTreeBranch: moving op %d from FallThru.\n",
               ThisItem->GetOpId()));
      hyp->AddItem(ThisItem);
      ThisItem->SetParentBlockPtr (hyp);
      
      if (i == 0) {
//      if (AddCtrlEdge == TRUE) {
          AddCtrlEdgeFallThru = TRUE; 
          fallthrufromop = prevop; 
          fallthrutoop = ThisItem; 
//        AddCtrlEdge = FALSE;
//      }
        prevop->SetNextLink (ThisItem);
        ThisItem->SetPrevLink (prevop);
      } // end if
      
      oprd = ThisItem->GetPredOprdPtr();
      // mdj - 4/2/99
      // Only want to update TRUE predicates here. If the predicate is now 
      // non-TRUE, it was updated by a prior hammock conversion. Leaving 
      // these predicates alone while updating (predicating) the CMPP ops 
      // that create these predicates produces the correct predicate values
      int dont_change_pred = 0;
      if (oprd != NULL) {
        if (oprd->GetOprdType() != OT_LITERAL_P ||
            oprd->GetLiteralPredicate() != TRUE ) {
          dont_change_pred = 1;
        }
        else {
          delete oprd;
        }
      }
      if (!dont_change_pred) {
        oprd = new legoOprd (*Fpredicate);
        ThisItem->SetPredOprdPtr (oprd);
        oprd->SetParentOpPtr (ThisItem);
      }
      // Set PredVector and orig_tree_hb_id attribute
      if (ThisItem->GetPredVectorPtr() == NULL) { 
        ThisItem->SetPredVectorPtr(new bitvector(*new_fallthru_vector));
      }
      else {
        // Add zeros right for additional taken paths
        AddZerosRight(ThisItem->GetPredVectorPtr(), FallThru_size, (Taken_size));
        ThisItem->SetPredVectorPtr(ReplicateBitsMask(ThisItem->GetPredVectorPtr(), mask_vector, Branch_size, (Taken_size + FallThru_size), PredVectorSize));
      }
      dderr ("OpId = " << ThisItem->GetOpId() << " (a FallThruBlock op)\n");
//      ThisItem->SetPredVectorPtr(new bitvector(*fallthru_vector));
//      oprd = new legoOprd;
//      oprd->SetOprdType (OT_LITERAL_I);
//      oprd->SetLiteralInteger(hyp->GetRegionId());
//      AddLcAttribute ("orig_tree_hb_id", oprd, ThisItem, proc);
    } // end for
    prevop = ThisItem;
  }  
  else {
    dderr ("adding FallThruBRU op " << FallThruBRU->GetOpId() << " to hyp. \n");
    dderr ("also adding FallThruPBRR op " << FallThruPBRR->GetOpId() << " to hyp. \n");
    dprintf((OUTF,"IfConvertTreeBranch: adding FallThruBRU op %d to hyp.\n",
             FallThruBRU->GetOpId()));

    hyp->AddItem(FallThruPBRR);
    FallThruPBRR->SetParentBlockPtr (hyp);
    
    prevop->SetNextLink (FallThruPBRR);
    FallThruPBRR->SetPrevLink (prevop);
    AddCtrlEdgeFallThruPrev = TRUE;
    fallthruprevfromop = prevop;
    fallthruprevtoop = FallThruPBRR;
    //AddEdge(prevop, FallThruPBRR, ET_CNTL);
    
    // When changing conditional branches to unconditional branches, 
    // we always want to update the predicate source (not just update 
    // for TRUE predicates as before).
    oprd = FallThruPBRR->GetPredOprdPtr();
    delete oprd;
    oprd = new legoOprd (*Fpredicate);
    FallThruPBRR->SetPredOprdPtr (oprd);
    oprd->SetParentOpPtr (FallThruPBRR);
    // Set PredVector and orig_tree_hb_id attribute
    FallThruPBRR->SetPredVectorPtr(new bitvector(*new_fallthru_vector));
    dderr ("OpId = " << FallThruPBRR->GetOpId() << " (FallThruPBRR op)\n");
//    oprd = new legoOprd;
//    oprd->SetOprdType (OT_LITERAL_I);
//    oprd->SetLiteralInteger(hyp->GetRegionId());
//    AddLcAttribute ("orig_tree_hb_id", oprd, FallThruPBRR, proc);

    hyp->AddItem(FallThruBRU);
    FallThruBRU->SetParentBlockPtr (hyp);
    
    FallThruPBRR->SetNextLink (FallThruBRU);
    FallThruBRU->SetPrevLink (FallThruPBRR);
    AddCtrlEdgeFallThruPBRR = TRUE;
    fallthrupbrrfromop = FallThruPBRR;
    fallthrupbrrtoop = FallThruBRU;
    //AddEdge(prevop, FallThruBRU, ET_CNTL);
    
    // When changing conditional branches to unconditional branches, 
    // we always want to update the predicate source (not just update 
    // for TRUE predicates as before).
    oprd = FallThruBRU->GetPredOprdPtr();
    delete oprd;
    oprd = new legoOprd (*Fpredicate);
    FallThruBRU->SetPredOprdPtr (oprd);
    oprd->SetParentOpPtr (FallThruBRU);
    // Set PredVector and orig_tree_hb_id attribute
    FallThruBRU->SetPredVectorPtr(new bitvector(*new_fallthru_vector));
    dderr ("OpId = " << FallThruBRU->GetOpId() << " (FallThruBRU op)\n");
//    oprd = new legoOprd;
//    oprd->SetOprdType (OT_LITERAL_I);
//    oprd->SetLiteralInteger(hyp->GetRegionId());
//    AddLcAttribute ("orig_tree_hb_id", oprd, FallThruBRU, proc);

    prevop = FallThruBRU;
//    AddCtrlEdge = TRUE;
  }

  // 2f. May need to fix an edge if blocks were added to an existing hyperblock
  if (!makingnewHB && (fixlinkop != NULL)) {
//    if (AddCtrlEdge == TRUE) {
      AddCtrlEdgeFix = TRUE; 
      fixfromop = prevop; 
      fixtoop = fixlinkop; 
//      AddCtrlEdge = FALSE;
//    }
    prevop->SetNextLink (fixlinkop);
    fixlinkop->SetPrevLink (prevop);    
  }
  
  // 2g. Remove BranchBlock, TakenBlock, and FallThruBlock, and insert hyp.
  region = BranchBlock->GetParentPtr();
  if (region == NULL) {
    dprintf((OUTF,"IfConvertTreeBranch: can't find parent of BranchBlock.\n"));
    return NULL;
  } // end if (for)
  if (makingnewHB) {
    i = region->Search (BranchBlock);
    // Get rid of attributes before destroying BranchBlock
    RemoveLiveAttribute (BranchBlock, proc); 
    atl = BranchBlock->GetRegionAttrListPtr();
    while (atl != NULL)
      {
        atype = atl->GetAttrType();
        if (atype != ATTR_LC)
          {
            atl = atl->GetNextListPtr(); continue;  // skip to first lc
          } // end if
        
        // Remove the first attribute here.
        a = atl->GetAttrPtr();
        RemoveLcAttribute (a->GetAttrString(), BranchBlock, proc);
        
        atl = BranchBlock->GetRegionAttrListPtr();  // reset for next scan
      } // end while
    if (i == MAX_UNSIGNED) {
      LegoNonFatal ("IfConvertTreeBranch", "Can't find BranchBlock %d in its "
                    "parent region %d.", BranchBlock->GetRegionId(),
                    region->GetRegionId());
      return NULL;
    } // end if
    if (BranchBlock == tree->GetRoot())
      tree->SetRoot(hyp);
    // Destroying BranchBlock, TakenBlock, FallThruBlock blocks seems to fuck 
    // up things such as ParentBlockPtrs of Ops. So I will 
    // just leave them as orphaned blocks now and mark them. 
    // Will skip them later
//    BranchBlock->Mark (RM_GENERAL);
    region->DestroyItem (i);
//    region->Insert (hyp, i);
    region->AddItem (hyp);
    hyp->SetParentPtr (region);
//    if (!(region->IsOwner())) delete BranchBlock;
  } // end if

  // Add required ctrl edges now that hyp belongs to proc 
  if (AddCtrlEdgeTakenPrev == TRUE) {
    AddEdge(takenprevfromop, takenprevtoop, ET_CNTL);
    AddCtrlEdgeTakenPrev = FALSE; 
  }
  if (AddCtrlEdgeTaken == TRUE) {
    AddEdge(takenfromop, takentoop, ET_CNTL);
    AddCtrlEdgeTaken = FALSE; 
  }
  if (AddCtrlEdgeFallThruPrev == TRUE) {
    AddEdge(fallthruprevfromop, fallthruprevtoop, ET_CNTL);
    AddCtrlEdgeFallThruPrev = FALSE; 
  }
  if (AddCtrlEdgeFallThruPBRR == TRUE) {
    AddEdge(fallthrupbrrfromop, fallthrupbrrtoop, ET_CNTL);
    AddCtrlEdgeFallThruPBRR = FALSE; 
  }
  if (AddCtrlEdgeFallThru == TRUE) {
    AddEdge(fallthrufromop, fallthrutoop, ET_CNTL);
    AddCtrlEdgeFallThru = FALSE; 
  }
  if (AddCtrlEdgeFix == TRUE) {
    AddEdge(fixfromop, fixtoop, ET_CNTL);
    AddCtrlEdgeFix = FALSE; 
  }

  if (TakenBlockInTree == TRUE) {
    region = TakenBlock->GetParentPtr();
    if (region == NULL) {
      LegoNonFatal ("IfConvertTreeBranch", "Can't find parent of TakenBlock %d.",
                    TakenBlock->GetRegionId());
      return NULL;
    } // end if (for)
    i = region->Search (TakenBlock);
    // Get rid of attributes before destroying TakenBlock
    RemoveLiveAttribute (TakenBlock, proc); 
    atl = TakenBlock->GetRegionAttrListPtr();
    while (atl != NULL)
      {
        atype = atl->GetAttrType();
        if (atype != ATTR_LC)
          {
            atl = atl->GetNextListPtr(); continue;  // skip to first lc
          } // end if
        
        // Remove the first attribute here.
        a = atl->GetAttrPtr();
        RemoveLcAttribute (a->GetAttrString(), TakenBlock, proc);
        
        atl = TakenBlock->GetRegionAttrListPtr();  // reset for next scan
      } // end while
    if (i == MAX_UNSIGNED) {
      LegoNonFatal ("IfConvertTreeBranch", "Can't find TakenBlock %d in its "
                    "parent region %d.", TakenBlock->GetRegionId(),
                    region->GetRegionId());
      return NULL;
    } // end if
    // Destroying BranchBlock, TakenBlock, FallThruBlock blocks seems to fuck 
    // up things such as ParentBlockPtrs of Ops. So I will 
    // just leave them as orphaned blocks now and mark them. 
    // Will skip them later
//    TakenBlock->Mark (RM_GENERAL);
    region->DestroyItem (i);
//    if (!(region->IsOwner())) delete TakenBlock;
  }
  
  if (FallThruBlockInTree == TRUE) {
    region = FallThruBlock->GetParentPtr();
    if (region == NULL) {
      LegoNonFatal ("IfConvertTreeBranch", "Can't find parent of FallThruBlock %d.",
                    FallThruBlock->GetRegionId());
      return NULL;
    } // end if (for)
    i = region->Search (FallThruBlock);
    // Get rid of attributes before destroying FallThruBlock
    RemoveLiveAttribute (FallThruBlock, proc); 
    atl = FallThruBlock->GetRegionAttrListPtr();
    while (atl != NULL)
      {
        atype = atl->GetAttrType();
        if (atype != ATTR_LC)
          {
            atl = atl->GetNextListPtr(); continue;  // skip to first lc
          } // end if
        
        // Remove the first attribute here.
        a = atl->GetAttrPtr();
        RemoveLcAttribute (a->GetAttrString(), FallThruBlock, proc);
        
        atl = FallThruBlock->GetRegionAttrListPtr();  // reset for next scan
      } // end while
    if (i == MAX_UNSIGNED) {
      LegoNonFatal ("IfConvertTreeBranch", "Can't find FallThruBlock %d in its "
                    "parent region %d.", FallThruBlock->GetRegionId(),
                    region->GetRegionId());
      return NULL;
    } // end if
    // Destroying BranchBlock, TakenBlock, FallThruBlock blocks seems to fuck 
    // up things such as ParentBlockPtrs of Ops. So I will 
    // just leave them as orphaned blocks now and mark them. 
    // Will skip them later
//    FallThruBlock->Mark (RM_GENERAL);
    region->DestroyItem (i);
//    if (!(region->IsOwner())) delete FallThruBlock;
  }
  
  // 2h. Refresh the ops/edges 
  ((legoHB *)hyp)->RefreshOps(); 
  ((legoHB *)hyp)->RefreshEdges(); 
  // Refresh tree regardless 
//  tree->RefreshAll(); 
  ((legoTreegion *)tree)->RefreshOps();
  ((legoTreegion *)tree)->RefreshEdges();
  if ((TakenBlockInTree == FALSE) &&
      (TakenBlock != BranchBlock)) {
//    TakenBlock->RefreshOpsAndEdges();
    switch (TakenBlock->GetRegionType())
      {
      case RT_BB:
        ((legoBB *) TakenBlock)->RefreshOps(); 
        ((legoBB *) TakenBlock)->RefreshEdges(); 
        break;
      case RT_SB:
        ((legoSB *) TakenBlock)->RefreshOps(); 
        ((legoSB *) TakenBlock)->RefreshEdges(); 
        break;
      case RT_HB:
        ((legoHB *) TakenBlock)->RefreshOps(); 
        ((legoHB *) TakenBlock)->RefreshEdges(); 
        break;
      default:
        LegoFatal ("IfConvertTree", "Can not determine RegionType");
      } // end switch
    // Should Refresh Parent if TakenBlock already belongs to another Treeion
    if (((legoRegion *)TakenBlock->GetParentPtr())->GetRegionType() 
        == RT_TREE) {
      ((legoTreegion *)TakenBlock->GetParentPtr())->RefreshEntryOps();
      ((legoTreegion *)TakenBlock->GetParentPtr())->RefreshEntryEdges();
    }
  }
  if ((FallThruBlockInTree == FALSE) &&
      (FallThruBlock != BranchBlock)) {
//    FallThruBlock->RefreshOpsAndEdges();
    switch (FallThruBlock->GetRegionType())
      {
      case RT_BB:
        ((legoBB *) FallThruBlock)->RefreshOps(); 
        ((legoBB *) FallThruBlock)->RefreshEdges(); 
        break;
      case RT_SB:
        ((legoSB *) FallThruBlock)->RefreshOps(); 
        ((legoSB *) FallThruBlock)->RefreshEdges(); 
        break;
      case RT_HB:
        ((legoHB *) FallThruBlock)->RefreshOps(); 
        ((legoHB *) FallThruBlock)->RefreshEdges(); 
        break;
      default:
        LegoFatal ("IfConvertTree", "Can not determine RegionType");
      } // end switch
    // Should Refresh Parent if FallThruBlock already belongs to another Treeion
    if (((legoRegion *)FallThruBlock->GetParentPtr())->GetRegionType() 
        == RT_TREE) {
      ((legoTreegion *)FallThruBlock->GetParentPtr())->RefreshEntryOps();
      ((legoTreegion *)FallThruBlock->GetParentPtr())->RefreshEntryEdges();
    }
  }
//  if (TreegionExit) {
//    tree->RefreshOpsAndEdges();
//  }

  delete Tpredicate;
  delete Fpredicate;
  delete new_true_vector;
  delete new_taken_vector;
  delete new_fallthru_vector; 
  delete mask_vector; 

  return return_prev_op;
} // end IfConvertTreeBranch



void PredicateTreeBranch (legoOp *branchop) 
{

  legoOp *predicate_op, *op; 
  legoOprd *predicate_oprd; 
  legoTreegion *tree;
  legoOprd *p1, *p2, *pX, *pTaken = NULL, *pFallThru = NULL;
  legoOprd *btroprd, *cmppoprd, *def, *use, *oprd;
  oprdList *defs, *uses;
  legoRegion *TakenBlock, *FallThruBlock; 
  legoOp *pbrrop, *cmppop;
  legoOp *duplicatecmppop; 
  attrs *attrdictionary, *attrtail, *atscan;
  attrList *atlscan;
  int eaid, count_uses, isBRCT, PBRRblock;
  int TreegionExit, TakenBlockInTree, FallThruBlockInTree;
  opList *oplist; 
  legoOprd *Tpredicate, *Fpredicate;
  legoProc *proc; 


  // Determine if branch is a Treegion exit
  tree = (legoTreegion *) FindParentRegionType(RT_TREE, branchop);
  if (tree == NULL) return; 
  TreegionExit = FALSE;
  for (oplist = tree->GetExitOpsPtr();
       oplist != NULL;
       oplist = oplist->GetNextListPtr()) {
    if ((op = oplist->GetOpPtr()) != NULL) 
      if (op == branchop) {
        TreegionExit = TRUE;
        break; 
      }
  }

  // Make sure that branch is a BRCT or BRCF op
  //if (branchop->IsBRCTOp())
  if(branchop->GetOpcode() == BRCT)
  {
      LegoNonFatal("IfConvertHammock", "BRCF is not supported yet.");      
    isBRCT = 1;
  }
  //else if (branchop->IsBRCFOp())
  else if(branchop->GetOpcode() == BRCF)
  {
      LegoNonFatal("IfConvertHammock", "BRCF is not supported yet.");
    isBRCT = 0;
  }
  else 
    return; 

  // Make sure that the branch has only two exit ops
  oplist = branchop->GetOutListPtr();
  if (oplist == NULL || oplist->GetNextListPtr() == NULL ||
      oplist->GetNextListPtr()->GetNextListPtr() != NULL)
    return;
  
  if (Chains == NULL) {
    LegoNonFatal ("PredicateTreeBranch", "Chains is NULL: call ReachingDefinitions().");
    return;
  } // end if

  // 1b. Find the target of the branch.
  btroprd = branchop->GetSrcOprdPtr(); // should be 1st source
  pbrrop = NULL;
  for (defs = Chains->GetUDChains()->Lookup (btroprd);
       (defs != NULL) && (Chains->GetUDChains()->NotFound() == FALSE);
       defs = defs->GetNextListPtr()) {
    def = defs->GetOprdPtr();
    pbrrop = def->GetParentOpPtr(); // only one PBRR op should reach
    break; 
  }

  dderr ("pbrrop OpId is: " << pbrrop->GetOpId() << "\n");
  dderr ("branchop OpId is: " << branchop->GetOpId() << "\n");
  
  if (pbrrop == NULL) {
    LegoNonFatal ("PredicateTreeBranch", "Can't find PBRR/PBRA in block.");
    return;
  } // end if

  oprd = pbrrop->GetSrcOprdPtr();
  if (oprd->GetOprdType() != OT_LITERAL_CB) {
    LegoNonFatal ("PredicateTreeBranch", "PBRR %d not to control block.",
                  pbrrop->GetOpId());
    return;
  } // end if
  
  // Find the Taken and FallThru Blocks 
  PBRRblock = oprd->GetLiteralControlBlock();
  oplist = branchop->GetOutListPtr();
  if (((legoRegion *) oplist->GetOpPtr()->GetParentBlockPtr())
      ->GetRegionId() ==  PBRRblock) {
    dderr ("oplist Valid = " << oplist->GetValid() << "\n");
    TakenBlock = (legoRegion *) oplist->GetOpPtr()->GetParentBlockPtr();
    dderr ("oplist Valid = " << oplist->GetNextListPtr()->GetValid() << "\n");
    FallThruBlock = (legoRegion *) oplist->GetNextListPtr()->GetOpPtr()->GetParentBlockPtr();
  }
  else if (((legoRegion *) oplist->GetNextListPtr()->GetOpPtr()
            ->GetParentBlockPtr())->GetRegionId() ==  PBRRblock) {
    dderr ("oplist Valid = " << oplist->GetValid() << "\n");
    FallThruBlock = (legoRegion *) oplist->GetOpPtr()->GetParentBlockPtr();
    dderr ("oplist Valid = " << oplist->GetNextListPtr()->GetValid() << "\n");
    TakenBlock = (legoRegion *) oplist->GetNextListPtr()->GetOpPtr()->GetParentBlockPtr();
  }
  else {
    LegoNonFatal ("PredicateTreeBranch", "Could not determine TakenBlock and FallThruBlock in block");
    return;
  } // end if

  dderr ("TakenBlock Id is: " << TakenBlock->GetRegionId() << "\n");  
  dderr ("FallThruBlock Id is: " << FallThruBlock->GetRegionId() << "\n");  
  
  // If TreegionExit == TRUE, determine if TakenBlock and FallThruBlock are 
  // within the Treegion (but not a loop back to Root)
  TakenBlockInTree = TRUE;
  FallThruBlockInTree = TRUE;
  if (TreegionExit == TRUE) {
    if ((tree != 
        ((legoTreegion *) FindParentRegionType(RT_TREE, TakenBlock))) ||
        (TakenBlock == tree->GetRoot())) {
      TakenBlockInTree = FALSE;
    }
    if ((tree != 
        ((legoTreegion *) FindParentRegionType(RT_TREE, FallThruBlock))) ||
        (FallThruBlock == tree->GetRoot())) {
      FallThruBlockInTree = FALSE;
    }
  }

  if ((TakenBlockInTree == FALSE) && (FallThruBlockInTree == FALSE)) 
    return; // Nothing to predicate in tree

  // Find the procedure
  proc = (legoProc *) FindParentRegionType(RT_PROC, branchop);
  if (proc == NULL) {
    dprintf((OUTF,"PredicateTreeBranch: can't find proc!\n"));
    return;    
  }
  
  // 1c. Find the predicate operands that are the destination of the CMPP.
  //     Put the first in p1, the second in p2. If the second isn't there, 
  //     take care of it.
  cmppoprd = branchop->GetSrcOprdPtr()->GetNextOprdPtr(); // 2nd source
  cmppop = NULL;
  for (defs = Chains->GetUDChains()->Lookup (cmppoprd);
       (defs != NULL) && (Chains->GetUDChains()->NotFound() == FALSE);
       defs = defs->GetNextListPtr()) {
    def = defs->GetOprdPtr();
    cmppop = def->GetParentOpPtr(); // only one CMPP op should reach
    break; 
  }
  
  dderr ("cmppop OpId is: " << cmppop->GetOpId() << "\n");

  if (cmppop == NULL) {
    LegoNonFatal ("PredicateTreeBranch", "Can't find CMPP for branch");
    return;
  } // end if

  if (cmppop->IsCMPPOp()) {
    LegoNonFatal ("PredicateTreeBranch", "Can't find CMPP for branch.");
    return;
  } // end if

  // make sure that the second D-action is a complement (odd-number opcode)
  div_t remainder = div(cmppop->GetOpcode(), 2);
  if (remainder.rem == 0) {
    cmppop->SetOpcode((cmppop->GetOpcode() + 1));
  }
  
  p1 = cmppop->GetDestOprdPtr();  // first destination!
  if (p1 == NULL || p1->GetNextOprdPtr() == NULL)
    {
      LegoNonFatal ("PredicateTreeBranch", "CMPP %d has bad destinations.",
                    cmppop->GetOpId());
      return;
    } // end if
  p2 = p1->GetNextOprdPtr();  // p2 is there always!
  if (p1->GetNextOprdPtr()->GetOprdType() != OT_UNDEFINED)
    /* do nothing - we have two predicates! */;
  else {   // Nuts, there's no second destination. 
    // We need a second destination. Scan through
    // every op in the proc to find the next predicate register that's
    // free.
    if (NextPredRegNum == 0) {  // find it
      legoOp *o;
      legoOprd *d;
      for (o = proc->GetListOpPtr(); o != NULL; o = o->GetListOpPtr()) {
        for (d = o->GetSrcOprdPtr(); d != NULL; d = d->GetNextOprdPtr())
          if (d->GetOprdType() == OT_REG &&
              //                    (d->GetOprdDataType() == DT_P ||
              //                     d->GetOprdFileType() == FT_PR) &&
              d->GetOprdRegNum() > NextPredRegNum)
            NextPredRegNum = d->GetOprdRegNum();
        
        for (d = o->GetDestOprdPtr(); d != NULL; d = d->GetNextOprdPtr())
          if (d->GetOprdType() == OT_REG &&
              //                    (d->GetOprdDataType() == DT_P ||
              //                     d->GetOprdFileType() == FT_PR) &&
              d->GetOprdRegNum() > NextPredRegNum)
            NextPredRegNum = d->GetOprdRegNum();
        
        for (d = o->GetPredOprdPtr(); d != NULL; d = d->GetNextOprdPtr())
          if (d->GetOprdType() == OT_REG &&
              //                    (d->GetOprdDataType() == DT_P ||
              //                     d->GetOprdFileType() == FT_PR) &&
              d->GetOprdRegNum() > NextPredRegNum)
            NextPredRegNum = d->GetOprdRegNum();
      } // end for
      
      NextPredRegNum++;  // next available one
      dprintf((OUTF, "PredicateTreeBranch: NextPredRegNum = %d\n",
               NextPredRegNum));
    } // end if
    
    // For hyperblocks, need to make sure that all predicates start out 
    // unique, so I will also refresh p1's number. With the lack of control
    // flow within a hyperblock control flow out can get confused when more 
    // than one CMPP uses the same prednumb (especially after scheduling). 
    // TailDuplication of CMPPs is a source for this problem. Once again, 
    // learned this one the hard way. 

    // If p1 reaches more than one branch (possible if merged due to dominator
    // parallelism) copy construct a new CMPP
    for (count_uses = 0, uses = Chains->GetDUChains()->Lookup (p1);
         (uses != NULL) && (Chains->GetDUChains()->NotFound() == FALSE);
         count_uses++, uses = uses->GetNextListPtr()) 
      use = uses->GetOprdPtr();  // just count uses
    if (count_uses > 1) { // more than one use found, copy construct CMPP
  // should update RDefs somewhere around here so that I do not need to 
  // copy construct CMPPs that now only reach one use.
      dderr ("*** This part has not been debugged yet *** count = " << count_uses << "\n");
      duplicatecmppop = new legoOp(*cmppop);
      duplicatecmppop->SetOpId(FindMaxOpId((legoProc *) proc)->GetOpId() + 1);
      // Duplicate op attributes.
      attrdictionary = proc->GetAttrDictionary();
      for (attrtail = attrdictionary; attrtail->GetNextAttrPtr() != NULL;
           attrtail = attrtail->GetNextAttrPtr()) /* do nothing */;
      eaid = FindMaxEdgeAttrId (proc);
      for (atlscan = duplicatecmppop->GetOpAttrListPtr(); atlscan != NULL;
           atlscan = atlscan->GetNextListPtr())
        {
          if (atlscan->GetAttrPtr() == NULL)
            continue;
          atscan = new attrs (*(atlscan->GetAttrPtr()), duplicatecmppop, ++eaid);
          atlscan->SetAttrPtr (atscan);
          atscan->SetAttrId (eaid);
          atlscan->SetAttrId (eaid);
          attrtail->SetNextAttrPtr (atscan);
          attrtail = attrtail->GetNextAttrPtr();
        } // end for
      // make sure to copy the hammockPredVector
      if (cmppop->GetPredVectorPtr() != NULL) {
        duplicatecmppop->SetPredVectorPtr(new bitvector(*cmppop->GetPredVectorPtr()));
      }
      
      p1 = duplicatecmppop->GetDestOprdPtr();  // first destination!
      if (p1 == NULL || p1->GetNextOprdPtr() == NULL)
        {
          LegoNonFatal ("PredicateTreeBranch", "duplicatecmppop %d has bad destinations.",
                        duplicatecmppop->GetOpId());
          return;
        } // end if
      AddMidOp (duplicatecmppop, cmppop);
      p2 = p1->GetNextOprdPtr();  // p2 is there always!
      p1->SetOprdRegNum (NextPredRegNum);
      // Need the same new number for the branch that this reaches
      branchop->GetSrcOprdPtr()->GetNextOprdPtr()->SetOprdRegNum(NextPredRegNum++);
    }
    else { // just rename p1 and the branchop that it should reach
      dderr ("A-OK: count = " << count_uses << "\n");
      dderr ("branchopId = " << branchop->GetOpId() << "\n");
      dderr ("UseOpId = " << use->GetParentOpPtr()->GetOpId() << "\n");
      p1->SetOprdRegNum (NextPredRegNum);
      // Need the same new number for the branch that this reaches
      branchop->GetSrcOprdPtr()->GetNextOprdPtr()->SetOprdRegNum(NextPredRegNum++);
    }
    
    // Make the new operand and plop it into the CMPP.
    p2->SetOprdType (p1->GetOprdType());
    p2->SetOprdRegNum (NextPredRegNum++);
    p2->SetOprdRegType (p1->GetOprdRegType());
    p2->SetOprdDataType (p1->GetOprdDataType());
    p2->SetOprdFileType (p1->GetOprdFileType());
    p2->SetOprdOmega (p1->GetOprdOmega());
    p2->SetOprdRegStyle (p1->GetOprdRegStyle());
    p2->SetIntValue (p1->GetOprdIntValue());
  } // end else

  // 1d. Figure out pTaken and pFallThru, the predicates for the 
  //     Taken Block and FallThru Block
  //          |       branch to Taken        |
  //          |                              |
  //  BRCT pX | pTaken = pX, pFallThru = !pX | 
  //          |                              |
  //  BRCF pX | pTaken = !pX, pFallThru = pX | 

  pX = branchop->GetSrcOprdPtr()->GetNextOprdPtr();
  if (pX->GetOprdRegNum() == p1->GetOprdRegNum())
    pX = p1;  // point pX to p1
  else
    pX = p2;  // point pX to p2
  
  if (isBRCT)    {
    pTaken = pX;
    pFallThru = (pTaken == p1 ? p2 : p1);
  } // end if
  else {
    pFallThru = pX;
    pTaken = (pFallThru == p1 ? p2 : p1);
  } // end else
  
  // 2a. Make new prototype predicate legoOprds based on pTaken and pFallThru
  Tpredicate = MakeDupPred (pTaken);
  Fpredicate = MakeDupPred (pFallThru);

  // Predicate ops in TakenBlock
  if (TakenBlockInTree == TRUE) {
    for (predicate_op = TakenBlock->GetEntryOpsPtr()->GetOpPtr();
         predicate_op != NULL;
         predicate_op = predicate_op->GetNextLink()) {
      
      // Don't bother with C_MERGES and branches other than BRLs
      if (predicate_op->IsCMERGEOp()) {
        continue; 
      }
      if (IsBranchOpButNotBRL(predicate_op)) {
        continue; 
      }
      
      // If already predicated, leave alone (assume already fully resolved)
      predicate_oprd = predicate_op->GetPredOprdPtr();
      int dont_change_pred = 0;
      if (predicate_oprd != NULL) {
        if (predicate_oprd->GetOprdType() != OT_LITERAL_P ||
            predicate_oprd->GetLiteralPredicate() != TRUE ) {
          dont_change_pred = 1;
        }
        else {
          delete predicate_oprd;
        }
      }
      if (!dont_change_pred) {
        predicate_oprd = new legoOprd (*Tpredicate);
        predicate_op->SetPredOprdPtr (predicate_oprd);
        predicate_oprd->SetParentOpPtr (predicate_op);
      }
    }
  }

  // Predicate ops in TallThruBlock
  if (FallThruBlockInTree == TRUE) {
    for (predicate_op = FallThruBlock->GetEntryOpsPtr()->GetOpPtr();
         predicate_op != NULL;
         predicate_op = predicate_op->GetNextLink()) {
      
      // Don't bother with C_MERGES and branches other than BRLs
      if (predicate_op->IsCMERGEOp()) {
        continue; 
      }
      if (IsBranchOpButNotBRL(predicate_op)) {
        continue; 
      }
      
      // If already predicated, leave alone (assume already fully resolved)
      predicate_oprd = predicate_op->GetPredOprdPtr();
      int dont_change_pred = 0;
      if (predicate_oprd != NULL) {
        if (predicate_oprd->GetOprdType() != OT_LITERAL_P ||
            predicate_oprd->GetLiteralPredicate() != TRUE ) {
          dont_change_pred = 1;
        }
        else {
          delete predicate_oprd;
        }
      }
      if (!dont_change_pred) {
        predicate_oprd = new legoOprd (*Fpredicate);
        predicate_op->SetPredOprdPtr (predicate_oprd);
        predicate_oprd->SetParentOpPtr (predicate_op);
      }
    }
  }

  delete Tpredicate;
  delete Fpredicate;

}


/*
 * IfConvertAndPredicateTreeBranch
 *
 * Calls IfConvertTreeBranch(legoOp *) or PredicateTreeBranch(legoOp *) 
 * for each branch in a Region
 *
 */
void IfConvertAndPredicateTreeBranch (legoRegion *region, knobs *K)
{
  legoRegion *childregion, *newregion;
  regionList *rl;
  legoOp *op, *entryop, *findblockop; 
  attrs *a;
  int mapping; 
  float accuracy; 
  int redoregion;

  region->Mark (RM_GENERAL);
  entryop = region->GetEntryOpsPtr()->GetOpPtr();
  redoregion = FALSE;

  for (op = entryop; 
       op != NULL;
       op = op->GetNextLink()) {
    if (op->IsBRCONDOp()) {
      if ( (a = FindLcAttribute( "branch_acc", op )) != NULL ) 
        accuracy = a->GetAttrOprdPtr()->GetLiteralFloat();
      else 
        accuracy = -1;
      if ( (a = FindLcAttribute( "branch_mapping", op )) != NULL ) 
        mapping = a->GetAttrOprdPtr()->GetLiteralInteger();
      else 
        mapping = -1;
      dderr ("branch mapping is " << mapping << "\n");
      dderr ("\t-- accuracy profiled to be " << accuracy << "\n");
      if ((accuracy < 0.90) && (accuracy != -1)) {
        // may need to redo a different block if new hyperblock is created
        // will use PrevLink to find new hyperblock to redo.
        // findblockop necessary because branchop (op) if removed
        //      findblockop = op->GetPrevLink();
        if ((findblockop = IfConvertTreeBranch (op, K)) != NULL) {
          redoregion = TRUE;
          break;
        }
      }
      else {
        PredicateTreeBranch (op);
      }
    }
  }

  if (redoregion) {
    dderr ("IfConvertAndPredicateTreeBranch: ReDoRegion !!\n");
    newregion = (legoRegion *) findblockop->GetParentBlockPtr();
    IfConvertAndPredicateTreeBranch (newregion, K);
  }
  else {
    for (rl = region->GetChildren();
         rl != NULL; 
         rl = rl->GetNextListPtr()) {
      childregion = rl->GetRegionPtr();
      if ((childregion != NULL) &&
          (!childregion->IsMarked(RM_GENERAL)) &&
          (FindParentRegionType(RT_TREE, childregion) == 
           FindParentRegionType(RT_TREE, region))) {
        IfConvertAndPredicateTreeBranch (childregion, K);
        // introduction of a new hyperblock may corrupt rl, redo 
        rl = region->GetChildren();
      }
    }
  }
  return; 
}


/*
 * IfConvertAndPredicateTreeBranch
 *
 * Calls IfConvertTreeBranch(legoOp *) or PredicateTreeBranch(legoOp *) 
 * for each branch in a Region
 *
 */
void IfConvertAndPredicateTreeBranch (legoTreegion *tree, knobs *K)
{
  legoRegion *treeroot;
  
  ClearMarks (RM_GENERAL, tree);
  treeroot = tree->GetRoot();
  IfConvertAndPredicateTreeBranch (treeroot, K);
  return; 
}


/*
 * FullyIfConvertTreeBranch
 *
 * Calls IfConvertTreeBranch(legoOp *) for each branch in a Region
 *
 */
void FullyIfConvertTreeBranch (legoRegion *region, knobs *K)
{
  legoRegion *childregion, *newregion;
  regionList *rl;
  legoOp *op, *entryop, *findblockop; 
  attrs *a;
  int mapping; 
  float accuracy; 
  int redoregion;

  region->Mark (RM_GENERAL);
  entryop = region->GetEntryOpsPtr()->GetOpPtr();
  redoregion = FALSE;

  for (op = entryop; 
       op != NULL;
       op = op->GetNextLink()) {
    if (op->IsBRCONDOp()) {
      // may need to redo a different block if new hyperblock is created
      // will use PrevLink to find new hyperblock to redo.
      // findblockop necessary because branchop (op) if removed
      //        findblockop = op->GetPrevLink();
      if ((findblockop = IfConvertTreeBranch (op, K)) != NULL) {
        redoregion = TRUE;
        break;
      }
    }
  }
  
  if (redoregion) {
    dderr ("FullyIfConvertTreeBranch: ReDoRegion !!\n");
    newregion = (legoRegion *) findblockop->GetParentBlockPtr();
    FullyIfConvertTreeBranch (newregion, K);
  }
  else {
    for (rl = region->GetChildren();
         rl != NULL; 
         rl = rl->GetNextListPtr()) {
      childregion = rl->GetRegionPtr();
      if ((childregion != NULL) &&
          (!childregion->IsMarked(RM_GENERAL)) &&
          (FindParentRegionType(RT_TREE, childregion) == 
           FindParentRegionType(RT_TREE, region))) {
        FullyIfConvertTreeBranch (childregion, K);
        // introduction of a new hyperblock may corrupt rl, redo 
        rl = region->GetChildren();
      }
    }
  }
  return; 
}


/*
 * FullyIfConvertTreeBranch
 *
 * Calls IfConvertTreeBranch(legoOp *) for each branch in a Region
 *
 */
void FullyIfConvertTreeBranch (legoTreegion *tree, knobs *K)
{
  legoRegion *treeroot;
  
  ClearMarks (RM_GENERAL, tree);
  treeroot = tree->GetRoot();
  FullyIfConvertTreeBranch (treeroot, K);
  return; 
}


/*
 * FullyPredicateTreeBranch
 *
 * Calls PredicateTreeBranch(legoOp *) for each branch in a Region
 *
 */
void FullyPredicateTreeBranch (legoRegion *region)
{
  legoRegion *childregion, *newregion;
  regionList *rl;
  legoOp *op, *entryop, *findblockop; 
  attrs *a;
  int mapping; 
  float accuracy; 
  int redoregion;

  region->Mark (RM_GENERAL);
  entryop = region->GetEntryOpsPtr()->GetOpPtr();
  redoregion = FALSE;

  for (op = entryop; 
       op != NULL;
       op = op->GetNextLink()) {
    if (op->IsBRCONDOp()) {
      PredicateTreeBranch (op); 
    }
  }
  
  for (rl = region->GetChildren();
       rl != NULL; 
       rl = rl->GetNextListPtr()) {
    childregion = rl->GetRegionPtr();
    if ((childregion != NULL) &&
        (!childregion->IsMarked(RM_GENERAL)) &&
        (FindParentRegionType(RT_TREE, childregion) == 
         FindParentRegionType(RT_TREE, region))) {
      FullyPredicateTreeBranch (childregion);
      // introduction of a new hyperblock may corrupt rl, redo 
      rl = region->GetChildren();
    }
  }
  
  return; 
}


/*
 * FullyPredicateTreeBranch
 *
 * Calls PredicateTreeBranch(legoOp *) for each branch in a Region
 *
 */
void FullyPredicateTreeBranch (legoTreegion *tree)
{
  legoRegion *treeroot;
  
  ClearMarks (RM_GENERAL, tree);
  treeroot = tree->GetRoot();
  FullyPredicateTreeBranch (treeroot);
  return; 
}


//===========================================================================

/*
 * DetectAndConvertHammock
 *   r = possible S region for hammock
 *   returns: result of if-conversion if successful, NULL otherwise
 *
 * Looks for a hammock at r and converts it if possible.
 */
legoRegion *DetectAndConvertHammock (legoRegion *r, knobs *K)
{
  hammock_info *h = DetectHammock (r);
  if (h->HammockDetected())
    {
      legoRegion *retval = IfConvertHammock (h, K);
      delete h;
      return retval;
    } // end if
  else
    {
      delete h;
      return NULL;
    } // end else
} // end DetectAndConvertHammock

/*
 * hammock
 *   r = region to consider for hammock conversion
 *   d = whether detection only is desired
 *   st = statistics of hammocks formed
 *   returns: 1 if hammock was found/converted, 0 otherwise
 *
 * Converts r and all contained regions to hammocks if possible. If st
 * is NULL, no statistics are logged.
 */
int
hammock (legoRegion *r, int d, knobs *K, hammock_stats *st = NULL)
{
  int i, converted;
  hammock_info *h;
  regionList *l;

#ifdef _HAMMOCK_DEBUG
  char fname[20];
#endif

  if (r->GetRegionType() == RT_PROC)
    {
#ifdef _HAMMOCK_DEBUG
      M = (legoModule *) (r->GetParentPtr());
#endif
      dprintf ((OUTF, "Hammock: in proc %s.\n",
                ((legoProc *) r)->GetProcName()));
      if (FindFlag (HAS_HB, r) != NULL ||
          FindFlag (HAS_SB, r) != NULL)
        {
          dprintf ((OUTF, "Hammock: proc contains hyperblocks or superblocks "
                    "already - aborting.\n"));
          return 0;
        } // end if
      ClearMarks (RM_GENERAL, r);
    } // end if

  if (!(IS_BLOCK(r->GetRegionType())))
    {  // r may hold blocks
      do
        {
          converted = 0;  // didn't convert anything
          for (i = 0; i < r->GetCount(); i++)
            {
              converted = hammock ((legoRegion *) r->GetItem(i), d, K, st);
              if (converted) break;  // stop after first conversion
            } // end for
#ifdef HAMMOCK_WRITE_INTERMEDIATE_REBEL
          if (converted && !d)
            {
              sprintf (fname, "h%d.el", numnum++);
              LegoWrite (M, fname);
            } // end if
#endif
                         
        } while (converted);  // if converted, restart on r since it changed

      if (r->GetRegionType() == RT_PROC) AddFlag (HAS_HB, r);
      return 0;  // in order to continue wih next container
    } // end if
  else  // it's a block ...
    {
      // A note about the use of marks here.
      // Two marks are used:
      // * RM_GENERAL: marks the S, T, and E blocks of existing hammocks.
      //   This is so subsequent detections don't use them as S blocks.
      // * RM_HAMMOCK: marks hyperblocks that are if-converted hammocks.
      //   The T and E blocks of a hammock can't be if-converted blocks
      //   themselves, since the architecture can't use multiple predicates.
      if (r->IsMarked (RM_GENERAL))  // mark => S, T, or E of existing hammock
        {
          //      r->Unmark (RM_GENERAL);
          return 0;  // shouldn't look for hammock here
        } // end if
      dprintf ((OUTF,"Hammock: analyzing block %d...", r->GetRegionId()));
      h = DetectHammock (r);
      if (h->HammockDetected() && !(h->T->IsMarked (RM_HAMMOCK)) &&
          !(h->E->IsMarked (RM_HAMMOCK)))  // can't have i-c'd T/E blocks
        {
          h->S->Mark (RM_GENERAL);  // mark S so we don't detect it agai
          h->T->Mark (RM_GENERAL);  // mark T so we don't use as S later
          if (h->IsDelta())
            dprintf ((OUTF,"found delta.\n"));
          else
            {
              dprintf ((OUTF,"found diamond.\n"));
              h->E->Mark (RM_GENERAL);  // mark E same as T
            } // end else
          if (h->S->GetRegionType() == RT_HB &&
              !(h->S->IsMarked (RM_HAMMOCK)))
            dprintf ((OUTF, "S block is code positioning SB!\n"));

          if (st != NULL)
            {
              if (h->IsDelta())
                st->numdelta++;
              else
                st->numdiamond++;
            } // end if

          if (!d)
            {
              r = IfConvertHammock (h, K);
              if (r == NULL)
                {
                  LegoFatal ("Hammock", "If-conversion failed.");
                  exit(10);
                } // end if
              delete h;
              r->Mark (RM_HAMMOCK);  // tag it
            } // end if
          return 1;  // woo-hoo! Got one!
        } // end if
      else
        {
          dprintf ((OUTF,"no hammock found.\n"));
          delete h;
          return 0;
        } // end else
    } // end else

  return 0;
} // end hammock

---