/**********************************************************************
// @@@ 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 @@@
**********************************************************************/
/* -*-C++-*-
****************************************************************************
*
* File:         ExpPCodeExpGen.cpp
* RCS:          $Id: exppcodeexpgen.cpp,v 1.2 2006/11/21 05:53:06  Exp $
* Description:  
*
* Created:      8/25/97
* Modified:     $ $Date: 2006/11/21 05:53:06 $ (GMT)
* Language:     C++
* Status:       $State: Exp $
*
*
*
****************************************************************************
*/

#include "Platform.h"


#include "exp_stdh.h"
#include "str.h"
#include "exp_expr.h"
#include "exp_clause_derived.h"
#include "ExpPCode.h"
#include "ExpPCodeOptimizations.h"

#define GenAssert(p, msg) if (!(p)) { NAAssert(msg, __FILE__ , __LINE__ ); };

ex_expr::exp_return_type ex_expr::pCodeGenerate(Space * space,
                                                CollHeap *heap,
						UInt32 f) {

#ifdef _DEBUG
  if (getenv("NO_PCODE"))
    return ex_expr::EXPR_OK;
#endif

  // If the expression mode does not indicate that PCODE is "ON", then
  // don't generate any code. It is important not to allocate any
  // memory either since this may be the resource fork expression which
  // currently has a NULL space pointer.
  //
  if(!(pCodeMode_ & PCODE_ON)) {
    setPCodeObject(0);
    pCode_ = 0;
    return ex_expr::EXPR_OK;
  }

  // cannot proceed if no space was passed in.
  if (! space)
    return ex_expr::EXPR_OK;

  PCodeBinary *pCode = NULL;
  NABoolean versionOK = TRUE;
#ifdef _DEBUG
  // for debug
  char  *buf;
  Int32 bufLen = 0;  // to store PCode in ascii for to buf, set it to 16384
  Int32 dumpPci = 0; // set this to 1 as well
  if (bufLen > 0) {
    buf = (char*) space->allocateSpaceMemory(bufLen);
    if (buf == NULL)  // failed to get memory
      bufLen = 0;
  }
#endif

  if (pCode_.getPointer()) {
    pCode = getPCodeBinary();
    versionOK = pCode_.getPointer()->versionOK();
  } 
  if (versionOK && pCode && getPCodeGenCompile()) {
    return ex_expr::EXPR_OK;
  }
  else
    // If pcode is supposedly generated at compile-time, but there's no pcode,
    // set PCodeGenCompile flag to 0
    if (getPCodeGenCompile()) { 
      setPCodeGenCompile(0);
    }

  // Allocate the PCODE object and instruction list.
  //
  PCode *codeObject = new(heap)PCode(heap, space); 
  PCIList code(heap);

  ex_clause *clause = clauses_;

  //
  // Clear count of branch targets from any previous processing.
  //
  NABoolean branchingClausesExist = FALSE;
  clause = clauses_;
  while(clause) 
    {
      // copy handleIndirectVC flag into the clause
      clause->setHandleIndirectVC( handleIndirectVC() );

      // copy forInsertUpdate flag into the clause
      clause->setForInsertUpdate( forInsertUpdate() );

      if(clause->isBranchingClause()) 
	{
	  ex_branch_clause *branchClause = (ex_branch_clause*)clause;
	  ex_clause *targetClause = branchClause->get_branch_clause();
          targetClause->setNumberBranchTargets(0);
          branchingClausesExist = TRUE;
	}
      clause = clause->getNextClause();
    }

  // Handle clauses that branch. Set the target clause's flags to
  // indicate that the clause is a target of a branch. This operation
  // was previously performed in the clause::pCodeGenerate but this
  // did not allow for backwards branching since the target clause
  // would have already been processed.  A TARGET PCI instruction
  // will be added when PCI's are generated for the target clause.
  // (See ExpPCode.cpp:preClausePCI()).
  //

  clause = clauses_;
  if (branchingClausesExist)
  {
    while(clause) 
    {
      if(clause->isBranchingClause()) 
	{
	  ex_branch_clause *branchClause = (ex_branch_clause*)clause;
	  ex_clause *targetClause = branchClause->get_branch_clause();
	  targetClause->addBranchTarget();
	}
      clause = clause->getNextClause();
    }
  }
  
  // If the expression mode indicates "EVAL", then generate PCIs for
  // calling the standard clause->eval() routine. IF pcode generate
  // returns EXPR_NULL, something fatal occurred so abort PCODE
  // generation altogether. Currently, this happens if generate encounters
  // an access to a column following a VARCHAR column (does not work because
  // of a bug with computeDataPtr).
  //
  clause = clauses_;
  if (pCodeMode_ & PCODE_EVAL) {
    while(clause) {
      // Check if any of the operands can not generate pCode.
      // See ExpTupleDesc::computeOffsets() for when offsets are set to
      // UINT_MAX.  It is dependent on the tuple data format.
      // If offset is UINT_MAX, pcode is normally generated unless
      // CQD says otherwise or if this operation is for insert/update.
      for(short i = 0; i < clause->getNumOperands(); i++) {
	if (((clause->getOperand(i)->getOffset() == UINT_MAX) && 
              !handleIndirectVC()) ||                             
            (clause->getOperand(i)->isAddedCol() && 
              !pCodeSpecialFields()))
        {
	  setPCodeObject(0);
	  pCode_ = 0;
	  NADELETE(codeObject, PCode, heap);
	  return ex_expr::EXPR_OK;
	}
      }

      // Allow for a clause to return EXPR_NULL - unlikely, but keep for
      // future possibilities.
      if(clause->ex_clause::pCodeGenerate(space, f) == ex_expr::EXPR_NULL) {
	setPCodeObject(0);
	pCode_ = 0;
	NADELETE(codeObject, PCode, heap);
	return ex_expr::EXPR_OK;
      }
      code.append(PCIList(clause->getPCIList(), space));
      clause = clause->getNextClause();
    }
  } 
  // Otherwise, generate PCI instructions for each clause and only use
  // clause->eval() for unimplemented operations.
  //
  else {
    Attributes *tmpAttr = NULL;
    while(clause) {
      // Check if any of the operands can not generate pCode.
      // See ExpTupleDesc::computeOffsets() for when offsets are set to
      // UINT_MAX.  It is dependent on the tuple data format.
      // If offset is UINT_MAX, pcode is normally generated unless
      // CQD says otherwise or if this operation is for insert/update.
      for(short i = 0; i < clause->getNumOperands(); i++) {
        if (! clause->getOperand(i))
          continue;

	if (((clause->getOperand(i)->getOffset() == UINT_MAX) &&
              !handleIndirectVC()) ||
            (clause->getOperand(i)->isAddedCol() && 
              !pCodeSpecialFields()))
        {
	  setPCodeObject(0);
	  pCode_ = 0;
	  NADELETE(codeObject, PCode, heap);
	  return ex_expr::EXPR_OK;
	}
      }

      // If we can't generate PCode for a specific clause, then no PCode
      // is generated at all and we throw away what we've generated already.
      if(clause->pCodeGenerate(space, f) == ex_expr::EXPR_NULL) {
	setPCodeObject(0);
	pCode_= 0;
	NADELETE(codeObject, PCode, heap);
	return ex_expr::EXPR_OK;
      }

      code.append(PCIList(clause->getPCIList(), space));

      // If the target type in the clause is varchar, save the attribute for
      // update row length.
      // (But not if the varchar is being treated as a fixed field (forceFixed)).
      if(clause->getNumOperands() > 0)
      {
        if((clause->getOperand()[0])->getVCIndicatorLength() > 0 &&
           (clause->getOperand()[0])->isSQLMXDiskFormat() &&
           !(clause->getOperand()[0])->isForceFixed())
        {
            // save the attribute for updateRowlen
            tmpAttr = clause->getOperand()[0];
        }
      }

      // update row len when the current clause is the last one in the list
      // and one of the target type in a clause is varchar.

      if(clause->getNextClause() == NULL && tmpAttr)
      {
        code.append(PCode::updateRowLen(tmpAttr, space, f));
      }

      clause = clause->getNextClause();
    }
  }

#ifdef _DEBUG
  if (dumpPci == 1)
    PCode::dumpContents(code, buf, bufLen);
#endif

  // Fixup PCI CLAUSE_BRANCH instructions. Modify the corresponding TARGET
  // PCIs so that they point to the actual PCIs for the branch sources.
  // The actual branch offset fixup is done at the end of this procedure.
  //
  PCIListIter iter(code);
  PCI * pci;
  NABoolean containsClauseEval = FALSE;
  for(pci = iter.first(); pci; pci = iter.next()) 
    {
      if ((NOT containsClauseEval) &&
	  (PCode::IsClauseEvalInstruction(pci)))
	containsClauseEval = TRUE;

      if(PCode::IsBranchInstruction(pci))
        {
          PCIListIter iter2(code);
          for(PCI *tpci = iter2.first(); tpci; tpci = iter2.next()) {
   
            // A TARGET PCI with the same pointer as the CLAUSE_BRANCH PCI
            // indicates a branch-target pair. The target PCI operand needs
            // to be changed to point to the branch PCI.
            //
            if(PCode::IsTargetInstruction(tpci) &&
               (pci->getLongOperand(0) == tpci->getLongOperand(0)))
              {
                pci->setLongOperand(0, (Long)0);
                tpci->setLongOperand(0, (Long)pci);
                break;
              }
          }
        }
    }


#ifdef _DEBUG
  if (dumpPci == 1)
    PCode::dumpContents(code, buf, bufLen);
#endif

  // Fixup addresses. This requires a pass over
  // the PCODE instruction list. Any instruction that access memory
  // may need to be fixed up with the correct pointers. These operations
  // include:  Op_SUM.
  //
  // Also, use this pass over the PCODE instructions to compute the 
  // minimum and maximum ATP and ATP indexes that are accessed in 
  // LD/ST_ATP operations. This information is used later to make the
  // ATP/ATP Index map.
  //
  // Also, use this pass over the PCODE instructions to compute the
  // maximum PCODE stack depth needed. If this exceeds the stack depth
  // allocated in eval (which is currently fixed), then abort PCODE
  // generation.
  //
  Int32 maximumStackDepth = 0;
  Int32 minAtp = INT_MAX, maxAtp = INT_MIN;
  Int32 minAtpIndex = INT_MAX, maxAtpIndex = INT_MIN;
  Int32 atpOperation = 0;
  for(pci = iter.first(); pci; pci = iter.next()) {

    // Fixup constant, temp, and persistent pointers, if necessary.
    //
    if(getFixupConstsAndTemps())
      {
	Long tempsArea  = (Long)(tempsArea_.getPointer());
	Long constsArea = (Long)(constantsArea_.getPointer());
	Long persistentArea = (Long)(persistentArea_.getPointer());
	
	PCIT::AddressingMode am;
	for(Int32 i=0,op=0; 
	    i<pci->getNumberAddressingModes(); 
	    i++,op+=PCIT::getNumberOperandsForAddressingMode(am))
	  {
	    am = pci->getAddressingMode(i);
	    if(!PCIT::isMemoryAddressingMode(am)) continue;
	    
	    if(pci->getOperand(op+1) == 0)
	      pci->setLongOperand(op+2, pci->getLongOperand(op+2) - constsArea);
	    else if(pci->getOperand(op+1) == 1)
	      {
		if(pci->getOperand(op) == 0)
		  pci->setLongOperand(op+2, pci->getLongOperand(op+2) - tempsArea);
		else
		  pci->setLongOperand(op+2, 
				  pci->getLongOperand(op+2) - persistentArea);
	      }
	    
	  }
      }

    // Record min and max ATP/ATP Index accesses.
    //
    atpOperation = 1;
    PCIT::AddressingMode am;
    for(Int32 i=0,op=0; 
	i<pci->getNumberAddressingModes(); 
	i++,op+=PCIT::getNumberOperandsForAddressingMode(am))
      {
	am = pci->getAddressingMode(i);
	if(!PCIT::isMemoryAddressingMode(am)) continue;
	
	minAtp = MINOF(minAtp, pci->getOperand(op));
	maxAtp = MAXOF(maxAtp, pci->getOperand(op));
	minAtpIndex = MINOF(minAtpIndex, pci->getOperand(op+1));
	maxAtpIndex = MAXOF(maxAtpIndex, pci->getOperand(op+1));
      }
  }

#ifdef _DEBUG
  if (dumpPci == 1)
    PCode::dumpContents(code, buf, bufLen);
#endif


  // Do some optimization if required and possible:
  // 1 Eliminate move to temporary space, e.g.
  //   MV(A->B) and ADD(C=D+B) becomes ADD(C=D+A) and MV(A->B) removed.
  // 2 Eliminate redundant MOVE_MBIN8_MBIN8_IBIN32S to TEMPORARY SPACE, e.g.
  //   MV(A->B, sizeof(A)) and MV(B->C, sizeof(B)) becomes
  //   MV(A->C, sizeof(A))
  //   ?? Improvement: could we combine 1 and 2 in one loop?
  // 3 Combine contiguous move instructions into one, e.g.
  //   MV(A->B, sizeof(A)) and MV((A+1)->(B+1), sizeof(A)) becomes
  //   MV(A->B, 2*sizeof(A))
  // 4 Use standard size move (assignment) instruction if possible, e.g.
  //   MV(A->B, sizeof(A)) becomes MV(A->B) if sizeof(A) is 1, 2, 4, or 8.
  //   Do not do this optimization if pCodeMoveFastpath optimization could
  //   be done. That opt depends on the instruction being MOVE_MBIN8_MBIN8_IBIN32S.

  if (pCodeMode_ & PCODE_OPTIMIZE) 
    {
      NABoolean doPCodeMoveFastpathOpt = FALSE;
      if ((iter.first()) &&
	  (iter.last() == iter.first()) &&
	  (PCode::getInstruction(iter.first()) ==
	   PCIT::MOVE_MBIN8_MBIN8_IBIN32S))
	doPCodeMoveFastpathOpt = TRUE;

      PCI *storePci = iter.first();

#if (defined (_DEBUG))
      if(!getenv("PCODE_NO_MOVE_REMOVE"))
#endif
        // Case 1:
        // Keep in mind that we do not eliminate the MOVE (storePci)
        // if the temporary space is the target space of PCI inside
        // or not inside a branch. For example, in the sequece of
        // MOVE (TEMP <- A) ... ADD (TEMP = TEMP + B), the MOVE PCI
        // can not be removed.
        // Any MOVE PCI inside a branch will not be removed either,
        // as the PCI might be conditionally executed.
        {
          Int32 inBranch = 0;
          Int32 branchCnt = 0;
          const Int32 maxBranches = 256;
          PCI *branches[maxBranches];
      
          while (storePci)
            {

              if (PCode::IsBranchInstruction(storePci)) {

                Int32 found = 0;
                for (Int32 i=0; i<branchCnt; i++) {
                  if (storePci == branches[i]) {
                    inBranch--;
                    GenAssert (inBranch >= 0,
			"Expression contains unmatched branch and target instruction")
                   // branches[i] = branches[inBranch];
                    found = 1;
                    break;
                  }
                }

                if (!found) {
                  if (branchCnt > maxBranches - 1) {
                    // Too many branches, give up now and assume what
                    // optmization has done is correct
                    inBranch = 0;
                    break;  // from while (storePci) loop
                  }
                  branches[branchCnt] = storePci;
                  inBranch++;
                  branchCnt++;
                }
              }
              else if (PCode::IsTargetInstruction(storePci)) {

                PCIID branchId = storePci->getLongOperand(0);
                PCI *branch = PCode::getPCI(branchId);
            
                Int32 found = 0;
                for (Int32 i=0; i<branchCnt; i++) {
                  if (branch == branches[i]) {
                    inBranch--;
                    GenAssert (inBranch >= 0,
			"Expression contains unmatched branch and target instruction")
                    found = 1;
                    break; // Should have no other branch instruction
                           // points to this target instruction
                  }
                }
            
                if (!found) {
                  // encounted the target before the branch instruction
                  if (branchCnt > maxBranches - 1) {
                    // Too many branches, give up now and assume what
                    // optmization has done is correct
                    inBranch = 0;
                    break;  // from while (storePci) loop
                  }
                  branches[branchCnt] = branch;
                  inBranch++;
                  branchCnt++;
                }
              }

              // If this instruction stores data to temporary space and
              // it is not in branch
              //
              else if (!inBranch && PCode::IsTemporaryStore(storePci))
                {
                  Int32 replaceUses = 1;
                  PCIListIter iterInner(iter);
                  PCI *usePci = iterInner.next();
                  for (; usePci; usePci = iterInner.next())
                    {
                      if (PCI::replaceUsesOfTarget(storePci, usePci, 1)) {
                        replaceUses = 0;
                        // since we can not eliminate the use of temp space
                        break;  // out from the for loop
                      }
                    }

                  if (replaceUses) {
                    // now we know we can at least replace the use of
                    // temp space. Replace it and see if we can remove it,
                    // i.e. no place the temp space is ever referenced
                    Int32 removeMove = 1;
                    PCIListIter iterInner(iter);
                    PCI *usePci = iterInner.next();
                    for (; usePci; usePci = iterInner.next())
                      {
                        if (PCI::replaceUsesOfTarget(storePci, usePci, 0)) {
                          // can not remove the store PCI
                          removeMove = 0;
                        }
                      }

                    if (removeMove) {
                      code.remove(iter.currItem());
                    }
                  }
                }  // If it's temporay store instruction and not in branch
                   // else check the next instruction

              storePci = iter.next();
            } // while (storePci)
#ifdef _DEBUG
          GenAssert(inBranch == 0, "Unmatched branch and target instruction")
#endif
        }  // !getenv("PCODE_NO_MOVE_REMOVE")

      // Case 2
      // Eliminate redundant MOVE_MBIN8_MBIN8_IBIN32S (to/from TEMPORARY SPACE) pairs
      // from ex_expr lists. All move operations between identical datatypes 
      // result in the generation of this move instruction. 
      // Once a matching MOVE pair is identified we scan the remaining
      // part of the list to ensure that no other instruction accesses the temporary 
      // location we are about to eliminate. 

      // And, combine contiguous move instructions.
      //

      storePci = iter.first();
      while(storePci)
	{
	  // If this instruction does not store data to temporary space,
	  // try the next one.
	  //
	  if(!PCode::IsTemporaryStore(storePci))
	    {
	      storePci = iter.next();
	      continue;
	    }

	  Int32 match = 0;
	  PCIListIter iterInner(iter);
          PCI *loadPci = iterInner.next();
	  for(; loadPci; 
	      loadPci = iterInner.next()) 
	    {
                if(PCode::IsBranchOrTarget(loadPci)) break;

                if(PCI::temporaryStoreLoadOverlap(storePci, loadPci))  
                {
                  if(PCode::getInstruction(loadPci) != PCIT::MOVE_MBIN8_MBIN8_IBIN32S) 
                    break ;  // an instruction other than a move access the same temporary
                             // space as the move in storepci

	          // Else if Move(store) and Move(load) are
	          // to/from the same location, see if the pair can be removed.
	          //
	          if(PCI::temporaryStoreLoadMatch(storePci, loadPci)) 
		  {
		    Int32 anotherLD = 0;
		    PCIListIter iterInnerInner(iterInner);
		    for(PCI *lastPci = iterInnerInner.next(); lastPci;
		        lastPci = iterInnerInner.next()) 
		      {
		        if(PCI::temporaryStoreLoadOverlap(storePci, lastPci)) 
			  {
			    anotherLD = 1;
			    break;
			  }
		      }
		    if(!anotherLD) match = 1;
		    break;
		  }
                  else   // not loadStoreMatch but is a MOVE_MBIN8_MBIN8_IBIN32S
                    break;
                }
               else  //not LoadStoreOverlap
                 continue;
	      }

	    // If a matching pair was not found, try the next instruction.
	    //
	    if(!match)
	      {
	        storePci = iter.next();
	        continue;
	      }

	  // We have found store and load operations to temporary space
	  // that are redundant.
	  //
	  // MV-MV becomes MV. 

	    else {
	      storePci->setOperand(0, loadPci->getOperand(0));
	      storePci->setOperand(1, loadPci->getOperand(1));
	      storePci->setOperand(2, loadPci->getOperand(2));
	      code.remove(iterInner.currItem());
	    }
          }


      // Case 3:
      // Now do two optimizations in this loop
      // a. Combine contiguous move operations into one.
      // b. Replace standard size moves with specific move instructions
      // c. Remove RANGE_MFLT64 instructions which companion MOVE MFLT64
      //    instructions were removed at previous steps
      //
      for(storePci = iter.first(); storePci; storePci = iter.next()) 
	{
	  // If this instruction is a MV, see if it can be combined with the
	  // next instruction if it is also a MV.
	  //
        if(PCode::getInstruction(storePci) == PCIT::MOVE_MBIN8_MBIN8_IBIN32S) 
	    {
	      PCIListIter iterNext(iter);

              // Don't do this optimization if LLO optimization is specified
	      for(PCI *nextPci = iterNext.next();
                  nextPci && !(pCodeMode_ & PCODE_LLO); 
		  nextPci=iterNext.next()) 
		{
                    if(PCode::getInstruction(nextPci) != PCIT::MOVE_MBIN8_MBIN8_IBIN32S) break;

		  // If the two MV's are contiguous, combine them.
		  // The DST ATP's must be the same, and the SRC
		  // ATP's must be the same, and the second DST
		  // start must be equal to the first DST end, and
		  // the second SRC start must be equal to the
		  // first SRC end.
		  //
                  if((nextPci->getOperand(0) == storePci->getOperand(0)) &&
		     (nextPci->getOperand(1) == storePci->getOperand(1)) &&
		     (nextPci->getOperand(3) == storePci->getOperand(3)) &&
		     (nextPci->getOperand(4) == storePci->getOperand(4)) &&
		     (nextPci->getOperand(2) == (storePci->getOperand(2) 
						 + storePci->getOperand(6))) &&
		     (nextPci->getOperand(5) == (storePci->getOperand(5) 
						 + storePci->getOperand(6)))) 
		    {
      
		      // The length of the combined MV is the sum
		      // of the two MV's.
		      //
		      storePci->setOperand(6, storePci->getOperand(6) 
					   + nextPci->getOperand(6));

		      // Remove the second MV.
		      //
		      code.remove(iterNext.currItem());
		    }
		  else 
		    {
		      break;
		    }
		}

                // Next try to replace standard size moves with specific
                // move instructions for these sizes.
                // Standard Sizes are: 1, 2, 4 and 8 byte moves.
                // This avoids doing a str_cpy_all for these standard sizes.
                //
#if (defined (_DEBUG))
                if (!getenv("PCODE_NO_STD_MOVE"))
#endif
                  {
                  if (NOT doPCodeMoveFastpathOpt)
                    {
                    Lng32 length = storePci->getOperand(6);

                    if (length == 1 ||
                        length == 2 ||
                        length == 4 ||
                        length == 8)
                      {
                        PCIType::AddressingMode am = PCIT::AM_NONE;

                        // Determine the proper addressing mode for this size.
                        //
                        switch(length)
                          {
                          case 1:
                            am = PCIT::MBIN8;
                            break;
                          case 2:
                            am = PCIT::MBIN16U;
                            break;
                          case 4:
                            am = PCIT::MBIN32U;
                            break;
                          case 8:
                            am = PCIT::MBIN64S;
                            break;
                          }

                        // Addressing modes for move instruction.
                        // These are always 'same-size' to 'same-size' moves.
                        //
                        AML aml(am, am);

                        // Location of data is the same as for original
                        // move instruction.  but we no longer need the
                        // length operand.
                        //
                        OL ol(storePci->getOperand(0),
                              storePci->getOperand(1),
                              storePci->getOperand(2),
                              storePci->getOperand(3),
                              storePci->getOperand(4),
                              storePci->getOperand(5));

                        // Change the generic move instuction to a standard
                        // move.
                        storePci->replaceAddressingModesAndOperands(aml, ol);
                      }
	            }   // if
	          }
	    }    // if PCIT::MOVE_MBIN8_MBIN8_IBIN32S
        else
#if (defined (_DEBUG))
             if(!getenv("PCODE_NO_FLOAT_RANGE_REMOVE"))
            {
#endif
              if(PCode::getInstruction(storePci) == PCIT::RANGE_MFLT64)
                {
                  PCIListIter iterRange(iter);
                  PCI *rangePci = iterRange.next();
                  for (; rangePci; rangePci = iterRange.next())
                    {
                      if(PCode::IsBranchOrTarget(rangePci)) break;

                      if(PCode::getInstruction(rangePci) == PCIT::RANGE_MFLT64)
                        {
                          if((rangePci->getOperand(0) == storePci->getOperand(0)) &&
                             (rangePci->getOperand(1) == storePci->getOperand(1)) &&
                             (rangePci->getOperand(2) == storePci->getOperand(2)))
                            {
                              code.remove(iterRange.currItem());
                            }
                        }
                    }
                }
#if (defined (_DEBUG))
            }  // !getenv("PCODE_NO_FLOAT_RANGE_REMOVE")
#endif

	}   // combine contiguous moves and use standard size move

    } // PCODE_OPTIMIZE

#ifdef _DEBUG
  if (dumpPci == 1)
    PCode::dumpContents(code, buf, bufLen);
#endif

  // Since the call to get the base data address for a tupp is relatively
  // expensive (triple dereference along with relocation checking), we want
  // to minimize the number of calls to getDataPointer. This is accomplished
  // be loading the base data address for each tupp that is possibly
  // accessed by the expression once before evaluating the expression. The
  // pointers are stored at the top of the expression stack and all
  // ATP references in the expression use the address pointers from the
  // stack.
  //
  // Make a map of the accessed tupps. The mapping function subtracts the
  // min ATP from the ATP and the min ATP index from the ATP index and then
  // maps the resuling shifted ATP and ATP index into a 2-D array. This
  // compacts the map somewhat.
  //
  Int32 opNum = 0;
  Int32 *atpMap = 0;
  Int32 *atpIndexMap = 0;
  if(atpOperation) {
    Int32 numAtps = (maxAtp - minAtp) + 1;
    Int32 numAtpIndexs = (maxAtpIndex - minAtpIndex) + 1;
    Int32 numOps = numAtps * numAtpIndexs;
    char *tuppMap = new(space) char[numOps];
    atpMap = new(space) Int32[numOps];
    atpIndexMap = new(space) Int32[numOps];
    Int32 i=0;
    for(; i<numOps; i++) {
      atpMap[i] = -1;
      atpIndexMap[i] = -1;
      tuppMap[i] = 0;
    }

    // Iterate over all of the LD/ST_ATP* operations.
    // Mark in the map the accessed tupps and change the LD/ST_ATP* operand
    // to be the computed index.
    //
    for(pci = iter.first(); pci; pci = iter.next()) {
      Int32 atp, atpIndex, index;
      PCIT::AddressingMode am;
      for(Int32 i=0,op=0; 
	  i<pci->getNumberAddressingModes(); 
	  i++,op+=PCIT::getNumberOperandsForAddressingMode(am))
	{
	  am = pci->getAddressingMode(i);
	  if(!PCIT::isMemoryAddressingMode(am)) continue;
	  
	  atp = pci->getOperand(op);
	  atpIndex = pci->getOperand(op+1);
	  index = numAtpIndexs * (atp - minAtp) + (atpIndex - minAtpIndex);
	  tuppMap[index] = 1;
	  atpMap[index] = atp;
	  atpIndexMap[index] = atpIndex;
	}
    }


    // Compress the array of ATPs and ATP indexes to those that are actually
    // accessed.
    //
    for(i=0; i<numOps; i++) {
      if(tuppMap[i] && (atpIndexMap[i] > 1)) {
        tuppMap[i] = opNum + 4;
        atpMap[opNum] = atpMap[i];
        atpIndexMap[opNum] = atpIndexMap[i];
        opNum++;
      } else if(tuppMap[i]) {
	if(atpMap[i] == 0)
	  tuppMap[i] = atpIndexMap[i] + 1;
	else
	  tuppMap[i] = 3;
      }
    }

    // Iterate over all of the LD/ST_ATP* operations.
    //
    for(pci = iter.first(); pci; pci = iter.next()) {
      Int32 atp, atpIndex, index, compressedIndex;
      PCIT::AddressingMode am;
      for(Int32 i=0,op=0; 
	  i<pci->getNumberAddressingModes(); 
	  i++,op+=PCIT::getNumberOperandsForAddressingMode(am))
	{
	  am = pci->getAddressingMode(i);
	  if(!PCIT::isMemoryAddressingMode(am)) continue;
	  
	  // Compute the index into the tupp map.
	  //
	  atp = pci->getOperand(op);
	  atpIndex = pci->getOperand(op+1);
	  index = numAtpIndexs * (atp - minAtp) + (atpIndex - minAtpIndex);
	  compressedIndex = tuppMap[index];
	  
	  // Store the new index as the ith operands and move the
	  // offset from the (i+2)th to the (i+1)th operand, etc.
	  //
	  pci->setOperand(op, compressedIndex);
	  for(Int32 j=op+1; j<pci->getNumberOperands()-1; j++)
	    pci->setOperand(j, pci->getOperand(j+1));
	  pci->setNumberOperands(pci->getNumberOperands()-1);
	  op--;
	}
    }
  }
    
  // There is only a fixed amount of PCODE stack space available for the
  // expression evaluation at runtime. This is currently fixed to
  // 256 integers. If the number of tupp pointers plus the maximum stack
  // depth exceeds 256, then abort PCODE generation because a PCODE stack
  // overflow is possible at runtime.
  //
  if(4 + opNum + maximumStackDepth >= 256) {
    setPCodeObject(0);
    pCode_ = 0;
    NADELETE(codeObject, PCode, heap);
    return ex_expr::EXPR_OK;
  }

  // Fixup the branch targets (no more code changes after this).
  //
  // Compute the offset in the generated code vector of the first element
  // for each PCI.
  //
  Int32 position = 0;
  for(pci = iter.first(); pci; pci = iter.next()) {
    pci->setCodePosition(position);
    position += pci->getGeneratedCodeSize();
  }
  // Based on the offset for the branch and target PCI's, compute and set 
  // the branch distance in the branch instruction.
  //
  for(pci = iter.first(); pci; pci = iter.next()) {
    if(PCode::IsTargetInstruction(pci)) {
      PCIID branchId = pci->getLongOperand(0);
      PCI *branchPci = PCode::getPCI(branchId);
      Int32 distance = pci->getCodePosition() - branchPci->getCodePosition() - 1;
      if((branchPci->getOperation() == PCIT::Op_CLAUSE_BRANCH) ||
	 (branchPci->getOperation() == PCIT::Op_BRANCH_AND) ||
	 (branchPci->getOperation() == PCIT::Op_BRANCH_OR))
	branchPci->setLongOperand(0, distance);
      else
	branchPci->setLongOperand(branchPci->getNumberOperands()-1, distance);
    }
  }

  //#ifndef NDEBUG
#ifdef _DEBUG
  if(getenv("PCODE_PRINT")) {
    fprintf(stderr, "PCode ...\n");
    PCode::print(code);
    fprintf(stderr, "\n");
  }
#endif

#ifdef _DEBUG
  if (dumpPci == 1)
    PCode::dumpContents(code, buf, bufLen);
#endif

  codeObject->setPCIList(code);
  setPCodeObject(codeObject);
  if (!pCode_.getPointer())
    pCode_ = new(space) PCodeSegment();

  Int32 codeSize;
  setPCodeBinary(codeObject->generateCodeSegment(opNum, atpMap, atpIndexMap, 
           &codeSize));
  pCode_.getPointer()->setPCodeSegmentSize(codeSize);
  pCode_.getPointer()->setContainsClauseEval(containsClauseEval);

#ifdef _DEBUG
  if (dumpPci == 1)
    PCode::dumpContents(pCode_.getPointer()->getPCodeBinary(), buf, bufLen);
#endif

  // get rid of the temporary object
  if (! ex_expr_base::forShowplan(f)) 
    setPCodeObject(0);

  // Perform PCODE optimizations
  if (pCodeMode_ & PCODE_LLO) {
    PCodeCfg* cfg = new(heap) PCodeCfg(this, atpMap, atpIndexMap, heap, space);
    cfg->optimize();
    NADELETE(cfg, PCodeCfg, heap);
  }

  // see if move fastpath could be done.
  // In this case, we move source to target directly without going
  // through expr eval at runtime.
  // Done if there is only one pcode instruction, MOVE_MBIN8_MBIN8_IBIN32S.
  // 
  PCodeBinary *pc = getPCodeBinary();
#ifdef _DEBUG
  if (getenv("NO_PCODE_MOVE_FASTPATH"))
    return ex_expr::EXPR_OK;
#endif
  if (pc)
    {
      if ((pc[0] == 2) &&
	  (pc[5] == PCIT::MOVE_MBIN8_MBIN8_IBIN32S) &&
          ((pc[11] == PCIT::END) || (pc[11] == PCIT::RETURN)))
	{
	  setPCodeMoveFastpath(TRUE);
	}
    }

  return ex_expr::EXPR_OK;
};

void ex_expr::pCodePrint() {
  PCode *pc = getPCodeObject();
  if(pc) {
    if(pc->isProfilingOn()) {
     // fprintf(stderr, "Expression ??? \n");
      pc->profilePrint();
    }
  }
};