/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
**********************************************************************/

#include "exp_ovfl_ptal.h"
#include "exp_ieee.h"
#include "BigNumHelper.h"
#include "ExpPCodeOptimizations.h"

//
// Perform constant propogation across all blocks.
//
NABoolean PCodeCfg::constantPropagation(NABoolean doPeeling)
{
  NABoolean notAllVisited, restart=FALSE;

  CollIndex i;

  // Mark all blocks as unvisited
  clearVisitedFlags();

  // Algorithm:
  //
  // Visit each block after all predecesors of that block have been visited.
  // For each block, merge constants from all pred blocks coming into the block.
  // 
  do
  {
    notAllVisited = FALSE;

    FOREACH_BLOCK_REV_DFO(block, firstInst, lastInst, index)
    {
      // If the block has already been processed, continue to the next block.
      if (block->getVisitedFlag())
        continue;

      const BLOCKLIST& preds = block->getPreds();

      // The constant propagation algorithm could result in dead blocks.  If
      // we process those dead blocks, it could result in incorrect propagation
      // information.
      if ((preds.entries() == 0) && (block != entryBlock_)) {
        deleteBlock(block);
        continue;
      }

      // Declare constant vectors used for this block.
      NABitVector zeroes(heap_), ones(heap_), neg1(heap_);

      // Visit each predecessor and merge in their constants.
      for (i=0; i < preds.entries(); i++)
      {
        if (preds[i]->getVisitedFlag() == FALSE) {
          notAllVisited = TRUE;
          break;
        }

        // Declare temp constant vectors used for merging purposes.
        NABitVector tempZeroes(heap_), tempOnes(heap_), tempNeg1(heap_);

        // Initialize the temp vectors with the predecessor's constant vectors.
        tempZeroes = preds[i]->zeroesVector;
        tempOnes = preds[i]->onesVector;
        tempNeg1 = preds[i]->neg1Vector;

        // Set implicit constants derived from knowing which target a branch 
        // took. 
        preds[i]->fixupConstantVectors(block, tempZeroes, tempOnes, tempNeg1);

        // If this is the first pred, initialize the block's constant vectors
        // to that of the preds.

        if (i == 0) {
          zeroes = tempZeroes;
          ones = tempOnes;
          neg1 = tempNeg1;
          continue;
        }

        // Merge the preds constants into that of this blocks.
        PCodeConstants::mergeConstantVectors(zeroes, ones, neg1,
                                             tempZeroes, tempOnes, tempNeg1);
      }

      // Bail out if not all preds are ready..
      if (i != preds.entries())
        continue;

      // If this is the entry block, initialize this block's constant vectors
      // with the known constant's vectors of the cfg.
      if (block == entryBlock_) {
        zeroes += *zeroes_;
        ones += *ones_;
        neg1 += *neg1_;
      }

      restart = localConstantPropagation(block, zeroes, ones, neg1) || restart;

      block->setVisitedFlag(TRUE);

      // Set the block's constant vectors to the local ones used here.
      block->zeroesVector = zeroes;
      block->onesVector = ones;
      block->neg1Vector = neg1;

      if (doPeeling && block->doesBlockQualifyForShortCircuit()) {
        PCodeBlock *t1, *t2;

        CollIndex entries = zeroes.entries();

#if 0
        CollIndex j;

        printf("Block %d:\n", block->getBlockNum());

        printf("  Zeroes: ");
        j = zeroes.getLastStaleBit();
        for (; (j = zeroes.prevUsed(j)) != NULL_COLL_INDEX; j--)
        {
          PCodeOperand* operand = getMap()->getFirstValue(&j);
          operand->print();
          printf ("(%d) ", j);
        }
        printf("\n");

        printf("  Ones: ");
        j = ones.getLastStaleBit();
        for (; (j = ones.prevUsed(j)) != NULL_COLL_INDEX; j--)
        {
          PCodeOperand* operand = getMap()->getFirstValue(&j);
          operand->print();
          printf ("(%d) ", j);
        }
        printf("\n");

        printf("  Neg1: ");
        j = neg1.getLastStaleBit();
        for (; (j = neg1.prevUsed(j)) != NULL_COLL_INDEX; j--)
        {
          PCodeOperand* operand = getMap()->getFirstValue(&j);
          operand->print();
          printf ("(%d) ", j);
        }
        printf("\n");
#endif

        t1 = shortCircuitOptForBlock(block, TRUE, TRUE, zeroes, ones, neg1);

        assert (zeroes.entries() == entries);

        // If peeled block was generated, mark visited flag since known
        // constants were updated (and set) in target block.
        if (t1)
          t1->setVisitedFlag(TRUE);

        t2 = shortCircuitOptForBlock(block, FALSE, TRUE, zeroes, ones, neg1);

        // If peeled block was generated, mark visited flag since known
        // constants were updated (and set) in target block.
        if (t2)
          t2->setVisitedFlag(TRUE);

        assert (zeroes.entries() == entries);

        restart = restart || (t1 != NULL) || (t2 != NULL);
      }

    } ENDFE_BLOCK_REV_DFO
  } while (notAllVisited);

  return restart;
}


NABoolean PCodeCfg::localConstantPropagation(PCodeBlock* block,
                                             NABitVector& zeroes,
                                             NABitVector& ones,
                                             NABitVector& neg1)
{
  CollIndex i;
  PCodeOperand *operand1, *operand2;
  CollIndex bvIndex1, bvIndex2;
  PCodeInst* returnInst = NULL;
  Int32 returnValue = PCodeConstants::UNKNOWN_CONSTANT;
  Int32 constant, constant2;

  NABoolean isZero, isOne, isNeg1;
  NABoolean graphChanged = FALSE;

  // Use zeroes, ones, and neg1 to start constant propagating and optimizing
  // this basic block
  FOREACH_INST_IN_BLOCK(block, inst)
  {
    PCIT::Instruction opc = (PCIT::Instruction) inst->getOpcode();
    PCodeBinary* code = inst->code;
    NABoolean restart = TRUE;

    switch (inst->getOpcode()) {
      case PCIT::MOVE_MBIN16U_IBIN16U:
      case PCIT::MOVE_MBIN32S_IBIN32S:
      case PCIT::MOVE_MBIN8_MBIN8:
      case PCIT::MOVE_MBIN16U_MBIN16U:
      case PCIT::MOVE_MBIN32U_MBIN32U:
      case PCIT::MOVE_MBIN64S_MBIN64S:
        // These cases actually use const info regarding the write operands
        // in order to optimize.  Let them clear out the write operands
        // themselves.
        break;

      default:
      {
        // Clear out constant assumptions for all writes
        for (i=0; i < inst->getWOps().entries(); i++) {
          CollIndex bvIndex = inst->getWOps()[i]->getBvIndex();
#if 0
          // TODO: May need to fix this so that source operands not cleared
          // as well
          for (j=0; j < inst->getROps().entries(); j++) {
            if ((bvIndex == inst->getROps()[j]->getBvIndex()) &&
               (PCodeConstants::getConstantValue(bvIndex, zeroes, ones, neg1) !=
                PCodeConstants::UNKNOWN_CONSTANT))
              assert(FALSE);
          }
#endif
          // Special logical branches are created for the purposes of predicate
          // reordering.  Ignore these cases.
          if (inst->isLogicalBranch())
            if (bvIndex == inst->getROps()[0]->getBvIndex())
              continue;

          PCodeConstants::clearConstantVectors(bvIndex, zeroes, ones, neg1);
        }
      }
    }

    switch (opc)
    {
      case PCIT::MOVE_MBIN16U_IBIN16U:
      case PCIT::MOVE_MBIN32S_IBIN32S:
      {
        operand1 = inst->getWOps()[0];
        bvIndex1 = operand1->getBvIndex();
        constant = inst->code[3];

        constant2 = PCodeConstants::getConstantValue(bvIndex1, zeroes,
                                                     ones, neg1);

        // Delete moves whose constants are already known.
        if ((constant2 != PCodeConstants::UNKNOWN_CONSTANT) &&
            (constant == constant2))
        {
          block->deleteInst(inst);
          break;
        }

        // Clear out vector first since it's not done initially before switch
        PCodeConstants::clearConstantVectors(bvIndex1, zeroes, ones, neg1);

        PCodeConstants::setConstantInVectors(constant, bvIndex1,
                                             zeroes, ones, neg1);

        // Use constant operand instead for potential copy prop
        if (constant == 0) {
          PCodeInst* mv;
          if (opc == PCIT::MOVE_MBIN16U_IBIN16U)
            mv = block->insertNewInstAfter(inst, PCIT::MOVE_MBIN16U_MBIN16U);
          else
            mv = block->insertNewInstAfter(inst, PCIT::MOVE_MBIN32U_MBIN32U);

          mv->code[1] = inst->code[1];
          mv->code[2] = inst->code[2];
          mv->code[3] = 1;
          mv->code[4] = zeroOffset_;

          mv->reloadOperands(this);

          // Don't need the old NULL instruction any more.
          block->deleteInst(inst);
        }

        break;
      }

      case PCIT::NULL_VIOLATION_MBIN16U:
        operand1 = inst->getROps()[0];
        zeroes += operand1->getBvIndex();
        break;

      case PCIT::NULL_VIOLATION_MPTR32_MPTR32_IPTR_IPTR:
      case PCIT::NULL_VIOLATION_MBIN16U_MBIN16U:
      {
        operand1 = inst->getROps()[0];
        zeroes += operand1->getBvIndex();

        if ((opc != PCIT::NULL_VIOLATION_MPTR32_MPTR32_IPTR_IPTR) ||
            (GetPCodeBinaryAsPtr(inst->code, 5 + PCODEBINARIES_PER_PTR) != 0))
        {
          operand2 = inst->getROps()[1];
          zeroes += operand2->getBvIndex();
        }
        break;
      }

      case PCIT::REPLACE_NULL_MATTR3_MBIN32S:
      case PCIT::REPLACE_NULL_MATTR3_MBIN32U:
      case PCIT::REPLACE_NULL_MATTR3_MBIN16S:
      case PCIT::REPLACE_NULL_MATTR3_MBIN16U:
      {
        bvIndex2 = inst->getROps()[0]->getBvIndex();
        constant = PCodeConstants::getConstantValue(bvIndex2,zeroes,ones,neg1);
        if (constant != PCodeConstants::UNKNOWN_CONSTANT) {
          inst->code[0] = (inst->getWOps()[0]->getLen() == 2)
                             ? PCIT::MOVE_MBIN16U_MBIN16U
                             : PCIT::MOVE_MBIN32U_MBIN32U;

          if (constant == 0) {
            inst->code[3] = inst->code[6];
            inst->code[4] = inst->code[7];
          }
          else {
            inst->code[3] = inst->code[8];
            inst->code[4] = inst->code[9];
          }

          inst->reloadOperands(this);

          // For some reason the src types are MASCII - change it.
          if (inst->code[0] == PCIT::MOVE_MBIN16U_MBIN16U) {
            inst->getWOps()[0]->setType(PCIT::MBIN16U);
            inst->getROps()[0]->setType(PCIT::MBIN16U);
          }
          else {
            inst->getWOps()[0]->setType(PCIT::MBIN32U);
            inst->getROps()[0]->setType(PCIT::MBIN32U);
          }

          RESTART_INST_IN_BLOCK;
        }
        break;
      }

      case PCIT::NULL_MBIN16U:
      {
        PCodeInst* mv;

        // Propagate the known zero constant
        bvIndex1 = inst->getWOps()[0]->getBvIndex();
        PCodeConstants::setConstantInVectors(0, bvIndex1, zeroes, ones, neg1);

        // Convert NULL into MOVE of the zero constant - good for copy prop
        mv = block->insertNewInstBefore(inst, PCIT::MOVE_MBIN16U_MBIN16U);
        mv->code[1] = inst->code[1];
        mv->code[2] = inst->code[2];
        mv->code[3] = 1;
        mv->code[4] = zeroOffset_;

        mv->reloadOperands(this);

        // Don't need the old NULL instruction any more.
        block->deleteInst(inst);

        break;
      }

      case PCIT::NULL_BITMAP:
        bvIndex1 = inst->getWOps()[0]->getBvIndex();
        if (inst->code[3] == PCIT::NULL_BITMAP_SET) {
          constant = (inst->code[5]) ? -1 : 0;
          PCodeConstants::setConstantInVectors(constant, bvIndex1,
                                               zeroes, ones, neg1);
        }
        break;


      case PCIT::MOVE_MBIN32S:
        bvIndex1 = inst->getROps()[0]->getBvIndex();
        constant = PCodeConstants::getConstantValue(bvIndex1,zeroes,ones,neg1);
        if (constant != PCodeConstants::UNKNOWN_CONSTANT) {
          returnInst = inst;
          returnValue = constant;
        }
        break;

      case PCIT::RETURN:
        if (returnInst) {
          PCodeInst* ret;
          ret = block->insertNewInstBefore(inst, PCIT::RETURN_IBIN32S);
          ret->code[1] = returnValue;

          block->deleteInst(returnInst);
          block->deleteInst(inst);
        }
        break;

      case PCIT::MOVE_MBIN8_MBIN8_IBIN32S:
      {
        operand1 = inst->getROps()[0];

        switch (operand1->getLen()) {
          case 1:
            inst->code[0] = PCIT::MOVE_MBIN8_MBIN8;
            break;
          case 2:
            inst->code[0] = PCIT::MOVE_MBIN16U_MBIN16U;
            break;
          case 4:
            inst->code[0] = PCIT::MOVE_MBIN32U_MBIN32U;
            break;
          case 8:
            inst->code[0] = PCIT::MOVE_MBIN64S_MBIN64S;
            break;
        }

        if (inst->code[0] != PCIT::MOVE_MBIN8_MBIN8_IBIN32S) {
          inst->reloadOperands(this);
          RESTART_INST_IN_BLOCK;
        }
        else {
          // Just propagate the constants over
          operand2 = inst->getWOps()[0];
          PCodeConstants::copyConstantVectors(operand1->getBvIndex(),
                                              operand2->getBvIndex(),
                                              zeroes, ones, neg1);
        }

        break;
      }

      case PCIT::MOVE_MBIN8_MBIN8:
      case PCIT::MOVE_MBIN16U_MBIN16U:
      case PCIT::MOVE_MBIN32U_MBIN32U:
      case PCIT::MOVE_MBIN64S_MBIN64S:
      {
        operand1 = inst->getROps()[0];
        operand2 = inst->getWOps()[0];

        bvIndex1 = operand1->getBvIndex();
        bvIndex2 = operand2->getBvIndex();

        constant = PCodeConstants::getConstantValue(bvIndex2, zeroes,
                                                    ones, neg1);

        // Delete moves whose constants are already known.
        if ((constant != PCodeConstants::UNKNOWN_CONSTANT) &&
            (constant ==
             PCodeConstants::getConstantValue(bvIndex1, zeroes, ones, neg1)))
        {
          block->deleteInst(inst);
          break;
        }

        // Clear out vector first since it's not done initially before switch
        PCodeConstants::clearConstantVectors(bvIndex2, zeroes, ones, neg1);

        constant = PCodeConstants::copyConstantVectors(bvIndex1, bvIndex2,
                                                       zeroes, ones, neg1);

        // Let peephole take care of the rest of this.  This will allow copy
        // propagation to proceed, which may be better.
        if (operand1->isConst())
          break;

        if (constant != PCodeConstants::UNKNOWN_CONSTANT) {
          // If constant is zero, use the constant operand in order to try and
          // promote copy propagation later on
          if (constant == 0) {
            inst->code[3] = 1;
            inst->code[4] = zeroOffset_;
            inst->reloadOperands(this);
          }
          else {
            switch (opc) {
              case PCIT::MOVE_MBIN16U_MBIN16U:
                inst->code[0] = PCIT::MOVE_MBIN16U_IBIN16U;
                break;

              case PCIT::MOVE_MBIN32U_MBIN32U:
                inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
                break;

              case PCIT::MOVE_MBIN8_MBIN8:
              case PCIT::MOVE_MBIN64S_MBIN64S:
                // TODO: No IBIN equivalent yet
                break;
            }

            // If the opcode changed, update operands
            if (opc != inst->code[0]) {
              inst->code[3] = constant;
              inst->getROps().clear();
            }
          }
        }
           
        break;
      }


      case PCIT::OR_MBIN32S_MBIN32S_MBIN32S:

#if 0
        // First take advantage of the fact that all source operands into
        // logical boolean operators can *AND SHOULD* only have values 0, 1,
        // or -1. Therefore set this up first.  Note, we don't do this if we
        // know more about the operand's values than this fact alone.

        for (i=0; i < 2; i++) {
          operand1 = inst->getROps()[i];
          bvIndex1 = operand1->getBvIndex();

          // If this value truly is unknown, set it to what we do know.
          if (!PCodeConstants::isAnyKnownConstants(bvIndex1,zeroes,ones,neg1)) {
            zeroes += bvIndex1;
            ones += bvIndex1;
            neg1 += bvIndex1;
          }
        }
#endif

        for (i=0; i < 2; i++)
        {
          operand1 = inst->getROps()[i];
          operand2 = inst->getROps()[(i+1)%2];

          bvIndex1 = operand1->getBvIndex();
          bvIndex2 = operand2->getBvIndex();

          constant = PCodeConstants::getConstantValue(bvIndex1, zeroes,
                                                      ones, neg1);

          if (constant == 1) {
            inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
            inst->code[3] = constant;
            inst->getROps().clear();

            RESTART_INST_IN_BLOCK;
            break;
          }

          if (constant == 0)
          {
            inst->code[0] = PCIT::MOVE_MBIN32U_MBIN32U;
            inst->code[3] = operand2->getStackIndex();
            inst->code[4] = operand2->getOffset();

            inst->reloadOperands(this);

            RESTART_INST_IN_BLOCK;
            break;
          }

          if (constant == -1) {
            if (PCodeConstants::isAnyKnownConstant(bvIndex2, zeroes,
                                                   ones, neg1) &&
                !PCodeConstants::canBeOne(bvIndex2, ones))
            {
              inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
              inst->code[3] = -1;
              inst->getROps().clear();

              RESTART_INST_IN_BLOCK;
              break;
            }
          }
        }

        // If no change was made above, see if we can fine tune what the known
        // values of the target operand should be.
        if (inst->code[0] == PCIT::OR_MBIN32S_MBIN32S_MBIN32S) {
          bvIndex2 = inst->getWOps()[0]->getBvIndex();
          for (i=0; i < 2; i++) {
            bvIndex1 = inst->getROps()[i]->getBvIndex();

            // If src is 1 or -1, result is also 1 or -1
            if (PCodeConstants::isAnyKnownConstant(bvIndex1,zeroes,ones,neg1)&&
                !PCodeConstants::canBeZero(bvIndex1, zeroes))
            {
              ones += bvIndex2;
              neg1 += bvIndex2;
              break;
            }
          }
        }

        break;


      case PCIT::AND_MBIN32S_MBIN32S_MBIN32S:

#if 0
        // First take advantage of the fact that all source operands into
        // logical boolean operators can *AND SHOULD* only have values 0, 1,
        // or -1. Therefore set this up first.  Note, we don't do this if we
        // know more about the operand's values than this fact alone.

        for (i=0; i < 2; i++) {
          operand1 = inst->getROps()[i];
          bvIndex1 = operand1->getBvIndex();

          // If this value truly is unknown, set it to what we do know.
          if (!PCodeConstants::isAnyKnownConstants(bvIndex1,zeroes,ones,neg1)) {
            zeroes += bvIndex1;
            ones += bvIndex1;
            neg1 += bvIndex1;
          }
        }
#endif

        for (i=0; i < 2; i++)
        {
          operand1 = inst->getROps()[i];
          operand2 = inst->getROps()[(i+1)%2];

          bvIndex1 = operand1->getBvIndex();
          bvIndex2 = operand2->getBvIndex();

          isZero = zeroes.testBit(bvIndex1);
          isOne = ones.testBit(bvIndex1);
          isNeg1 = neg1.testBit(bvIndex1);

          if (isZero && !isOne && !isNeg1) {
            inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
            inst->code[3] = 0;

            inst->reloadOperands(this);

            RESTART_INST_IN_BLOCK;
            break;
          }

          // If this operand has a value of one, and the second operand is
          // known to have a value of 0, 1, or -1, result is the second 
          // operand.  Similarly, if this operand is -1 and the second
          // operand has value 0 or -1, then follow suit.

          if (((isOne && !isZero && !isNeg1) &&
              (zeroes.testBit(bvIndex2) || ones.testBit(bvIndex2) ||
               neg1.testBit(bvIndex2)))
              ||
              ((isNeg1 && !isZero && !isOne) &&
               (zeroes.testBit(bvIndex2) && neg1.testBit(bvIndex2) &&
                !ones.testBit(bvIndex2))))
          {
            inst->code[0] = PCIT::MOVE_MBIN32U_MBIN32U;
            inst->code[3] = operand2->getStackIndex();
            inst->code[4] = operand2->getOffset();

            inst->reloadOperands(this);

            RESTART_INST_IN_BLOCK;
            break;
          }

          // If this operand is -1, and the second operand is either -1
          // or one, the result is -1

          if ((isNeg1 && !isZero && !isOne) &&
               ((neg1.testBit(bvIndex2) || (ones.testBit(bvIndex2))) &&
                !zeroes.testBit(bvIndex2)))
          {
            inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
            inst->code[3] = -1;

            inst->reloadOperands(this);

            RESTART_INST_IN_BLOCK;
            break;
          }
        }

        // If no change was made above, see if we can fine tune what the known
        // values of the target operand should be.
        if (inst->code[0] == PCIT::AND_MBIN32S_MBIN32S_MBIN32S) {
          bvIndex2 = inst->getWOps()[0]->getBvIndex();
          for (i=0; i < 2; i++) {
            bvIndex1 = inst->getROps()[i]->getBvIndex();

            // If src is 0 or -1, result is also 0 or -1
            if (PCodeConstants::isAnyKnownConstant(bvIndex1,zeroes,ones,neg1)&&
                !PCodeConstants::canBeOne(bvIndex1, ones))
            {
              zeroes += bvIndex2;
              neg1 += bvIndex2;
              break;
            }
          }
        }

        break;

          case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN32S_MBIN32S:
          case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN64S:
          case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN32S:
          case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MFLT64_MFLT64:
          case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIGS_MBIGS_IBIN32S:
          {
            // Look for the null indicator used in this PCODE instruction and
            // see if we know it to be NULL.  If so, then this instruction
            // doesn't get invoked, and therefore we can remove it.
            for (i=0; i < inst->getROps().entries(); i++) {
              if (((inst->getROps()[i]->getStackIndexPos() == 2) &&
                   (inst->getROps()[i]->getOffsetPos() == 3)) ||
                  ((inst->getROps()[i]->getStackIndexPos() == 3) &&
                   (inst->getROps()[i]->getOffsetPos() == 4)))
              {
                bvIndex1 = inst->getROps()[i]->getBvIndex();
                constant = PCodeConstants::getConstantValue(bvIndex1,
                                                            zeroes,ones,neg1);

                if (constant == -1)
                  block->deleteInst(inst);

                break;
              }
            }
            break;
          }

          case PCIT::CLAUSE_EVAL:
          {
            ex_clause* clause = (ex_clause*)*(Long*)&(inst->code[1]);
            if ((clause->getType() == ex_clause::FUNCTION_TYPE) &&
                (clause->getClassID() == ex_clause::FUNC_RAISE_ERROR_ID) &&
                (((ExpRaiseErrorFunction*)clause)->raiseError()))
            {
              // Create a RETURN instruction after the clause, and then fix
              // up the block so as to remove trailing instrs in the block,
              // *IF* a RETURN isn't already there.

              if (!inst->next || !(inst->next->getOpcode() == PCIT::RETURN)) {
                inst = block->insertNewInstAfter(inst, PCIT::RETURN);
                block->setLastInst(inst);
                inst->next = NULL;
                while (block->getSuccs().entries())
                  block->removeEdge(block->getSuccs()[0]);


                RESTART_INST_IN_BLOCK;
              }
            }

            if (clause->getClassID() == ex_clause::AGGR_MIN_MAX_ID) {
              // Get the previous opdata.  It represents the condition for
              // which the min/max will be performed or not.  If not, then the
              // entire CLAUSE_EVAL sequence can be deleted.
              PCodeInst* opComp = inst->prev;
              bvIndex2 = opComp->getROps()[0]->getBvIndex();

              constant = PCodeConstants::getConstantValue(bvIndex2, zeroes,
                                                          ones, neg1);
              if (constant == 0) {
                // Delete clause-eval instruction
                block->deleteInst(inst);
              }
            }
            break;
          }

          case PCIT::OPDATA_MPTR32_IBIN32S_IBIN32S:
          case PCIT::OPDATA_MPTR32_IBIN32S:
          case PCIT::OPDATA_MBIN16U_IBIN32S:
          case PCIT::OPDATA_MATTR5_IBIN32S:
            if (inst->getWOps().entries()) {
              PCodeInst* tInst = NULL;
              ex_clause* clause = NULL;

              // Use for identifying read operands
              operand1 = NULL;
              operand2 = NULL;

              // Find the clause eval associated with this opdata and set
              // read operands along the way.
              for (tInst = inst->next;
                   tInst->getOpcode() != PCIT::CLAUSE_EVAL;
                   tInst = tInst->next)
              {
                if (tInst->getROps().entries()) {
                  if (operand1 == NULL)
                    operand1 = tInst->getROps()[0];
                  else
                    operand2 = tInst->getROps()[0];
                }
              }

              assert (tInst->block == block);

              // We can determine the constants of some clauses
              clause = (ex_clause*)*(Long*)&(tInst->code[1]);
              switch (clause->getType())
              {
                case ex_clause::UN_LOGIC_TYPE:
                  // Get read and write operands
                  bvIndex1 = operand1->getBvIndex();
                  bvIndex2 = inst->getWOps()[0]->getBvIndex();

                  constant = PCodeConstants::getConstantValue(bvIndex1, zeroes,
                                                              ones, neg1);

                  if (constant != PCodeConstants::UNKNOWN_CONSTANT) {

                    constant2 = PCodeConstants::UNKNOWN_CONSTANT;

                    switch (clause->getOperType()) {
                      case ITM_IS_UNKNOWN:
                        constant2 = (constant == -1) ? 1 : 0;
                        break;

                      case ITM_IS_NOT_UNKNOWN:
                        constant2 = (constant != -1) ? 1 : 0;
                        break;

                      case ITM_IS_TRUE:
                        constant2 = (constant == 1) ? 1 : 0;
                        break;

                      case ITM_IS_FALSE:
                        constant2 = (constant == 0) ? 1 : 0;
                        break;

                      case ITM_NOT:
                        if (constant == 1)
                          constant2 = 0;
                        else if (constant == 0)
                          constant2 = 1;
                        else
                          constant2 = -1;
                        break;

                      default:
                        break;
                    }

                    if (constant2 != PCodeConstants::UNKNOWN_CONSTANT) {
                      PCodeInst* move =
                        block->insertNewInstAfter(tInst,
                                                  PCIT::MOVE_MBIN32S_IBIN32S);
                      move->code[1] = inst->getWOps()[0]->getStackIndex();
                      move->code[2] = inst->getWOps()[0]->getOffset();
                      move->code[3] = constant2;

                      move->reloadOperands(this);

                      // Delete clause-eval instruction
                      block->deleteInst(tInst);

                      //PCodeConstants::setConstantInVectors(constant2,bvIndex2,
                                                         //zeroes, ones, neg1);

                      // In order to restart inst, inst needs to be assigned
                      // new move instruction, since inst was deleted
                      inst = move;
                      RESTART_INST_IN_BLOCK;

                      break;
                    }
                  }
                  else if (clause->getOperType() == ITM_NOT) {
                    if (PCodeConstants::canBeZero(bvIndex1, zeroes) &&
                        PCodeConstants::canBeOne(bvIndex1, ones) &&
                        !PCodeConstants::canBeNeg1(bvIndex1, neg1))
                    {
                      // Clause can be replaced with simple compare inst
                      PCodeInst* cmp =
                        block->insertNewInstAfter(tInst,
                                   PCIT::EQ_MBIN32S_MBIN32S_MBIN32S);

                      cmp->code[1] = inst->getWOps()[0]->getStackIndex();
                      cmp->code[2] = inst->getWOps()[0]->getOffset();
                      cmp->code[3] = operand1->getStackIndex();
                      cmp->code[4] = operand1->getOffset();
                      cmp->code[5] = 1;
                      cmp->code[6] = zeroOffset_;

                      cmp->reloadOperands(this);

                      // Delete clause-eval instruction
                      block->deleteInst(tInst);

                      inst = cmp;
                      RESTART_INST_IN_BLOCK;

                      break;
                    }
                    else
                      // Result can be -1
                      neg1 += bvIndex2;
                  }

                  // All UN_LOGIC clauses will return 0 or 1
                  zeroes += bvIndex2;
                  ones += bvIndex2;

                  break;

                case ex_clause::LIKE_TYPE:
                case ex_clause::LIKE_CLAUSE_CHAR_ID:
                case ex_clause::COMP_TYPE:
                  bvIndex2 = inst->getWOps()[0]->getBvIndex();
                  zeroes += bvIndex2;
                  ones += bvIndex2;

                  // If this clause processes nulls, we have to assume -1 can
                  // be returned - uggh.
                  if (tInst->code[1 + PCODEBINARIES_PER_PTR] & 1)
                    neg1 += bvIndex2;
                  break;

                case ex_clause::BOOL_TYPE:
                  assert(FALSE);
                  break;

                case ex_clause::FUNCTION_TYPE:
                  switch (clause->getClassID()) {
                    case ex_clause::FUNC_GET_BIT_VALUE_AT_ID:
                      bvIndex2 = inst->getWOps()[0]->getBvIndex();
                      zeroes += bvIndex2;
                      ones += bvIndex2;
                      break;
                  }
                  break;
              }
            }

            break;

     
          case PCIT::NULL_TEST_MBIN32S_MATTR5_IBIN32S_IBIN32S:
            // TODO: Indirect varchars are not supported right now
            if (inst->code[8] == 1) {
              bvIndex1 = inst->getWOps()[0]->getBvIndex();
              zeroes += bvIndex1;
              ones += bvIndex1;
              break;
            }
            // Otherwise non-indirect varchar, so fall-through

          case PCIT::NULL_TEST_MBIN32S_MBIN16U_IBIN32S:
          {
            bvIndex2= inst->getROps()[0]->getBvIndex();
            constant = PCodeConstants::getConstantValue(bvIndex2, zeroes,
                                                        ones, neg1);

            if (constant != PCodeConstants::UNKNOWN_CONSTANT) {
              Int32 val = 0;

              switch (opc) {
                case PCIT::NULL_TEST_MBIN32S_MBIN16U_IBIN32S:
                  val = inst->code[5];
                  break;

                case PCIT::NULL_TEST_MBIN32S_MATTR5_IBIN32S_IBIN32S:
                  val = inst->code[9];
                  break;
              }

              assert((val == 0) || (val == -1));

              inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
              inst->code[3] = (constant == val) ? 1 : 0;

              inst->getROps().clear();

              RESTART_INST_IN_BLOCK;
              break;
            }

            bvIndex1 = inst->getWOps()[0]->getBvIndex();
            zeroes += bvIndex1;
            ones += bvIndex1;

            break;
          }


          case PCIT::ZERO_MBIN32S_MBIN32U:
          case PCIT::NOTZERO_MBIN32S_MBIN32U:

          case PCIT::EQ_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::NE_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::LT_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::GT_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::LE_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::GE_MBIN32S_MBIN16S_MBIN16S:

          case PCIT::EQ_MBIN32S_MBIN16S_MBIN32S:
          case PCIT::LT_MBIN32S_MBIN16S_MBIN32S:
          case PCIT::GT_MBIN32S_MBIN16S_MBIN32S:
          case PCIT::LE_MBIN32S_MBIN16S_MBIN32S:
          case PCIT::GE_MBIN32S_MBIN16S_MBIN32S:

          case PCIT::EQ_MBIN32S_MBIN32S_MBIN32S:
          case PCIT::LT_MBIN32S_MBIN32S_MBIN32S:
          case PCIT::GT_MBIN32S_MBIN32S_MBIN32S:
          case PCIT::LE_MBIN32S_MBIN32S_MBIN32S:
          case PCIT::GE_MBIN32S_MBIN32S_MBIN32S:

          case PCIT::EQ_MBIN32S_MBIN16U_MBIN16U:
          case PCIT::LT_MBIN32S_MBIN16U_MBIN16U:
          case PCIT::GT_MBIN32S_MBIN16U_MBIN16U:
          case PCIT::LE_MBIN32S_MBIN16U_MBIN16U:
          case PCIT::GE_MBIN32S_MBIN16U_MBIN16U:

          case PCIT::EQ_MBIN32S_MBIN16U_MBIN32U:
          case PCIT::LT_MBIN32S_MBIN16U_MBIN32U:
          case PCIT::GT_MBIN32S_MBIN16U_MBIN32U:
          case PCIT::LE_MBIN32S_MBIN16U_MBIN32U:
          case PCIT::GE_MBIN32S_MBIN16U_MBIN32U:

          case PCIT::EQ_MBIN32S_MBIN32U_MBIN32U:
          case PCIT::LT_MBIN32S_MBIN32U_MBIN32U:
          case PCIT::GT_MBIN32S_MBIN32U_MBIN32U:
          case PCIT::LE_MBIN32S_MBIN32U_MBIN32U:
          case PCIT::GE_MBIN32S_MBIN32U_MBIN32U:

          case PCIT::EQ_MBIN32S_MBIN16S_MBIN32U:
          case PCIT::LT_MBIN32S_MBIN16S_MBIN32U:
          case PCIT::GT_MBIN32S_MBIN16S_MBIN32U:
          case PCIT::LE_MBIN32S_MBIN16S_MBIN32U:
          case PCIT::GE_MBIN32S_MBIN16S_MBIN32U:

          case PCIT::EQ_MBIN32S_MBIN16U_MBIN16S:
          case PCIT::LT_MBIN32S_MBIN16U_MBIN16S:
          case PCIT::GT_MBIN32S_MBIN16U_MBIN16S:
          case PCIT::LE_MBIN32S_MBIN16U_MBIN16S:
          case PCIT::GE_MBIN32S_MBIN16U_MBIN16S:

          case PCIT::NE_MBIN32S_MBIN64S_MBIN64S:
          case PCIT::EQ_MBIN32S_MBIN64S_MBIN64S:
          case PCIT::LT_MBIN32S_MBIN64S_MBIN64S:
          case PCIT::GT_MBIN32S_MBIN64S_MBIN64S:
          case PCIT::LE_MBIN32S_MBIN64S_MBIN64S:
          case PCIT::GE_MBIN32S_MBIN64S_MBIN64S:

          case PCIT::NE_MBIN32S_MASCII_MASCII:
          case PCIT::EQ_MBIN32S_MASCII_MASCII:
          case PCIT::LT_MBIN32S_MASCII_MASCII:
          case PCIT::GT_MBIN32S_MASCII_MASCII:
          case PCIT::LE_MBIN32S_MASCII_MASCII:
          case PCIT::GE_MBIN32S_MASCII_MASCII:

          case PCIT::NE_MBIN32S_MFLT64_MFLT64:
          case PCIT::EQ_MBIN32S_MFLT64_MFLT64:
          case PCIT::LT_MBIN32S_MFLT64_MFLT64:
          case PCIT::GT_MBIN32S_MFLT64_MFLT64:
          case PCIT::LE_MBIN32S_MFLT64_MFLT64:
          case PCIT::GE_MBIN32S_MFLT64_MFLT64:

          case PCIT::NE_MBIN32S_MFLT32_MFLT32:
          case PCIT::EQ_MBIN32S_MFLT32_MFLT32:
          case PCIT::LT_MBIN32S_MFLT32_MFLT32:
          case PCIT::GT_MBIN32S_MFLT32_MFLT32: 
          case PCIT::LE_MBIN32S_MFLT32_MFLT32:
          case PCIT::GE_MBIN32S_MFLT32_MFLT32:

          case PCIT::COMP_MBIN32S_MUNIV_MUNIV_IBIN32S:
          case PCIT::COMP_MBIN32S_MATTR5_MATTR5_IBIN32S:
          case PCIT::COMP_MBIN32S_MUNI_MUNI_IBIN32S_IBIN32S_IBIN32S:
          case PCIT::COMP_MBIN32S_MBIGS_MBIGS_IBIN32S_IBIN32S:
          case PCIT::COMP_MBIN32S_MASCII_MASCII_IBIN32S_IBIN32S_IBIN32S:

          case PCIT::LIKE_MBIN32S_MATTR5_MATTR5_IBIN32S_IBIN32S:
          {
            bvIndex2 = inst->getWOps()[0]->getBvIndex();
            zeroes += bvIndex2;
            ones += bvIndex2;

            break;
          }

          case PCIT::SWITCH_MBIN32S_MBIN64S_MPTR32_IBIN32S_IBIN32S:
          case PCIT::SWITCH_MBIN32S_MATTR5_MPTR32_IBIN32S_IBIN32S:
          {
            // If for IN-lists, result can only be 0 or 1.
            if (inst->isInListSwitch()) {
              bvIndex2 = inst->getWOps()[0]->getBvIndex();
              zeroes += bvIndex2;
              ones += bvIndex2;
            }
            break;
          }

      case PCIT::NNB_MBIN32S_MATTR3_IBIN32S_IBIN32S:
      {
        PCodeInst* mv;
        PCodeBlock* fallThrough = block->getSuccs()[0];

        // Add move to fall-through
        mv = fallThrough->insertNewInstBefore(NULL, PCIT::MOVE_MBIN32S_IBIN32S);
        mv->code[1] = inst->getWOps()[0]->getStackIndex();
        mv->code[2] = inst->getWOps()[0]->getOffset();
        mv->code[3] = inst->code[6];
        mv->reloadOperands(this);

        // Rewrite branch to not have write operand
        inst->code[0] = PCIT::NNB_MATTR3_IBIN32S;
        inst->code[1] = inst->getROps()[0]->getStackIndex();
        inst->code[2] = inst->getROps()[0]->getOffset();
        inst->code[3] = inst->getROps()[0]->getNullBitIndex();
        inst->reloadOperands(this);

        RESTART_INST_IN_BLOCK;
        break;
      }

      case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN16S_IBIN32S_IBIN32S:
      {
        PCodeInst* mv;
        PCodeBlock* fallThrough = block->getSuccs()[0];

        // Add move to fall-through
        mv = fallThrough->insertNewInstBefore(NULL, PCIT::MOVE_MBIN32S_IBIN32S);
        mv->code[1] = inst->getWOps()[0]->getStackIndex();
        mv->code[2] = inst->getWOps()[0]->getOffset();
        mv->code[3] = inst->code[5];
        mv->reloadOperands(this);

        // Rewrite branch to not have write operand
        inst->code[0] = PCIT::NOT_NULL_BRANCH_MBIN16S_IBIN32S;
        inst->code[1] = inst->getROps()[0]->getStackIndex();
        inst->code[2] = inst->getROps()[0]->getOffset();
        inst->reloadOperands(this);

        RESTART_INST_IN_BLOCK;
        break;
      }

      case PCIT::NNB_MATTR3_IBIN32S:
      case PCIT::NOT_NULL_BRANCH_MBIN16S_IBIN32S:
      {
        bvIndex1 = inst->getROps()[0]->getBvIndex();
        constant = PCodeConstants::getConstantValue(bvIndex1, zeroes,
                                                    ones, neg1);

        if (constant != PCodeConstants::UNKNOWN_CONSTANT) {
          if (constant == 0) {
            inst->code[0] = PCIT::BRANCH;
            inst->getROps().clear();
            block->removeEdge(block->getFallThroughBlock());
            break;
          }
          else {
            block->removeEdge(block->getTargetBlock());
            block->deleteInst(inst);
          }

          graphChanged = TRUE; // CFG was modifed
        }

        // Otherwise we can at least propagate what we do know
        zeroes += bvIndex1;
        neg1 += bvIndex1;
        break;
      }

      case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_IATTR3_IBIN32S:
      {
        operand1 = inst->getWOps()[0];
        bvIndex1 = operand1->getBvIndex();
        bvIndex2 = inst->getROps()[0]->getBvIndex();
        constant = PCodeConstants::getConstantValue(bvIndex2, zeroes,
                                                    ones, neg1);

        // Constants must be known, *and* target can't be indirect varchar
        if (((constant == -1) || (constant == 0)) &&
            (operand1->getOffset() >= 0))

        {
          if (!operand1->forAlignedFormat()) {
            inst->code[0] = PCIT::MOVE_MBIN16U_IBIN16U;
            inst->code[3] = (constant == 0) ? 0 : -1;
          }
          else {
            inst->code[0] = PCIT::NULL_BITMAP;
            inst->code[3] = PCIT::NULL_BITMAP_SET;
            inst->code[4] = operand1->getNullBitIndex();
            inst->code[5] = (constant == 0) ? 0 : 1;
          }

          if (constant == 0) {
            block->insertNewInstAfter(inst, PCIT::BRANCH);
            block->removeEdge(block->getFallThroughBlock());
          }
          else {
            block->removeEdge(block->getTargetBlock());
          }

          graphChanged = TRUE; // CFG was modifed

          inst->reloadOperands(this);

          RESTART_INST_IN_BLOCK;
          break;
        }

        zeroes += bvIndex1;
        neg1 += bvIndex1;
        break;
      }

      case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
      {
        operand1 = inst->getWOps()[0];

        constant = PCodeConstants::getConstantValue(
              inst->getROps()[0]->getBvIndex(), zeroes, ones, neg1);

        constant2 = PCodeConstants::getConstantValue(
              inst->getROps()[1]->getBvIndex(), zeroes, ones, neg1);

        NABoolean isNull = ((constant == -1) || (constant2 == -1));
        NABoolean isNotNull = ((constant == 0) && (constant2 == 0));

        //TODO: add case where if either constant or constant2 is 0, then
        //reduce NNBB branch to shorter form.

        // Constants must be known, *and* target can't be indirect varchar
        if ((isNull || isNotNull) && (operand1->getOffset() >= 0))
        {
          if (!operand1->forAlignedFormat()) {
            inst->code[0] = PCIT::MOVE_MBIN16U_IBIN16U;
            inst->code[3] = (isNull) ? -1 : 0;
          }
          else {
            inst->code[0] = PCIT::NULL_BITMAP;
            inst->code[3] = PCIT::NULL_BITMAP_SET;
            inst->code[4] = operand1->getNullBitIndex();
            inst->code[5] = (isNull) ? 1 : 0;
          }

          if (isNotNull) {
            block->insertNewInstAfter(inst, PCIT::BRANCH);
            block->removeEdge(block->getFallThroughBlock());
          }
          else {
            block->removeEdge(block->getTargetBlock());
          }

          graphChanged = TRUE; // CFG was modifed

          inst->reloadOperands(this);

          RESTART_INST_IN_BLOCK;
          break;
        }
        else if ((constant == 0) || (constant2 == 0))
        {
        }

        bvIndex1 = operand1->getBvIndex();
        zeroes += bvIndex1;
        neg1 += bvIndex1;
        break;
      }

      case PCIT::NNB_SPECIAL_NULLS_MBIN32S_MATTR3_MATTR3_IBIN32S_IBIN32S:
      {
        // Go through each read operand.
        for (i=0; i < 2; i++) {
          operand2 = inst->getROps()[i];
          bvIndex2 = inst->getROps()[i]->getBvIndex();
          constant = PCodeConstants::getConstantValue(bvIndex2, zeroes,
                                                      ones, neg1);

          if (constant != PCodeConstants::UNKNOWN_CONSTANT) {
            if (constant == 0) {
              // Get constant of second operand
              constant = PCodeConstants::getConstantValue(
                           inst->getROps()[(i+1)%2]->getBvIndex(), 
                           zeroes, ones, neg1);

              if (constant != 0)
                continue;

              // Both operands are zero
              inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
              inst->code[3] = 0;

              inst->reloadOperands(this);

              block->insertNewInstAfter(inst, PCIT::BRANCH);
              block->removeEdge(block->getFallThroughBlock());
            }
            else {
              assert (constant == -1);

              PCodeInst* newInst;
              PCodeOperand* op = (i == 0) ? inst->getROps()[1]
                                          : inst->getROps()[0];
 
              newInst = block->insertNewInstBefore(inst,
                          PCIT::NULL_TEST_MBIN32S_MATTR5_IBIN32S_IBIN32S);
              newInst->code[1] = inst->code[1];
              newInst->code[2] = inst->code[2];
              newInst->code[3] = op->getStackIndex();
              newInst->code[4] = op->getOffset();
              newInst->code[5] = -1; // voa that's unnecessary.
              newInst->code[6] = (op->forAlignedFormat())
                                   ? ExpTupleDesc::SQLMX_ALIGNED_FORMAT
                                   : ExpTupleDesc::SQLARK_EXPLODED_FORMAT;
              newInst->code[7] = op->getNullBitIndex();
              newInst->code[8] = 0;  // No voa lookup needed.
              newInst->code[9] = -1; // Test for NULL

              newInst->reloadOperands(this);

              block->deleteInst(inst);
              inst = newInst;

//              inst->code[0] = PCIT::EQ_MBIN32S_MBIN16S_MBIN16S;

              block->removeEdge(block->getTargetBlock());
            }

            graphChanged = TRUE; // CFG was modifed

            RESTART_INST_IN_BLOCK;
            break;
          }
        }

        bvIndex1 = inst->getWOps()[0]->getBvIndex();
        zeroes += bvIndex1;
        ones += bvIndex1;
        break;
      }


      case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S:
      case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN16S_IBIN32S:
      case PCIT::NOT_NULL_BRANCH_MBIN16S_MBIN16S_IBIN32S:
      {
        operand1 = inst->getROps()[0];
        operand2 = inst->getWOps()[0];

        bvIndex1 = operand1->getBvIndex();
        bvIndex2 = operand2->getBvIndex();

        constant = PCodeConstants::getConstantValue(bvIndex1, zeroes,
                                                    ones, neg1);

        if (constant != PCodeConstants::UNKNOWN_CONSTANT) {
          switch(opc) {
            case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S:
            case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN16S_IBIN32S:
              inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
              break;

            case PCIT::NOT_NULL_BRANCH_MBIN16S_MBIN16S_IBIN32S:
              inst->code[0] = PCIT::MOVE_MBIN16U_IBIN16U;
              break;
          }

          inst->code[1] = operand2->getStackIndex();
          inst->code[2] = operand2->getOffset();
          inst->code[3] = constant;

          inst->reloadOperands(this);

          if (constant == 0) {
            block->insertNewInstAfter(inst, PCIT::BRANCH);
            block->removeEdge(block->getFallThroughBlock());
          }
          else {
            block->removeEdge(block->getTargetBlock());
          }

          graphChanged = TRUE; // CFG was modifed

          RESTART_INST_IN_BLOCK;
          continue;
        }

        zeroes += bvIndex1;
        neg1 += bvIndex1;

        zeroes += bvIndex2;
        neg1 += bvIndex2;
        break;
      }

      case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
        operand1 = inst->getWOps()[0];
        bvIndex1 = operand1->getBvIndex();

        for (i=0; i < 2; i++) {
          operand2 = inst->getROps()[i];
          bvIndex2 = operand2->getBvIndex();
          constant = PCodeConstants::getConstantValue(bvIndex2, zeroes,
                                                      ones, neg1);

          if (constant != PCodeConstants::UNKNOWN_CONSTANT) {
              inst->code[0] =
                PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S;

              if (constant == -1) {
                inst->code[3] = operand2->getStackIndex();
                inst->code[4] = operand2->getOffset();
                inst->code[5] = inst->code[7];

                PCodeAttrNull * newAttr = (PCodeAttrNull *)&(inst->code[5]);
                PCodeAttrNull * oldAttr = (PCodeAttrNull *)&(inst->code[7]);

                // New size is 3 less since we're getting rid of 1 source op,
                // which is made up of index and offset, and 1 null bit index,
                // which corresponds to that source.
                newAttr->fmt_.size_ = oldAttr->fmt_.size_ - 3;
 
                // If src is second operand, need to set format correctly.
                // Otherwise it, along with target, are already set right.
                if (i == 1)
                  newAttr->fmt_.op2Fmt_ = oldAttr->fmt_.op3Fmt_;

                inst->code[6] = operand1->getNullBitIndex();
                inst->code[7] = operand2->getNullBitIndex();
                
              }
              else {
                inst->code[3] = inst->getROps()[(i+1)%2]->getStackIndex();
                inst->code[4] = inst->getROps()[(i+1)%2]->getOffset();
                inst->code[5] = inst->code[7];

                PCodeAttrNull * newAttr = (PCodeAttrNull *)&(inst->code[5]);
                PCodeAttrNull * oldAttr = (PCodeAttrNull *)&(inst->code[7]);

                // New size is 2 less since we're getting rid of 1 source op
                // which is made up of index and offset.
                newAttr->fmt_.size_ = oldAttr->fmt_.size_ - 3;
 
                // If src is first operand, need to get format of 2nd op
                // Otherwise it, along with target, are already set right.
                if (i == 0)
                  newAttr->fmt_.op2Fmt_ = oldAttr->fmt_.op3Fmt_;

                inst->code[6] = operand1->getNullBitIndex();
                inst->code[7] = inst->getROps()[(i+1)%2]->getNullBitIndex();
              }

            inst->reloadOperands(this);

            RESTART_INST_IN_BLOCK;
            break;
          }
        }

        zeroes += bvIndex1;
        neg1 += bvIndex1;

        break;


          case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN16S_MBIN16S_IBIN32S:
          case PCIT::NOT_NULL_BRANCH_MBIN16S_MBIN16S_MBIN16S_IBIN32S:
            operand1 = inst->getWOps()[0];
            bvIndex1 = operand1->getBvIndex();

            for (i=0; i < 2; i++) {
              operand2 = inst->getROps()[i];
              bvIndex2 = operand2->getBvIndex();
              constant = PCodeConstants::getConstantValue(bvIndex2, zeroes,
                                                          ones, neg1);

              if ((constant == -1) || (constant == 0)) {
                if (opc==PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN16S_MBIN16S_IBIN32S)
                  inst->code[0] = PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN16S_IBIN32S;
                else
                  inst->code[0] = PCIT::NOT_NULL_BRANCH_MBIN16S_MBIN16S_IBIN32S;

                if (constant == 0) {
                  inst->code[3] = inst->getROps()[(i+1)%2]->getStackIndex();
                  inst->code[4] = inst->getROps()[(i+1)%2]->getOffset();
                }
                else {
                  inst->code[3] = operand2->getStackIndex();
                  inst->code[4] = operand2->getOffset();
                }
                inst->code[5] = inst->code[7];

                inst->reloadOperands(this);

                // No need to change anything else since retrying the new
                // instruction will end up removing this instruction.

                RESTART_INST_IN_BLOCK;
                break;
              }
            }

            zeroes += bvIndex1;
            neg1 += bvIndex1;

            break;

          case PCIT::NULL_BITMAP_BULK:
          case PCIT::NOT_NULL_BRANCH_BULK:
            for (i=0; i < inst->getROps().entries(); i++) {
              bvIndex2 = inst->getROps()[i]->getBvIndex();
              zeroes += bvIndex2;
              neg1 += bvIndex2;
            }
            break;

          case PCIT::BRANCH_OR:
          case PCIT::BRANCH_AND:
          {
            operand1 = inst->getROps()[0];
            operand2 = inst->getWOps()[0];

            bvIndex1 = operand1->getBvIndex();
            bvIndex2 = operand2->getBvIndex();

            constant = PCodeConstants::getConstantValue(bvIndex1, zeroes,
                                                        ones, neg1);

            if (constant != PCodeConstants::UNKNOWN_CONSTANT) {
              inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
              inst->code[1] = operand2->getStackIndex();
              inst->code[2] = operand2->getOffset();
              inst->code[3] = constant;

              inst->reloadOperands(this);

              if (((opc == PCIT::BRANCH_OR) && (constant == 1)) ||
                  ((opc == PCIT::BRANCH_AND) && (constant == 0)))
              {
                block->insertNewInstAfter(inst, PCIT::BRANCH);
                block->removeEdge(block->getFallThroughBlock());
              }
              else {
                block->removeEdge(block->getTargetBlock());
              }

              graphChanged = TRUE; // CFG was modifed

              RESTART_INST_IN_BLOCK;
              break;
            }
            else if (block->getFallThroughBlock() == block->getTargetBlock())
            {
              // Don't ask me why, but sometimes we see this: executor/TEST038
              // Change branch to move and fall-through
              inst->code[0] = PCIT::MOVE_MBIN32U_MBIN32U;
              inst->code[1] = operand2->getStackIndex();
              inst->code[2] = operand2->getOffset();
              inst->code[3] = operand1->getStackIndex();
              inst->code[4] = operand1->getOffset();

              inst->reloadOperands(this);
              block->removeEdge(block->getTargetBlock());

              graphChanged = TRUE; // CFG was modifed

              // TODO: Restart once we add constant prop support for MOVEs
              // other than constant moves.
              //RESTART_INST_IN_BLOCK;
              //break;
            }

            // The operand of a logical branch should have a boolean value.  In
            // our case, the values can be 0, 1, or -1.  If the read operand
            // is unknown, or if certain values are not possible (e.g. -1)
            // then set that up first.

            if (!PCodeConstants::isAnyKnownConstant(bvIndex1,zeroes,ones,neg1))
            {
              zeroes += bvIndex1;
              ones += bvIndex1;
              neg1 += bvIndex1;
            }

            // If a change was a made, restart without setting write constants
            if (inst->getOpcode() != opc) {
              RESTART_INST_IN_BLOCK;
              break;
            }

            // Set up write constants
            PCodeConstants::copyConstantVectors(bvIndex1, bvIndex2,
                                                zeroes, ones, neg1);

            //
            // Sometimes a logical branch targets a logic instruction
            // unnecessarily.  This is a branch optimization which could be
            // done in cfgRewiring(), but we opt to do it here instead.  An
            // example of this is:
            //
            // [1]
            // BRANCH_AND (168) 13 0 2 8 2 12  (Tgt: 4)
            // ...
            // [4]  (Preds: 2 )
            // AND_MBIN32S_MBIN32S_MBIN32S (63) 2 8 2 12 2 16
            //
            // [5]  (Preds: 1 )
            // OR_MBIN32S_MBIN32S_MBIN32S (64) 2 0 2 4 2 8
            //
            // We should just be able to branch from 1 directly to 5.
            //

            // Target block should have a single logical instruction.
            PCodeBlock* tgtBlock = block->getTargetBlock();
            if (tgtBlock->getLastInst() &&
                (tgtBlock->getLastInst() == tgtBlock->getFirstInst()))
            {
              PCodeInst* logicInst = tgtBlock->getLastInst();
              Int32 subOpc = logicInst->getOpcode();

              // ((BRANCH_OR -> OR) or (BRANCH_AND -> AND)) and both insts have
              // the same write operand.
              if ((((opc == PCIT::BRANCH_OR) &&
                   (subOpc == PCIT::OR_MBIN32S_MBIN32S_MBIN32S)) ||
                   ((opc == PCIT::BRANCH_AND) &&
                    (subOpc == PCIT::AND_MBIN32S_MBIN32S_MBIN32S))) &&
                  (logicInst->getWOps()[0]->getBvIndex() ==
                   inst->getWOps()[0]->getBvIndex()))
              {
                // The read operand of the branch must be a read operand of the
                // logic instruction.
                CollIndex branchOpIdx = inst->getROps()[0]->getBvIndex();
                if ((logicInst->getROps()[0]->getBvIndex() == branchOpIdx) ||
                    (logicInst->getROps()[1]->getBvIndex() == branchOpIdx))
                {
                  // Re-target branch to fall-through of original target block.
                  block->removeEdge(block->getTargetBlock());
                  block->addEdge(tgtBlock->getFallThroughBlock());

                  graphChanged = TRUE; // CFG was modifed
                }
              }
            }

            break;
          }
    }
  } ENDFE_INST_IN_BLOCK

  return graphChanged;
}

// 
// Change moves from constant's area to direct immediate moves.
//
void PCodeCfg::constantFolding()
{
  FOREACH_BLOCK(block, firstInst, lastInst, index) {
    FOREACH_INST_IN_BLOCK(block, inst) {
      if (inst->isMove()) {
        PCodeOperand* operand2 = inst->getROps()[0];
        if (!operand2->isConst())
          continue;

        switch(inst->getOpcode()) {
          case PCIT::MOVE_MBIN16U_MBIN8:
            inst->code[0] = PCIT::MOVE_MBIN16U_IBIN16U;
            inst->code[3] = (UInt8)getIntConstValue(operand2);
            break;

          case PCIT::MOVE_MBIN32U_MBIN16U:
          case PCIT::MOVE_MBIN32S_MBIN16U:
            inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
            inst->code[3] = (UInt16)getIntConstValue(operand2);
            break;

          case PCIT::MOVE_MBIN32S_MBIN16S:
          case PCIT::MOVE_MBIN32U_MBIN16S:
            inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
            inst->code[3] = (Int16)getIntConstValue(operand2);
            break;

          case PCIT::MOVE_MBIN16U_MBIN16U:
            inst->code[0] = PCIT::MOVE_MBIN16U_IBIN16U;
            inst->code[3] = (UInt16)getIntConstValue(operand2);
            break;

          case PCIT::MOVE_MBIN32U_MBIN32U:
            inst->code[0] = PCIT::MOVE_MBIN32S_IBIN32S;
            inst->code[3] = (UInt32)getIntConstValue(operand2);
            break;

          case PCIT::MOVE_MBIN8_MBIN8:
            continue;

          case PCIT::MOVE_MBIN64S_MBIN16U:
          case PCIT::MOVE_MBIN64S_MBIN16S:
          case PCIT::MOVE_MBIN64S_MBIN32U:
          case PCIT::MOVE_MBIN64S_MBIN32S:
            continue;

          case PCIT::MOVE_MBIN64S_MBIN64S:
            continue;

          default:
            continue;
        }

        inst->reloadOperands(this);
      }
    } ENDFE_INST_IN_BLOCK
  } ENDFE_BLOCK
}

//
// Given an operand known to be a constant, lookup it's value as a string and
// return it (and its length via an incoming parameter).
//
char* PCodeCfg::getStringConstValue(PCodeOperand* op, Int32* len)
{
  CollIndex off = op->getOffset();

  if (op->isVarchar()) {
    off = off - op->getVcIndicatorLen() - op->getVcNullIndicatorLen();
  }

  PCodeConstants* constPtr = offsetToConstMap_->getFirstValue(&off);

  assert(constPtr != NULL);

  switch (op->getType()) {
    case PCIT::MASCII:
      *len = op->getLen();
      return (char*)(constPtr->getData());

    case PCIT::MATTR5:
      if (op->isVarchar()) {
        *len = ((op->getVcIndicatorLen() == 2)
          ? (Int32)(*((Int16*)((char*)constPtr->getData() +
              op->getVcNullIndicatorLen())))
          : (Int32)(*((Int32*)((char*)constPtr->getData() +
              op->getVcNullIndicatorLen()))));

        return ((char*)constPtr->getData() + op->getVcIndicatorLen() +
                       op->getVcNullIndicatorLen());
      }

      // Otherwise we have a fixed-length string.
      *len = op->getLen();
      return (char*)(constPtr->getData());

    default:
      assert(FALSE);
      break;
  }

  return NULL;
}

//
// Given any pointer operand, return the pointer to it.
//
void* PCodeCfg::getPtrConstValue(PCodeOperand* op)
{
  CollIndex off = op->getOffset();

  // This routine can be called before PCodeConstant objects are initialized.
  // As such, the offset must come directly from the constants area of the expr.
  if (offsetToConstMap_ == NULL) {
    char * stk = expr_->getConstantsArea();
    Int32 len = expr_->getConstsLength();

    assert (off < (CollIndex)len);

    return (void*)(stk + off);
  }

  // Otherwise constant should be recorded in constants map.
  PCodeConstants* constPtr = offsetToConstMap_->getFirstValue(&off);
  if (constPtr == NULL)
    return NULL;

  return (void*)(constPtr->getData());
}


//
// Given an operand known to be an integer, find its value and return it.
//
Int64 PCodeCfg::getIntConstValue(PCodeOperand* op)
{
  CollIndex off = op->getOffset();

  // TODO: move this calculation to getStringValue()
  if (op->isVarchar()) {
    off = off - op->getVcIndicatorLen() - op->getVcNullIndicatorLen();
  }

  PCodeConstants* constPtr = offsetToConstMap_->getFirstValue(&off);

  //
  // All integer constant operands should be found in constants hash table.  If
  // not, then they must be constants defined prior to optimizations.  An
  // example on how this can happen is a MOVE_MBIN8_MBIN8_IBIN32S which has a
  // constant read operand with type MPTR32.  Operands with type MPTR32 are not
  // currently tracked.  If this instruction is converted into a normal (known
  // sized) move, then constant folding may be called and it may be further
  // converted into an immediate move.
  //
  // TODO: Keep the assert for now (change made in ::getAlign() to recognize
  // PCIT::MPTR32 operand (giving it worst-case 8-byte alignment).
  //

  assert(constPtr != NULL);

  Int64 value = 0;

  switch (op->getType()) {
    case PCIT::MBIN8:
      value = (Int64)*((UInt8*)(constPtr->getData()));
      break;
    case PCIT::MBIN8S:
      value = (Int64)*((Int8*)(constPtr->getData()));
      break;
    case PCIT::MBIN8U:
      value = (Int64)*((UInt8*)(constPtr->getData()));
      break;
    case PCIT::MBIN16S:
      value = (Int64)*((Int16*)(constPtr->getData()));
      break;
    case PCIT::MBIN16U:
      value = (Int64)*((UInt16*)(constPtr->getData()));
      break;
    case PCIT::MBIN32S:
      value = (Int64)*((Int32*)(constPtr->getData()));
      break;
    case PCIT::MBIN32U:
      value = (Int64)*((UInt32*)(constPtr->getData()));
      break;
    case PCIT::MBIN64S:
      value = (Int64)*((Int64*)(constPtr->getData()));
      break;
    case PCIT::MPTR32:
      switch (constPtr->getLen()) {
        case 1:
          value = (Int64)*((UInt8*)(constPtr->getData()));
          break;
        case 2:
          value = (Int64)*((Int16*)(constPtr->getData()));
          break;
        case 4:
          value = (Int64)*((Int32*)(constPtr->getData()));
          break;
        case 8:
          value = (Int64)*((Int64*)(constPtr->getData()));
          break;
        default:
          assert(FALSE);
      }
      break;

    default:
      assert(FALSE);
      break;
  }

  return value;
}

//
// Given an operand known to be a float, find its value and return it.
//
double PCodeCfg::getFloatConstValue(PCodeOperand* op)
{
  CollIndex off = op->getOffset();

  // TODO: move this calculation to getStringValue()
  if (op->isVarchar()) {
    off = off - op->getVcIndicatorLen() - op->getVcNullIndicatorLen();
  }

  PCodeConstants* constPtr = offsetToConstMap_->getFirstValue(&off);

  // All integer constant operands should be found in constants hash table.
  assert(constPtr != NULL);

  double value = 0;

  switch (op->getType()) {
    case PCIT::MFLT64:
      value = *((double*)(constPtr->getData()));
      break;

    case PCIT::MFLT32:
      value = *((float*)(constPtr->getData()));
      break;

    default:
      assert(FALSE);
      break;
  }

  return value;
}

//
// Add a new integer constant.  The alignment param is used to indicate the
// size of the datum as well as it's alignment.
//
Int32 PCodeCfg::addNewIntConstant(Int64 value, Int32 alignment)
{
  // Quickly return the zero offset if it exists and we're looking to add 0.
  if ((value == 0) && (zeroOffset_ != -1))
    return zeroOffset_;

  switch (alignment) {
    case 1:
    {
      UInt8 val = (UInt8)value;
      return *(addConstant(&val, alignment, alignment));
    }

    case 2:
    {
      UInt16 val = (UInt16)value;
      return *(addConstant(&val, alignment, alignment));
    }

    case 4:
    {
      UInt32 val = (UInt32)value;
      return *(addConstant(&val, alignment, alignment));
    }

    case 8:
    {
      return *(addConstant(&value, alignment, alignment));
    }

    default:
      assert(FALSE);
  }

  return -1;
}

//
// Add a new float constant.  The alignment param is used to indicate the
// size of the datum as well as it's alignment.
//
Int32 PCodeCfg::addNewFloatConstant(double value, Int32 alignment)
{
  switch (alignment) {
    case 4:
    {
      float val = (float)value;
      return *(addConstant(&val, alignment, alignment));
    }

    case 8:
    {
      return *(addConstant(&value, alignment, alignment));
    }

    default:
      assert(FALSE);
  }

  return -1;
}

//
// Constant fold instructions with input operands known to be constant.  It's
// important to update the reaching defs information if the new instruction
// being added is generated from scratch - see updateReachingDefs().
//
PCodeInst* PCodeCfg::constantFold(PCodeInst* inst, NABoolean rDefsAvailable)
{
  CollIndex i;
  PCodeOperand *op1, *op2;
  Int16 ov; // overflow indicator

  Int32 opc = inst->getOpcode();

  switch (opc) {
#if 0
    case PCIT::CLAUSE_EVAL:
    {
      ex_expr::exp_return_type retCode;
      char *opData[3 * ex_clause::MAX_OPERANDS];
      char **opDataData = &opData[2 * ex_clause::MAX_OPERANDS];

      clause = inst->code[1];

      if (inst->mustProcessNulls() ||
          !inst->clauseInitOperandsForConstFold(opData, heap_))
        return;

      retCode = clause->eval(opDataData, heap_, diagsArea)

      if (retCode == ex_expr::EXPR_ERROR)
        return;

      break;
    }
#endif

    case PCIT::MOVE_MASCII_MASCII_IBIN32S_IBIN32S:
    case PCIT::MOVE_MASCII_MATTR5_IBIN32S:
    {
      Int32 len, tgtLen;
      CollIndex* off;

      // Folding inst into same-sized moves is useful for copy propagation, and
      // that being only if the write operand is a temp.
      if (!inst->getWOps()[0]->isTemp())
        break;

      op2 = inst->getROps()[0];
      if (op2->isConst()) {
        assert(!op2->isIndirectVarchar());

        op1 = inst->getWOps()[0];
        tgtLen = op1->getLen();

        char* str = getStringConstValue(op2, &len);
        Int32 padLen = tgtLen - len;

        char* newStr = (char*)new(heap_) char[tgtLen];
        if (padLen > 0) {
          str_cpy_all(newStr, str, len);
          str_pad(newStr + len, padLen, ' ');
        }
        else {
          str_cpy_all(newStr, str, tgtLen);
        }

        off = addConstant((void*)newStr, tgtLen, 1);

        inst->code[0] = PCIT::MOVE_MBIN8_MBIN8_IBIN32S;
        inst->code[3] = 1;
        inst->code[4] = *off;
        inst->code[5] = tgtLen;

        NADELETEBASIC(newStr, heap_);
        inst->reloadOperands(this);
      }

      break;
    }

    case PCIT::MOVE_MATTR5_MASCII_IBIN32S:
    {
      Int32 len, tgtLen;
      CollIndex* off;

      op1 = inst->getWOps()[0];

      // Folding inst into same-sized moves is useful for copy propagation, and
      // that being only if the write operand is a temp.
      if (!op1->isTemp())
        break;

      op2 = inst->getROps()[0];
      if (op2->isConst()) {
        // Get source string
        char* str = getStringConstValue(op2, &len);

        // Since char is being stored in varchar, if the length is too big to
        // be represented by a varchar (in terms of a 2-byte vc length field),
        // then skip this transformation.
        if (len >= SHRT_MAX)
          break;

        // Target length that should be stored.
        tgtLen = (op1->getVcMaxLen() >= len) ? len : op1->getVcMaxLen();

        // Allocate new varchar string with 2 bytes for vc len
        char* newStr = (char*) new(heap_) char[2 + tgtLen];
        *((Int16*)(newStr)) = (Int16)tgtLen;  
        str_cpy_all(newStr + 2, str, tgtLen);

        off = addConstant((void*)newStr, tgtLen + 2, 2);

        Int32 comboLen = 0;
        char* comboPtr = (char*)(&comboLen);
        comboPtr[0] = 0; // no null
        comboPtr[1] = 2; // vc length is 2 bytes

        PCodeInst* newInst;
        PCodeBlock* block = inst->block;

        newInst = block->insertNewInstAfter(inst, PCIT::MOVE_MATTR5_MATTR5);

        newInst->code[1] = inst->code[1];
        newInst->code[2] = inst->code[2];
        newInst->code[3] = inst->code[3];
        newInst->code[4] = inst->code[4];
        newInst->code[5] = inst->code[5];

        newInst->code[6] = 1;
        newInst->code[7] = *off + 2;            // Up 2 to get to str itself
        newInst->code[8] = -1;                  // voa
        newInst->code[9] = op1->getVcMaxLen();  // tgt/src share max vc length
        newInst->code[10] = comboLen;

        newInst->reloadOperands(this);

        // Attempt to update reaching defs info.
        if (rDefsAvailable)
          updateReachingDefs(block, op1->getBvIndex(), inst, newInst);

        block->deleteInst(inst);
        inst = newInst;

        NADELETEBASIC(newStr, heap_);
      }

      break;
    }

    case PCIT::MOVE_MBIGS_MBIN16S_IBIN32S:
    case PCIT::MOVE_MBIGS_MBIN32S_IBIN32S:
    case PCIT::MOVE_MBIGS_MBIN64S_IBIN32S:
    {
      op1 = inst->getWOps()[0];

      // Folding inst into same-sized moves is useful for copy propagation, and
      // that being only if the write operand is a temp.
      if (!op1->isTemp())
        break;

      op2 = inst->getROps()[0];
      if (op2->isConst()) {
        CollIndex* off;
        Int64 value = getIntConstValue(op2);
        Int32 tgtLen = inst->getWOps()[0]->getLen();
        char* result = (char*) new(heap_) char[tgtLen];
        BigNumHelper::ConvInt64ToBigNumWithSignHelper(tgtLen, value, result, FALSE);

        off = addConstant((void*)result, tgtLen,inst->getWOps()[0]->getAlign());

        PCodeInst* newInst;
        PCodeBlock* block = inst->block;

        newInst = block->insertNewInstAfter(inst,
                    PCIT::MOVE_MBIGS_MBIGS_IBIN32S_IBIN32S);
        newInst->code[1] = inst->code[1];
        newInst->code[2] = inst->code[2];
        newInst->code[3] = 1;
        newInst->code[4] = *off;
        newInst->code[5] = tgtLen;
        newInst->code[6] = tgtLen;

        newInst->reloadOperands(this);

        // Attempt to update reaching defs info.
        if (rDefsAvailable)
          updateReachingDefs(block, op1->getBvIndex(), inst, newInst);

        block->deleteInst(inst);
        inst = newInst;
      }

      break;
    }

    case PCIT::MOVE_MBIN32S_IBIN32S:
    {
      PCodeInst* newInst;
      PCodeBlock* block = inst->block;

      op1 = inst->getWOps()[0];

      // Folding inst into same-sized moves is useful for copy propagation, and
      // that being only if the write operand is a temp.
      if (!op1->isTemp())
        break;

      newInst = block->insertNewInstAfter(inst, PCIT::MOVE_MBIN32U_MBIN32U);
      newInst->code[1] = inst->code[1];
      newInst->code[2] = inst->code[2];
      newInst->code[3] = 1;
      newInst->code[4] = addNewIntConstant(inst->code[3], 4);

      newInst->reloadOperands(this);

      // Attempt to update reaching defs info.
      if (rDefsAvailable)
        updateReachingDefs(block, op1->getBvIndex(), inst, newInst);

      block->deleteInst(inst);
      inst = newInst;

      break;
    }

    case PCIT::MOVE_MBIN64S_MBIN16U:
    case PCIT::MOVE_MBIN64S_MBIN16S:
    case PCIT::MOVE_MBIN64S_MBIN32S:
    case PCIT::MOVE_MBIN64S_MBIN32U:

    case PCIT::MOVE_MBIN32U_MBIN16U:
    case PCIT::MOVE_MBIN32S_MBIN16U:
    case PCIT::MOVE_MBIN32U_MBIN16S:
    case PCIT::MOVE_MBIN32S_MBIN16S:

    case PCIT::MOVE_MBIN16U_MBIN8:
    {
      // Folding inst into same-sized moves is useful for copy propagation, and
      // that being only if the write operand is a temp.
      if (!inst->getWOps()[0]->isTemp())
        break;

      op1 = inst->getROps()[0];
      if (op1->isConst()) {
        Int64 value = getIntConstValue(op1);

        // Re-define the instruction and reload operands
        switch (inst->getWOps()[0]->getType()) {
          case PCIT::MBIN64S:
            inst->code[0] = PCIT::MOVE_MBIN64S_MBIN64S;
            inst->code[4] = addNewIntConstant(value, 8);
            break;

          case PCIT::MBIN32U:
          case PCIT::MBIN32S:
            inst->code[0] = PCIT::MOVE_MBIN32U_MBIN32U;
            inst->code[4] = addNewIntConstant(value, 4);
            break;

          case PCIT::MBIN16U:
            inst->code[0] = PCIT::MOVE_MBIN16U_MBIN16U;
            inst->code[4] = addNewIntConstant(value, 2);
            break;
        }

        inst->reloadOperands(this);
      }

      break;
    }

    case PCIT::MOVE_MFLT64_MBIN16S:
    case PCIT::MOVE_MFLT64_MBIN32S:
    case PCIT::MOVE_MFLT64_MBIN64S:
    case PCIT::MOVE_MFLT64_MFLT32:
    {
      // Folding inst into same-sized moves is useful for copy propagation, and
      // that being only if the write operand is a temp.
      if (!inst->getWOps()[0]->isTemp())
        break;

      op1 = inst->getROps()[0];
      if (op1->isConst()) {
        double fvalue =
          (inst->getROps()[0]->getType() == PCIT::MFLT32)
            ? (double)(getFloatConstValue(op1))
            : (double)(getIntConstValue(op1));

        // Re-define the instruction and reload operands
        inst->code[0] = PCIT::MOVE_MBIN64S_MBIN64S;
        inst->code[4] = addNewFloatConstant(fvalue, 8);

        inst->reloadOperands(this);
      }

      break;
    }

    case PCIT::MUL_MBIN16S_MBIN16S_MBIN16S:
    case PCIT::MUL_MBIN32S_MBIN32S_MBIN32S:
    case PCIT::MUL_MBIN32S_MBIN16S_MBIN16S:
    case PCIT::MUL_MBIN32S_MBIN16S_MBIN32S:
    case PCIT::MUL_MBIN64S_MBIN16S_MBIN32S:
    case PCIT::MUL_MBIN64S_MBIN32S_MBIN32S:
    case PCIT::MUL_MBIN64S_MBIN64S_MBIN64S:
      for (i=0; i < inst->getROps().entries(); i++) {
        op1 = inst->getROps()[i];
        if (op1->isConst() && (getIntConstValue(op1) == 1)) {
          switch (opc) {
            case PCIT::MUL_MBIN64S_MBIN16S_MBIN32S:
              inst->code[0] = (i == 0) ? PCIT::MOVE_MBIN64S_MBIN32S :
                                         PCIT::MOVE_MBIN64S_MBIN16S;
              break;

            case PCIT::MUL_MBIN32S_MBIN16S_MBIN32S:
              inst->code[0] = (i == 0) ? PCIT::MOVE_MBIN32U_MBIN32U :
                                         PCIT::MOVE_MBIN32S_MBIN16S;
              break;

            case PCIT::MUL_MBIN16S_MBIN16S_MBIN16S:
              inst->code[0] = PCIT::MOVE_MBIN16U_MBIN16U;
              break;

            case PCIT::MUL_MBIN32S_MBIN32S_MBIN32S:
              inst->code[0] = PCIT::MOVE_MBIN32U_MBIN32U;
              break;

            case PCIT::MUL_MBIN32S_MBIN16S_MBIN16S:
              inst->code[0] = PCIT::MOVE_MBIN32S_MBIN16S;
              break;

            case PCIT::MUL_MBIN64S_MBIN32S_MBIN32S:
              inst->code[0] = PCIT::MOVE_MBIN64S_MBIN32S;
              break;

            case PCIT::MUL_MBIN64S_MBIN64S_MBIN64S:
              inst->code[0] = PCIT::MOVE_MBIN64S_MBIN64S;
              break;
          }

          inst->code[3] = inst->getROps()[(i+1)%2]->getStackIndex();
          inst->code[4] = inst->getROps()[(i+1)%2]->getOffset();

          inst->reloadOperands(this);

          // Try to fold the move even further
          return constantFold(inst, rDefsAvailable);
        }
      }

      op1 = inst->getROps()[0];
      op2 = inst->getROps()[1];

      if (op1->isConst() && op2->isConst())
      {
        Int64 x = getIntConstValue(op1);
        Int64 y = getIntConstValue(op2);

        Int64 value = EXP_FIXED_OV_MUL(x, y, &ov);

        if (ov)
          return inst;

        Int32 offset = addNewIntConstant(value, inst->getWOps()[0]->getLen());
        inst->code[0] = inst->generateCopyMoveOpc(
                          inst->getWOps()[0]->getType());
        inst->code[3] = 1;
        inst->code[4] = offset;

        inst->reloadOperands(this);
      }

      break;

    case PCIT::EQ_MBIN32S_MASCII_MASCII:
    case PCIT::LT_MBIN32S_MASCII_MASCII:
    case PCIT::LE_MBIN32S_MASCII_MASCII:
    case PCIT::GT_MBIN32S_MASCII_MASCII:
    case PCIT::GE_MBIN32S_MASCII_MASCII:
    {
      op1 = inst->getROps()[0];
      op2 = inst->getROps()[1];

      if (op1->isConst() && op2->isConst())
      {
        Int32 z, len;

        char* x = getStringConstValue(op1, &len);
        char* y = getStringConstValue(op2, &len);

        z = memcmp(x, y, op1->getLen());

        switch (opc) {
          case PCIT::EQ_MBIN32S_MASCII_MASCII:
            z = (z == 0);
            break;

          case PCIT::LT_MBIN32S_MASCII_MASCII:
            z = (z < 0);
            break;

          case PCIT::LE_MBIN32S_MASCII_MASCII:
            z = (z <= 0);
            break;

          case PCIT::GT_MBIN32S_MASCII_MASCII:
            z = (z > 0);
            break;

          case PCIT::GE_MBIN32S_MASCII_MASCII:
            z = (z >= 0);
            break;
        }

        Int32 offset = addNewIntConstant(z, 4);
        inst->code[0] = inst->generateCopyMoveOpc(PCIT::MBIN32S);
        inst->code[3] = 1;
        inst->code[4] = offset;

        inst->reloadOperands(this);
      }

      break;
    }


    case PCIT::LE_MBIN32S_MBIN16S_MBIN16S:
    case PCIT::LE_MBIN32S_MBIN16S_MBIN32S:
    case PCIT::LE_MBIN32S_MBIN32S_MBIN32S:
    case PCIT::LE_MBIN32S_MBIN16U_MBIN16U:
    case PCIT::LE_MBIN32S_MBIN16U_MBIN32U:
    case PCIT::LE_MBIN32S_MBIN32U_MBIN32U:
    case PCIT::LE_MBIN32S_MBIN16S_MBIN32U:
    case PCIT::LE_MBIN32S_MBIN16U_MBIN16S:
    case PCIT::LE_MBIN32S_MBIN64S_MBIN64S:

    case PCIT::GE_MBIN32S_MBIN16S_MBIN16S:
    case PCIT::GE_MBIN32S_MBIN16S_MBIN32S:
    case PCIT::GE_MBIN32S_MBIN32S_MBIN32S:
    case PCIT::GE_MBIN32S_MBIN16U_MBIN16U:
    case PCIT::GE_MBIN32S_MBIN16U_MBIN32U:
    case PCIT::GE_MBIN32S_MBIN32U_MBIN32U:
    case PCIT::GE_MBIN32S_MBIN16S_MBIN32U:
    case PCIT::GE_MBIN32S_MBIN16U_MBIN16S:
    case PCIT::GE_MBIN32S_MBIN64S_MBIN64S:

    case PCIT::LT_MBIN32S_MBIN16S_MBIN16S:
    case PCIT::LT_MBIN32S_MBIN16S_MBIN32S:
    case PCIT::LT_MBIN32S_MBIN32S_MBIN32S:
    case PCIT::LT_MBIN32S_MBIN16U_MBIN16U:
    case PCIT::LT_MBIN32S_MBIN16U_MBIN32U:
    case PCIT::LT_MBIN32S_MBIN32U_MBIN32U:
    case PCIT::LT_MBIN32S_MBIN16S_MBIN32U:
    case PCIT::LT_MBIN32S_MBIN16U_MBIN16S:
    case PCIT::LT_MBIN32S_MBIN64S_MBIN64S:

    case PCIT::GT_MBIN32S_MBIN16S_MBIN16S:
    case PCIT::GT_MBIN32S_MBIN16S_MBIN32S:
    case PCIT::GT_MBIN32S_MBIN32S_MBIN32S:
    case PCIT::GT_MBIN32S_MBIN16U_MBIN16U:
    case PCIT::GT_MBIN32S_MBIN16U_MBIN32U:
    case PCIT::GT_MBIN32S_MBIN32U_MBIN32U:
    case PCIT::GT_MBIN32S_MBIN16S_MBIN32U:
    case PCIT::GT_MBIN32S_MBIN16U_MBIN16S:
    case PCIT::GT_MBIN32S_MBIN64S_MBIN64S:

    case PCIT::EQ_MBIN32S_MBIN16S_MBIN16S:
    case PCIT::EQ_MBIN32S_MBIN16S_MBIN32S:
    case PCIT::EQ_MBIN32S_MBIN32S_MBIN32S:
    case PCIT::EQ_MBIN32S_MBIN16U_MBIN16U:
    case PCIT::EQ_MBIN32S_MBIN16U_MBIN32U:
    case PCIT::EQ_MBIN32S_MBIN32U_MBIN32U:
    case PCIT::EQ_MBIN32S_MBIN16S_MBIN32U:
    case PCIT::EQ_MBIN32S_MBIN16U_MBIN16S:
    case PCIT::EQ_MBIN32S_MBIN64S_MBIN64S:

    case PCIT::NE_MBIN32S_MBIN64S_MBIN64S:
    case PCIT::NE_MBIN32S_MBIN16S_MBIN16S:
    {
      op1 = inst->getROps()[0];
      op2 = inst->getROps()[1];

      if (op1->isConst() && op2->isConst())
      {
        Int32 z = 0;

        Int64 x = getIntConstValue(op1);
        Int64 y = getIntConstValue(op2);

        switch (opc) {
          case PCIT::LE_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::LE_MBIN32S_MBIN16S_MBIN32S:
          case PCIT::LE_MBIN32S_MBIN32S_MBIN32S:
          case PCIT::LE_MBIN32S_MBIN16U_MBIN16U:
          case PCIT::LE_MBIN32S_MBIN16U_MBIN32U:
          case PCIT::LE_MBIN32S_MBIN32U_MBIN32U:
          case PCIT::LE_MBIN32S_MBIN16S_MBIN32U:
          case PCIT::LE_MBIN32S_MBIN16U_MBIN16S:
          case PCIT::LE_MBIN32S_MBIN64S_MBIN64S:
            z = (x <= y) ? 1 : 0;
            break;

          case PCIT::GE_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::GE_MBIN32S_MBIN16S_MBIN32S:
          case PCIT::GE_MBIN32S_MBIN32S_MBIN32S:
          case PCIT::GE_MBIN32S_MBIN16U_MBIN16U:
          case PCIT::GE_MBIN32S_MBIN16U_MBIN32U:
          case PCIT::GE_MBIN32S_MBIN32U_MBIN32U:
          case PCIT::GE_MBIN32S_MBIN16S_MBIN32U:
          case PCIT::GE_MBIN32S_MBIN16U_MBIN16S:
          case PCIT::GE_MBIN32S_MBIN64S_MBIN64S:
            z = (x >= y) ? 1 : 0;
            break;

          case PCIT::LT_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::LT_MBIN32S_MBIN16S_MBIN32S:
          case PCIT::LT_MBIN32S_MBIN32S_MBIN32S:
          case PCIT::LT_MBIN32S_MBIN16U_MBIN16U:
          case PCIT::LT_MBIN32S_MBIN16U_MBIN32U:
          case PCIT::LT_MBIN32S_MBIN32U_MBIN32U:
          case PCIT::LT_MBIN32S_MBIN16S_MBIN32U:
          case PCIT::LT_MBIN32S_MBIN16U_MBIN16S:
          case PCIT::LT_MBIN32S_MBIN64S_MBIN64S:
            z = (x < y) ? 1 : 0;
            break;

          case PCIT::GT_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::GT_MBIN32S_MBIN16S_MBIN32S:
          case PCIT::GT_MBIN32S_MBIN32S_MBIN32S:
          case PCIT::GT_MBIN32S_MBIN16U_MBIN16U:
          case PCIT::GT_MBIN32S_MBIN16U_MBIN32U:
          case PCIT::GT_MBIN32S_MBIN32U_MBIN32U:
          case PCIT::GT_MBIN32S_MBIN16S_MBIN32U:
          case PCIT::GT_MBIN32S_MBIN16U_MBIN16S:
          case PCIT::GT_MBIN32S_MBIN64S_MBIN64S:
            z = (x > y) ? 1 : 0;
            break;

          case PCIT::EQ_MBIN32S_MBIN16S_MBIN16S:
          case PCIT::EQ_MBIN32S_MBIN16S_MBIN32S:
          case PCIT::EQ_MBIN32S_MBIN32S_MBIN32S:
          case PCIT::EQ_MBIN32S_MBIN16U_MBIN16U:
          case PCIT::EQ_MBIN32S_MBIN16U_MBIN32U:
          case PCIT::EQ_MBIN32S_MBIN32U_MBIN32U:
          case PCIT::EQ_MBIN32S_MBIN16S_MBIN32U:
          case PCIT::EQ_MBIN32S_MBIN16U_MBIN16S:
          case PCIT::EQ_MBIN32S_MBIN64S_MBIN64S:
            z = (x == y) ? 1 : 0;
            break;

          case PCIT::NE_MBIN32S_MBIN64S_MBIN64S:
          case PCIT::NE_MBIN32S_MBIN16S_MBIN16S:
            z = (x != y) ? 1 : 0;
            break;
        }

        Int32 offset = addNewIntConstant(z, 4);
        inst->code[0] = inst->generateCopyMoveOpc(PCIT::MBIN32S);
        inst->code[3] = 1;
        inst->code[4] = offset;

        inst->reloadOperands(this);
      }

      break;
    }

    case PCIT::ADD_MBIN16S_MBIN16S_MBIN16S:
    case PCIT::ADD_MBIN32S_MBIN32S_MBIN32S:
    case PCIT::ADD_MBIN64S_MBIN64S_MBIN64S:
    case PCIT::ADD_MBIN32S_MBIN16S_MBIN16S:
    case PCIT::ADD_MBIN32S_MBIN16S_MBIN32S:
    case PCIT::ADD_MBIN64S_MBIN32S_MBIN64S:
    {
      op1 = inst->getROps()[0];
      op2 = inst->getROps()[1];

      if (op1->isConst() && op2->isConst())
      {
        Int64 x = getIntConstValue(op1);
        Int64 y = getIntConstValue(op2);

        Int64 value = EXP_FIXED_OV_ADD(x, y, &ov);

        if (ov)
          return inst;

        Int32 offset = addNewIntConstant(value, inst->getWOps()[0]->getLen());
        inst->code[0] = inst->generateCopyMoveOpc(
                          inst->getWOps()[0]->getType());
        inst->code[3] = 1;
        inst->code[4] = offset;

        inst->reloadOperands(this);
      }

      break;
    }

    case PCIT::SUB_MBIN16S_MBIN16S_MBIN16S:
    case PCIT::SUB_MBIN32S_MBIN32S_MBIN32S:
    case PCIT::SUB_MBIN64S_MBIN64S_MBIN64S:
    case PCIT::SUB_MBIN32S_MBIN16S_MBIN16S:
    case PCIT::SUB_MBIN32S_MBIN16S_MBIN32S:
    case PCIT::SUB_MBIN32S_MBIN32S_MBIN16S:
    {
      op1 = inst->getROps()[0];
      op2 = inst->getROps()[1];

      if (op1->isConst() && op2->isConst())
      {
        Int64 x = getIntConstValue(op1);
        Int64 y = getIntConstValue(op2);

        Int64 value = EXP_FIXED_OV_SUB(x, y, &ov);

        if (ov)
          return inst;

        Int32 offset = addNewIntConstant(value, inst->getWOps()[0]->getLen());
        inst->code[0] = inst->generateCopyMoveOpc(
                          inst->getWOps()[0]->getType());
        inst->code[3] = 1;
        inst->code[4] = offset;

        inst->reloadOperands(this);
      }

      break;
    }

    case PCIT::MUL_MFLT64_MFLT64_MFLT64:
    case PCIT::ADD_MFLT64_MFLT64_MFLT64:
    case PCIT::SUB_MFLT64_MFLT64_MFLT64:
    case PCIT::DIV_MFLT64_MFLT64_MFLT64:
    {
      op1 = inst->getROps()[0];
      op2 = inst->getROps()[1];

      if (op1->isConst() && op2->isConst()) {
        double x = getFloatConstValue(op1);
        double y = getFloatConstValue(op2);

        double res = 0.0;
        Int16 ov = 0;

        switch (opc) {
          case PCIT::MUL_MFLT64_MFLT64_MFLT64:
            res = MathReal64Mul(x, y, &ov);
            break;
          case PCIT::ADD_MFLT64_MFLT64_MFLT64:
            res = MathReal64Add(x, y, &ov);
            break;
          case PCIT::SUB_MFLT64_MFLT64_MFLT64:
            res = MathReal64Sub(x, y, &ov);
            break;
          case PCIT::DIV_MFLT64_MFLT64_MFLT64:
            res = MathReal64Div(x, y, &ov);
            break;
        }

        if (ov)
          return inst;

        // FIXME: I think we need to appropriately support a MOVE_MFLT64_MFLT64
        // instruction so that Native Expressions doesn't get confused.

        Int32 offset = addNewFloatConstant(res, 8);
        inst->code[0] = PCIT::MOVE_MBIN64S_MBIN64S;
        inst->code[3] = 1;
        inst->code[4] = offset;

        inst->reloadOperands(this);
      }

      break;
    }

    case PCIT::HASH_MBIN32U_MATTR5:
    case PCIT::HASH_MBIN32U_MPTR32_IBIN32S_IBIN32S:
    case PCIT::HASH_MBIN32U_MBIN16_IBIN32S_IBIN32S:
    case PCIT::HASH_MBIN32U_MBIN32_IBIN32S_IBIN32S:
    case PCIT::HASH_MBIN32U_MBIN64_IBIN32S_IBIN32S:
    {
      op1 = inst->getROps()[0];

      if (op1->isConst()) {
        Int32 len;
        char* x;
        UInt32 flags = ExHDPHash::NO_FLAGS;

        if (opc == PCIT::HASH_MBIN32U_MATTR5) {
          x = getStringConstValue(op1, &len);

          // Reduce length if padding exists.
          while ((len > 0) && (x[len-1] == ' '))
            len--;
        }
        else {
          len = op1->getLen();
          x = (char*)getPtrConstValue(op1);
          flags = inst->code[5];
        }

        UInt32 res = ExHDPHash::hash(x, flags, len);

        Int32 offset = addNewIntConstant(res, 4);
        inst->code[0] = inst->generateCopyMoveOpc(PCIT::MBIN32S);
        inst->code[3] = 1;
        inst->code[4] = offset;

        inst->reloadOperands(this);
      }

      break;
    }

    case PCIT::RANGE_LOW_S32S64:
    case PCIT::RANGE_HIGH_S32S64:
    case PCIT::RANGE_LOW_U32S64:
    case PCIT::RANGE_HIGH_U32S64:
    case PCIT::RANGE_LOW_S64S64:
    case PCIT::RANGE_HIGH_S64S64:
    case PCIT::RANGE_LOW_S16S64:
    case PCIT::RANGE_HIGH_S16S64:
    case PCIT::RANGE_MFLT64:
    {
      Int64 x, y;
      NABoolean error = TRUE; // Assume range instruction is needed

      PCodeOperand* op = inst->getROps()[0];

      // Only range instructions with const operands can be removed
      if (!op->isConst())
        break;

      if (opc != PCIT::RANGE_MFLT64) {
        x = getIntConstValue(op);
        y = (*(Int64*)&inst->code[3]);
      }

      switch (opc) {
        case PCIT::RANGE_LOW_S32S64:
        case PCIT::RANGE_LOW_U32S64:
        case PCIT::RANGE_LOW_S64S64:
        case PCIT::RANGE_LOW_S16S64:
          error = (x < y);
          break;

        case PCIT::RANGE_HIGH_S32S64:
        case PCIT::RANGE_HIGH_U32S64:
        case PCIT::RANGE_HIGH_S64S64:
        case PCIT::RANGE_HIGH_S16S64:
          error = (x > y);
          break;

        case PCIT::RANGE_MFLT64:
          error = FALSE;
          break;
      }

      if (!error) {
        PCodeBlock* block = inst->block;
        block->deleteInst(inst);
        inst = NULL;
      }
      break;
    }

    case PCIT::COMP_MBIN32S_MATTR5_MATTR5_IBIN32S:
    {
      op1 = inst->getROps()[0];
      op2 = inst->getROps()[1];
      if (!op1->isConst() || !op2->isConst())
        break;

      Int32 len1, len2;

      char* str1 = getStringConstValue(op1, &len1);
      char* str2 = getStringConstValue(op2, &len2);

      Int32 compTable[6][3] = {
        /* ITM_EQUAL */      {0, 1, 0},
        /* ITM_NOT_EQUAL */  {1, 0, 1},
        /* ITM_LESS */       {1, 0, 0},
        /* ITM_LESS_EQ */    {1, 1, 0},
        /* ITM_GREATER */    {0, 0, 1},
        /* ITM_GREATER_EQ */ {0, 1, 1}
      };

      // Set table pointer to appropriate position based on operation
      Int32* table = &(compTable[inst->code[13] - ITM_EQUAL][1]);

      Int32 compCode = charStringCompareWithPad(str1, len1, str2, len2, ' ');
      Int32 res = table[compCode];

      Int32 offset = addNewIntConstant(res, 4);
      inst->code[0] = inst->generateCopyMoveOpc(PCIT::MBIN32S);
      inst->code[3] = 1;
      inst->code[4] = offset;

      inst->reloadOperands(this);

      break;
    }

    case PCIT::GENFUNC_MATTR5_MATTR5_IBIN32S:
    {
      Int32 len;
      Int32 subOpc = inst->code[11];

      // Get source operand and check if constant.
      op2 = inst->getROps()[0];
      if (!op2->isConst())
        break;

      // Get tgt operand.
      op1 = inst->getWOps()[0];

      switch (subOpc) {
        case ITM_TRIM:
        case ITM_LTRIM:
        case ITM_RTRIM:
        case ITM_UPPER:
        case ITM_LOWER:
        {
          Int32 startIdx = 0;
          char* fromStr = NULL;
          NABoolean fromStrAllocated = FALSE;
          PCodeInst* newInst;

          PCodeBlock* block = inst->block;

          // Get source string and len (initial target length)
          char* str = getStringConstValue(op2, &len);
          CollIndex tgtLen = len;

          if ((subOpc == ITM_LOWER) || (subOpc == ITM_UPPER))
          {
            fromStr = (char*) new(heap_) char[tgtLen];
            for (i=0; i < tgtLen; i++)
              fromStr[i] = (subOpc == ITM_UPPER)
                ? TOUPPER(str[i]) : TOLOWER(str[i]);

            fromStrAllocated = TRUE;
          }
          else {
            // Set string up to first non-space
            if ((subOpc == ITM_TRIM) || (subOpc == ITM_LTRIM)) {
              for (i=0; i < (CollIndex)len; i++, startIdx++, tgtLen--)
                if (str[i] != ' ')
                  break;
            }

            // Set string up to last non-space
            if ((subOpc == ITM_TRIM) || (subOpc == ITM_RTRIM)) {

              if ( len > 0 ) // Protect against 0-length strings
              {
                for (i=len-1; i > (CollIndex)startIdx; i--, tgtLen--)
                  if (str[i] != ' ')
                    break;
              }
            }

            // Set "fromStr" to be "str" so that code below works for all cases.
            fromStr = str;
          }

          if (op1->isVarchar()) {
            // Allocate new varchar string with 2 bytes for vc len
            char* newStr = (char*) new(heap_) char[2 + tgtLen];
            *((Int16*)(newStr)) = (Int16)tgtLen;  

            if (tgtLen > 0)
              str_cpy_all(newStr + 2, &fromStr[startIdx], tgtLen);

            CollIndex* off = addConstant((void*)newStr, tgtLen + 2, 2);

            Int32 comboLen = 0;
            char* comboPtr = (char*)(&comboLen);
            comboPtr[0] = 0; // no null
            comboPtr[1] = 2; // vc length is 2 bytes

            newInst = block->insertNewInstAfter(inst, PCIT::MOVE_MATTR5_MATTR5);

            newInst->code[1] = inst->code[1];
            newInst->code[2] = inst->code[2];
            newInst->code[3] = inst->code[3];
            newInst->code[4] = inst->code[4];
            newInst->code[5] = inst->code[5];

            newInst->code[6] = 1;
            newInst->code[7] = *off + 2;            // Up 2 to get to str itself
            newInst->code[8] = -1;                  // voa
            newInst->code[9] = op1->getVcMaxLen();  // tgt/src share max vc len
            newInst->code[10] = comboLen;
 
            NADELETEBASIC(newStr, heap_);
          }
          else {
            CollIndex* off = addConstant((void*)fromStr, tgtLen, 1);

            newInst =
              block->insertNewInstAfter(inst, PCIT::MOVE_MBIN8_MBIN8_IBIN32S);

            newInst->code[1] = inst->code[1];
            newInst->code[2] = inst->code[2];
            newInst->code[3] = 1;
            newInst->code[4] = *off;
            newInst->code[5] = tgtLen;
          }

          newInst->reloadOperands(this);

          // Attempt to update reaching defs info.
          if (rDefsAvailable)
            updateReachingDefs(block, op1->getBvIndex(), inst, newInst);

          block->deleteInst(inst);
          inst = newInst;

          // Cleanup if needed.
          if (fromStrAllocated)
            NADELETEBASIC(fromStr, heap_);

          break;
        }

        default:
          break;
      }
    }

    default:
      break;
  }

  return inst;
}