/**********************************************************************
// @@@ 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 @@@
**********************************************************************/

// Native Expressions only officially supported on Linux for now.

//#ifndef __EID  /* MOVED THIS LINE DOWN PAST PCodeCfg::NExLog() */

///////////////////////////////////////////////////////////////////////
//
// The following are a few notes regarding native exprs
//
// 1. A few things are implemented differently for native expressions.
//    For example, NULL values will be represented internally as an unsigned
//    char.  It will have either a non-zero value (null) or zero value (not
//    null).
//
// 2. Code the the pcode graph is generated in program layout order for
//    libjit, as there doesn't seem to be any other way or doing this.  This
//    can prove difficult in maintaining correctness for determining the temps
//    that correspond to various operands.
//
// 3. Related to (2), both getJitValue() and storeJitValue() may need to be
//    re-examined (specifically for attempting to use a jitValue_ that was
//    declared along one particular path, but not on another.  Since jitValue_
//    for an operand is saved irrespective of control flow, we can have problems
//
// 4. If a value is created in along a conditional path, it may still be
//    referenced anywhere if it is marked addressable.
//
///////////////////////////////////////////////////////////////////////

#include "Platform.h"

#if 1   /* NA_LINUX_LLVMJIT */
#include "NAAssert.h"

// This #define must come *before* the #include "ExpPCodeOptimizations.h" line
#define COMING_FROM_NATIVE_EXPR_SOURCE_FILE

#endif  /* NA_LINUX_LLVMJIT */

#include "ExpPCodeOptimizations.h"
#include <signal.h>

#if 1   /* NA_LINUX_LLVMJIT */
#include "llvm/Support/raw_ostream.h"    /* FOR NEW MODULE DUMPING IDEA */
#include "llvm/Support/InstIterator.h"   /* FOR NEW MODULE DUMPING IDEA */
#include <fstream>
#endif  /* NA_LINUX_LLVMJIT */

//
// NExLog() - Routine used to log Native Expression debug info to the
// log file for this instance of the Compiler.
//
void PCodeCfg::NExLog(const char *data)
{
   char       * NExLogPth    = NULL ;

   if ( NExDbgInfoPtr_  &&  NExDbgInfoPtr_ > (NExDbgInfo *)4096 ) // May be offset
        NExLogPth = NExDbgInfoPtr_->getNExLogPath() ;

   if ( NExLogPth         && // May be null when called by showplan
       *NExLogPth != '\0' )  // OR may have null pathname
   {
     ofstream fileout( NExLogPth, ios::app);
     fileout << data ;
   }
}

#ifndef __EID

#if NExprDbgLvl > VV_NO
//
// For routines in the PCodeCfg class, we have access to the
// NExprDbgLvl_ member variable and we use it to determine how
// verbose the user wants the output to be.
//
#define DPT0( str1, VBlvl, str2 )                                      \
 { if ( NExprDbgLvl_ >= VBlvl ) {                                      \
      sprintf( NExBuf, str1 str2 );                                    \
      NExLog( NExBuf ); } }
#define DPT1( str1, VBlvl, str2, Arg5 )                                \
 { if ( NExprDbgLvl_ >= VBlvl ) {                                      \
      sprintf( NExBuf, str1 str2, Arg5 );                              \
      NExLog( NExBuf ); } }
#define DPT2( str1, VBlvl, str2, Arg5, Arg6 )                          \
 { if ( NExprDbgLvl_ >= VBlvl ) {                                      \
      sprintf( NExBuf, str1 str2, Arg5, Arg6 );                        \
      NExLog( NExBuf ); } }
#define DPT3( str1, VBlvl, str2, Arg5, Arg6, Arg7 )                    \
 { if ( NExprDbgLvl_ >= VBlvl ) {                                      \
      sprintf( NExBuf, str1 str2, Arg5, Arg6, Arg7 );                  \
      NExLog( NExBuf ); } }
#define DPT4( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8 )              \
 { if ( NExprDbgLvl_ >= VBlvl ) {                                      \
      sprintf( NExBuf, str1 str2, Arg5, Arg6, Arg7, Arg8 );            \
      NExLog( NExBuf ); } }
#define DPT5( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8, Arg9 )        \
 { if ( NExprDbgLvl_ >= VBlvl ) {                                      \
      sprintf( NExBuf, str1 str2, Arg5, Arg6, Arg7, Arg8, Arg9 );      \
      NExLog( NExBuf ); } }
#define DPT6( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8, Arg9, Arg10 )     \
 { if ( NExprDbgLvl_ >= VBlvl ) {                                          \
      sprintf( NExBuf, str1 str2, Arg5, Arg6, Arg7, Arg8, Arg9, Arg10 );   \
      NExLog( NExBuf ); } }
//
// NOTE: The following CDPTxx macros are useable ONLY within routines
//       that have 'cfg' defined as a pointer to the PCodeCfg.
//
#define CDPT0( str1, VBlvl, str2 )                                     \
 { if ( cfg->getNExprDbgLvl() >= VBlvl ) {                             \
      sprintf( NExBuf, str1 str2 );                                    \
      cfg->NExLog( NExBuf ); } }
#define CDPT1( str1, VBlvl, str2, Arg5 )                               \
 { if ( cfg->getNExprDbgLvl() >= VBlvl ) {                             \
      sprintf( NExBuf, str1 str2, Arg5 );                              \
      cfg->NExLog( NExBuf ); } }
#define CDPT2( str1, VBlvl, str2, Arg5, Arg6 )                         \
 { if ( cfg->getNExprDbgLvl() >= VBlvl ) {                             \
      sprintf( NExBuf, str1 str2, Arg5, Arg6 );                        \
      cfg->NExLog( NExBuf ); } }
#define CDPT3( str1, VBlvl, str2, Arg5, Arg6, Arg7 )                   \
 { if ( cfg->getNExprDbgLvl() >= VBlvl ) {                             \
      sprintf( NExBuf, str1 str2, Arg5, Arg6, Arg7 );                  \
      cfg->NExLog( NExBuf ); } }
#define CDPT4( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8 )             \
 { if ( cfg->getNExprDbgLvl() >= VBlvl ) {                             \
      sprintf( NExBuf, str1 str2, Arg5, Arg6, Arg7, Arg8 );            \
      cfg->NExLog( NExBuf ); } }
#define CDPT5( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8, Arg9 )       \
 { if ( cfg->getNExprDbgLvl() >= VBlvl ) {                             \
      sprintf( NExBuf, str1 str2, Arg5, Arg6, Arg7, Arg8, Arg9 );      \
      cfg->NExLog( NExBuf ); } }
#define CDPT6( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8, Arg9, Arg10 )    \
 { if ( cfg->getNExprDbgLvl() >= VBlvl ) {                                 \
      sprintf( NExBuf, str1 str2, Arg5, Arg6, Arg7, Arg8, Arg9, Arg10 );   \
      cfg->NExLog( NExBuf ); } }


#define PRINT_DETAILS_OF_RDOp( OpNum, PCOp ) {                                \
    if ( NExprDbgLvl_ >= VV_XD ) {                                            \
      if ( PCOp->getStackIndex() == 2 )                                       \
         sprintf( NExBuf, "DETAILS of RD_Op[%d] at %p "                       \
                          "WITH stackIndex_ = 2 are: \n",                     \
                           OpNum, PCOp );                                     \
      else                                                                    \
         sprintf( NExBuf, "DETAILS of RD_Op[%d] at %p are: \n", OpNum, PCOp );\
      NExLog( NExBuf );                                                       \
      sprintf( NExBuf, "stackIndex_ = %d, offset_ = %d, len_=%d, "            \
             "operandType_=%d, nullBitIdx=%d, CJV=%p\n",                      \
             PCOp->getStackIndex(), PCOp->getOffset(), PCOp->getLen(),        \
             PCOp->getType(), PCOp->getNullBitIndex(), PCOp->getCurrJitVal());\
      NExLog( NExBuf );                                                       \
    }                                                                         \
  }

#define PRINT_DETAILS_OF_WROp( OpNum, PCOp ) {                                \
    if ( NExprDbgLvl_ >= VV_XD ) {                                            \
      if ( PCOp->getStackIndex() == 2 )                                       \
         sprintf( NExBuf, "DETAILS of WR_Op[%d] at %p "                       \
                          "WITH stackIndex_ = 2 are: \n",                     \
                                 OpNum, PCOp );                               \
      else                                                                    \
         sprintf( NExBuf, "DETAILS of WR_Op[%d] at %p are: \n", OpNum, PCOp );\
      NExLog( NExBuf );                                                       \
      sprintf( NExBuf, "stackIndex_ = %d, offset_ = %d, len_=%d, "            \
             "operandType_=%d, nullBitIdx=%d, CJV=%p\n",                      \
             PCOp->getStackIndex(), PCOp->getOffset(), PCOp->getLen(),        \
             PCOp->getType(), PCOp->getNullBitIndex(), PCOp->getCurrJitVal());\
      NExLog( NExBuf );                                                       \
   }                                                                          \
 }
#else   /* Define this macros to result in nothing. */
#define DPT0( str1, VBlvl, str2 )
#define DPT1( str1, VBlvl, str2, Arg5 )
#define DPT2( str1, VBlvl, str2, Arg5, Arg6 )
#define DPT3( str1, VBlvl, str2, Arg5, Arg6, Arg7 )
#define DPT4( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8 )
#define DPT5( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8, Arg9 )
#define DPT6( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8, Arg9, Arg10 )
#define CDPT0( str1, VBlvl, str2 )
#define CDPT1( str1, VBlvl, str2, Arg5 )
#define CDPT2( str1, VBlvl, str2, Arg5, Arg6 )
#define CDPT3( str1, VBlvl, str2, Arg5, Arg6, Arg7 )
#define CDPT4( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8 )
#define CDPT5( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8, Arg9 )
#define CDPT6( str1, VBlvl, str2, Arg5, Arg6, Arg7, Arg8, Arg9, Arg10 )
#define PRINT_DETAILS_OF_RDOp( OpNum, PCOp )
#define PRINT_DETAILS_OF_WROp( OpNum, PCOp )

#endif /* NExprDbgLvl >= VV_I0 */

#include "exp_datetime.h"


#include "udis86.h"

#include <sstream>
#include <iostream>
using namespace llvm;


// Can we have null tuple pointers (no, if we're on R2.5)
#define NULL_TUPLE_PTRS 0

//
// Compute the dominator tree
//
void PCodeCfg::computeDomTree()
{
  CollIndex i;

  // First we clear bit vector that tracks available ops.
  //
  // NOTE: We are using the onesVector to hold the "Dominator Tree" info.
  // There is a onesVector for each PCBlock.  For any particular PCBlock X,
  // if the bit corresponding to PCBlock Y is ON (in block X's onesVector),
  // then it means that PCBlock Y "dominates" block X.  That is, *all* paths
  // in the flow graph (PCodeCfg) from the entry block to block X are
  // guaranteed to go through block Y.  
  //
  FOREACH_BLOCK_REV_DFO( PCBlk, firstPCInst, lastPCInst, indx ) {
    PCBlk->onesVector.clear();
  } ENDFE_BLOCK_REV_DFO

  FOREACH_BLOCK_REV_DFO( PCBlk, firstPCInst, lastPCInst, indx ) {

    // IN = INTERSECT(PREDS)
    for (i=0; i < PCBlk->getPreds().entries(); i++) {
      if (i == 0)
        PCBlk->onesVector = PCBlk->getPreds()[i]->onesVector;
      else
        PCBlk->onesVector.intersectSet(PCBlk->getPreds()[i]->onesVector);
    }

    // Every PCode block dominates itself (immediate dominator)
    PCBlk->onesVector += PCBlk->getBlockNum();

  } ENDFE_BLOCK_REV_DFO
}

#if 1 /* NA_LINUX_LLVMJIT */
//
// NatExprName:  routine used by debug and instrumentation code to
// return a PCode Instruction name given its opcode.
//
// NOTE: This routine handles only the opcodes for PCODE instructions
//       that are translatable to native code.
//
// NOTE: In the future, as more PCODE instructions are made translatable
//       to native code, the routine should have lines of code added
//       to know about the new PCODE instructions.
//
#if NExprDbgLvl > VV_NO
const char * NatExprName( Int32 opc )
{
   switch ( opc )
   {
    case PCIT::OPDATA_MPTR32_IBIN32S:  {return "OPDATA_MPTR32_IBIN32S" ; break;}
    case PCIT::OPDATA_MBIN16U_IBIN32S: {return "OPDATA_MBIN16U_IBIN32S"; break;}
    case PCIT::MOVE_MBIN32S:             {return "MOVE_MBIN32S"        ; break;}
    case PCIT::MOVE_MBIN32S_IBIN32S:     {return "MOVE_MBIN32S_IBIN32S"; break;}
    case PCIT::MOVE_MBIN8_MBIN8_IBIN32S: {return "MOVE_MBIN8_MBIN8_IBIN32S"; break;}
    case PCIT::MOVE_MBIN32U_MBIN16U:     {return "MOVE_MBIN32U_MBIN16U"; break;}
    case PCIT::MOVE_MBIN32S_MBIN16U:     {return "MOVE_MBIN32S_MBIN16U"; break;}
    case PCIT::MOVE_MBIN64S_MBIN16U:     {return "MOVE_MBIN64S_MBIN16U"; break;}
    case PCIT::MOVE_MBIN32U_MBIN16S:     {return "MOVE_MBIN32U_MBIN16S"; break;}
    case PCIT::MOVE_MBIN32S_MBIN16S:     {return "MOVE_MBIN32S_MBIN16S"; break;}
    case PCIT::MOVE_MBIN64S_MBIN16S:     {return "MOVE_MBIN64S_MBIN16S"; break;}
    case PCIT::MOVE_MBIN64S_MBIN32U:     {return "MOVE_MBIN64S_MBIN32U"; break;}
    case PCIT::MOVE_MBIN64S_MBIN32S:     {return "MOVE_MBIN64S_MBIN32S"; break;}
    case PCIT::EQ_MBIN32S_MBIN16S_MBIN16S: {return "EQ_MBIN32S_MBIN16S_MBIN16S"; break;}
    case PCIT::EQ_MBIN32S_MBIN16S_MBIN32S: {return "EQ_MBIN32S_MBIN16S_MBIN32S"; break;}
    case PCIT::EQ_MBIN32S_MBIN32S_MBIN32S: {return "EQ_MBIN32S_MBIN32S_MBIN32S"; break;}
    case PCIT::EQ_MBIN32S_MBIN16U_MBIN16U: {return "EQ_MBIN32S_MBIN16U_MBIN16U"; break;}
    case PCIT::EQ_MBIN32S_MBIN16U_MBIN32U: {return "EQ_MBIN32S_MBIN16U_MBIN32U"; break;}
    case PCIT::EQ_MBIN32S_MBIN32U_MBIN32U: {return "EQ_MBIN32S_MBIN32U_MBIN32U"; break;}
    case PCIT::EQ_MBIN32S_MBIN16S_MBIN32U: {return "EQ_MBIN32S_MBIN16S_MBIN32U"; break;}
    case PCIT::LT_MBIN32S_MBIN16S_MBIN16S: {return "LT_MBIN32S_MBIN16S_MBIN16S"; break;}
    case PCIT::LT_MBIN32S_MBIN16S_MBIN32S: {return "LT_MBIN32S_MBIN16S_MBIN32S"; break;}
    case PCIT::LT_MBIN32S_MBIN32S_MBIN32S: {return "LT_MBIN32S_MBIN32S_MBIN32S"; break;}
    case PCIT::LT_MBIN32S_MBIN16U_MBIN16U: {return "LT_MBIN32S_MBIN16U_MBIN16U"; break;}
    case PCIT::LT_MBIN32S_MBIN16U_MBIN32U: {return "LT_MBIN32S_MBIN16U_MBIN32U"; break;}
    case PCIT::LT_MBIN32S_MBIN32U_MBIN32U: {return "LT_MBIN32S_MBIN32U_MBIN32U"; break;}
    case PCIT::GT_MBIN32S_MBIN16S_MBIN16S: {return "GT_MBIN32S_MBIN16S_MBIN16S"; break;}
    case PCIT::GT_MBIN32S_MBIN16S_MBIN32S: {return "GT_MBIN32S_MBIN16S_MBIN32S"; break;}
    case PCIT::GT_MBIN32S_MBIN32S_MBIN32S: {return "GT_MBIN32S_MBIN32S_MBIN32S"; break;}
    case PCIT::GT_MBIN32S_MBIN16U_MBIN16U: {return "GT_MBIN32S_MBIN16U_MBIN16U"; break;}
    case PCIT::GT_MBIN32S_MBIN16U_MBIN32U: {return "GT_MBIN32S_MBIN16U_MBIN32U"; break;}
    case PCIT::GT_MBIN32S_MBIN32U_MBIN32U: {return "GT_MBIN32S_MBIN32U_MBIN32U"; break;}
    case PCIT::SUM_MBIN32S_MBIN32S:        {return "SUM_MBIN32S_MBIN32S"; break;}
    case PCIT::SUM_MBIN64S_MBIN64S:        {return "SUM_MBIN64S_MBIN64S"; break;}
    case PCIT::MINMAX_MBIN8_MBIN8_MBIN32S_IBIN32S:
      {return "MINMAX_MBIN8_MBIN8_MBIN32S_IBIN32S"; break;}
    case PCIT::BRANCH:                     {return "BRANCH"; break;}
    case PCIT::CLAUSE_EVAL:                {return "CLAUSE_EVAL"; break;}
    case PCIT::FILL_MEM_BYTES:             {return "FILL_MEM_BYTES"; break;}
    case PCIT::MOVE_MBIN16U_IBIN16U:       {return "MOVE_MBIN16U_IBIN16U"; break;}
    case PCIT::LE_MBIN32S_MBIN16S_MBIN16S: {return "LE_MBIN32S_MBIN16S_MBIN16S"; break;}
    case PCIT::LE_MBIN32S_MBIN16S_MBIN32S: {return "LE_MBIN32S_MBIN16S_MBIN32S"; break;}
    case PCIT::LE_MBIN32S_MBIN32S_MBIN32S: {return "LE_MBIN32S_MBIN32S_MBIN32S"; break;}
    case PCIT::LE_MBIN32S_MBIN16U_MBIN16U: {return "LE_MBIN32S_MBIN16U_MBIN16U"; break;}
    case PCIT::LE_MBIN32S_MBIN16U_MBIN32U: {return "LE_MBIN32S_MBIN16U_MBIN32U"; break;}
    case PCIT::LE_MBIN32S_MBIN32U_MBIN32U: {return "LE_MBIN32S_MBIN32U_MBIN32U"; break;}
    case PCIT::GE_MBIN32S_MBIN16S_MBIN16S: {return "GE_MBIN32S_MBIN16S_MBIN16S"; break;}
    case PCIT::GE_MBIN32S_MBIN16S_MBIN32S: {return "GE_MBIN32S_MBIN16S_MBIN32S"; break;}
    case PCIT::GE_MBIN32S_MBIN32S_MBIN32S: {return "GE_MBIN32S_MBIN32S_MBIN32S"; break;}
    case PCIT::GE_MBIN32S_MBIN16U_MBIN16U: {return "GE_MBIN32S_MBIN16U_MBIN16U"; break;}
    case PCIT::GE_MBIN32S_MBIN16U_MBIN32U: {return "GE_MBIN32S_MBIN16U_MBIN32U"; break;}
    case PCIT::GE_MBIN32S_MBIN32U_MBIN32U: {return "GE_MBIN32S_MBIN32U_MBIN32U"; break;}
    case PCIT::EQ_MBIN32S_MBIN16U_MBIN16S: {return "EQ_MBIN32S_MBIN16U_MBIN16S"; break;}
    case PCIT::EQ_MBIN32S_MBIN64S_MBIN64S: {return "EQ_MBIN32S_MBIN64S_MBIN64S"; break;}
    case PCIT::LT_MBIN32S_MBIN64S_MBIN64S: {return "LT_MBIN32S_MBIN64S_MBIN64S"; break;}
    case PCIT::LE_MBIN32S_MBIN64S_MBIN64S: {return "LE_MBIN32S_MBIN64S_MBIN64S"; break;}
    case PCIT::GT_MBIN32S_MBIN64S_MBIN64S: {return "GT_MBIN32S_MBIN64S_MBIN64S"; break;}
    case PCIT::GE_MBIN32S_MBIN64S_MBIN64S: {return "GE_MBIN32S_MBIN64S_MBIN64S"; break;}
    case PCIT::BRANCH_AND:                 {return "BRANCH_AND"; break;}
    case PCIT::BRANCH_OR:                  {return "BRANCH_OR"; break;}
    case PCIT::MOVE_MBIN8_MBIN8:           {return "MOVE_MBIN8_MBIN8"; break;}
    case PCIT::MOVE_MBIN16U_MBIN16U:       {return "MOVE_MBIN16U_MBIN16U"; break;}
    case PCIT::MOVE_MBIN32U_MBIN32U:       {return "MOVE_MBIN32U_MBIN32U"; break;}
    case PCIT::MOVE_MBIN64S_MBIN64S:       {return "MOVE_MBIN64S_MBIN64S"; break;}
    case PCIT::OPDATA_MPTR32_IBIN32S_IBIN32S: {return "OPDATA_MPTR32_IBIN32S_IBIN32S"; break;}
    case PCIT::OPDATA_MATTR5_IBIN32S:      {return "OPDATA_MATTR5_IBIN32S"; break;}
    case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_IATTR3_IBIN32S:
      {return "NOT_NULL_BRANCH_MBIN32S_MBIN32S_IATTR3_IBIN32S"; break;}
    case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S:
      {return "NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S"; break;}
    case PCIT::NULL_TEST_MBIN32S_MATTR5_IBIN32S_IBIN32S:
      {return "NULL_TEST_MBIN32S_MATTR5_IBIN32S_IBIN32S"; break;}
    case PCIT::RETURN:             {return "RETURN"; break;}
    case PCIT::RETURN_IBIN32S:     {return "RETURN_IBIN32S"; break;}
    case PCIT::MOVE_MATTR5_MATTR5: {return "MOVE_MATTR5_MATTR5"; break;}
    case PCIT::MOVE_MBIN16U_MBIN8: {return "MOVE_MBIN16U_MBIN8"; break;}
    case PCIT::NNB_MATTR3_IBIN32S: {return "NNB_MATTR3_IBIN32S"; break;}
    case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
         {return "NOT_NULL_BRANCH_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S"; break;}
    case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
         {return "NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S"; break;}
    case PCIT::NNB_SPECIAL_NULLS_MBIN32S_MATTR3_MATTR3_IBIN32S_IBIN32S:
         {return "NNB_SPECIAL_NULLS_MBIN32S_MATTR3_MATTR3_IBIN32S_IBIN32S"; break;}
    case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN32S_MBIN32S:
         {return "SUM_MATTR3_MATTR3_IBIN32S_MBIN32S_MBIN32S"; break;}
    case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN64S:
         {return "SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN64S"; break;}
    case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN32S:
         {return "SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN32S"; break;}
    case PCIT::ADD_MBIN32S_MBIN16S_MBIN16S: {return "ADD_MBIN32S_MBIN16S_MBIN16S"; break;}
    case PCIT::ADD_MBIN16S_MBIN16S_MBIN16S: {return "ADD_MBIN16S_MBIN16S_MBIN16S"; break;}
    case PCIT::ADD_MBIN32S_MBIN32S_MBIN32S: {return "ADD_MBIN32S_MBIN32S_MBIN32S"; break;}
    case PCIT::ADD_MBIN64S_MBIN64S_MBIN64S: {return "ADD_MBIN64S_MBIN64S_MBIN64S"; break;}
    case PCIT::ADD_MBIN32S_MBIN16S_MBIN32S: {return "ADD_MBIN32S_MBIN16S_MBIN32S"; break;}
    case PCIT::ADD_MBIN64S_MBIN32S_MBIN64S: {return "ADD_MBIN64S_MBIN32S_MBIN64S"; break;}
    case PCIT::SUB_MBIN16S_MBIN16S_MBIN16S: {return "SUB_MBIN16S_MBIN16S_MBIN16S"; break;}
    case PCIT::SUB_MBIN32S_MBIN32S_MBIN32S: {return "SUB_MBIN32S_MBIN32S_MBIN32S"; break;}
    case PCIT::SUB_MBIN64S_MBIN64S_MBIN64S: {return "SUB_MBIN64S_MBIN64S_MBIN64S"; break;}
    case PCIT::SUB_MBIN32S_MBIN16S_MBIN16S: {return "SUB_MBIN32S_MBIN16S_MBIN16S"; break;}
    case PCIT::SUB_MBIN32S_MBIN16S_MBIN32S: {return "SUB_MBIN32S_MBIN16S_MBIN32S"; break;}
    case PCIT::SUB_MBIN32S_MBIN32S_MBIN16S: {return "SUB_MBIN32S_MBIN32S_MBIN16S"; break;}
    case PCIT::MUL_MBIN32S_MBIN32S_MBIN32S: {return "MUL_MBIN32S_MBIN32S_MBIN32S"; break;}
    case PCIT::MUL_MBIN32S_MBIN16S_MBIN16S: {return "MUL_MBIN32S_MBIN16S_MBIN16S"; break;}
    case PCIT::MUL_MBIN32S_MBIN16S_MBIN32S: {return "MUL_MBIN32S_MBIN16S_MBIN32S"; break;}
    case PCIT::MUL_MBIN16S_MBIN16S_MBIN16S: {return "MUL_MBIN16S_MBIN16S_MBIN16S"; break;}
    case PCIT::MUL_MBIN64S_MBIN64S_MBIN64S: {return "MUL_MBIN64S_MBIN64S_MBIN64S"; break;}
    case PCIT::MUL_MBIN64S_MBIN16S_MBIN32S: {return "MUL_MBIN64S_MBIN16S_MBIN32S"; break;}
    case PCIT::MUL_MBIN64S_MBIN32S_MBIN32S: {return "MUL_MBIN64S_MBIN32S_MBIN32S"; break;}
    case PCIT::FILL_MEM_BYTES_VARIABLE:     {return "FILL_MEM_BYTES_VARIABLE"    ; break;}
    case PCIT::EQ_MBIN32S_MASCII_MASCII:    {return "EQ_MBIN32S_MASCII_MASCII"   ; break;}
    case PCIT::NE_MBIN32S_MASCII_MASCII:    {return "NE_MBIN32S_MASCII_MASCII"   ; break;}
    case PCIT::LT_MBIN32S_MASCII_MASCII:    {return "LT_MBIN32S_MASCII_MASCII"   ; break;}
    case PCIT::GT_MBIN32S_MASCII_MASCII:    {return "GT_MBIN32S_MASCII_MASCII"   ; break;}
    case PCIT::LE_MBIN32S_MASCII_MASCII:    {return "LE_MBIN32S_MASCII_MASCII"   ; break;}
    case PCIT::GE_MBIN32S_MASCII_MASCII:    {return "GE_MBIN32S_MASCII_MASCII"   ; break;}
    default: 
      return "Opcode UNSUPPORTED by NatExprName()" ;
   }
}
#endif /* #if NExprDbgLvl >= VV_I1 */

//
// inTempsList() - Routine used to determine if the specified Temp operand
// is already in the Temps List.
//
NABoolean PCodeCfg::inTempsList( Int32 Offset, PCIT::AddressingMode OprTyp )
{
   for (  Int32 tli = 0 ; tli < NExTempsList_->entries() ; tli++ )
   {
      NExTempListEntry * tliEntry = (*NExTempsList_)[tli] ;

      if ( ( Offset == tliEntry->getOffset() ) && ( OprTyp == tliEntry->getOprTyp() ) )
         return TRUE;
   }
   return FALSE;
}

//
// addToTempsList() - Routine used to add the specified Temp operand
// to the Temps List.
//
void PCodeCfg::addToTempsList( PCodeOperand       * PCOp
                             , PCIT::AddressingMode OprTyp
                             , Int32                Offset
                             , Int32                Num
                             )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   DPT4( "VVA2T0: ", VV_XD, "In addToTempsList( %p, OprTyp = %d, Offset=%d, Num=%d)\n",
                                               PCOp, (Int32) OprTyp, Offset, Num ) ;
   CollIndex i = PCOp->getBvIndex();
   PCodeOperand* operand = this->getMap()->getFirstValue(&i);

#if NExprDbgLvl >= VV_BD
   PRINT_DETAILS_OF_WROp( 0, PCOp );
   DPT2( "VVA2T3: ", VV_XD, "In addToTempsList(): operand=%p, PCOp=%p\n",
                                                  operand,    PCOp );

   if (operand != NULL && operand != PCOp )
      PRINT_DETAILS_OF_WROp( 0, operand );
#endif

   if (operand != NULL && operand != PCOp )
   {
      PCOp = operand;
      OprTyp = operand->getType();
      // We assume that operand's offset and num values are the same as PCOp's values.
   }

   if ( inTempsList( Offset, OprTyp ) )
      return; // We will resuse the existing allocated space
   
   DPT1( "VVA2T4: ", VV_XD, "At start, NExTempsList_->entries() = %d\n", NExTempsList_->entries() );

   NExTempListEntry * newEntry = new(heap_) NExTempListEntry();

   newEntry->setPCOp( PCOp )          ;
   newEntry->setOprTyp( OprTyp )      ;
   newEntry->setOffset( Offset )      ;
   newEntry->setNum( Num )            ;

   DPT0( "VVA2T9: ", VV_XD, "Inserting into TempsList\n");
   NExTempsList_->insert( newEntry );
}

//
// Return TRUE if native instructions can be generated for this pcode graph.
//
NABoolean PCodeCfg::canGenerateNativeExpr()
{
#if NExprDbgLvl >= VV_NO
  char  NExBuf[500];
#endif

#if NExprDbgLvl >= VV_I2
  NABoolean RTNV = TRUE ; // Return TRUE for now.
  Int32     NumBad = 0 ;
  Int32     BadOpc = 0 ;
#endif

  FOREACH_BLOCK_REV_DFO(PCBlk, firstPCInst, lastPCInst, indx) {
    FOREACH_INST_IN_BLOCK(PCBlk, PCInst) {

//DPT1( "VVYN00: ", VV_I3, "In canGEN loop: Found opcd = %d \n", (int) PCInst->getOpcode() );
      Int32 opc = PCInst->getOpcode() ;
      switch ( opc )
      {

        // PCode Instructions with 0 Read Operands AND 0 Write Operands

        case PCIT::BRANCH:
        case PCIT::RETURN:
        case PCIT::RETURN_IBIN32S:
        {
          DPT2( "VVY001: ", VV_I3, "CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                      opc, NatExprName( opc ) );
          break;
        }


        // PCode Instructions with 1 Read Operand AND 0 Write Operands

        case PCIT::NNB_MATTR3_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_IATTR3_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S:
        {
           PCodeOperand* read = PCInst->getROps()[0];
           if ( read->isTemp() &&  ! inTempsList( read->getOffset(), read->getType() ) )
           {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
              DPT2( "VVN030: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                       "%3d  %s - Reads undefined temp\n",
                                        opc, NatExprName( opc ) );
              RTNV = FALSE;
              NumBad ++ ; BadOpc = opc;
              break;
 }
#endif
              return FALSE;
           }
           //Otherwise, instruction is OK

           DPT2("VVY001: ", VV_I3, "CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                      opc, NatExprName( opc ) );
           break;
        }
        case PCIT::OPDATA_MPTR32_IBIN32S:
        case PCIT::OPDATA_MBIN16U_IBIN32S:
        case PCIT::OPDATA_MPTR32_IBIN32S_IBIN32S:
        case PCIT::OPDATA_MATTR5_IBIN32S:
        {
           if ( PCInst->getWOps().entries() )
           {
              NABoolean canHandle = TRUE;
              OPLIST opList = PCInst->getWOps() ;
              for (Int32 iii = 0; iii < opList.entries(); iii++ )
              {
                  PCodeOperand *PCOp = opList[iii];
                  if ( PCOp->getStackIndex() == 2 ) // DON'T YET KNOW HOW TO HANDLE THIS with LLVM!
                  {
                     canHandle = FALSE ;

#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
                     DPT1( "VVN001: ", VV_I3, "Cannot GENERATE for PCODE "
                                       "opcode %3d - Writes To Temp Var\n",
                                                     PCInst->getOpcode() );
                     DPT6( "VVN001a: ", VV_I3, "Details of Bad Temp Var:\n"
                           "stackIndex_ = %d, offset_ = %d, len_=%d, "
                           "operandType_=%d, nullBitIdx=%d, CJV=%p\n",
                           PCOp->getStackIndex(), PCOp->getOffset(),
                           PCOp->getLen(), PCOp->getType(),
                           PCOp->getNullBitIndex(), PCOp->getCurrJitVal() );

                     RTNV = FALSE;
                     NumBad ++ ; BadOpc = opc;
                     break;
 }
#endif
                     return FALSE;
                  }
              }
              if ( canHandle == FALSE )
                 break;
           }
           else // May have Read Operands
           {
              OPLIST opList = PCInst->getROps() ;
              for (Int32 iii = 0; iii < opList.entries(); iii++ )
              {
                 PCodeOperand *PCOp = opList[iii];
                 if ( PCOp->isTemp() &&  ! inTempsList( PCOp->getOffset(), PCOp->getType() ) )
                 {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
                    DPT2( "VVN030: ", VV_I3, "Cannot GENERATE for PCODE "
                                    "opcode %3d  %s - Reads undefined temp\n",
                                            opc, NatExprName( opc ) );
                    RTNV = FALSE;
                    NumBad ++ ; BadOpc = opc;
                    break;
 }
#endif
                    return FALSE;
                 }
              }
           }

          DPT2("VVY001: ", VV_I3, "CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                     opc, NatExprName( opc ) );
          break;
        }


        // PCode Instructions with 2 Read Operands AND 1 Write Operand

        case PCIT::NNB_SPECIAL_NULLS_MBIN32S_MATTR3_MATTR3_IBIN32S_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
        case PCIT::EQ_MBIN32S_MASCII_MASCII:
        case PCIT::NE_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::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_MBIN16U_MBIN16S:
        case PCIT::EQ_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_MBIN64S_MBIN64S:
        case PCIT::LT_MBIN32S_MBIN16U_MBIN16U:
        case PCIT::LT_MBIN32S_MBIN16U_MBIN32U:
        case PCIT::LT_MBIN32S_MBIN32U_MBIN32U:
        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_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_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_MBIN64S_MBIN64S:
        case PCIT::MINMAX_MBIN8_MBIN8_MBIN32S_IBIN32S:
        case PCIT::SUM_MBIN32S_MBIN32S:           // (Note: not used by regression tests! ?)
        case PCIT::SUM_MBIN64S_MBIN64S:
        case PCIT::ADD_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::ADD_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::ADD_MBIN32S_MBIN32S_MBIN32S:
/////// case PCIT::ADD_MBIN64S_MBIN64S_MBIN64S:   // Cannot support yet: no overflow support
        case PCIT::ADD_MBIN32S_MBIN16S_MBIN32S:
/////// case PCIT::ADD_MBIN64S_MBIN32S_MBIN64S:   // Cannot support yet: no overflow support
        case PCIT::SUB_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::SUB_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::SUB_MBIN32S_MBIN32S_MBIN32S:
/////// case PCIT::SUB_MBIN64S_MBIN64S_MBIN64S:   // Cannot support yet: no overflow support
        case PCIT::SUB_MBIN32S_MBIN16S_MBIN32S:
        case PCIT::SUB_MBIN32S_MBIN32S_MBIN16S:
/////// case PCIT::MUL_MBIN64S_MBIN64S_MBIN64S:   // Cannot support yet: no overflow support
/////// case PCIT::MUL_MBIN64S_MBIN32S_MBIN32S:   // Cannot support yet: no overflow support
/////// case PCIT::MUL_MBIN64S_MBIN16S_MBIN32S:   // Cannot support yet: no overflow support
        case PCIT::MUL_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::MUL_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::MUL_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::MUL_MBIN32S_MBIN16S_MBIN32S:
        {
           PCodeOperand* read = PCInst->getROps()[1];
           if ( read->isTemp() &&  ! inTempsList( read->getOffset(), read->getType() ) )
           {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
              DPT2( "VVN030: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                       "%3d  %s - Reads undefined temp\n",
                                        opc, NatExprName( opc ) );
              RTNV = FALSE;
              NumBad ++ ; BadOpc = opc;
              break;
 }
#endif
              return FALSE;
           }
        }
        /* FALLTHROUGH */


        // PCode Instructions with 1 Read Operand AND 1 Write Operand

        case PCIT::BRANCH_OR:
        case PCIT::BRANCH_AND:
        case PCIT::MOVE_MBIN16U_MBIN8:
        case PCIT::MOVE_MBIN32U_MBIN16U:
        case PCIT::MOVE_MBIN32S_MBIN16U:
        case PCIT::MOVE_MBIN64S_MBIN16U:
        case PCIT::MOVE_MBIN64S_MBIN32U:
        case PCIT::MOVE_MBIN32U_MBIN16S:
        case PCIT::MOVE_MBIN32S_MBIN16S:
        case PCIT::MOVE_MBIN64S_MBIN16S:
        case PCIT::MOVE_MBIN64S_MBIN32S:
        case PCIT::MOVE_MBIN16U_MBIN16U:
        case PCIT::MOVE_MBIN8_MBIN8_IBIN32S:
        case PCIT::MOVE_MBIN32U_MBIN32U:
        case PCIT::MOVE_MBIN64S_MBIN64S:
        {
           //
           // NOTE: PCIT::MOVE_MBIN16U_MBIN8, in particular, has been observed
           // being used to reference the last part of a string that was put
           // into Temp space (i.e. stackIndex_ == 2) by a preceding PCODE
           // instruction.  When this happens, PCodeOperand::getJitValue()
           // comes to the conclusion that the reference to the last part of
           // the string is a reference to a new (and hence *undefined*) 
           // temporary variable and does an assert(FALSE) since such a 
           // reference is not supposed to happen.  Perhaps someday we will
           // be able to figure out how to get getJitValue() to understand
           // that the reference is OK, but for now, we just ensure this does
           // not happen by preventing reads of Temp variables that appear to
           // be undefined.   Since we don't really know all the possible 
           // situations that could lead to apparently undefined temp variables,
           // we test *all* reads of Temp variables by *any* PCODE instructions
           // that take a Read Operand and, if it looks like it is an
           // undefined Temp variable, we prevent generating a Native Expr.
           //
           PCodeOperand* read = PCInst->getROps()[0];
           if ( read->isTemp() &&  ! inTempsList( read->getOffset(), read->getType() ) )
           {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
              DPT2( "VVN030: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                       "%3d  %s - Reads undefined temp\n",
                                        opc, NatExprName( opc ) );
              RTNV = FALSE;
              NumBad ++ ; BadOpc = opc;
              break;
 }
#endif
              return FALSE;
           }
        }
        /* FALLTHROUGH */


        // PCode Instructions with 1 Write Operand

        case PCIT::MOVE_MBIN16U_IBIN16U:
        case PCIT::MOVE_MBIN32S_IBIN32S:
        {
           PCodeOperand* write = PCInst->getWOps()[0];
           if ( write->isTemp() )
           {
              // Some regression tests fail if these opcodes write to Temp variables!
              // Perhaps someday this restriction will be removed?
              if ( opc == PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S )
              {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
                 DPT2( "VVN001: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                          "%3d  %s - Writes To Temp Var\n",
                                           opc, NatExprName( opc ) );
                 RTNV = FALSE;
                 NumBad ++ ; BadOpc = opc;
                 break;
 }
#endif
                 return FALSE;
              }

              addToTempsList( write , write->getType() , write->getOffset() );
           }
           DPT2("VVY001: ", VV_I3, "CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                      opc, NatExprName( opc ) );
           break;
        }

        case PCIT::MOVE_MBIN8_MBIN8:
        {
           PCodeOperand * src1 = PCInst->getROps()[0];
           if ( src1->isTemp() &&  ! inTempsList( src1->getOffset(), src1->getType() ) )
           {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
              DPT2( "VVN030: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                       "%3d  %s - Reads undefined temp\n",
                                        opc, NatExprName( opc ) );
              RTNV = FALSE;
              NumBad ++ ; BadOpc = opc;
              break;
 }
#endif
              return FALSE;
           }

           if ( src1->isConst() )
           {
              if ( src1->getType() == PCIT::MPTR32 )
              {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
                 DPT0( "VVN002: ", VV_I3, "Cannot GENERATE for PCODE "
                                          "opcode 200 - Const MPTR32 type\n");
                 RTNV = FALSE;
                 NumBad ++ ; BadOpc = opc;
 }
#endif
                 return FALSE;
              }
              else
              {
                 DPT3("VVY003: ", VV_I3, "CAN    GENERATE for PCODE opcode "
                                         "%3d  %s  type=%d\n",
                                          opc, NatExprName( opc ),
                                          (int)src1->getType() );
                 PCodeOperand* write = PCInst->getWOps()[0];
                 if ( write->isTemp() ) addToTempsList( write
                                                      , write->getType()
                                                      , write->getOffset()
                                                      );
              }
           }
           break;
        }

        case PCIT::CLAUSE_EVAL:
        {
          // on 64-bit the clause pointer is in code[1] and code[2]
          ex_clause* clause = (ex_clause*)*(Long*)&(PCInst->code[1]);
          NABoolean processNulls = PCInst->code[1 + PCODEBINARIES_PER_PTR];

          // Only certain clause eval instructions will be supported for now.
          switch (clause->getClassID()) {
            case ex_clause::AGGR_MIN_MAX_ID:
            {
              /* ZZZZ  CAN WE LIFT THIS RESTRICTION ??? */
              // Because of the "assert(!opDataNulls[0]->forAlignedFormat());"
              // line in the CLAUSE_EVAL handling within layoutNativeCode(),
              // AND because that assertion is apparently no longer valid
              // (as of 07/01/2013), we disallow the ex_clause::AGGR_MIN_MAX_ID
              // clause for now -- until we can add code in the CLAUSE_EVAL
              // handling to deal with AlignedFormat in the null indicator
              // for the aggregate.

#if 1  /* ZZZZ  CAN WE LIFT THIS RESTRICTION ??? */
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
              DPT1( "VVN005: ", VV_I3, "Cannot GENERATE for PCODE opcode %d -"
                                       " AGGR_MIN_MAX_ID disallowed for now\n",
                                                         PCInst->getOpcode() );
              RTNV = FALSE;
              NumBad ++ ; BadOpc = opc;
              break;
 }
#endif
              return FALSE;

#else /* the old code: allow AGGR_MIN_MAX_ID when we know how to do so: */

              // This clause must not call process nulls when evaluated
              if (!processNulls) {
                // Can only tolerate certain types for now.
                if (isSupportedClauseOperandType(clause->getOperand(0)))
                {
                  DPT2( "VVY004: ", VV_I3,
                        "CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                    opc, NatExprName( opc ) );
                  break;
                }

              }

#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
              DPT1( "VVN005: ", VV_I3, "Cannot GENERATE for PCODE opcode %d -"
                                       " AGGR processes nulls\n",
                                                         PCInst->getOpcode() );
              RTNV = FALSE;
              NumBad ++ ; BadOpc = opc;
              break;
 }
#endif
              return FALSE;
#endif /* 1 */
            }

            case ex_clause::COMP_TYPE:
            {
              // No special nulls allowed for now.
              if (clause->isSpecialNulls())
              {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
                DPT1( "VVN006: ", VV_I3, "Cannot GENERATE for PCODE opcode %d -"
                                         " COMP_TYPE wants Special Nulls\n",
                                                         PCInst->getOpcode() );
                RTNV = FALSE;
                NumBad ++ ; BadOpc = opc;
                break;
 }
#endif
                return FALSE;
              }

              switch (((ex_comp_clause*)clause)->getInstruction()) {
                case NE_DATETIME_DATETIME:
                case EQ_DATETIME_DATETIME:
                case LT_DATETIME_DATETIME:
                case GT_DATETIME_DATETIME:
                case LE_DATETIME_DATETIME:
                case GE_DATETIME_DATETIME:
                {
                  // Only support standard types
                  long dtCode =
                    ((ExpDatetime*)(clause->getOperand(1)))->getPrecision();

                  // The lengths of the source operands must be the same.
                  if ((clause->getOperand(1)->getLength()) !=
                      (clause->getOperand(1)->getLength()))
                  {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
                     DPT1( "VVN007: ", VV_I3, "Cannot GENERATE for PCODE "
                           "opcode %d - COMP_TYPE Opers diff lengths\n",
                                                  PCInst->getOpcode() );
                     RTNV = FALSE;
                     NumBad ++ ; BadOpc = opc;
                     break;
 }
#endif
                     return FALSE;
                  }

                  switch (dtCode)
                  {
                    case REC_DTCODE_DATE:
                    case REC_DTCODE_TIME:
                    case REC_DTCODE_TIMESTAMP:
                      DPT2( "VVY008: ", VV_I3,
                            "CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                     opc, NatExprName( opc ) );
                      break;
                    default:
                    {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
                      DPT1( "VVN009: ", VV_I3, "Cannot GENERATE for PCODE "
                            "opcode %d - COMP_TYPE unsupported dtCode\n",
                                                   PCInst->getOpcode() );
                      RTNV = FALSE;
                      NumBad ++ ; BadOpc = opc;
                      break;
 }
#endif
                      return FALSE;
                    }
                  }
                  break;
                }

                default:
                {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
                  DPT1( "VVN010: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                     "%d - COMP_TYPE unsupported D/T clause\n",
                                                         PCInst->getOpcode() );
                  RTNV = FALSE;
                  NumBad ++ ; BadOpc = opc;
                  break;
 }
#endif
                  return FALSE;
                }
              }
              break;
            }

            default:
            {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
              DPT1( "VVN011: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                       "%d - COMP_TYPE unsupported ClassID\n",
                                                        PCInst->getOpcode() );
              RTNV = FALSE;
              NumBad ++ ; BadOpc = opc;
              break;
 }
#endif
              return FALSE;
            }
          }
          break;
        }

        case PCIT::FILL_MEM_BYTES:
        {
           PCodeOperand * write = PCInst->getWOps()[0];
           if ( write->isTemp() ) addToTempsList( write
                                                , write->getType()
                                                , write->getOffset()
                                                , PCInst->code[3]
                                                );
          break;
        }

        case PCIT::FILL_MEM_BYTES_VARIABLE:
        {
           PCodeOperand* write = PCInst->getWOps()[0];

          // Only support non-aligned format case.  Otherwise we have to start
          // tracking local varOffset (which we can do, but just not there yet).
          if ( write->getVoaOffset() == -1 )
          {
            DPT2("VVY012: ", VV_I3,"CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                      opc, NatExprName( opc ) );

            if ( write->isTemp() ) addToTempsList( write
                                                  , write->getType()
                                                  , write->getOffset()
                                                  , PCInst->code[6]
                                                  );
            break;
          }

#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
          DPT1( "VVN013: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                   "%d - getVoaOffset() != -1\n",
                                           PCInst->getOpcode() );
          RTNV = FALSE;
          NumBad ++ ; BadOpc = opc;
          break;
 }
#endif
          return FALSE;
        }

        case PCIT::MOVE_MATTR5_MATTR5:
        {
          PCodeOperand* read = PCInst->getROps()[0];
          PCodeOperand* write = PCInst->getWOps()[0];

          if ( read->isTemp() &&  ! inTempsList( read->getOffset(), read->getType() ) )
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT2( "VVN030: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                      "%3d  %s - Reads undefined temp\n",
                                       opc, NatExprName( opc ) );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }

          // Since we plan on copying everyting (length + string) in one shot,
          // make sure the vc lengths of the operands are the same.
          if (read->getVcIndicatorLen() != write->getVcIndicatorLen())
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT1( "VVN014: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                      "%d - diff VcIndLen's\n",
                                      PCInst->getOpcode() );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }

          // For now, no support for temp varchars (since temp varchars will
          // likely need to come from a separate temps area.
          if (write->isTemp() || read->isTemp())
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT1( "VVN015: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                               "%d - write->isTemp() || read->isTemp()\n",
                                                     PCInst->getOpcode() );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }

          // Also, target max length must be greater than that of source
          if (read->getVcMaxLen() > write->getVcMaxLen())
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT1( "VVN016: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                      "%d - srcLen > tgtLen\n",
                                         PCInst->getOpcode() );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }

          DPT2( "VVY017: ", VV_I3, "CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                      opc, NatExprName( opc ) );
          break;
        }

        case PCIT::NULL_TEST_MBIN32S_MATTR5_IBIN32S_IBIN32S:
        {
          PCodeOperand* write = PCInst->getWOps()[0];

          // FIX: For now, just disallow the expr if write operand is not a temp
          if ( ! write->isTemp() )
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT2( "VVN022: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                      "%3d  %s - Writes to non temp\n",
                                       opc, NatExprName( opc ) );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }

          // Just don't support case with nullable varchar in packed format,
          // since that requires an extra level of indirection when accessing
          // the null indicator -- not expensive/complicated to implement, but
          // rare enough to want to avoid.

          PCodeOperand* src = PCInst->getROps()[0];

          if ( src->isTemp() &&  ! inTempsList( src->getOffset(), src->getType() ) )
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT2( "VVN030: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                      "%3d  %s - Reads undefined temp\n",
                                       opc, NatExprName( opc ) );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }

          if ((src->getOffset() == -1) && !src->forAlignedFormat())
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT1( "VVN017: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                      "%d - srcLen > tgtLen\n",
                                         PCInst->getOpcode() );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }

          // Note: Could skip the write->isTemp() check in the next line
          // since we assert'd that above, but that assert may be removed
          // some day, so leave it for now...even though it is redundant.
          if ( write->isTemp() ) addToTempsList( write
                                               , write->getType()
                                               , write->getOffset()
                                               );
          DPT2( "VVY018: ", VV_I3,
                "CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                  opc, NatExprName( opc ) );
          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:
        {
          // Make sure that this is nullable before we proceed
          if (!PCInst->code[7])
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT1( "VVN018: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                      "%d - !PCInst->code[7] \n",
                                           PCInst->getOpcode() );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }

          PCodeOperand * src1 = PCInst->getROps()[0];
          PCodeOperand * src2 = PCInst->getROps()[1];
          PCodeOperand * src3 = PCInst->getROps()[(PCInst->getROps()).entries()-1];

          if ( ( src1->isTemp() &&  ! inTempsList( src1->getOffset(), src1->getType() ) ) ||
               ( src2->isTemp() &&  ! inTempsList( src2->getOffset(), src2->getType() ) ) ||
               ( src3->isTemp() &&  ! inTempsList( src3->getOffset(), src3->getType() ) )
             )
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT2( "VVN030: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                      "%3d  %s - Reads undefined temp\n",
                                       opc, NatExprName( opc ) );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }

          DPT2( "VVY019: ", VV_I3,
                "CAN    GENERATE for PCODE opcode %3d  %s\n",
                                                  opc, NatExprName( opc ) );

          PCodeOperand * write = PCInst->getWOps()[ (PCInst->getWOps()).entries()-1 ];
          if ( write->isTemp() ) addToTempsList( write
                                               , write->getType()
                                               , write->getOffset()
                                               );
          break;
        }

        case PCIT::MOVE_MBIN32S:
        {
          PCodeOperand* read = PCInst->getROps()[0];
          if ( read->isTemp() &&  ! inTempsList( read->getOffset(), read->getType() ) )
          {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
             DPT2( "VVN030: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                      "%3d  %s - Reads undefined temp\n",
                                       opc, NatExprName( opc ) );
             RTNV = FALSE;
             NumBad ++ ; BadOpc = opc;
             break;
 }
#endif
             return FALSE;
          }
          // Only supported if RETURN follows it (as it always should)
          if (PCInst->next && (PCInst->next->code[0] == PCIT::RETURN))
          {
             DPT2( "VVY020: ", VV_I3, "CAN    GENERATE for PCODE opcode "
                                      "%3d  %s\n", opc, NatExprName( opc ) );
             break;
          }

#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
           DPT1("VVN021: ", VV_I3, "Cannot GENERATE for PCODE opcode "
                                   "%d - not followed by RETURN\n",
                                              PCInst->getOpcode());
           RTNV = FALSE;
           NumBad ++ ; BadOpc = opc;
           break;
 }
#endif
           return FALSE;
        }
        default:
        {
#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
           DPT2( "VVN090: ", VV_I3,"Cannot GENERATE for PCODE opcode %3d  %s\n",
                                            opc, NatExprName( opc ) );
           RTNV = FALSE;
           NumBad ++ ; BadOpc = opc;
           break;
 }
#endif
           return FALSE;
        }
      }
    } ENDFE_INST_IN_BLOCK
  } ENDFE_BLOCK_REV_DFO

#if NExprDbgLvl >= VV_I2
  if ( NumBad == 1 )
  {
     DPT2( "VVN099: ", VV_I2,
           "Cannot GENERATE for PCODE opcode %3d  %s ONLY\n\n",
                                          BadOpc, NatExprName( BadOpc ) );
  }
  return RTNV;
#else
  return TRUE;
#endif
}
#endif /* NA_LINUX_LLVMJIT */

#ifdef NA_LINUX_LIBJIT
//
// Return TRUE if native instructions can be generated for this pcode graph.
//
NABoolean PCodeCfg::canGenerateNativeExpr()
{
  // . No persistent data (for now)
  // . Only certain instructions  

  FOREACH_BLOCK_REV_DFO(PCBlk, firstPCInst, lastPCInst, indx) {
    FOREACH_INST_IN_BLOCK(PCBlk, inst) {
      switch (inst->getOpcode()) {
        case PCIT::BRANCH:
        case PCIT::BRANCH_OR:
        case PCIT::BRANCH_AND:
        case PCIT::BRANCH_OR_CNT:
        case PCIT::BRANCH_AND_CNT:
          break;

        case PCIT::OR_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::AND_MBIN32S_MBIN32S_MBIN32S:
          break;

        case PCIT::NNB_MATTR3_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_IATTR3_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
        case PCIT::NNB_SPECIAL_NULLS_MBIN32S_MATTR3_MATTR3_IBIN32S_IBIN32S:
          break;

        case PCIT::FILL_MEM_BYTES:
          break;

        case PCIT::FILL_MEM_BYTES_VARIABLE:
        {
          // Only support non-aligned format case.  Otherwise we have to start
          // tracking local varOffset (which we can do, but just not there yet).
          if (inst->getWOps()[0]->getVoaOffset() == -1)
            break;

          return FALSE;
        }

        /* 64-bit comps (except EQ/NE) not supported in libjit. */
        //case PCIT::LT_MBIN32S_MBIN64S_MBIN64S:
        //case PCIT::LE_MBIN32S_MBIN64S_MBIN64S:
        //case PCIT::GT_MBIN32S_MBIN64S_MBIN64S:
        //case PCIT::GE_MBIN32S_MBIN64S_MBIN64S:
        case PCIT::EQ_MBIN32S_MBIN64S_MBIN64S:
        case PCIT::NE_MBIN32S_MBIN64S_MBIN64S:
          break;

        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:
        {
          // The MBIN16S operand is casted to a 64-bit value before the comp is
          // performed.  Until we have 64-bit comparison support, we can only
          // do a little here.
          if (inst->getROps()[0]->isConst()) {
            Int64 val = getIntConstValue(inst->getROps()[0]);
            if (val < 0)
              return FALSE;

            // Positive value found that can be used in a MBIN32U comparison.
          }
          else
            return FALSE;

          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_MBIN16U_MBIN16S:
          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_MBIN16U_MBIN16S:
          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_MBIN16U_MBIN16S:
          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_MBIN16U_MBIN16S:
          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_MBIN16U_MBIN16S:
          break;

        case PCIT::EQ_MBIN32S_MASCII_MASCII:
        case PCIT::NE_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:
          break;

        case PCIT::COMP_MBIN32S_MASCII_MASCII_IBIN32S_IBIN32S_IBIN32S:
        case PCIT::COMP_MBIN32S_MATTR5_MATTR5_IBIN32S:
          break;

        case PCIT::SWITCH_MBIN32S_MBIN64S_MPTR32_IBIN32S_IBIN32S:
        {
          // Only in-lists supported, for now.
          if (inst->code[8] & 0x1)
            break;

          return (FALSE);
        }

        case PCIT::SWITCH_MBIN32S_MATTR5_MPTR32_IBIN32S_IBIN32S:
        {
          // Only in-lists supported, for now.
          if (inst->code[11] & 0x1)
            break;

          return (FALSE);
        }

        case PCIT::COMP_MBIN32S_MBIGS_MBIGS_IBIN32S_IBIN32S:
        case PCIT::ADD_MBIGS_MBIGS_MBIGS_IBIN32S:
        case PCIT::SUB_MBIGS_MBIGS_MBIGS_IBIN32S:
          break;

        case PCIT::ADD_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::ADD_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::ADD_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::ADD_MBIN64S_MBIN64S_MBIN64S:
        case PCIT::ADD_MBIN32S_MBIN16S_MBIN32S:
        case PCIT::ADD_MBIN64S_MBIN32S_MBIN64S:
          break;

        // case PCIT::SUB_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::SUB_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::SUB_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::SUB_MBIN64S_MBIN64S_MBIN64S:
        case PCIT::SUB_MBIN32S_MBIN16S_MBIN32S:
        case PCIT::SUB_MBIN32S_MBIN32S_MBIN16S:
          break;

        /* 64-bit multiply not supported in libjit - need to call routine. */
        /* No support to downcast result to 16-bit type for now - not needed */
        //case PCIT::MUL_MBIN64S_MBIN64S_MBIN64S:
        //case PCIT::MUL_MBIN64S_MBIN32S_MBIN32S:
        //case PCIT::MUL_MBIN64S_MBIN16S_MBIN32S:
        //case PCIT::MUL_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::MUL_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::MUL_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::MUL_MBIN32S_MBIN16S_MBIN32S:
          break;

        case PCIT::ADD_MFLT64_MFLT64_MFLT64:
        case PCIT::SUB_MFLT64_MFLT64_MFLT64:
        case PCIT::MUL_MFLT64_MFLT64_MFLT64:
        case PCIT::DIV_MFLT64_MFLT64_MFLT64:
          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:
          break;

        case PCIT::RETURN_IBIN32S:
        case PCIT::RETURN:
          break;

        case PCIT::MOVE_MBIN16U_MBIN8:
        case PCIT::MOVE_MBIN32U_MBIN16U:
        case PCIT::MOVE_MBIN32S_MBIN16U:
        case PCIT::MOVE_MBIN64S_MBIN16U:
        case PCIT::MOVE_MBIN32U_MBIN16S:
        case PCIT::MOVE_MBIN32S_MBIN16S:
        case PCIT::MOVE_MBIN64S_MBIN16S:
        case PCIT::MOVE_MBIN64S_MBIN32U:
        case PCIT::MOVE_MBIN64S_MBIN32S:
          break;

        case PCIT::MOVE_MFLT64_MBIN32S:
        case PCIT::MOVE_MFLT64_MBIN16S:
          break;

        case PCIT::MOVE_BULK:
          break;

        case PCIT::MOVE_MBIN16U_MBIN16U:
        case PCIT::MOVE_MBIN8_MBIN8:
        case PCIT::MOVE_MBIN32U_MBIN32U:
        case PCIT::MOVE_MBIN64S_MBIN64S:
        case PCIT::MOVE_MBIN16U_IBIN16U:
        case PCIT::MOVE_MBIN32S_IBIN32S:
          break;

        case PCIT::MOVE_MATTR5_MATTR5:
        {
          PCodeOperand* read = inst->getROps()[0];
          PCodeOperand* write = inst->getWOps()[0];

          // Since we plan on copying everyting (length + string) in one shot,
          // make sure the vc lengths of the operands are the same.
          if (read->getVcIndicatorLen() != write->getVcIndicatorLen())
            return FALSE;

          // For now, no support for temp varchars (since temp varchars will
          // likely need to come from a separate temps area.
          if (write->isTemp() || read->isTemp())
            return FALSE;

          // Also, target max length must be greater than that of source
          if (read->getVcMaxLen() > write->getVcMaxLen())
            return FALSE;

          break;
        }

        case PCIT::NULL_TEST_MBIN32S_MATTR5_IBIN32S_IBIN32S:
        {
          // FIX: assert for now that write operand should be a temp
          assert(inst->getWOps()[0]->isTemp());

          // Just don't support case with nullable varchar in packed format,
          // since that requires an extra level of indirection when accessing
          // the null indicator -- not expensive/complicated to implement, but
          // rare enough to want to avoid.

          PCodeOperand* src = inst->getROps()[0];
          if ((src->getOffset() == -1) && !src->forAlignedFormat())
            return FALSE;

          break;
        }

        case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MFLT64_MFLT64:
        case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN32S_MBIN32S:
        case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN64S:
        case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN32S:
        {
          // Make sure that this is nullable before we proceed
          if (!inst->code[7])
            return FALSE;

          break;
        }

        case PCIT::SUM_MFLT64_MFLT64:
        case PCIT::SUM_MBIN32S_MBIN32S:
        case PCIT::SUM_MBIN64S_MBIN64S:
        case PCIT::SUM_MBIN64S_MBIN32S:
          break;

        case PCIT::STRLEN_MBIN32U_MATTR5:
        {
          // Only if we're dealing with a varchar (since fixed-chars should be
          // optimized anyways to just return constant length)
          if (inst->getROps()[0]->isVarchar())
            break;

          return FALSE;
        }

#if 0
        //
        // SUBSTR should be fully-implemented, but testing may still be needed.
        //
        case PCIT::SUBSTR_MATTR5_MATTR5_MBIN32S_MBIN32S:
        {
          PCodeOperand *op1, *op2 = NULL;

          // Assert that result is a varchar
          assert(inst->getWOps()[0]->isVarchar());

          op1 = inst->getROps()[1];
          if (inst->getROps().entries() == 3)
            op2 = inst->getROps()[2];

          // To simplify code generation, both the start offset and the length,
          // if provided, should be constants.
          if (!op1->isConst() || (op2 && !op2->isConst()))
            return FALSE;

          // To simplify code generation, do not process if the start point
          // provided is negative or 0.
          if (getIntConstValue(op1) <= 0)
            return FALSE;

          // Also, some bozo may put 0 for the for length - just ignore that,
          // even though the answer will always be an empty string.
          if (op2 && (getIntConstValue(op2) <= 0))
            return FALSE;

          break;
        }
#endif

#if 0
        case PCIT::POS_MBIN32S_MATTR5_MATTR5:
        {
          // Only do this if pattern string is a constant
          if (inst->getROps()[0]->isConst())
            break;

          return FALSE;
        }
#endif


        case PCIT::MOVE_MBIN32S:
        {
          // Only supported if RETURN follows it (as it always should)
          if (inst->next && (inst->next->code[0] == PCIT::RETURN))
            break;

          return FALSE;
        }


        case PCIT::MOVE_MBIN8_MBIN8_IBIN32S:
        {
          // With genUnalignedMemcpy() available, the jit's version of memcpy
          // is not needed, and so no external calls will be made.
          break;
#if 0
          // Only support if it's guaranteed to be inlined
          if (inst->getWOps()[0]->isVar() && inst->getROps()[0]->isVar() &&
              inst->getROps()[0]->getLen() <= 32)
            break;

          return FALSE;
#endif
        }

        case PCIT::HASHCOMB_BULK_MBIN32U:
          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:
        {
          // Is it possible that we're hashing constants??  Fold that sh!%@#t !
          assert (!inst->getROps()[0]->isConst());

          // Only if source is a var.  Dealing with temps can be messy since
          // we would have to have the address of it and walk through it one
          // byte at a time - doable, but we shouldn't expect to see temps.
          if (!inst->getROps()[0]->isVar())
            return FALSE;

          // If we're hashing a fixed string, only support it for reasonable
          // sizes (TODO: until code is written to make the hash a loop).
          if ((inst->getOpcode() == PCIT::HASH_MBIN32U_MPTR32_IBIN32S_IBIN32S) &&
              (inst->getROps()[0]->getLen() > 1000))
            return FALSE;

          break;
        }

        case PCIT::MINMAX_MBIN8_MBIN8_MBIN32S_IBIN32S:
          break;

        case PCIT::RANGE_MFLT64:
          break;

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

        case PCIT::OPDATA_MPTR32_IBIN32S:
        case PCIT::OPDATA_MPTR32_IBIN32S_IBIN32S:
        case PCIT::OPDATA_MBIN16U_IBIN32S:
        case PCIT::OPDATA_MATTR5_IBIN32S:
          break;

        case PCIT::CLAUSE_EVAL:
        {
          // on 64-bit the clause pointer is in code[1] and code[2]
          ex_clause* clause = (ex_clause*)*(Long*)&(inst->code[1]);
          NABoolean processNulls = inst->code[1 + PCODEBINARIES_PER_PTR];

          // Only certain clause eval instructions will be supported for now.
          switch (clause->getClassID()) {
            case ex_clause::AGGR_MIN_MAX_ID:
            {
              // This clause must not call process nulls when evaluated
              if (!processNulls) {
                // Can only tolerate certain types for now.
                if (isSupportedClauseOperandType(clause->getOperand(0)))
                  break;

              }

              return FALSE;
            }

            case ex_clause::COMP_TYPE:
            {
              // No special nulls allowed for now.
              if (clause->isSpecialNulls())
                return FALSE;

              switch (((ex_comp_clause*)clause)->getInstruction()) {
                case NE_DATETIME_DATETIME:
                case EQ_DATETIME_DATETIME:
                case LT_DATETIME_DATETIME:
                case GT_DATETIME_DATETIME:
                case LE_DATETIME_DATETIME:
                case GE_DATETIME_DATETIME:
                {
                  // Only support standard types
                  long dtCode =
                    ((ExpDatetime*)(clause->getOperand(1)))->getPrecision();

                  // The lengths of the source operands must be the same.
                  if ((clause->getOperand(1)->getLength()) !=
                      (clause->getOperand(1)->getLength()))
                    return FALSE;

                  switch (dtCode)
                  {
                    case REC_DTCODE_DATE:
                    case REC_DTCODE_TIME:
                    case REC_DTCODE_TIMESTAMP:
                      break;
                    default:
                      return FALSE;
                  }
                  break;
                }

                default:
                  return FALSE;
              }

              break;
            }

            default:
              return FALSE;
          }

          break;
        }

        case PCIT::CONCAT_MATTR5_MATTR5_MATTR5:
        {
          Int32 src1Len = inst->getROps()[0]->getVcMaxLen();
          Int32 src2Len = inst->getROps()[1]->getVcMaxLen();
          Int32 resLen = inst->getWOps()[0]->getVcMaxLen();

          Int32 maxSize = src1Len + src2Len;

          // If the max length of the target operand is less than the sum of
          // the lengths of the source operands, do not support.  Note, this is
          // an easy thing to support, but in almost all the cases the tgt len
          // should be big enough.
          if (resLen < maxSize) {
            assert(FALSE);
            return FALSE;
          }

          break;
        }

        case PCIT::GENFUNC_MATTR5_MATTR5_IBIN32S:
        {
          if ((inst->code[11] == ITM_UPPER) || (inst->code[11] == ITM_LOWER))
            break;

          return FALSE;
        }

        default:
          return FALSE;
      }
    } ENDFE_INST_IN_BLOCK
  } ENDFE_BLOCK_REV_DFO

  return TRUE;
}

jit_type_t PCodeOperand::getJitType()
{
  switch (operandType_) {
    case PCIT::MBIN8:
      return jit_type_ubyte;
    case PCIT::MBIN16U:
      return jit_type_ushort;
    case PCIT::MBIN16S:
      return jit_type_short;
    case PCIT::MBIN32U:
      return jit_type_uint;
    case PCIT::MBIN32S:
      return jit_type_int;
    case PCIT::MBIN64S:
      return jit_type_long;
    case PCIT::MASCII:
    case PCIT::MATTR5:
    case PCIT::MBIGS:
      return jit_type_void_ptr;
    case PCIT::MPTR32:
    {
      if (nullBitIndex_ != -1)
        return jit_type_ubyte;
      else
        return jit_type_void_ptr;
    }
    case PCIT::MFLT64:
      return jit_type_float64;
  }

  // No other types supported
  assert(FALSE);

  return jit_type_void;
}
#endif /* NA_LINUX_LIBJIT */

#if 1 /* NA_LINUX_LLVMJIT */
//
// FIX: This routine was added because of a bug in libjit involving a register
// allocation bug and integer promotion.  If a 32-bit value X is promoted to a
// 64-bit value, so that it can be added to an existing 64-bit value Y, then
// the "sar" instruction is used to extend the value.  Libjit's allocator then
// mistakingly confuses the shifted value to replace the 32-bit value itself.
// If we end up reusing/referencing the 32-bit value elsewhere, the wrong jit
// value will get used.  See fullstack2/TEST023.  Also, included below is a
// simple example that shows the problem:
//
//        temp1 = jit_insn_load_relative(function, s, 0, jit_type_long);
//        temp2 = jit_insn_load_relative(function, s, 8, jit_type_int);
//        temp3 = jit_insn_add(function, temp1, temp2);
//        jit_insn_store_relative(function, s, 12, temp3);
//
//        temp4 = jit_insn_convert(function, temp2, jit_type_long, 0);
//        jit_insn_store_relative(function, t, 0, temp4);
//
//        jit_insn_return(function, tempZero);
//
// If a newer version of libjit comes our way, or if a patch is made to fix the
// problem, this routine is not needed.  For now, it should be called whenever
// a source operand needs to be promoted to a 64-bit value before use.  It
// really is only needed if the operand is live after the use, but there's no
// harm in removing/clearing the saved jit values at this point.
//

void PCodeOperand::clearJitValues(PCodeCfg* cfg)
{
#if 1 /* NA_LINUX_LLVMJIT */
  return;  // Routine NOT needed for LLVM....we hope!
#endif /* NA_LINUX_LLVMJIT */

#ifdef NA_LINUX_LIBJIT
  // Get operand in hash table
  CollIndex i = bvIndex_;
  PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);
  if (operand != this)
    return operand->clearJitValues(cfg);

  jitValue_ = NULL;
  jitValuePtr_ = NULL;
  jitValueBlock_ = NULL;
#endif /* NA_LINUX_LIBJIT */
}

//
// setJitValue() - see code for what this does.
//
// FIX: Overlapped types can have problems
// NOTE: It is unknown if this is a problem when using LLVM
// as opposed to LIBJIT.
//
void PCodeOperand::setJitValue( PCodeCfg    * cfg
                              , IRBldr_t    * Bldr
                              , jit_value_t   val
                              , PCodeBlock  * b
                              , NABoolean     noSave = FALSE
                              )
{
#if NExprDbgLvl >= VV_NO
  char  NExBuf[500];
#endif
  // If this was called to store into a non-temp, storeJitValue should be
  // called instead.
  if (!isTemp())
////return storeJitValue(cfg, f, jit_value_get_type(val), val, b, NULL, noSave);
    return storeJitValue(cfg, Bldr, val->getType(), val, b, NULL, noSave );

  // Also call storeJitValue if it's a temp and the temp already has a different
  // jit value associated with it.
  if (isTemp() && (jitValue_ != val))
////return storeJitValue(cfg, f, jit_value_get_type(val), val, b, NULL, noSave);
    return storeJitValue(cfg, Bldr, val->getType(), val, b, NULL, noSave );

  // Get operand in hash table
  CollIndex i = bvIndex_;
  PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);

    CDPT2( "VV0c00: ", VV_BD, "In setJitValue(): operand=%p, this=%p\n", operand, this );

  if (operand != this)
    return operand->setJitValue(cfg, Bldr, val, b, noSave);

  // If we are directly told not to save the jit values, don't!
  if (!noSave) {
    jitValue_ = val;

    CDPT2( "VV0c10: ", VV_BD, "In setJitValue(): setting jitValue_ in PCodeOp "
                              "at %p to %p\n", this, jitValue_ );
    CDPT1( "VV0c11: ", VV_BD, "jitValue_'s Type ID is %d\n",
                                     (int) val->getType()->getTypeID() );
    CDPT2( "VV0c12: ", VV_BD, "In setJitValue(): setting jitValueBlock_ = "
                              "%p for PCOp = %p\n", b , this);
    jitValueBlock_ = b;
  }
}
#endif /* NA_LINUX_LLVMJIT */

#ifdef NA_LINUX_LIBJIT
// FIX: Overlapped types can have problems
void PCodeOperand::setJitValue(PCodeCfg* cfg,
                               jit_function_t f,
                               jit_value_t val,
                               PCodeBlock* b,
                               NABoolean noSave = FALSE)
{
  // If this was called to store into a non-temp, storeJitValue should be
  // called instead.
  if (!isTemp())
    return storeJitValue(cfg, f, jit_value_get_type(val), val, b, NULL, noSave);

  // Also call storeJitValue if it's a temp and the temp already has a different
  // jit value associated with it.
  if (isTemp() && (jitValue_ != val))
    return storeJitValue(cfg, f, jit_value_get_type(val), val, b, NULL, noSave);

  // Get operand in hash table
  CollIndex i = bvIndex_;
  PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);
  if (operand != this)
    return operand->setJitValue(cfg, f, val, b, noSave);

  // If we are directly told not to save the jit values, don't!
  if (!noSave) {
    jitValue_ = val;
    jitValueBlock_ = b;
  }
}
#endif /* NA_LINUX_LIBJIT */

//
// isSupportedClauseOperandType() - determine if the NE code 
// supports this particular PCIT::CLAUSE_EVAL's operand.
//
NABoolean PCodeCfg::isSupportedClauseOperandType(exp_Attributes* attr)
{
  switch(PCIT::getMemoryAddressingMode(attr->getDatatype()))
  {
    case PCIT::MBIN8:
    case PCIT::MBIN16U:
    case PCIT::MBIN16S:
    case PCIT::MBIN32U:
    case PCIT::MBIN32S:
    case PCIT::MBIN64S:
    case PCIT::MASCII:
    case PCIT::MATTR3:
    // case PCIT::MATTR5: // Need to fix MIN_MAX for varchars first

#ifdef  NA_LINUX_LIBJIT
    case PCIT::MFLT64:       // Not supported by LLVMJIT yet
    case PCIT::MBIGS:        // Not supported by LLVMJIT yet
#endif /* NA_LINUX_LIBJIT */
      return TRUE;
  }

  return FALSE;
}

void PCodeCfg::setupClauseOperand(PCodeCfg* cfg,
                                  OPLIST& opList,
                                  PCodeOperand** opData,
                                  Int32 index,
                                  ex_clause* clause)
{
#if NExprDbgLvl > VV_NO
  char  NExBuf[500];
#endif
  Int32 len;
  PCIT::AddressingMode am;
  DPT5( "VV0a00: ", VV_XD, 
        "In setupClauseOperand(), cfg=%p, opList at %p, opData at %p, "
        "index=%d, clause at %p\n", cfg, &opList[0], opData, index, clause );

  // Ignore calls to setup the operand for varchar lengths, since that is not
  // useful once we have the actual column attribute.
  if ((index >= 5) && (index < 10))
  {
    DPT1( "VV0a01: ", VV_XD, 
          "Returning from setupClauseOperand() because index = %d - "
          "indicating varchar\n", index);
    return;
  }

  // Get the attribute pointer corresponding to this clause operand
  Int32 opIndex = index % ex_clause::MAX_OPERANDS;
  exp_Attributes* attr = clause->getOperand(opIndex);

  // Get the old (pcode opts) operand from the opList and clear the list now.

#if NExprDbgLvl >= VV_XD
  for (Int32 iii = 0; iii < opList.entries(); iii++ )
     DPT2( "VV0a10: ", VV_XD, "At start of setupClauseOperand(), opList[%d] = "
                              "%p\n", iii, opList[iii]);
#endif

  PCodeOperand* operand = opList[0];
  opList.clear();
  DPT1( "VV0a20: ", VV_XD, "AFTER clearing opList, 'operand=OLD opList[0] == "
                           "%p\n", operand );

#if NExprDbgLvl >= VV_XD
  for (Int32 jjj = 0; jjj < opList.entries(); jjj++ )
     DPT2( "VV0a30: ", VV_XD, "AFTER clearing opList, opList[%d] = %p\n",
                                                             jjj,  opList[jjj]);
#endif

  // Set up a bogus pcode array needed to call ::addOperand later on.
  PCodeBinary fakePCode[2] = { operand->getStackIndex(), operand->getOffset() };

  // Process things separately if we're getting the null indicator.
  if(index < 5) {
    am = ((attr->getNullBitIndex() != -1) ? PCIT::MPTR32 : PCIT::MBIN16S);
    len = (am == PCIT::MPTR32) ? -1 : 2;
    DPT3( "VV0a40: ", VV_XD, " AM = PCIT::%d, len=%d, index=%d\n",
                                     (int)am, len,        index );

    cfg->addOperand(fakePCode, opList, 0, 1, attr->getNullBitIndex(),am,len,-1);
  }
  // Now we're processing any other type (e.g string, int, floats, etc).
  else if (attr->getVCIndicatorLength() > 0) {
    am = PCIT::MATTR5;
    len = attr->getLength();
    DPT2( "VV0a50: ", VV_XD, " AM = PCIT::%d, index=%d\n", (int)am, index );

    cfg->addOperand(fakePCode, opList, 0, 1, -1, am, len, attr->getVoaOffset());
  }
  else {
    switch (attr->getLength()) {
      case 1:
      case 2:
      case 4:
      case 8:
        am = PCIT::getMemoryAddressingMode(attr->getDatatype());
        break;
      default:
        am = PCIT::MASCII;
        break;
    }

    DPT3("VV0a60: ", VV_XD, " AM = PCIT::%d, index=%d, attrLen = %d\n",
                                   (int)am , index,    attr->getLength());

    DPT2("VV0a80: ", VV_XD, " attr->getDatatype() = %d, "
     "PCIT::getMemoryAddressingMode(attr->getDatatype()= %d\n",
      attr->getDatatype(), PCIT::getMemoryAddressingMode(attr->getDatatype()) );

    cfg->addOperand(fakePCode, opList, 0, 1, -1, am, attr->getLength(), -1);
  }

  // Update the opData array with the new operand.
  opData[index] = opList[0];
  DPT2("VV0a90: ", VV_XD, " JUST UPDATED opData[index = %d] to be %p\n",
                                                     index,    opData[index] );
  DPT2("VV0a98: ", VV_XD, " At END of setupClauseOperand, opData[%d] == %p\n",
                                                         index, opData[index]);
  PCodeOperand *PCOp = opData[index];

  DPT6("VV0a99: ", VV_XD, " DETAILS OF PCodeOperand are: \n"
     "stackIndex_ = %d, offset_ = %d, len_=%d, operandType_=%d, "
     "nullBitIdx=%d, CJV=%p\n",
      PCOp->getStackIndex(), PCOp->getOffset(), PCOp->getLen(),
      PCOp->getType(), PCOp->getNullBitIndex(), PCOp->getCurrJitVal() );
}

#if 1 /* NA_LINUX_LLVMJIT */

//
// IR_LoadRelativeWithType() - generate a "load" instruction to load a value
// at a specified byte offset from where the specified pointer points.  
// The "typeToLoad" argument specifies what kind of "load" to generate.
//
// NOTE: Although this routine generates a "load" instruction, it returns
// the pointer to that instruction as a jit_value_t (i.e. an llvm::Value).
// The caller can use this jit_value_t AS IF we had returned the value
// that would actually be fetched by the load!  Basically, what we are
// really doing is NOT generating a "load" instruction, but rather
// teaching the Intermediate Representation generator HOW TO materialize
// the value at runtime for the object (byte, short, int, or whatever)
// that would be fetched if a "load" instruction was actually done.
// It is for this reason that the caller can use the returned jit_value_t
// AS IF we had returned the value of the object.
//
jit_value_t  PCodeCfg::IR_LoadRelativeWithType( IRBldr_t    * Bldr
                                              , jit_value_t   int8p
                                              , Int64         byteOffset
                                              , jit_type_t    typeToLoad
                                              )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   DPT0(  "VV0100: ", VV_BD, "In IR_LoadRelativeWithType\n" );

   jit_value_t int8p2, byOff, finalPtr, rtnVal ;

   if ( byteOffset == 0 )
      int8p2 = int8p ;
   else
   {
      byOff   = ConstantInt::get( int64Ty_, byteOffset ) ;

      DPT1("VV0101: ", VV_VD,
     "int8p2 = Bldr->CreateGEP( int8p, byOff = %ld)\n", byteOffset );
      int8p2 = Bldr->CreateGEP( int8p, byOff );
   }

   DPT0("VV0102: ", VV_VD, 
  "finalPtr   = Bldr->CreatePointerCast(int8p2, typeToLoad->getPointerTo() )\n" );
   finalPtr   = Bldr->CreatePointerCast( int8p2, typeToLoad->getPointerTo() );

   DPT0("VV0103: ", VV_VD,
              "Load_inst = Bldr->CreateLoad( finalPtr, 'DataVal' )\n" );
   LoadInst *  Load_inst = Bldr->CreateLoad( finalPtr, "DataVal" );

   rtnVal    = Load_inst ;
   return( rtnVal );
}

//
// IR_StoreRelativeWithType() - generate a "store" instruction to store a
// value at a specified byte offset from where the specified pointer points.  
// The "typeToStore" argument specifies what kind of "store" to generate.
//
void PCodeCfg::IR_StoreRelativeWithType( IRBldr_t    * Bldr
                                       , jit_value_t   val
                                       , jit_value_t   tgt8ByPtr
                                       , Int64         byteOffset
                                       , jit_type_t    typeToStore
                                       )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   jit_value_t tgt8ByPtr2, byOff, finalTgt ;

   DPT0(  "VV0200: ", VV_BD, "In IR_StoreRelativeWithType\n" );

   if ( byteOffset == 0 )
      tgt8ByPtr2 = tgt8ByPtr ;
   else
   {
      byOff  = ConstantInt::get( int64Ty_, byteOffset ) ;

      DPT1( "VV0201: ", VV_VD, 
     "Tgt_8p2 = Bldr->CreateGEP( tgt8ByPtr, byOff = %ld ) \n", byteOffset );
      tgt8ByPtr2 = Bldr->CreateGEP( tgt8ByPtr, byOff );
   }

   DPT0( "VV0202: ", VV_VD,
  "finalTgt = Bldr->CreatePointerCast(tgt8ByPtr2, typeToStore->getPointerTo() )\n" );
   finalTgt = Bldr->CreatePointerCast(tgt8ByPtr2, typeToStore->getPointerTo() );

   DPT0( "VV0202: ", VV_VD,
  "Bldr->CreateStore( val, finalTgt )\n" );
   Bldr->CreateStore( val, finalTgt );
}

//
// getJitValue() - generate code to fetch the specified value.
//
// FIX: Overlapped types can have problems too
// NOTE: It is unknown if this is a problem when using LLVM
// as opposed to LIBJIT.
//
jit_value_t PCodeOperand::getJitValue( PCodeCfg        * cfg
                                     , IRBldr_t        * Bldr
                                     , jit_type_t        IRtype
                                     , PCodeBlock      * blk
                                     , PCodeOperand    * orig = NULL
                                     , NABoolean         noSave = FALSE
                                     )
{
#if NExprDbgLvl >= VV_NO
  char  NExBuf[500];
#endif
  CDPT1( "VV0300: ", VV_BD, "GOT into getJitValue() on PCode Operand at %p\n", this );

  // Get operand in hash table
  CollIndex i = bvIndex_;
  PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);

  CDPT2( "VV0301: ", VV_BD, "In getJitValue(): operand=%p, this=%p\n", operand, this );

  if (operand != this)
  {
    return operand->getJitValue(cfg, Bldr, IRtype, blk, this, noSave);
  }

  // Make sure we properly indicate that this object *is* the original one.
  if (orig == NULL)
      orig = this;

  //
  // Get pointer to operand, if that's what is needed
  // 

  if ( IRtype == cfg->getInt1PtrTy() ) {

  CDPT0( "VV0310: ", VV_BD, "In getJitValue, IRtype == cfg->getInt1PtrTy()\n");
  CDPT1( "VV0311: ", VV_BD, "jitValuePtr_ = %p\n", jitValuePtr_ );

    // If already defined somewhere, perhaps it can be reused?
    if (jitValuePtr_) {
      assert(jitValuePtrBlock_ != NULL);

      // If the PCBlock given in jitValuePtrBlock_ dominates PCBlock blk,
      // then we are assured that jitValuePtr_ is valid.
      //
      if (blk->onesVector.testBit(jitValuePtrBlock_->getBlockNum()))
        return jitValuePtr_;
      else
        jitValuePtr_ = NULL;
    }
    CDPT1( "VV0315: ", VV_BD, "jitValuePtr_ is NOW = %p\n", jitValuePtr_);

    // Non-native temps will be accessed directly from the passed in temps
    // area.  If that temp was previously defined as a jit value (e.g. size of
    // temp fit native storage container), then we skip to the else clause so
    // the address is simply taken for the jit value.
    if (isVar() || isConst() || (!jitValue_ && orig->isNonNativeTemp())) {
      jit_value_t parm1 = cfg->getJitParams()[stackIndex_];

    CDPT2( "VV0317: ", VV_BD, "In getJitValue, stackIndex_ = %d, parm1 at %p \n", stackIndex_ , parm1 );
    CDPT0( "VV0320: ", VV_BD, "param = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() )\n" );

    jit_value_t param = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() );

    CDPT1( "VV0321: ", VV_BD, "In getJitValue, param [Int8Ptr] at %p \n", param );
    CDPT0( "VV0322: ", VV_BD, "In getJitValue, found isVar() || isConst() || ...\n" );

#if  NExprDbgLvl >= VV_BD
    if (isVar())
       CDPT0( "VV0323: ", VV_BD, "In getJitValue, found isVar() TRUE\n" );
    if (isConst())
       CDPT0( "VV0324: ", VV_BD, "In getJitValue, found isConst() TRUE\n" );
    if (isNonNativeTemp())
       CDPT0( "VV0325: ", VV_BD, "In getJitValue, found isNonNativeTemp() TRUE\n" );
#endif
    CDPT1( "VV0326: ", VV_BD, "In getJitValue, getType() returns %d\n", getType() );

      // For varchars we return a pointer to the start of length indicator.
      if (getType() == PCIT::MATTR5) {

        // If we're not dealing with a varchar, or if it is the first varchar,
        // we don't need to go through the VOA offset.
        if (!isVarchar() || (getVoaOffset() == -1)) {
//        jitValuePtr_ =
//          jit_insn_add_relative(param, (offset_ - vcIndicatorLen_));

           jit_value_t tmp1 = ConstantInt::get( cfg->getInt64Ty(),
                                                offset_ - vcIndicatorLen_ ) ;
           CDPT2( "VV0330: ", VV_BD,
                  "jitValuePtr_ = Bldr->CreateGEP( param, tmp1 = %d - %d )\n",
                                                    offset_, vcIndicatorLen_ );

           jitValuePtr_ = Bldr->CreateGEP( param, tmp1 );
        }
        else
        {
          jit_type_t MyTy = ((vcIndicatorLen_ == 2)
//                         ? jit_type_ushort : jit_type_uint);
                           ? cfg->getInt16Ty() : cfg->getInt32Ty());

////      jit_value_t v = jit_insn_load_relative(f, param, voaOffset_, MyTy);

          jit_value_t vcLen = cfg->IR_LoadRelativeWithType( Bldr, param,
                                                    voaOffset_,  MyTy );

          //
          // NOTE: The 16-bit or 32-bit offset that we just "loaded" should be
          // treated as an *unsigned* value so that we don't reference some 
          // negative offset from the beginning of the string/object/structure.
          // So, here we generate a Zero-Extend instruction to get the offset
          // extended out to 64 bits before it is added to the address of the object.
          //
          jit_value_t unsignedVcLen ;

          CDPT0( "VV0334: ", VV_BD,
         "unsignedVcLen  = Bldr->CreateZExt( vcLen, cfg->getInt64Ty() , 'ZExtVcLen' )\n" );
          unsignedVcLen  = Bldr->CreateZExt( vcLen, cfg->getInt64Ty() , "ZExtVcLen" );

////      jitValuePtr_ = jit_insn_add(f, param, v);

          CDPT0( "VV0335: ", VV_BD,
         "jitValuePtr_ = Bldr->CreateGEP( param, unsignedVcLen )\n" );
          jitValuePtr_ = Bldr->CreateGEP( param, unsignedVcLen );

          // Now set up pointer, moving past null indicator if required.
          if (vcNullIndicatorLen_)
          {
////        jitValuePtr_ = jit_insn_add_relative(f, jitValuePtr_,
////                                             vcNullIndicatorLen_);

            CDPT0( "VV0340: ", VV_BD,
           "jitValuePtr_ = Bldr->CreatePointerCast( jitValuePtr_, cfg->getInt8PtrTy() )\n" );
            jitValuePtr_ = Bldr->CreatePointerCast( jitValuePtr_, cfg->getInt8PtrTy() );

            jit_value_t NI_len = ConstantInt::get( cfg->getInt64Ty(), vcNullIndicatorLen_ ) ;

            // Now make jitValuePtr_ point to the first byte AFTER the Null Indicator

            CDPT0( "VV0341: ", VV_BD,
           "jitValuePtr_ = Bldr->CreateGEP( jitValuePtr_ , NI_len )\n" );
            jitValuePtr_ = Bldr->CreateGEP( jitValuePtr_ , NI_len );
          }
        }
         CDPT0( "VV0345: ", VV_BD,
        "jitValuePtr_ = Bldr->CreatePointerCast( jitValuePtr_, cfg->getInt8PtrTy() )\n" );
         jitValuePtr_ = Bldr->CreatePointerCast( jitValuePtr_, cfg->getInt8PtrTy() );

      } // End: if (getType() == PCIT::MATTR5)

      else {
////    jitValuePtr_ = jit_insn_add_relative(f, param, offset_);

        jit_value_t tmp1 = ConstantInt::get( cfg->getInt64Ty(), offset_ ) ;

         CDPT1( "VV0348: ", VV_BD,
        "jitValuePtr_ = Bldr->CreateGEP( param, tmp1 = %d )\n", offset_ );
         jitValuePtr_ = Bldr->CreateGEP( param, tmp1 );
      }

    } // End: if (isVar() || isConst() || (!jitValue_ && orig->isNonNativeTemp()))

    else {

      CDPT1( "VV0350: ", VV_BD, "PCodeOperand::getType() RETURNED %d\n", (int)getType() );

      // Normally we would force the jitValue_ to be defined if we're attempting
      // to get it.  However, in some cases (like FILL_MEM_BYTES) we make a 
      // a call to get it first so that things like the vc length can be written
      // to it first.
      // FIX: fix this so that we can continue to assert that jitValue_ should
      //      be defined first.  Fixing it involves having storeJitValue support
      //      all possible stores (vc lengths, actual values, etc.).

      // Must be called and it must already be defined

      if (!jitValue_) {
        // We reached a situation that we can't support.  For example, we could
        // having something like this:
        //
        // B1:  [2,0] = ...
        //      Branch B3
        // B2:  [2,0] = ...
        // B3:    = [2,0]
        //
        // If we allocated space for [2,0] in B1, and then do the same in B2,
        // which one do we use for B3?  Also, if we try to allocate space for
        // [2,0] in B3, then it would be completely wrong.

        cfg->setJitFailureSeen();
        CDPT0( "VV0352: ", VV_BD, "setJitFailureSeen() was just called!\n" );

        // And for the sake of nothing else failing along the way, use a
        // bogus value to return.
        return cfg->getFalse_JitVal_() ;
      }

      assert (jitValue_ && isTemp());

#if 0 /* NOT NEEDED WITH LLVM */
      // Temporary value needs to be addressable.
      jit_value_set_addressable(jitValue_);
#endif

      // Return the address of this temp variable.

      // jitValuePtr_ = jit_insn_address_of(f, jitValue_);

      CDPT0( "VV0355: ", VV_BD,
     "jitValuePtr_ = jitValue_ ; // USE jitValue_ AS ITS ADDRESS\n");
      jitValuePtr_ = jitValue_ ; // For LLVM, we can use the Value ptr *AS* its address!

      CDPT2( "VV0357: ", VV_BD, "jitValuePtr_ at %p is POINTING to Value rep by "
                                                       "jitValue_ at %p\n",
                                                     jitValuePtr_, jitValue_ );
      CDPT1( "VV0359: ", VV_BD, "CREATED Value's Type ID is %d\n",
                                     (int) jitValue_->getType()->getTypeID() );

      // If the jitValue_ was not defined in this current block, then the safe
      // thing to do is simply return the address of jitValue, but *do not* 
      // save the pointer in jitValuePtr_, since that will lead to confusion
      // on what was defined where.
      if (jitValuePtrBlock_ != blk) {
        jit_value_t temp = jitValuePtr_;
        jitValuePtr_ = NULL;

        CDPT1( "VV0360: ", VV_BD, "returning tempVal = %p\n", temp );
        return temp;
      }

    } //End: else [i.e. NOT ((isVar() || isConst() || ... ]

    CDPT2( "VV0361: ", VV_BD, "In getJitValue(): setting jitValuePtrBlock_ = %p "
                                        "for PCop = %p\n", blk, this );
    jitValuePtrBlock_ = blk;

    // If we are directly told not to save the jit values, don't!
    if (noSave)
    {
      jit_value_t tempVal = jitValuePtr_;
      jitValueBlock_ = NULL;
      jitValuePtrBlock_ = NULL;

      CDPT1( "VV0362: ", VV_BD, "In getJitValue(): NULLing jitValue_ in PCodeOp at %p\n", this );
      jitValue_ = jitValuePtr_ = NULL;

      CDPT1( "VV0364: ", VV_BD, "returning tempVal = %p\n", tempVal );

      return tempVal;
    }

    CDPT1( "VV0366: ", VV_BD, "returning jitValuePtr_ = %p\n", jitValuePtr_ );

    return jitValuePtr_;

  } //End: if ( IRtype == cfg->getInt1PtrTy() )

  CDPT2( "VV0368: ", VV_BD, "IRtype != cfg->getInt1PtrTy() for PCodeOp at %p "
                                   "with jitValue_ = %p\n", this, jitValue_ );

  //
  // Get value of operand
  //

  // If already defined somewhere, perhaps it can be reused?  If it's a temp,
  // however, then the assumption is that all uses have a def which reach it,
  // and that def is available in jitValue_.
  if (jitValue_) {
    jit_type_t valType = jitValue_->getType() ;

    CDPT1( "VV0370: ", VV_BD, "jitValue_ != NULL, nullBitIndex_ = %d\n", nullBitIndex_ );
    CDPT2( "VV0372: ", VV_BD, "FOUND jitValue_ in PCodeOp at %p set to %p\n",
                                                           this, jitValue_ );
    CDPT2( "VV0374: ", VV_BD,
           "In getJitValue(): valType->getTypeID() = %d, IRtype->getTypeID()=%d \n",
                        (int) valType->getTypeID(), (int) IRtype->getTypeID() );
#if NExprDbgLvl >= VV_BD
    if (valType->isPointerTy())
       CDPT1( "VV0376: ", VV_BD, "In getJitValue(): valType->getContainedType(0)->getTypeID() = %d\n",
                                              (int) valType->getContainedType(0)->getTypeID() );
#endif

    assert(jitValueBlock_ != NULL);

  CDPT1( "VV0376A: ", VV_BD, "In getJitValue(): jitValueBlock_ = %p\n", jitValueBlock_) ;
  CDPT1( "VV0376A: ", VV_BD, "In getJitValue(): isTemp() = %x\n", (Int32) isTemp() );
  CDPT2( "VV0376A: ", VV_BD, "In getJitValue(): blk = %p, jitValueBlock Dominates blk = %x\n",
               blk,  (Int32) blk->onesVector.testBit(jitValueBlock_->getBlockNum()) );

    // If the PCBlock given in jitValueBlock_ dominates PCBlock blk,
    // then we are assured that jitValue_ is valid.
    //
    if ( (isTemp() || blk->onesVector.testBit(jitValueBlock_->getBlockNum())) &&
         (( valType->getTypeID() == IRtype->getTypeID() ) ||
          ( valType->isPointerTy()  &&
            valType->getContainedType(0)->getTypeID() == IRtype->getTypeID()
          ) ||
          ( isTemp() && valType->isPointerTy()  &&
            valType->getContainedType(0)->isPointerTy()
          )
         )
       )
    {
      CDPT0( "VV0377: ", VV_BD, "Found jitValue_ != NULL and MAY be able to use it\n" );

      // It's possible that we have some overlapping operands.  The following
      // deals with it (or at least for the majority of the cases where we see
      // an overlap :()
//      jit_type_t jitValType = jit_value_get_type(jitValue_);
//      if (jit_type_get_size(jitValType) > jit_type_get_size(type))
//        return jit_insn_convert(f, jitValue_, type, 0);

      assert ( IRtype->getTypeID() == Type::IntegerTyID );

      Int32        valBitWdth ;
      jit_value_t  actualVal = jitValue_ ;

      if ( valType->isPointerTy() )
      {
         CDPT0( "VV0378: ", VV_BD,
        "actualVal = Bldr->CreateLoad( jitValue_, 'loadTemp' )\n" );
         actualVal = Bldr->CreateLoad( jitValue_, "loadTemp" ) ;

         valBitWdth = actualVal->getType()->getIntegerBitWidth() ;
      }
      else
      {
         valBitWdth = valType->getIntegerBitWidth() ;
      }

      if ( valBitWdth != IRtype->getIntegerBitWidth() )
      {
         CDPT0( "VV0380: ", VV_BD,
        "return( Bldr->CreateSExtOrTrunc( actualVal, (IntegerType *)IRtype, 'SExtOrTrunk' ) )\n" );
         return( Bldr->CreateSExtOrTrunc( actualVal,
                                       (IntegerType *)IRtype, "SExtOrTrunk" ) );
      }

      return actualVal ;

    } // End: if ( (isTemp() || blk->onesVector.testBit(... 

    CDPT1( "VV0382: ", VV_BD, "In getJitValue(): NULLing jitValue_ in PCodeOp at %p\n", this );

    jitValue_  = NULL;

  } // End: if (jitValue_)

  // NOTE: If we get here, then either jitValue_ was NULL or
  //       we decided it was not valid.

  if (isConst()) {

    CDPT1( "VV0384: ", VV_BD, "isConst() is TRUE.  Also - nullBitIndex_ = %d\n", nullBitIndex_ );

    //
    // FIX: the assumption right now is that only integers are considered for
    // native expressions.  That will change shortly.  In the meantime, however,
    // this implies that getIntConstValue() should be called on the operand to
    // retrieve the constant value.
    //
    // FIX: getIntConstValue() should probably be "relaxed" a little so as to
    // support MPTR32 and MFLT (both of which may be casted into integer types
    // during same-sized moves).  For now, work around by adding logic here.
    //

    if ( IRtype == cfg->getInt64Ty() ) {
      // MFLT64 can sometimes be the original type of the operand being sought
      // after (e.g. PCIT::MFLT64_MFLT64 --> PCIT::MBIN64S_MBIN64S).  Use the
      // original operand to get the constant value.
      // Likewise, we should use the original type in the case of MBIGS or MBIGU
      // because PCODE optimization may change MBIG[SU]-type PCODE instructions
      // to simpler instructions such as 64-bit move instructions.

      PCodeOperand* op = ((getType() == PCIT::MFLT64) ||
                          (getType() == PCIT::MFLT32) ||
                          (getType() == PCIT::MBIGS ) ||
                          (getType() == PCIT::MBIGU )
                         )
                            ? orig : this;

      Int64 val = cfg->getIntConstValue(op);

//    jitValue_ = jit_value_create_long_constant(f, type, val);
      jitValue_ = ConstantInt::get( IRtype, val );
      CDPT2( "VV0386: ", VV_BD,
             "In getJitValue(): setting jitValue_ in PCodeOp at %p to %p\n",
                                                       this, jitValue_ );
      CDPT1( "VV0388: ", VV_BD, "In getJitValue(): CREATED Value's Type ID is %d\n",
                                        (int) jitValue_->getType()->getTypeID() );
    }
    else if (getType() == PCIT::MPTR32) {
      // MPTR32 can sometimes be the original type of the operand being sought
      // after (e.g. PCIT::MBIN8_MBIN8_IBIN32S --> PCIT::MBIN8_MBIN8).  Use the
      // original operand to get the constant value.

      Int32 val = (Int32)cfg->getIntConstValue(((orig) ? orig : this));
//    jitValue_ = jit_value_create_nint_constant(f, type, val);

      CDPT1( "VV0390: ", VV_BD, "In getJitValue(): setting jitValue_ to be a constant Int of %d\n", val );
      CDPT1( "VV0391: ", VV_BD, "In getJitValue(): and jitValue_'s bitWidth is %d\n",
                                               IRtype->getIntegerBitWidth() );
      jitValue_ = ConstantInt::get( IRtype, val );

      CDPT2( "VV0392: ", VV_BD, "In getJitValue(): setting jitValue_ in PCodeOp at %p to %p\n",
                                            this, jitValue_ );
      CDPT1( "VV0394: ", VV_BD, "In getJitValue(): CREATED Value's Type ID is %d\n",
                                         (int) jitValue_->getType()->getTypeID() );
    }
    else if ( IRtype->isFloatTy() ) {
      assert(0==245); // NEED TO add real code here when 
                      // we want to use LLVM on Floating Pt
                      // related PCODE instructions

      // Unless the value is "1.0", libjit will store a double constant in
      // memory, referenced via %ip, and that will blow us up at runtime.  Get
      // it from memory instead (if not 1.0)
#if 0  // FIX THIS when want to use LLVM on Floating Pt related PCODE instructions
      double val = cfg->getFloatConstValue(((orig) ? orig : this));
      if (val == 1.0)
        jitValue_ = jit_value_create_float64_constant(f, type, val);
      else {
        jit_value_t parm1 = cfg->getJitParams()[stackIndex_];
        jit_value_t param  = Bldr->CreatePointerCast(parm1, Int8PtrTy );
        jitValue_ = jit_insn_load_relative(f, param, offset_, type);
      }
#endif // 0
    }
    else {
      Int32 val = (Int32)cfg->getIntConstValue(((orig) ? orig : this));
//    jitValue_ = jit_value_create_nint_constant(f, type, val);
      jitValue_ = ConstantInt::get( IRtype , val );

      CDPT2( "VV0396: ", VV_BD, "In getJitValue(): setting jitValue_ in PCodeOp at %p to %p\n",
                                        this, jitValue_ );
      CDPT1( "VV0397: ", VV_BD, "CREATED Value's Type ID is %d\n", (int) jitValue_->getType()->getTypeID() );
      CDPT1( "VV0398: ", VV_BD, "CREATED Value's actual value is %d\n", val );
    }

  } // End: if (isConst())

  else if (isVar()) {

    CDPT1( "VV0399: ", VV_BD, "nullBitIndex_ = %d\n", nullBitIndex_ );

    jit_value_t parm1 = cfg->getJitParams()[stackIndex_];

    CDPT0( "VV0400: ", VV_BD,
             "param = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() )\n" );
    jit_value_t param = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() );

    // Are we getting the null bit?
    if (nullBitIndex_ != -1) {
      // For paranoia, make sure offset_ is not -1 also (indicating packed
      // format against a varchar, which is not supported yet).
      assert(offset_ != -1);

////  jit_value_t mask = jit_value_create_nint_constant(f, jit_type_ubyte,
////                       (UInt8)0x1 << (7 - (nullBitIndex_ & 7)));

      jit_value_t mask = ConstantInt::get( cfg->getInt8Ty(),
                                 ((UInt8)0x1 << (7 - (nullBitIndex_ & 7)) ) );

////  jit_value_t nByte = jit_insn_load_relative(f, param,
////                        offset_ + (nullBitIndex_ >> 3), jit_type_ubyte);

      jit_value_t nByte = cfg->IR_LoadRelativeWithType( Bldr, param,
                                     offset_ + (nullBitIndex_ >> 3),
                                     cfg->getInt8Ty() );

////  jitValue_ = jit_insn_and(f, nByte, mask);

      CDPT1( "VV0410: ", VV_BD,
     "jitValue_ = Bldr->CreateAnd( nByte, mask = 0x%x )\n", (UInt8)0x1 << (7 - (nullBitIndex_ & 7)) );
      jitValue_ = Bldr->CreateAnd( nByte, mask );

      //
      // NOTE: There is an interesting point to make here.  The CreateAnd()
      // operation that we just did actually returned a pointer to an
      // "AND" instruction whose first operand (nByte) is a pointer to a "load"
      // instruction!   See the discussion at the beginning of
      // IR_LoadRelativeWithType about the fact that what we are really doing
      // is teaching the IR generator HOW TO materialize values at runtime.
      // It is for this reason that jitValue_ now points to an "AND" instruction
      // whose first operand is a "load" instruction.
      //

      CDPT2( "VV0412: ", VV_BD, "In getJitValue(): setting jitValue_ in PCodeOp at %p to %p\n",
                                          this, jitValue_ );
      CDPT1( "VV0413: ", VV_BD, "CREATED Value's Type ID is %d\n",
                                   (int) jitValue_->getType()->getTypeID() );
    }
    else
    {
////  jitValue_ = jit_insn_load_relative(f, param, offset_, type);
      jitValue_ = cfg->IR_LoadRelativeWithType( Bldr, param, offset_, IRtype );

      CDPT2( "VV0415: ", VV_BD, "In getJitValue(): setting jitValue_ in PCodeOp at "
                                "%p to %p\n", this, jitValue_ );
      CDPT1( "VV0417: ", VV_BD, "CREATED Value's Type ID is %d\n",
                                   (int) jitValue_->getType()->getTypeID() );
    }

  } // End: else if (isVar())


  else {
    // Accessing an undefined temp is not allowed.
    // NOTE: An "undefined temp" is one which does not currently have a value.
    // If it has not been given a value, then we should not be in this routine
    // trying to get its value!

    CDPT0( "VV0420: ", VV_BD,
           "ABOUT TO DO assert (FALSE) -- undefined temp is not allowed\n" );

    assert (FALSE);
  }

  CDPT2( "VV0421: ", VV_BD, "In getJitValue(): setting jitValueBlock_ = %p for PCop = %p\n", blk, this );

  jitValueBlock_ = blk;

  // If we are directly told not to save the jit values, don't!
  if (noSave)
  {
    jit_value_t tempVal = jitValue_;
    jitValueBlock_ = NULL;
    jitValuePtrBlock_ = NULL;

    CDPT1( "VV0VV0422: ", VV_BD, "In getJitValue(): NULLing jitValue_ in PCodeOp at "
                                 "%p\n", this );

    jitValue_ = jitValuePtr_ = NULL;
    return tempVal;
  }

  return jitValue_;
}

//
// jitGenCompare() - generate a series of code to do a comparison
// between 2 values.  Returns a "PHI Node".
//
jit_value_t PCodeCfg::jitGenCompare( IRBldr_t    * Bldr
                                   , enum cmpKind  kindOfCompare
                                   , jit_value_t   oper1
                                   , jit_value_t   oper2
                                   , jit_value_t   trueRslt
                                   , jit_value_t   falseRslt
                                   )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   DPT0( "VV0500: ", VV_BD, "GOT into jitGenCompare()\n" );

   llvm::LLVMContext &LLContxt = Bldr->getContext();

   jit_value_t  Zero   = ConstantInt::get( oper1->getType(), 0 );
   jit_value_t  IsZero = (Value *)NULL;
   jit_value_t  Rslt   = (Value *)NULL;

   DPT2( "VV0502: ", VV_XD, "In jitGenCompare(): oper1 has TypeID = "
                            "%d, oper2 has %d\n",
               oper1->getType()->getTypeID(), oper2->getType()->getTypeID() );

#if NExprDbgLvl >= VV_BD
   if ( ( NExprDbgLvl_ >= VV_XD ) &&
        ( oper1->getType()->getTypeID() != oper2->getType()->getTypeID() ) )
   {
      DPT2( "VV0504: ", VV_XD, "In jitGenCompare(): oper1 at %p, oper2 at %p\n",
                                                    oper1,       oper2 );
   }
   else if ( oper1->getType()->getTypeID() == Type::IntegerTyID )
   {
      if ( oper1->getType()->getIntegerBitWidth() != 
           oper2->getType()->getIntegerBitWidth() )
      {
        DPT2( "VV0506: ", VV_XD,
              "In jitGenCompare(): oper1 width = %d, oper2 width = %d\n",
                                   oper1->getType()->getIntegerBitWidth(),
                                   oper2->getType()->getIntegerBitWidth() );
        DPT2( "VV0508: ", VV_XD,
              "In jitGenCompare(): oper1 at %p, oper2 at %p\n",
                                   oper1,       oper2 );
      }
   }
#endif
   switch ( kindOfCompare )
   {
      case IntCompare_EQ :
      {
         // NOTE: We use an XOR instruction here INSTEAD OF a ICmpEQ because
         // LLVM's JIT Compiler for the x86 has a bug in it ... at least in
         // Version 3.2 of LLVM.   If we use a ICmpEQ and the operands are
         // 32-bit operands, LLVM's JIT Compiler sometimes ends up producing
         // a 64-bit comparison!
#if 0
         DPT0( "VV0510: ", VV_VD,
        "IsZero = Bldr->CreateICmpEQ( oper1, oper2, 'ICmpEQ' )\n" );
         IsZero = Bldr->CreateICmpEQ( oper1, oper2, "ICmpEQ" );
#else
         DPT0( "VV0510: ", VV_VD,
        "Rslt = Bldr->CreateXor( oper1, oper2, 'IXor' )\n" );
         Rslt = Bldr->CreateXor( oper1, oper2, "IXor" );

         // NOTE: We must follow the XOR operation with a test for zero.
         // You would think this unnecessary since the 'xor' machine
         // instruction sets the Z flag in the x86's EFLAGS register.
         // However, LLVM requires the CreateCondBr call (see 
         // the one below) to be done on a boolean variable and the
         // result of the XOR is not a boolean, but multiple bits wide.
         // NOTE: This does *not* result in two insructions in the
         // final native code since LLVM's JIT Compiler is smart enough
         // to optimize the unnecessary 'cmp' instruction away!
         // 
         DPT0( "VV0511: ", VV_VD,
        "IsZero  = Bldr->CreateICmpEQ( Rslt, Zero, 'check0' )\n" );
         IsZero  = Bldr->CreateICmpEQ( Rslt, Zero, "check0" );
#endif

         break ;
      }
      case IntCompare_NE :
      {
         DPT0( "VV0520: ", VV_VD,
        "IsZero = Bldr->CreateICmpNE( oper1, oper2, 'ICmpNE' )\n" );
         IsZero = Bldr->CreateICmpNE( oper1, oper2, "ICmpNE" );
         break ;
      }
      case IntCompare_SGT :
      {
         DPT0( "VV0523: ", VV_VD,
        "IsZero = Bldr->CreateICmpSGT( oper1, oper2, 'ICmpSGT' )\n" );
         IsZero = Bldr->CreateICmpSGT( oper1, oper2, "ICmpSGT" );
         break ;
      }
      case IntCompare_UGT :
      {
         DPT0( "VV0525: ", VV_VD,
        "IsZero = Bldr->CreateICmpUGT( oper1, oper2, 'ICmpUGT' )\n" );
         IsZero = Bldr->CreateICmpUGT( oper1, oper2, "ICmpUGT" );
         break ;
      }
      case IntCompare_UGE :
      {
         DPT0( "VV0526: ", VV_VD,
        "IsZero = Bldr->CreateICmpUGE( oper1, oper2, 'ICmpUGE' )\n" );
         IsZero = Bldr->CreateICmpUGE( oper1, oper2, "ICmpUGE" );
         break ;
      }
      case IntCompare_SGE :
      {
         DPT0( "VV0527: ", VV_VD,
        "IsZero = Bldr->CreateICmpSGE( oper1, oper2, 'ICmpSGE' )\n" );
         IsZero = Bldr->CreateICmpSGE( oper1, oper2, "ICmpSGE" );
         break ;
      }
      case IntCompare_SLT:
      {
         DPT0( "VV0528: ", VV_VD,
        "IsZero = Bldr->CreateICmpSLT( oper1, oper2, 'ICmpSLT' )\n" );
         IsZero = Bldr->CreateICmpSLT( oper1, oper2, "ICmpSLT" );
         break ;
      }
      case IntCompare_SLE:
      {
         DPT0( "VV0529: ", VV_VD,
        "IsZero = Bldr->CreateICmpSLE( oper1, oper2, 'ICmpSLE' )\n" );
         IsZero = Bldr->CreateICmpSLE( oper1, oper2, "ICmpSLE" );
         break ;
      }
      case IntCompare_ULT :
      {
         DPT0( "VV0530: ", VV_VD,
        "IsZero = Bldr->CreateICmpULT( oper1, oper2, 'ICmpULT' )\n" );
         IsZero = Bldr->CreateICmpULT( oper1, oper2, "ICmpULT" );
         break ;
      }
      case IntCompare_ULE :
      {
         DPT0( "VV0531: ", VV_VD,
        "IsZero = Bldr->CreateICmpULE( oper1, oper2, 'ICmpULE' )\n" );
         IsZero = Bldr->CreateICmpULE( oper1, oper2, "ICmpULE" );
         break ;
      }
      default :
         assert(0==250) ; // ZZZZ FIX IF WE EVER GET HERE.
         break ;
   }
   // Get ptr to current Function
   llvm::Function *ExpFn = Bldr->GetInsertBlock()->getParent();

   // Create 3 BasicBlock objects
   //
   // Note: We tell LLVM to give informative "names" to the blocks
   // so we more easily recognize what we are seeing when we do an
   // Intermediate Representation (IR) dump....used in debugging.
   //
   p_IR_block_t ThenBB  = BasicBlock::Create( LLContxt, "CmpThenBlk"  );
   p_IR_block_t ElseBB  = BasicBlock::Create( LLContxt, "CmpElseBlk"  );
   p_IR_block_t MergeBB = BasicBlock::Create( LLContxt, "CmpMergeBlk" );

   DPT3( "VV0550: ", VV_VD, "ThenBB = %p, ElseBB = %p, MergeBB = %p\n",
                             ThenBB,      ElseBB,      MergeBB );
   DPT2( "VV0551: ", VV_VD,
  "Bldr->CreateCondBr( IsZero, ThenBB = %p, ElseBB = %p )\n", ThenBB, ElseBB );
   Bldr->CreateCondBr( IsZero, ThenBB, ElseBB );

   DPT1( "VV0552: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( ThenBB = %p )\n", ThenBB );
   ExpFn->getBasicBlockList().push_back( ThenBB );

   DPT1( "VV0553: ", VV_VD,
  "Bldr->SetInsertPoint( ThenBB = %p )\n", ThenBB );
   Bldr->SetInsertPoint( ThenBB );

   jit_value_t ThenVal = trueRslt;
// NOTE: Since the "Then" Value was passed in, we don't need to generate
// any code here except for a Branch to the Merge Block.

   DPT1( "VV0555: ", VV_VD,
  "Bldr->CreateBr( MergeBB = %p )\n", MergeBB );
   Bldr->CreateBr( MergeBB );

   DPT1( "VV0556: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( ElseBB = %p )\n", ElseBB );
   ExpFn->getBasicBlockList().push_back( ElseBB );

   DPT1( "VV0557: ", VV_VD,
  "Bldr->SetInsertPoint( ElseBB = %p )\n", ElseBB );
   Bldr->SetInsertPoint( ElseBB );

   jit_value_t  ElseVal = falseRslt;
// NOTE: Since the "Else" Value was passed in, we don't need to generate
// any code here except for a Branch to the Merge Block.

   DPT1( "VV0560: ", VV_VD,
  "Bldr->CreateBr( MergeBB = %p )\n", MergeBB );
   Bldr->CreateBr( MergeBB );

   // Now set up to insert code into the "merge back" common place
   DPT1( "VV0561: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( MergeBB = %p )\n", MergeBB );
   ExpFn->getBasicBlockList().push_back( MergeBB );

   DPT1( "VV0562: ", VV_VD,
  "Bldr->SetInsertPoint( MergeBB = %p )\n", MergeBB );
   Bldr->SetInsertPoint( MergeBB );

   //
   // Create PHI node.  NOTE: Type of PHI node *must* match Type of Values passed to
   //                         addIncoming(...)
   //
   DPT0( "VV0570: ", VV_VD,
           "PN = Bldr->CreatePHI( trueRslt->getType(), 2, 'iftmp' )\n" );
   PHINode *PN = Bldr->CreatePHI( trueRslt->getType(), 
                                    2, "iftmp" ); // '2' is LLVM version # !!
   DPT2( "VV0571: ", VV_VD,
  "PN->addIncoming( ThenVal at %p, from IR blk at %p )\n", ThenVal, ThenBB );
   PN->addIncoming( ThenVal, ThenBB );

   DPT2( "VV0572: ", VV_VD,
  "PN->addIncoming( ElseVal at %p, from IR blk at %p )\n", ElseVal, ElseBB );
   PN->addIncoming( ElseVal, ElseBB );
   return (PN);
}

//
// getJitType() - return an LLVM type corresponding to the specified
// operand type.
//
jit_type_t  PCodeOperand::getJitType( PCodeCfg * cfg , PCIT::AddressingMode oprTyp )
{
  PCIT::AddressingMode OperTyp = operandType_ ;

  if ( oprTyp != PCIT::AM_NONE )
     OperTyp = oprTyp ;

  switch ( OperTyp ) {
    case PCIT::MBIN8:   return cfg->getInt8Ty()  ;
    case PCIT::MBIN16U: return cfg->getInt16Ty() ;
    case PCIT::MBIN16S: return cfg->getInt16Ty() ;
    case PCIT::MBIN32U: return cfg->getInt32Ty() ;
    case PCIT::MBIN32S: return cfg->getInt32Ty() ;
    case PCIT::MBIN64S: return cfg->getInt64Ty() ;
    case PCIT::MASCII:
    case PCIT::MATTR5:
    case PCIT::MBIGS:
       return cfg->getInt1PtrTy() ; // Use instead of LIBJIT's void ptr type
    case PCIT::MPTR32:
    {
       if ( forAlignedFormat() )
          return cfg->getInt8Ty() ;  // Return a single byte
       else
          return cfg->getInt1PtrTy() ; // Use instead of LIBJIT's void ptr type
    }
    case PCIT::MFLT64:
       return cfg->getFloatPtrTy() ;
  }

  // No other types supported
  assert(FALSE);

  return cfg->getInt1PtrTy() ; // Should not get here.
}

//
// genMemCopyLoop() - generate code to do a memory-to-memory copy.
//
void PCodeCfg::genMemCopyLoop( IRBldr_t    * Bldr
                             , jit_value_t   srcPtr
                             , jit_value_t   tgtPtr
                             , jit_value_t   maxLen
                             )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   jit_value_t  BytesPer, CmpRslt ;
   jit_value_t  RndMaxLen, ByteCtVal ;
   jit_value_t  MaxLen64 ;
   DPT0( "VV0600: ", VV_BD, "GOT into genMemCopyLoop()\n" );

   jit_value_t  Zero  = ConstantInt::get( int64Ty_, 0 );

   llvm::LLVMContext &LLContxt = Bldr->getContext();
   llvm::Function *ExpFn       = Bldr->GetInsertBlock()->getParent();

   p_IR_block_t fastLoopLabel = BasicBlock::Create( LLContxt, "MemCpyFastBlk" );
   p_IR_block_t endLabel      = BasicBlock::Create( LLContxt, "MemCpyEndBlk" );

   DPT2( "VV0602: ", VV_VD, "fastLoopLabel = %p, endLabel = %p\n",
                             fastLoopLabel,      endLabel ); 

   Int32 bytesAtOnce = 8;

   BytesPer          = ConstantInt::get( int64Ty_, bytesAtOnce );
   DPT0( "VV0605: ", VV_VD,
  "MaxLen64          = Bldr->CreateZExt( maxLen, int64Ty_, 'ExtMaxLen')\n" );
   MaxLen64          = Bldr->CreateZExt( maxLen, int64Ty_, "ExtMaxLen");

   DPT0( "VV0606: ", VV_VD,
  "RndMaxLen         = Bldr->CreateUDiv( MaxLen64, BytesPer, 'UDiv' )\n" );
   RndMaxLen         = Bldr->CreateUDiv( MaxLen64, BytesPer, "UDiv" );

   DPT0( "VV0607: ", VV_VD,
  "RndMaxLen         = Bldr->CreateMul( RndMaxLen, BytesPer, 'Mul' )\n" );
   RndMaxLen         = Bldr->CreateMul( RndMaxLen, BytesPer, "Mul" );

   DPT0( "VV0610: ", VV_VD,
  "AllocaInst *  ByteCt = Bldr->CreateAlloca( int64Ty_ )\n" );
   AllocaInst *  ByteCt = Bldr->CreateAlloca( int64Ty_ );

   DPT0( "VV0611: ", VV_VD,
  "Bldr->CreateStore( Zero, ByteCt )\n" );
   Bldr->CreateStore( Zero, ByteCt );

   DPT0( "VV0612: ", VV_VD,
  "CmpRslt = Bldr->CreateICmpULT( RndMaxLen, BytesPer, 'ICmp.RndMaxLen' )\n" );
   CmpRslt = Bldr->CreateICmpULT( RndMaxLen, BytesPer, "ICmp.RndMaxLen" );

   DPT0( "VV0613: ", VV_VD,
  "Bldr->CreateCondBr( CmpRslt, endLabel, fastLoopLabel )\n" );
   Bldr->CreateCondBr( CmpRslt, endLabel, fastLoopLabel );

   // Start fast loop here

   DPT1( "VV0615: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( fastLoopLabel = %p )\n" , fastLoopLabel);
   ExpFn->getBasicBlockList().push_back( fastLoopLabel );

   DPT0( "VV0616: ", VV_VD,
  "Bldr->SetInsertPoint( fastLoopLabel )\n" );
   Bldr->SetInsertPoint( fastLoopLabel );

   // Copy multiple bytes at a time.
   DPT0( "VV0617: ", VV_VD,
  "ByteCtVal = Bldr->CreateLoad( ByteCt, 'loadByteCt' )\n");
   ByteCtVal = Bldr->CreateLoad( ByteCt, "loadByteCt" ); // Re-load within loop

   DPT0( "VV0618: ", VV_VD,
               "ThisSrc = Bldr->CreateGEP( srcPtr, ByteCtVal, 'ThisSrc' )\n" );
   jit_value_t  ThisSrc = Bldr->CreateGEP( srcPtr, ByteCtVal, "ThisSrc" );

   DPT0( "VV0619: ", VV_VD,
               "ThisTgt = Bldr->CreateGEP( tgtPtr, ByteCtVal, 'ThisTgt' )\n" );
   jit_value_t  ThisTgt = Bldr->CreateGEP( tgtPtr, ByteCtVal, "ThisTgt" );

   jit_value_t MultiBytes = IR_LoadRelativeWithType( Bldr, ThisSrc,
                                                     0, int64Ty_ );
   IR_StoreRelativeWithType( Bldr, MultiBytes, ThisTgt,
                                                     0, int64Ty_ );

   // Increment count of bytes copyied
   DPT0( "VV0621: ", VV_VD,
  "ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, 'nextIncr')\n");
   ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, "nextIncr" );

   DPT0( "VV0622: ", VV_VD,
  "Bldr->CreateStore( ByteCtVal, ByteCt, 'storeByteCt' )\n" );
   Bldr->CreateStore( ByteCtVal, ByteCt, "storeByteCt" );


   // while (ByteCtVal < RndMaxLen) branch to fastLoop
   DPT0( "VV0623: ", VV_VD,
  "CmpRslt = Bldr->CreateICmpULT( ByteCtVal, RndMaxLen, 'ICmp.ByteCt' )\n" );
   CmpRslt = Bldr->CreateICmpULT( ByteCtVal, RndMaxLen, "ICmp.ByteCt" );

   DPT0( "VV0624: ", VV_VD,
  "Bldr->CreateCondBr( CmpRslt, fastLoopLabel, endLabel )\n" );
   Bldr->CreateCondBr( CmpRslt, fastLoopLabel, endLabel );

   DPT1( "VV0625: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( endLabel = %p )\n", endLabel );
   ExpFn->getBasicBlockList().push_back( endLabel );

   DPT0( "VV0626: ", VV_VD,
  "Bldr->SetInsertPoint( endLabel )\n" );
   Bldr->SetInsertPoint( endLabel );

   // Now copy any remaining bytes (from 0 to 7 bytes possible)

   p_IR_block_t slowLoopLabel = BasicBlock::Create( LLContxt, "MemCpySlowBlk" );
   p_IR_block_t end2Label     = BasicBlock::Create( LLContxt, "MemCpyEndBlk" );

   DPT2( "VV0628: ", VV_VD, "slowLoopLabel = %p, end2Label = %p\n",
                             slowLoopLabel,      end2Label ); 

   bytesAtOnce = 1;

   BytesPer          = ConstantInt::get( int64Ty_, bytesAtOnce );

   DPT0( "VV0630: ", VV_VD,
  "ByteCtVal = Bldr->CreateLoad( ByteCt, 'loadByteCt' )\n");
   ByteCtVal = Bldr->CreateLoad( ByteCt, "loadByteCt" );

   DPT0( "VV0632: ", VV_VD,
  "CmpRslt = Bldr->CreateICmpUGE( ByteCtVal, MaxLen64, 'ICmp.RndMaxLen' )\n" );
   CmpRslt = Bldr->CreateICmpUGE( ByteCtVal, MaxLen64, "ICmp.RndMaxLen" );

   DPT0( "VV0633: ", VV_VD,
  "Bldr->CreateCondBr( CmpRslt, end2Label, slowLoopLabel )\n" );
   Bldr->CreateCondBr( CmpRslt, end2Label, slowLoopLabel );

   // Start slow loop here

   DPT1( "VV0635: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( slowLoopLabel = %p )\n", slowLoopLabel );
   ExpFn->getBasicBlockList().push_back( slowLoopLabel );

   DPT0( "VV0636: ", VV_VD,
  "Bldr->SetInsertPoint( slowLoopLabel )\n" );
   Bldr->SetInsertPoint( slowLoopLabel );

   // Copy multiple bytes at a time.
   DPT0( "VV0637: ", VV_VD,
  "ByteCtVal = Bldr->CreateLoad( ByteCt, 'loadByteCt' )\n");
   ByteCtVal = Bldr->CreateLoad( ByteCt, "loadByteCt" ); // Re-load within the loop

   DPT0( "VV0638: ", VV_VD,
               "CurrSrc = Bldr->CreateGEP( srcPtr, ByteCtVal, 'CurrSrc' )\n" );
   jit_value_t  CurrSrc = Bldr->CreateGEP( srcPtr, ByteCtVal, "CurrSrc" );

   DPT0( "VV0639: ", VV_VD,
               "CurrTgt = Bldr->CreateGEP( tgtPtr, ByteCtVal, 'CurrTgt' )\n" );
   jit_value_t  CurrTgt = Bldr->CreateGEP( tgtPtr, ByteCtVal, "CurrTgt" );

   jit_value_t OneByte = IR_LoadRelativeWithType( Bldr, CurrSrc,
                                                  0, int8Ty_ );
   IR_StoreRelativeWithType( Bldr, OneByte, CurrTgt,
                                                  0, int8Ty_ );

   // Increment loop count
   DPT0( "VV0641: ", VV_VD,
  "ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, 'nextIncr')\n");
   ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, "nextIncr" );

   DPT0( "VV0642: ", VV_VD,
  "Bldr->CreateStore( ByteCtVal, ByteCt, 'storeByteCt' )\n" );
   Bldr->CreateStore( ByteCtVal, ByteCt, "storeByteCt" );


   // while (ByteCtVal < MaxLen64) branch to slowLoop
   DPT0( "VV0643: ", VV_VD,
  "CmpRslt = Bldr->CreateICmpULT( ByteCtVal, MaxLen64, 'ICmp.ByteCt' )\n" );
   CmpRslt = Bldr->CreateICmpULT( ByteCtVal, MaxLen64, "ICmp.ByteCt" );

   DPT0( "VV0644: ", VV_VD,
  "Bldr->CreateCondBr( CmpRslt, slowLoopLabel, end2Label )\n" );
   Bldr->CreateCondBr( CmpRslt, slowLoopLabel, end2Label );

   DPT1( "VV0645: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( end2Label = %p )\n", end2Label );
   ExpFn->getBasicBlockList().push_back( end2Label );

   DPT0( "VV0646: ", VV_VD,
  "Bldr->SetInsertPoint( end2Label )\n" );
   Bldr->SetInsertPoint( end2Label );
}

//
// genMemCmpLoop() - generate code to do a memory-to-memory compare.
//
jit_value_t PCodeCfg::genMemCmpLoop( IRBldr_t    * Bldr
                                   , enum cmpKind  KindOfCmp
                                   , jit_value_t   src1Ptr
                                   , jit_value_t   src2Ptr
                                   , jit_value_t   maxLen
                                   )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   jit_value_t  BytesPer, Is_LT ;
   jit_value_t  RndMaxLen, ByteCtVal ;
   jit_value_t  MaxLen64 ;
   jit_value_t  IsZero   ;
   jit_value_t  IsEqual  ;
   DPT0( "VVa600: ", VV_BD, "GOT into genMemCmpLoop()\n" );

   jit_value_t  Zero  = ConstantInt::get( int64Ty_, 0 );

   llvm::LLVMContext &LLContxt = Bldr->getContext();
   llvm::Function *ExpFn       = Bldr->GetInsertBlock()->getParent();

   p_IR_block_t fastCmpLpLabel  = BasicBlock::Create( LLContxt, "MemCmpFastBlk" );
   p_IR_block_t fastCmpNxtLabel = BasicBlock::Create( LLContxt, "MemCmpFastNextBlk" );
   p_IR_block_t slowCmpLpLabel  = BasicBlock::Create( LLContxt, "MemCmpSlwBlk" );
   p_IR_block_t slowContLabel   = BasicBlock::Create( LLContxt, "MemCmpSlwContBlk" );
   p_IR_block_t slowCmpEndLabel = BasicBlock::Create( LLContxt, "MemCmpSlwEndBlk" );

   DPT2( "VVa602: ", VV_VD, "fastCmpLpLabel = %p, fastCmpNxtLabel = %p\n",
                             fastCmpLpLabel,      fastCmpNxtLabel ); 
   DPT2( "VVa602: ", VV_VD, "slowCmpLpLabel = %p, slowContLabel  = %p\n" ,
                             slowCmpLpLabel,      slowContLabel ); 
   DPT1( "VVa602: ", VV_VD, "slowCmpEndLabel = %p\n",
                             slowCmpEndLabel ); 
   Int32 bytesAtOnce = 8;

   BytesPer          = ConstantInt::get( int64Ty_, bytesAtOnce );
   DPT0( "VVa605: ", VV_VD,
  "MaxLen64          = Bldr->CreateZExt( maxLen, int64Ty_, 'ExtMaxLen')\n" );
   MaxLen64          = Bldr->CreateZExt( maxLen, int64Ty_, "ExtMaxLen");

// NOTE: We subtract 1 so that we ensure we always go through the slow loop
// and do the caller-specified comparison for at least one byte.

   jit_value_t One = ConstantInt::get( int64Ty_, 1 );

   DPT0( "VVa606: ", VV_VD,
  "RndMaxLen         = Bldr->CreateSub( MaxLen64, One, 'Sub1' )\n" );
   RndMaxLen         = Bldr->CreateSub( MaxLen64, One, "Sub1" );

   DPT0( "VVa607: ", VV_VD,
  "RndMaxLen         = Bldr->CreateUDiv( RndMaxLen, BytesPer, 'UDiv' )\n" );
   RndMaxLen         = Bldr->CreateUDiv( RndMaxLen, BytesPer, "UDiv" );

   DPT0( "VVa608: ", VV_VD,
  "RndMaxLen         = Bldr->CreateMul( RndMaxLen, BytesPer, 'Mul' )\n" );
   RndMaxLen         = Bldr->CreateMul( RndMaxLen, BytesPer, "Mul" );

   DPT0( "VVa610: ", VV_VD,
  "AllocaInst *  ByteCt = Bldr->CreateAlloca( int64Ty_ )\n" );
   AllocaInst *  ByteCt = Bldr->CreateAlloca( int64Ty_ );

   DPT0( "VVa611: ", VV_VD,
  "Bldr->CreateStore( Zero, ByteCt )\n" );
   Bldr->CreateStore( Zero, ByteCt );

   //
   // NOTE: If we don't have at least BytesPer bytes to compare, then
   // we go directly to the slow loop.
   //
   DPT0( "VVa612: ", VV_VD,
  "Is_LT = Bldr->CreateICmpSLT( RndMaxLen, BytesPer, 'ICmp.RndMaxLen' )\n" );
   Is_LT = Bldr->CreateICmpSLT( RndMaxLen, BytesPer, "ICmp.RndMaxLen" );

   DPT0( "VVa613: ", VV_VD,
  "Bldr->CreateCondBr( Is_LT, slowCmpLpLabel, fastCmpLpLabel )\n" );
   Bldr->CreateCondBr( Is_LT, slowCmpLpLabel, fastCmpLpLabel );

   // Start fast loop here

   DPT1( "VVa615: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( fastCmpLpLabel = %p )\n" , fastCmpLpLabel);
   ExpFn->getBasicBlockList().push_back( fastCmpLpLabel );

   DPT1( "VVa616: ", VV_VD,
  "Bldr->SetInsertPoint( fastCmpLpLabel = %p )\n", fastCmpLpLabel );
   Bldr->SetInsertPoint( fastCmpLpLabel );

   // Copy multiple bytes at a time.
   DPT0( "VVa617: ", VV_VD,
  "ByteCtVal = Bldr->CreateLoad( ByteCt, 'loadByteCt' )\n");
   ByteCtVal = Bldr->CreateLoad( ByteCt, "loadByteCt" ); // Re-load within loop

   DPT0( "VVa618: ", VV_VD,
               "ThisSrc1 = Bldr->CreateGEP( src1Ptr, ByteCtVal, 'ThisSrc1' )\n" );
   jit_value_t  ThisSrc1 = Bldr->CreateGEP( src1Ptr, ByteCtVal, "ThisSrc1" );

   DPT0( "VVa619: ", VV_VD,
               "ThisSrc2 = Bldr->CreateGEP( src2Ptr, ByteCtVal, 'ThisSrc2' )\n" );
   jit_value_t  ThisSrc2 = Bldr->CreateGEP( src2Ptr, ByteCtVal, "ThisSrc2" );

   jit_value_t MultiBytes1 = IR_LoadRelativeWithType( Bldr, ThisSrc1,
                                                      0, int64Ty_ );
   jit_value_t MultiBytes2 = IR_LoadRelativeWithType( Bldr, ThisSrc2,
                                                      0, int64Ty_ );
   // NOTE: Always compare for EQ in the fast loop.
   // The slow loop will do the real comparison -- once we find a difference
   DPT0( "VVa619a: ", VV_VD,
  "IsZero = Bldr->CreateICmpEQ( MultiBytes1, MultiBytes2, 'cmp8Bytes' )\n" );
   IsZero = Bldr->CreateICmpEQ( MultiBytes1, MultiBytes2, "cmp8Bytes" );

   DPT2( "VVa620: ", VV_VD,
  "Bldr->CreateCondBr( IsZero, fastCmpNxtLabel = %p, slowCmpLpLabel = %p )\n",
                               fastCmpNxtLabel, slowCmpLpLabel );
   Bldr->CreateCondBr( IsZero, fastCmpNxtLabel, slowCmpLpLabel );
   
   DPT1( "VVa620a: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( fastCmpNxtLabel = %p )\n" , fastCmpNxtLabel );
   ExpFn->getBasicBlockList().push_back( fastCmpNxtLabel );

   DPT1( "VVa620b: ", VV_VD,
  "Bldr->SetInsertPoint( fastCmpNxtLabel = %p )\n", fastCmpNxtLabel );
   Bldr->SetInsertPoint( fastCmpNxtLabel );

   // Increment count of bytes copied
   DPT0( "VVa621: ", VV_VD,
  "ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, 'nextIncr')\n");
   ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, "nextIncr" );

   DPT0( "VVa622: ", VV_VD,
  "Bldr->CreateStore( ByteCtVal, ByteCt, 'storeByteCt' )\n" );
   Bldr->CreateStore( ByteCtVal, ByteCt, "storeByteCt" );


   // while (ByteCtVal < RndMaxLen) branch to fastLoop
   DPT0( "VVa623: ", VV_VD,
  "Is_LT = Bldr->CreateICmpULT( ByteCtVal, RndMaxLen, 'ICmp.ByteCt' )\n" );
   Is_LT = Bldr->CreateICmpULT( ByteCtVal, RndMaxLen, "ICmp.ByteCt" );

   DPT0( "VVa624: ", VV_VD,
  "Bldr->CreateCondBr( Is_LT, fastCmpLpLabel, slowCmpLpLabel )\n" );
   Bldr->CreateCondBr( Is_LT, fastCmpLpLabel, slowCmpLpLabel );

   // Now compare any remaining bytes (from 1 to 8 bytes possible)

   // NOTE: Because we subtracted 1 from RndMaxLen (above), we are
   // guaranteed that ByteCt < MaxLen64 so we are guaranteed that
   // we *must* go through the slow loop at least once.

   // Start slow loop here

   DPT1( "VVa635: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( slowCmpLpLabel = %p )\n", slowCmpLpLabel );
   ExpFn->getBasicBlockList().push_back( slowCmpLpLabel );

   DPT1( "VVa636: ", VV_VD,
  "Bldr->SetInsertPoint( slowCmpLpLabel = %p )\n", slowCmpLpLabel );
   Bldr->SetInsertPoint( slowCmpLpLabel );

   bytesAtOnce = 1;

   BytesPer    = ConstantInt::get( int64Ty_, bytesAtOnce );

   // Copy one byte at a time.
   DPT0( "VVa637: ", VV_VD,
  "ByteCtVal = Bldr->CreateLoad( ByteCt, 'loadByteCt' )\n");
   ByteCtVal = Bldr->CreateLoad( ByteCt, "loadByteCt" ); // Re-load within the loop

   DPT0( "VVa638: ", VV_VD,
               "CurrSrc1 = Bldr->CreateGEP( src1Ptr, ByteCtVal, 'CurrSrc1' )\n" );
   jit_value_t  CurrSrc1 = Bldr->CreateGEP( src1Ptr, ByteCtVal, "CurrSrc1" );

   DPT0( "VVa639: ", VV_VD,
               "CurrSrc2 = Bldr->CreateGEP( src2Ptr, ByteCtVal, 'CurrSrc2' )\n" );
   jit_value_t  CurrSrc2 = Bldr->CreateGEP( src2Ptr, ByteCtVal, "CurrSrc2" );

   jit_value_t OneByte1 = IR_LoadRelativeWithType( Bldr, CurrSrc1,
                                                   0, int8Ty_ );
   jit_value_t OneByte2 = IR_LoadRelativeWithType( Bldr, CurrSrc2,
                                                   0, int8Ty_ );
   switch ( KindOfCmp )
   {
      default:
      case ByteCompare_EQ:
         DPT0( "VVa640eq: ", VV_VD,
        "IsZero = Bldr->CreateICmpEQ( OneByte1, OneByte2, 'cmp1ByteEQ' )\n" );
         IsZero = Bldr->CreateICmpEQ( OneByte1, OneByte2, "cmp1ByteEQ" );
         break;
      case ByteCompare_NE:
         DPT0( "VVa640ne: ", VV_VD,
        "IsZero = Bldr->CreateICmpNE( OneByte1, OneByte2, 'cmp1ByteNE' )\n" );
         IsZero = Bldr->CreateICmpNE( OneByte1, OneByte2, "cmp1ByteNE" );
         break;
      case ByteCompare_LT:
         DPT0( "VVa640ult: ", VV_VD,
        "IsZero = Bldr->CreateICmpULT( OneByte1, OneByte2, 'cmp1ByteLT' )\n" );
         IsZero = Bldr->CreateICmpULT( OneByte1, OneByte2, "cmp1ByteLT" );
         break;
      case ByteCompare_LE:
         DPT0( "VVa640ule: ", VV_VD,
        "IsZero = Bldr->CreateICmpULE( OneByte1, OneByte2, 'cmp1ByteLE' )\n" );
         IsZero = Bldr->CreateICmpULE( OneByte1, OneByte2, "cmp1ByteLE" );
         break;
      case ByteCompare_GT:
         DPT0( "VVa640ugt: ", VV_VD,
        "IsZero = Bldr->CreateICmpUGT( OneByte1, OneByte2, 'cmp1ByteGT' )\n" );
         IsZero = Bldr->CreateICmpUGT( OneByte1, OneByte2, "cmp1ByteGT" );
         break;
      case ByteCompare_GE:
         DPT0( "VVa640uge: ", VV_VD,
        "IsZero = Bldr->CreateICmpUGE( OneByte1, OneByte2, 'cmp1ByteGE' )\n" );
         IsZero = Bldr->CreateICmpUGE( OneByte1, OneByte2, "cmp1ByteGE" );
         break;
   }

   DPT0( "VVa641: ", VV_VD,
  "IsEqual = Bldr->CreateICmpEQ( OneByte1, OneByte2, 'cmp1ByteEQ' )" );
   IsEqual = Bldr->CreateICmpEQ( OneByte1, OneByte2, "cmp1ByteEQ" );

   DPT2( "VVa642: ", VV_VD,
  "Bldr->CreateCondBr( IsEqual, slowContLabel = %p, slowCmpEndLabel = %p )\n",
                                slowContLabel, slowCmpEndLabel );
   Bldr->CreateCondBr( IsEqual, slowContLabel, slowCmpEndLabel );
   
   DPT1( "VVa642a: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( slowContLabel = %p )\n" , slowContLabel );
   ExpFn->getBasicBlockList().push_back( slowContLabel );

   DPT1( "VVa642b: ", VV_VD,
  "Bldr->SetInsertPoint( slowContLabel = %p )\n", slowContLabel );
   Bldr->SetInsertPoint( slowContLabel );

   // Increment loop count
   DPT0( "VVa643: ", VV_VD,
  "ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, 'nextIncr')\n");
   ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, "nextIncr" );

   DPT0( "VVa644: ", VV_VD,
  "Bldr->CreateStore( ByteCtVal, ByteCt, 'storeByteCt' )\n" );
   Bldr->CreateStore( ByteCtVal, ByteCt, "storeByteCt" );


   // while (ByteCtVal < MaxLen64) branch to slowLoop
   DPT0( "VVa645: ", VV_VD,
  "Is_LT = Bldr->CreateICmpULT( ByteCtVal, MaxLen64, 'ICmp.ByteCt' )\n" );
   Is_LT = Bldr->CreateICmpULT( ByteCtVal, MaxLen64, "ICmp.ByteCt" );

   DPT0( "VVa646: ", VV_VD,
  "Bldr->CreateCondBr( Is_LT, slowCmpLpLabel, slowCmpEndLabel )\n" );
   Bldr->CreateCondBr( Is_LT, slowCmpLpLabel, slowCmpEndLabel );

   DPT1( "VVa647: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( slowCmpEndLabel = %p )\n", slowCmpEndLabel );
   ExpFn->getBasicBlockList().push_back( slowCmpEndLabel );

   DPT1( "VVa648: ", VV_VD,
  "Bldr->SetInsertPoint( slowCmpEndLabel = %p )\n", slowCmpEndLabel );
   Bldr->SetInsertPoint( slowCmpEndLabel );

   return ( IsZero );
}

//
// allocJitValue() - tell LLVM to allocate a location (on the stack)
// to hold a temporary value.  NOTE: Most of these are allocated
// just *before* we start generating native code for PCODE instructions.
// By doing it early, we ensure that all paths through the PCODE
// instructions will use the same allocation location for the 
// specified operand.
//
void PCodeOperand::allocJitValue( PCodeCfg            * cfg
                                , IRBldr_t            * Bldr
                                , PCIT::AddressingMode  OprTyp
                                , Int32                 Len
                                , Int32                 Num
                                )
{
#if NExprDbgLvl >= VV_NO
      char  NExBuf[500];
#endif
      // Get operand in hash table
      CollIndex i = bvIndex_;
      PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);

      CDPT2( "VV0647: ", VV_BD, "In allocJitValue(): operand=%p, this=%p\n",
                                                     operand,    this );
      if (operand != this)
         return operand->allocJitValue( cfg, Bldr, OprTyp, Len, Num );

      if ( jitValue_ ) return;  // Already allocated 

      jit_type_t  IRtype = getJitType( cfg, OprTyp );
      if ( IRtype == cfg->getInt1PtrTy() )
      {
         if ( Len = 2 ) IRtype = cfg->getInt16PtrTy() ;
         if ( Len = 4 ) IRtype = cfg->getInt32PtrTy() ;
         if ( Len = 8 ) IRtype = cfg->getInt64PtrTy() ;
      }
      CDPT2( "VV0647a: ", VV_BD, "In allocJitValue(): Len = %d, IRtype = %p\n",
                                                      Len,      IRtype );

      jit_value_t NumV   = ConstantInt::get( cfg->getInt32Ty() , Num );

      CDPT3( "VV0648: ", VV_BD,
     "jitValue_  = (llvm::Value *)Bldr->CreateAlloca( IRtype = %p, NumV = %d )"
                                  " for PCOp = %p\n", IRtype,      Num, this );
      jitValue_  = (llvm::Value *)Bldr->CreateAlloca( IRtype , NumV );

      CDPT1( "VV0649: ", VV_BD, "Just set jitValue_ = %p (ptr to AllocaInst)\n",
                                            jitValue_ );
}
#endif /* NA_LINUX_LLVMJIT */

#ifdef NA_LINUX_LIBJIT

// FIX: Overlapped types can have problems too
jit_value_t PCodeOperand::getJitValue(PCodeCfg* cfg,
                                      jit_function_t f,
                                      jit_type_t type,
                                      PCodeBlock* b,
                                      PCodeOperand* orig = NULL,
                                      NABoolean noSave = FALSE)
{
  // Get operand in hash table
  CollIndex i = bvIndex_;
  PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);
  if (operand != this)
    return operand->getJitValue(cfg, f, type, b, this, noSave);

  // Make sure we properly indicate this this object *is* the original one.
  if (orig == NULL)
    orig = this;

  //
  // Get pointer to operand, if that's what is needed
  // 

  if (type == jit_type_void_ptr) {

    // If already defined somewhere, perhaps it can be reused?
    if (jitValuePtr_) {
      assert(jitValueBlock_ != NULL);
      if (b->onesVector.testBit(jitValueBlock_->getBlockNum()))
        return jitValuePtr_;
      else
        jitValuePtr_ = NULL;
    }

    // Non-native temps will be accessed directly from the passed in temps
    // area.  If that temp was previously defined as a jit value (e.g. size of
    // temp fit native storage container), then we skip to the else clause so
    // the address is simply taken for the jit value.
    if (isVar() || isConst() || (!jitValue_ && orig->isNonNativeTemp())) {
      jit_value_t parm1 = cfg->getJitParams()[stackIndex_];

      // For varchars we return a pointer to the start of length indicator.
      if (getType() == PCIT::MATTR5) {
        // If we're not dealing with a varchar, or if it is the first varchar,
        // we don't need to go through the VOA offset.
        if (!isVarchar() || (getVoaOffset() == -1)) {
          jitValuePtr_ =
            jit_insn_add_relative(f, param, (offset_ - vcIndicatorLen_));
        }
        else
        {
          jit_type_t t = ((vcIndicatorLen_ == 2)
                           ? jit_type_ushort : jit_type_uint);

          jit_value_t v = jit_insn_load_relative(f, param, voaOffset_, t);

          jitValuePtr_ = jit_insn_add(f, param, v);

          // Now set up pointer, moving past null indicator if required.
          if (vcNullIndicatorLen_)
            jitValuePtr_ = jit_insn_add_relative(f, jitValuePtr_,
                                                 vcNullIndicatorLen_);
        }
      }
      else
        jitValuePtr_ = jit_insn_add_relative(f, param, offset_);
    }
    else {
      // Normally we would force the jitValue_ to be defined if we're attempting
      // to get it.  However, in some cases (like FILL_MEM_BYTES) we make a 
      // a call to get it first so that things like the vc length can be written
      // to it first.
      // FIX: fix this so that we can continue to assert that jitValue_ should
      //      be defined first.  Fixing it involves having storeJitValue support
      //      all possible stores (vc lengths, actual values, etc.).

      // Must be called and it must already be defined

      if (!jitValue_) {
        // We reached a situation that we can't support.  For example, we could
        // having something like this:
        //
        // B1:  [2,0] = ...
        //      Branch B3
        // B2:  [2,0] = ...
        // B3:    = [2,0]
        //
        // If we allocated space for [2,0] in B1, and then do the same in B2,
        // which one do we use for B3?  Also, if we try to allocate space for
        // [2,0] in B3, then it would be completely wrong.

        cfg->setJitFailureSeen();

        // And for the sake of nothing else failing along the way, create a
        // bogus value to return.
        return jit_value_create(f, jit_type_int);
      }

      assert (jitValue_ && isTemp());

      // Temporary value needs to be addressable.
      jit_value_set_addressable(jitValue_);

      // Return the address of this temp variable.
      jitValuePtr_ = jit_insn_address_of(f, jitValue_);

      // If the jitValue_ was not defined in this current block, then the safe
      // thing to do is simply return the address of jitValue, but *do not* 
      // save the pointer in jitValuePtr_, since that will lead to confusion
      // on what was defined where.
      if (jitValueBlock_ != b) {
        jit_value_t temp = jitValuePtr_;
        jitValuePtr_ = NULL;
        return temp;
      }
    }

    jitValueBlock_ = b;

    // If we are directly told not to save the jit values, don't!
    if (noSave) {
      jit_value_t tempVal = jitValuePtr_;
      jitValueBlock_ = NULL;
      jitValue_ = jitValuePtr_ = NULL;
      return tempVal;
    }

    return jitValuePtr_;
  }

  //
  // Get value of operand
  //

  // If already defined somewhere, perhaps it can be reused?  If it's a temp,
  // however, then the assumption is that all uses have a def which reach it,
  // and that def is available in jitValue_.
  if (jitValue_) {
    assert(jitValueBlock_ != NULL);
    if (isTemp() || b->onesVector.testBit(jitValueBlock_->getBlockNum()))
    {
      // It's possible that we have some overlapping operands.  The following
      // deals with it (or at least for the majority of the cases where we see
      // an overlap :()
      jit_type_t jitValType = jit_value_get_type(jitValue_);
      if (jit_type_get_size(jitValType) > jit_type_get_size(type))
        return jit_insn_convert(f, jitValue_, type, 0);

      return jitValue_;
    }

    jitValue_ = NULL;
  }

  if (isConst()) {
    //
    // FIX: the assumption right now is that only integers are considered for
    // native expressions.  That will change shortly.  In the meantime, however,
    // this implies that getIntConstValue() should be called on the operand to
    // retrieve the constant value.
    //
    // FIX: getIntConstValue() should probably be "relaxed" a little so as to
    // support MPTR32 and MFLT (both of which may be casted into integer types
    // during same-sized moves).  For now, work around by adding logic here.
    //

    if (type == jit_type_long) {
      // MFLT64 can sometimes be the original type of the operand being sought
      // after (e.g. PCIT::MFLT64_MFLT64 --> PCIT::MBIN64S_MBIN64S).  Use the
      // original operand to get the constant value.

      PCodeOperand* op = ((getType() == PCIT::MFLT64) ||
                          (getType() == PCIT::MFLT32))
                            ? orig : this;

      Int64 val = cfg->getIntConstValue(op);

      jitValue_ = jit_value_create_long_constant(f, type, val);
    }
    else if (getType() == PCIT::MPTR32) {
      // MPTR32 can sometimes be the original type of the operand being sought
      // after (e.g. PCIT::MBIN8_MBIN8_IBIN32S --> PCIT::MBIN8_MBIN8).  Use the
      // original operand to get the constant value.

      Int32 val = (Int32)cfg->getIntConstValue(((orig) ? orig : this));
      jitValue_ = jit_value_create_nint_constant(f, type, val);
    }
    else if (type == jit_type_float64) {
      // Unless the value is "1.0", libjit will store a double constant in
      // memory, referenced via %ip, and that will blow us up at runtime.  Get
      // it from memory instead (if not 1.0)
      double val = cfg->getFloatConstValue(((orig) ? orig : this));
      if (val == 1.0)
        jitValue_ = jit_value_create_float64_constant(f, type, val);
      else {
        jit_value_t param = cfg->getJitParams()[stackIndex_];
        jitValue_ = jit_insn_load_relative(f, param, offset_, type);
      }
    }
    else {
      Int32 val = (Int32)cfg->getIntConstValue(((orig) ? orig : this));
      jitValue_ = jit_value_create_nint_constant(f, type, val);
    }
  }
  else if (isVar()) {
    jit_value_t param = cfg->getJitParams()[stackIndex_];

    // Are we getting the null bit?
    if (nullBitIndex_ != -1) {
      // For paranoia, make sure offset_ is not -1 also (indicating packed
      // format against a varchar, which is not supported yet).
      assert(offset_ != -1);

      jit_value_t mask = jit_value_create_nint_constant(f, jit_type_ubyte,
                           (UInt8)0x1 << (7 - (nullBitIndex_ & 7)));

      jit_value_t nByte = jit_insn_load_relative(f, param,
                            offset_ + (nullBitIndex_ >> 3), jit_type_ubyte);
      jitValue_ = jit_insn_and(f, nByte, mask);
    }
    else
      jitValue_ = jit_insn_load_relative(f, param, offset_, type);
  }
  else {
    // Accessing an undefined temp is not allowed.
    assert (FALSE);
  }

  jitValueBlock_ = b;

  // If we are directly told not to save the jit values, don't!
  if (noSave) {
    jit_value_t tempVal = jitValue_;
    jitValueBlock_ = NULL;
    jitValue_ = jitValuePtr_ = NULL;
    return tempVal;
  }

  return jitValue_;
}

//
// 1. Get string length of varchar and return to caller.
// 2. Move pointer past string length field.
// 3. If asked to, resize length by subtracting off padding
//
jit_value_t PCodeCfg::genStringSetup(jit_function_t f,
                                      jit_value_t* tStr,
                                      PCodeOperand* src,
                                      NABoolean padExists = FALSE,
                                      NABoolean lenNeeded = TRUE)
{
  jit_value_t lenJitVal = NULL;

  Int32 vcIndLen = src->getVcIndicatorLen();

  // If pad exists, then the length must surely be retrieved.
  if (padExists)
    lenNeeded = TRUE;

  if (vcIndLen <= 0) {
    // For fixed chars, just record the max length, if length is needed
    if (lenNeeded) {
      jit_value_t max;
      max = jit_value_create_nint_constant(f, jit_type_uint, src->getLen());

      lenJitVal = jit_value_create(f, jit_type_uint);
      jit_insn_store(f, lenJitVal, max);
    }
  }
  else
  {
    // Only get length if needed - which is most of the time.
    if (lenNeeded) {
      if (vcIndLen == 2)
        lenJitVal = jit_insn_load_relative(f, *tStr, 0, jit_type_ushort);
      else
        lenJitVal = jit_insn_load_relative(f, *tStr, 0, jit_type_uint);
    }

    *tStr = jit_insn_add_relative(f, *tStr, vcIndLen);
  }

  // If padding exists that needs to be factored into the length, computet it
  // now with a loop.

  if (padExists) {
    jit_value_t temp1, temp2, temp3;
    jit_value_t spaceJitVal =
      jit_value_create_nint_constant(f, jit_type_ubyte, ' ');

    jit_label_t padStartLabel = jit_label_undefined;
    jit_label_t padEndLabel = jit_label_undefined;

    jit_insn_label(f, &padStartLabel);
    jit_insn_branch_if_not(f, lenJitVal, &padEndLabel);

    temp1 = jit_insn_sub(f, lenJitVal, oneJitVal_);
    temp2 = jit_insn_load_elem(f, *tStr, temp1, jit_type_ubyte);
    temp3 = jit_insn_eq(f, temp2, spaceJitVal);
    jit_insn_branch_if_not(f, temp3, &padEndLabel);

    jit_insn_store(f, lenJitVal, temp1);
    jit_insn_branch(f, &padStartLabel);

    jit_insn_label(f, &padEndLabel);
  }

  return lenJitVal;
}

jit_value_t PCodeCfg::genHash(jit_function_t f,
                              jit_value_t tStr,
                              jit_value_t tStrLen,
                              jit_value_t loopIndex,
                              Int32 constantLen = 0)
{
  // If constantLen is provided (i.e. tStrLen is NULL) then that implies that we
  // are hashing a standard-sized column.  Otherwise we are hashing some kind've
  // string.

  Int32 j;

  jit_value_t t1, t2, t3, t4, t5, t6, resJitVal;
  jit_label_t startLoop = jit_label_undefined;
  jit_label_t endLoop = jit_label_undefined;

  jit_value_t shiftRVal = jit_value_create_nint_constant(f, jit_type_int, 31);

  // In an effort to reduce space, generate loop for hashing fixed-length
  // strings greater than a certain length.
  if ((tStrLen == NULL) && (constantLen > 32))
    tStrLen = jit_value_create_nint_constant(f, jit_type_int, constantLen);

  if (tStrLen == NULL) {
    t1 = jit_insn_load_relative(f, tStr, 0, jit_type_ubyte);
    resJitVal = jit_insn_load_elem(f, hashTableJitVal_, t1, jit_type_uint);

    // Unroll hash using known length
    for (j=1; j < constantLen; j++)
    {
      //
      // Compute: t1 = src[j]
      //          t2 = randomHashValues[t1]
      //          t3 = resJitVal << 1
      //          t4 = resJitVal >> 31
      //          t5 = (t3 | t4)
      //    resJitVal = t5 ^ resJitVal
      //
      t1 = jit_insn_load_relative(f, tStr, j, jit_type_ubyte);
      t2 = jit_insn_load_elem(f, hashTableJitVal_, t1, jit_type_uint);
      t3 = jit_insn_shl(f, resJitVal, oneJitVal_);
      t4 = jit_insn_ushr(f, resJitVal, shiftRVal);
      t5 = jit_insn_or(f, t3, t4);
      resJitVal = jit_insn_xor(f, t5, t2);
    }

    return resJitVal;
  }

  // Create temp var to hold result of hashing string.  Temp space needs to be
  // allocated since it can have, by default, the value 0 (if length is 0)
  resJitVal = jit_value_create(f, jit_type_uint);

  jit_insn_store(f, resJitVal, zeroJitVal_);
  jit_insn_store(f, loopIndex, tStrLen);

  // Loop start
  jit_insn_label(f, &startLoop);

  // Branch to end label if loopIndex <= 0
  t1 = jit_insn_le(f, loopIndex, zeroJitVal_);
  jit_insn_branch_if(f, t1, &endLoop);

  //
  // Compute: t1 = src[i]
  //          t2 = randomHashValues[t1]
  //          t3 = resJitVal << 1
  //          t4 = resJitVal >> 31
  //          t5 = (t3 | t4)
  //    resJitVal = t5 ^ resJitVal
  //
  t1 = jit_insn_load_relative(f, tStr, 0, jit_type_ubyte);
  t2 = jit_insn_load_elem(f, hashTableJitVal_, t1, jit_type_uint);
  t3 = jit_insn_shl(f, resJitVal, oneJitVal_);
  t4 = jit_insn_ushr(f, resJitVal, shiftRVal);
  t5 = jit_insn_or(f, t3, t4);
  t6 = jit_insn_xor(f, t5, t2);
  jit_insn_store(f, resJitVal, t6);

  // Decrement loop index and store
  t1 = jit_insn_sub(f, loopIndex, oneJitVal_);
  jit_insn_store(f, loopIndex, t1);

  // Increment pointer and store
  t2 = jit_insn_add(f, tStr, oneJitVal_);
  jit_insn_store(f, tStr, t2);

  // Branch back to head of loop
  jit_insn_branch(f, &startLoop);

  // End label
  jit_insn_label(f, &endLoop);

  return resJitVal;
}
#endif /* NA_LINUX_LIBJIT */

#if 1 /* NA_LINUX_LLVMJIT */

//
// genMemSetLoop() - generate code to set every element in an long array
// to the same value.
//
void PCodeCfg::genMemSetLoop( IRBldr_t   * Bldr
                            , Int32        val
                            , jit_value_t  tgtPtr
                            , jit_value_t  maxLen
                            )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   UInt8  val1 = (UInt8)val;
   UInt16 val2 = (val1 << 8) | val1;
   UInt32 val4 = (val2 << 16) | val2;
   UInt64 val8 = val4 ;               //Note: if we use (val4 << 32) we get C++ error
          val8 = (val8 << 32) | val8;

   jit_value_t MultiBytes = ConstantInt::get( int64Ty_ , val8 );
   jit_value_t OneByte    = ConstantInt::get( int8Ty_ , val1 );

   jit_value_t  BytesPer, CmpRslt ;
   jit_value_t  RndMaxLen, ByteCtVal ;
   jit_value_t  MaxLen64 ;

   DPT0( "VV0700: ", VV_BD, "GOT into genMemSetLoop()\n" );

   jit_value_t  Zero  = ConstantInt::get( int64Ty_ , 0 );

   llvm::LLVMContext &LLContxt = Bldr->getContext();
   llvm::Function *ExpFn       = Bldr->GetInsertBlock()->getParent();

   p_IR_block_t fastLoopLabel = BasicBlock::Create( LLContxt, "MemSetFastBlk" );
   p_IR_block_t endLabel      = BasicBlock::Create( LLContxt, "MemSetEndBlk" );

   DPT2( "VV0702: ", VV_VD, "fastLoopLabel = %p, endLabel = %p\n",
                             fastLoopLabel,      endLabel ); 

   Int32 bytesAtOnce = 8;

   BytesPer  = ConstantInt::get( int64Ty_ , bytesAtOnce );
   DPT0( "VV0705: ", VV_VD,
  "MaxLen64  = Bldr->CreateZExt( maxLen, int64Ty_ , 'ExtMaxLen' )\n" );
   MaxLen64  = Bldr->CreateZExt( maxLen, int64Ty_ , "ExtMaxLen" );

   DPT0( "VV0706: ", VV_VD,
  "RndMaxLen = Bldr->CreateUDiv( MaxLen64, BytesPer, 'UDiv' )\n" );
   RndMaxLen = Bldr->CreateUDiv( MaxLen64, BytesPer, "UDiv" );

   DPT0( "VV0707: ", VV_VD,
  "RndMaxLen = Bldr->CreateMul( RndMaxLen, BytesPer, 'Mul' )\n" );
   RndMaxLen = Bldr->CreateMul( RndMaxLen, BytesPer, "Mul" );

   DPT0( "VV0710: ", VV_VD,
  "AllocaInst * ByteCt = Bldr->CreateAlloca( int64Ty_ )\n" );
   AllocaInst * ByteCt = Bldr->CreateAlloca( int64Ty_ );

   DPT0( "VV0711: ", VV_VD,
  "Bldr->CreateStore( Zero, ByteCt )\n" );
   Bldr->CreateStore( Zero, ByteCt );

   DPT0( "VV0712: ", VV_VD,
  "CmpRslt = Bldr->CreateICmpULT( RndMaxLen, BytesPer, 'ICmp.RndMaxLen' )\n" );
   CmpRslt = Bldr->CreateICmpULT( RndMaxLen, BytesPer, "ICmp.RndMaxLen" );

   DPT0( "VV0713: ", VV_VD,
  "Bldr->CreateCondBr( CmpRslt, endLabel, fastLoopLabel )\n" );
   Bldr->CreateCondBr( CmpRslt, endLabel, fastLoopLabel );

   // Start fast loop here

   DPT1( "VV0715: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( fastLoopLabel = %p )\n" , fastLoopLabel );
   ExpFn->getBasicBlockList().push_back( fastLoopLabel );

   DPT0( "VV0716: ", VV_VD,
  "Bldr->SetInsertPoint( fastLoopLabel )\n" );
   Bldr->SetInsertPoint( fastLoopLabel );

   // Copy multiple bytes at a time.
   DPT0( "VV0718: ", VV_VD,
  "ByteCtVal = Bldr->CreateLoad( ByteCt, 'loadByteCt' )\n");
   ByteCtVal = Bldr->CreateLoad( ByteCt, "loadByteCt" ); // Re-load within the loop

   DPT0( "VV0719: ", VV_VD,
               "ThisTgt = Bldr->CreateGEP( tgtPtr, ByteCtVal, 'ThisTgt' )\n" );
   jit_value_t  ThisTgt = Bldr->CreateGEP( tgtPtr, ByteCtVal, "ThisTgt" );

   IR_StoreRelativeWithType( Bldr, MultiBytes, ThisTgt,
                                                     0, int64Ty_ );

   // Increment count of bytes handled
   DPT0( "VV0721: ", VV_VD,
  "ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, 'nextIncr')\n");
   ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, "nextIncr" );

   DPT0( "VV0722: ", VV_VD,
  "Bldr->CreateStore( ByteCtVal, ByteCt, 'storeByteCt' )\n" );
   Bldr->CreateStore( ByteCtVal, ByteCt, "storeByteCt" );

   // while (ByteCtVal < RndMaxLen) branch to fastLoop
   DPT0( "VV0723: ", VV_VD,
  "CmpRslt = Bldr->CreateICmpULT( ByteCtVal, RndMaxLen, 'ICmp.ByteCt' )\n" );
   CmpRslt = Bldr->CreateICmpULT( ByteCtVal, RndMaxLen, "ICmp.ByteCt" );

   DPT0( "VV0724: ", VV_VD,
  "Bldr->CreateCondBr( CmpRslt, fastLoopLabel, endLabel )\n" );
   Bldr->CreateCondBr( CmpRslt, fastLoopLabel, endLabel );

   DPT1( "VV0725: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( endLabel = %p )\n" , endLabel );
   ExpFn->getBasicBlockList().push_back( endLabel );

   DPT0( "VV0726: ", VV_VD,
  "Bldr->SetInsertPoint( endLabel )\n" );
   Bldr->SetInsertPoint( endLabel );

   // Now copy any remaining bytes (from 0 to 7 bytes are possible)

   p_IR_block_t slowLoopLabel = BasicBlock::Create( LLContxt, "MemSetSlowBlk" );
   p_IR_block_t end2Label     = BasicBlock::Create( LLContxt, "MemSetEndBlk" );

   DPT2( "VV0728: ", VV_VD, "slowLoopLabel = %p, end2Label = %p\n",
                             slowLoopLabel,      end2Label ); 

   bytesAtOnce = 1;

   BytesPer  = ConstantInt::get( int64Ty_ , bytesAtOnce );

   DPT0( "VV0730: ", VV_VD,
  "ByteCtVal = Bldr->CreateLoad( ByteCt, 'loadByteCt' )\n");
   ByteCtVal = Bldr->CreateLoad( ByteCt, "loadByteCt" );

   DPT0( "VV0732: ", VV_VD,
  "CmpRslt = Bldr->CreateICmpUGE( ByteCtVal, MaxLen64, 'ICmp.RndMaxLen' )\n" );
   CmpRslt = Bldr->CreateICmpUGE( ByteCtVal, MaxLen64, "ICmp.RndMaxLen" );

   DPT0( "VV0733: ", VV_VD,
  "Bldr->CreateCondBr( CmpRslt, end2Label, slowLoopLabel )\n" );
   Bldr->CreateCondBr( CmpRslt, end2Label, slowLoopLabel );

   // Start slow loop here

   DPT1( "VV0735: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( slowLoopLabel = %p )\n", slowLoopLabel  );
   ExpFn->getBasicBlockList().push_back( slowLoopLabel );

   DPT0( "VV0736: ", VV_VD,
  "Bldr->SetInsertPoint( slowLoopLabel )\n" );
   Bldr->SetInsertPoint( slowLoopLabel );

   // Copy multiple bytes at a time.
   DPT0( "VV0738: ", VV_VD,
  "ByteCtVal = Bldr->CreateLoad( ByteCt, 'loadByteCt' )\n");
   ByteCtVal = Bldr->CreateLoad( ByteCt, "loadByteCt" ); // Re-load within the loop

   DPT0( "VV0739: ", VV_VD,
               "CurrTgt = Bldr->CreateGEP( tgtPtr, ByteCtVal, 'CurrTgt' )\n" );
   jit_value_t  CurrTgt = Bldr->CreateGEP( tgtPtr, ByteCtVal, "CurrTgt" );

   IR_StoreRelativeWithType( Bldr, OneByte, CurrTgt,
                                                  0, int8Ty_ );

   // Increment count of bytes handled
   DPT0( "VV0740: ", VV_VD,
  "ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, 'nextIncr')\n");
   ByteCtVal = Bldr->CreateAdd( ByteCtVal, BytesPer, "nextIncr" );

   DPT0( "VV0742: ", VV_VD,
  "Bldr->CreateStore( ByteCtVal, ByteCt, 'storeByteCt' )\n" );
   Bldr->CreateStore( ByteCtVal, ByteCt, "storeByteCt" );


   // while (ByteCtVal < MaxLen64) branch to slowLoop
   DPT0( "VV0743: ", VV_VD,
  "CmpRslt = Bldr->CreateICmpULT( ByteCtVal, MaxLen64, 'ICmp.ByteCt' )\n" );
   CmpRslt = Bldr->CreateICmpULT( ByteCtVal, MaxLen64, "ICmp.ByteCt" );

   DPT0( "VV0744: ", VV_VD,
  "Bldr->CreateCondBr( CmpRslt, slowLoopLabel, end2Label )\n" );
   Bldr->CreateCondBr( CmpRslt, slowLoopLabel, end2Label );

   DPT1( "VV0745: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( end2Label = %p )\n", end2Label );
   ExpFn->getBasicBlockList().push_back( end2Label );

   DPT0( "VV0746: ", VV_VD,
  "Bldr->SetInsertPoint( end2Label )\n" );
   Bldr->SetInsertPoint( end2Label );
}

void PCodeCfg::genUnalignedMemset( IRBldr_t   * Bldr
                                 , jit_value_t  tgtPtr
                                 , Int32        val
                                 , Int32        length
                                 )
{
#if NExprDbgLvl > VV_NO
  char  NExBuf[500];
#endif
  Int32 i;
  UInt8  val1 = (UInt8)val;
  UInt16 val2 = (val1 << 8)  | val1;
  UInt32 val4 = (val2 << 16) | val2;
  UInt64 val8 = val4 ;               //Note: if we use (val4 << 32) we get C++ error
         val8 = (val8 << 32) | val8;

  if ( length < 32 )
  {
     // First try multiples of 8 
//// jit_value_t jVal8 = jit_value_create_nint_constant(f, jit_type_uint, val8);
     jit_value_t jVal8 = ConstantInt::get( int64Ty_, val8 );

     for (i=0; length >= 8; i+=8, length-=8) {
////   jit_insn_store_relative(f, Tgt, i, jVal8);

        DPT0( "VV0750: ", VV_VD,
       "IR_StoreRelativeWithType( Bldr, jVal8, tgtPtr, i, int64Ty_ )\n" );
        IR_StoreRelativeWithType( Bldr, jVal8, tgtPtr, i, int64Ty_ );
     }

     // Then try multiples of 4 
//// jit_value_t jVal4 = jit_value_create_nint_constant(f, jit_type_uint, val4);
     jit_value_t jVal4 = ConstantInt::get( int32Ty_, val4 );

     for (i=0; length >= 4; i+=4, length-=4) {
////   jit_insn_store_relative(f, Tgt, i, jVal4);

        DPT0( "VV0760: ", VV_VD,
       "IR_StoreRelativeWithType( Bldr, jVal4, tgtPtr, i, int32Ty_ )\n" );
        IR_StoreRelativeWithType( Bldr, jVal4, tgtPtr, i, int32Ty_ );
     }

     // Then try multiples of 2
//// jit_value_t jVal2 = jit_value_create_nint_constant(f, jit_type_ushort, val2);
     jit_value_t jVal2 = ConstantInt::get( int16Ty_, val2 );

     for (; length >= 2; i+=2, length-=2) {
////   jit_insn_store_relative(f, Tgt, i, jVal2);

        DPT0( "VV0770: ", VV_VD,
       "IR_StoreRelativeWithType( Bldr, jVal2, tgtPtr, i, int16Ty_ )\n" );
        IR_StoreRelativeWithType( Bldr, jVal2, tgtPtr, i, int16Ty_ );
     }

     // Lastly copy 1 byte at a time
//// jit_value_t jVal1 = jit_value_create_nint_constant(f, jit_type_ubyte, val1);
     jit_value_t jVal1 = ConstantInt::get( int8Ty_, val1 );

     for (; length >= 1; i+=1, length-=1) {
////   jit_insn_store_relative(f, Tgt, i, jVal1);

        DPT0( "VV0780: ", VV_VD,
       "IR_StoreRelativeWithType( Bldr, jVal1, tgtPtr, i, int8Ty_ )\n" );
        IR_StoreRelativeWithType( Bldr, jVal1, tgtPtr, i, int8Ty_ );
     }

  } // End: if ( length < 32 )

  else // long, fixed-length string ... use a loop instead of voluminous instruction generation
  {
      jit_value_t ConstLen = ConstantInt::get( int64Ty_, length );

      genMemSetLoop( Bldr, val, tgtPtr, ConstLen );
  }

  return;
}
#endif /* NA_LINUX_LLVMJIT */

#ifdef NA_LINUX_LIBJIT

void PCodeCfg::genUnalignedMemset(jit_function_t f,
                                  jit_value_t tgt,
                                  Int32 val,
                                  Int32 length)
{
  Int32 i;

#if 0
  // For lengths <= 32, jit_insn_memset can be called to generate the code.
  // Anything greater and an intrinsic call is made.  UPDATE: This is true only
  // when jit_optimization_level is 0.  If the optimization level is higher,
  // then the cutoff is 16 (not 32).  The best thing is to generate the code
  // ourselves.
  if (length <= 32) {
    jit_value_t jVal = jit_value_create_nint_constant(f, jit_type_int, val);
    jit_value_t jLen = jit_value_create_nint_constant(f, jit_type_int, length);

    jit_insn_memset(f, tgt, jVal, jLen);

    return;
  }
#endif

  UInt8 val1 = (UInt8)val;
  UInt16 val2 = (val1 << 8) | val1;
  UInt32 val4 = (val2 << 16) | val2;

  // First try multiples of 4 
  jit_value_t jVal4 = jit_value_create_nint_constant(f, jit_type_uint, val4);
  for (i=0; length >= 4; i+=4, length-=4) {
    jit_insn_store_relative(f, tgt, i, jVal4);
  }

  // Then try multiples of 2
  jit_value_t jVal2 = jit_value_create_nint_constant(f, jit_type_ushort, val2);
  for (; length >= 2; i+=2, length-=2) {
    jit_insn_store_relative(f, tgt, i, jVal2);
  }

  // Lastly copy 1 byte at a time
  jit_value_t jVal1 = jit_value_create_nint_constant(f, jit_type_ubyte, val1);
  for (; length >= 1; i+=1, length-=1) {
    jit_insn_store_relative(f, tgt, i, jVal1);
  }

  return;
}
#endif /* NA_LINUX_LIBJIT */

#if 1 /* NA_LINUX_LLVMJIT */
void PCodeCfg::genUnalignedMemcpy( IRBldr_t  * Bldr
                                 , jit_value_t tgt
                                 , jit_value_t src
                                 , jit_value_t len
                                 , Int32       constantLen = 0
                                 )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   DPT0( "VV0800: ", VV_BD, "GOT into genUnalignedMemcpy()\n" );

   // If dealing with a *short* fixed-length string ...
   // Note: The 32 in the next line is arbitrary.  We just don't want 
   // to generate dozens or even hundreds or thousands of load/store instructions.
   if ( (len == NULL) &&  (constantLen < 32) )
   {
      Int32 i, length = constantLen;

      DPT0( "VV0810: ", VV_BD,
            " GOT into genUnalignedMemcpy() with short fixed-length string\n" );

      // First try multiples of 8
      for (i=0; length >= 8; i+=8, length-=8)
      {
        jit_value_t val = IR_LoadRelativeWithType( Bldr, src, i, int64Ty_ );

        DPT0( "VV0812: ", VV_VD,
       "IR_StoreRelativeWithType( Bldr, val, tgt, i, int64Ty_ )\n" );
        IR_StoreRelativeWithType( Bldr, val, tgt, i, int64Ty_ );
      }

      // Then try multiples of 4
      for (; length >= 4; i+=4, length-=4)
      {
////    jit_value_t val = jit_insn_load_relative(f, src, i, jit_type_uint);
////    jit_insn_store_relative(f, tgt, i, val);

        jit_value_t val = IR_LoadRelativeWithType( Bldr, src, i, int32Ty_ );

        DPT0( "VV0814: ", VV_VD,
       "IR_StoreRelativeWithType( Bldr, val, tgt, i, int32Ty_ )\n" );
        IR_StoreRelativeWithType( Bldr, val, tgt, i, int32Ty_ );
      }

      // Then try multiples of 2
      for (; length >= 2; i+=2, length-=2)
      {
////    jit_value_t val = jit_insn_load_relative(f, src, i, jit_type_ushort);
////    jit_insn_store_relative(f, tgt, i, val);

        jit_value_t val = IR_LoadRelativeWithType( Bldr, src, i, int16Ty_ );

        DPT0( "VV0816: ", VV_VD,
       "IR_StoreRelativeWithType( Bldr, val, tgt, i, int16Ty_ )\n" );
        IR_StoreRelativeWithType( Bldr, val, tgt, i, int16Ty_ );
      }

      // Lastly copy 1 byte at a time
      for (; length >= 1; i+=1, length-=1)
      {
////    jit_value_t val = jit_insn_load_relative(f, src, i, jit_type_ubyte);
////    jit_insn_store_relative(f, tgt, i, val);

        jit_value_t val = IR_LoadRelativeWithType( Bldr, src, i, int8Ty_ );

        DPT0( "VV0819: ", VV_VD,
       "IR_StoreRelativeWithType( Bldr, val, tgt, i, int8Ty_ )\n" );
        IR_StoreRelativeWithType( Bldr, val, tgt, i, int8Ty_ );
      }

      return;

   } // End: if ( (len == NULL) &&  (constantLen < 32) )

   else if ( len == NULL ) // *long* fixed-length string
   {
      DPT0( "VV0820: ", VV_BD,
            "GOT into genUnalignedMemcpy() with long fixed-length string\n" );

      jit_value_t ConstLen = ConstantInt::get( int64Ty_, constantLen );

      genMemCopyLoop( Bldr, src, tgt, ConstLen );
   }
   else  // len != NULL
   {
       DPT0( "VV0830: ", VV_BD,
             "GOT into genUnalignedMemcpy() with len != NULL ptr\n" );

       genMemCopyLoop( Bldr, src, tgt, len );
   }

   return;
}
#endif /* NA_LINUX_LLVMJIT */

#ifdef NA_LINUX_LIBJIT

void PCodeCfg::genUnalignedMemcpy(jit_function_t f,
                                  jit_value_t tgt,
                                  jit_value_t src,
                                  jit_value_t len,
                                  Int32 constantLen = 0)
{
  //
  // Upon entering this routine, tgt, src, and len should all be temp operands
  // that were already initialized by caller.  len may be NULL, however,
  // indicating that a constant length (stored in "constantLen") is provided.
  // In this case, we attempt to use wide loads and stores to implement the
  // copy.
  //
 
  jit_value_t comp, val, temp1, temp2, temp3;

  jit_label_t fastLoopLabel = jit_label_undefined;
  jit_label_t remainderLabel = jit_label_undefined;
  jit_label_t endLabel = jit_label_undefined;

  jit_value_t max = jit_value_create_nint_constant(f, jit_type_int, 4);

  if (len == NULL) {
    Int32 i, length = constantLen;

    // First try multiples of 4
    for (i=0; length >= 4; i+=4, length-=4) {
      jit_value_t val = jit_insn_load_relative(f, src, i, jit_type_uint);
      jit_insn_store_relative(f, tgt, i, val);
    }

    // Then try multiples of 2
    for (; length >= 2; i+=2, length-=2) {
      jit_value_t val = jit_insn_load_relative(f, src, i, jit_type_ushort);
      jit_insn_store_relative(f, tgt, i, val);
    }

    // Lastly copy 1 byte at a time
    for (; length >= 1; i+=1, length-=1) {
      jit_value_t val = jit_insn_load_relative(f, src, i, jit_type_ubyte);
      jit_insn_store_relative(f, tgt, i, val);
    }

    return;
  }

  // Initial check for entering fast loop (i.e. if len >= max)
  comp = jit_insn_lt(f, len, max);
  jit_insn_branch_if(f, comp, &remainderLabel);

  // Start fast loop here
  jit_insn_label(f, &fastLoopLabel);

  // Copy 4 bytes at a time.
  val = jit_insn_load_relative(f, src, 0, jit_type_uint);
  jit_insn_store_relative(f, tgt, 0, val);

  // Decrement loop index
  temp1 = jit_insn_sub(f, len, max);
  jit_insn_store(f, len, temp1);

  // Increment string pointers
  temp2 = jit_insn_add(f, tgt, max);
  temp3 = jit_insn_add(f, src, max);
  jit_insn_store(f, tgt, temp2);
  jit_insn_store(f, src, temp3);

  // while (len >= 4) branch to fastLoop
  comp = jit_insn_ge(f, len, max);
  jit_insn_branch_if(f, comp, &fastLoopLabel);

  //
  // Start of remainder loop
  //

  jit_insn_label(f, &remainderLabel);

  // Branch to end label if len <= 0
  comp = jit_insn_le(f, len, zeroJitVal_);
  jit_insn_branch_if(f, comp, &endLabel);

  // Copy 1 byte at a time.
  val = jit_insn_load_relative(f, src, 0, jit_type_ubyte);
  jit_insn_store_relative(f, tgt, 0, val);

  // Decrement loop index
  temp1 = jit_insn_sub(f, len, oneJitVal_);
  jit_insn_store(f, len, temp1);

  // Increment string pointers
  temp2 = jit_insn_add(f, tgt, oneJitVal_);
  temp3 = jit_insn_add(f, src, oneJitVal_);
  jit_insn_store(f, tgt, temp2);
  jit_insn_store(f, src, temp3);

  jit_insn_branch(f, &remainderLabel);


  // End label
  jit_insn_label(f, &endLabel);
}

#if 0
void PCodeCfg::genUnalignedPadCheck(jit_function_t f,
                                    jit_value_t src,
                                    jit_value_t len,
                                    Int32 constantLen = 0)
{
  // Upon entering this routine, src, and len should all be temp operands
  // that were already initialized by caller.  len may be NULL, however,
  // indicating that a constant length (stored in "constantLen") is provided.
  // In this case, we attempt to use wide loads and stores to implement the
  // pad comparison

  if (len == NULL) {
  }
}
#endif

#if 0
void PCodeCfg::genUnalignedMemcmp(jit_function_t f,
                                  jit_value_t tgt,
                                  jit_value_t src,
                                  jit_value_t len,
                                  Int32 constantLen = 0)
{
  //
  // Upon entering this routine, tgt, src, and len should all be temp operands
  // that were already initialized by caller.  len may be NULL, however,
  // indicating that a constant length (stored in "constantLen") is provided.
  // In this case, we attempt to use wide loads and stores to implement the
  // compare.
  //
 
  jit_value_t comp, val, temp1, temp2, temp3;

  jit_label_t fastLoopLabel = jit_label_undefined;
  jit_label_t remainderLabel = jit_label_undefined;
  jit_label_t endLabel = jit_label_undefined;

  jit_value_t max = jit_value_create_nint_constant(f, jit_type_int, 4);

  if (len == NULL) {
    Int32 i, length = constantLen;

    // First try multiples of 4
    for (i=0; length >= 4; i+=4, length-=4) {
      jit_value_t val = jit_insn_load_relative(f, src, i, jit_type_uint);
      jit_insn_store_relative(f, tgt, i, val);
    }

    // Then try multiples of 2
    for (; length >= 2; i+=2, length-=2) {
      jit_value_t val = jit_insn_load_relative(f, src, i, jit_type_ushort);
      jit_insn_store_relative(f, tgt, i, val);
    }

    // Lastly copy 1 byte at a time
    for (; length >= 1; i+=1, length-=1) {
      jit_value_t val = jit_insn_load_relative(f, src, i, jit_type_ubyte);
      jit_insn_store_relative(f, tgt, i, val);
    }

    return;
  }

  // Initial check for entering fast loop (i.e. if len >= max)
  comp = jit_insn_lt(f, len, max);
  jit_insn_branch_if(f, comp, &remainderLabel);

  // Start fast loop here
  jit_insn_label(f, &fastLoopLabel);

  // Copy 4 bytes at a time.
  val = jit_insn_load_relative(f, src, 0, jit_type_uint);
  jit_insn_store_relative(f, tgt, 0, val);

  // Decrement loop index
  temp1 = jit_insn_sub(f, len, max);
  jit_insn_store(f, len, temp1);

  // Increment string pointers
  temp2 = jit_insn_add(f, tgt, max);
  temp3 = jit_insn_add(f, src, max);
  jit_insn_store(f, tgt, temp2);
  jit_insn_store(f, src, temp3);

  // while (len >= 4) branch to fastLoop
  comp = jit_insn_ge(f, len, max);
  jit_insn_branch_if(f, comp, &fastLoopLabel);

  //
  // Start of remainder loop
  //

  jit_insn_label(f, &remainderLabel);

  // Branch to end label if len <= 0
  comp = jit_insn_le(f, len, zeroJitVal_);
  jit_insn_branch_if(f, comp, &endLabel);

  // Copy 1 byte at a time.
  val = jit_insn_load_relative(f, src, 0, jit_type_ubyte);
  jit_insn_store_relative(f, tgt, 0, val);

  // Decrement loop index
  temp1 = jit_insn_sub(f, len, oneJitVal_);
  jit_insn_store(f, len, temp1);

  // Increment string pointers
  temp2 = jit_insn_add(f, tgt, oneJitVal_);
  temp3 = jit_insn_add(f, src, oneJitVal_);
  jit_insn_store(f, tgt, temp2);
  jit_insn_store(f, src, temp3);

  jit_insn_branch(f, &remainderLabel);


  // End label
  jit_insn_label(f, &endLabel);
}
#endif

void PCodeCfg::genBignumSub(PCodeCfg* cfg,
                            jit_function_t f,
                            PCodeOperand* res,
                            jit_value_t src1,
                            jit_value_t src2,
                            jit_value_t sign1,
                            jit_value_t sign2,
                            jit_value_t tSrc1,
                            jit_value_t tSrc2,
                            PCodeBlock* block)
{
  Int32 i;

  jit_value_t t1, t2, t3, t4, t5, t6 = NULL, carry = NULL;
  jit_label_t keepStringsLabel = jit_label_undefined;
  jit_label_t switchStringsLabel = jit_label_undefined;

  jit_value_t jitValMask16 =
    jit_value_create_nint_constant(f, jit_type_ushort, 0x8000);
  jit_value_t jitValNotMask16 =
    jit_value_create_nint_constant(f, jit_type_ushort, 0x7fff);
  jit_value_t jitValNotMask32 =
    jit_value_create_nint_constant(f, jit_type_ushort, 0x7fffffff);

  jit_value_t jitValUpper32 =
    jit_value_create_nint_constant(f, jit_type_int, 0x10000);

  Int32 len = res->getLen();
  Int32 len16 = len >> 1;

  Int32 bignumSize = len16;
  jit_type_t bignumType = jit_type_ushort;
  jit_value_t bignumNotMask = jitValNotMask16;

  // If we can process the bignum faster in chunks of 32-bits, we will.
  if ((len % 4) == 0) {
    bignumSize = len >> 2;
    bignumType = jit_type_uint;
    bignumNotMask = jitValNotMask32;
  }

  // Assume by default that the source order is correct - i.e. src1 has a
  // bigger magnitude that src2.
  jit_insn_store(f, tSrc1, src1);
  jit_insn_store(f, tSrc2, src2);

  // Which string is bigger?
  for (i=bignumSize-1; i >= 0; i--) {
    if (i == (bignumSize-1)) {
      // Need to compare without sign bit.
      t1 = jit_insn_and(f, sign1, bignumNotMask);
      t2 = jit_insn_and(f, sign2, bignumNotMask);

      // Store back into the source strings w/o sign bit enabled
      jit_insn_store_relative(f, tSrc1, i, t1);
      jit_insn_store_relative(f, tSrc2, i, t2);
    }
    else {
      t1 = jit_insn_load_relative(f, tSrc1, i, bignumType);
      t2 = jit_insn_load_relative(f, tSrc2, i, bignumType);
    }

    t3 = jit_insn_gt(f, t1, t2);
    jit_insn_branch_if(f, t3, &keepStringsLabel);

    // No need to do switcharoo comparison if this is the last one.  src1 will
    // either be equal or less that src2.  Since the chances of the two being
    // equal are unlikely, we assume not and always do a switcharoo.
    //
    // BTW, if both sources are equal, this is an example where we can have -0
    // emitted.  This is because, depending on which source we say is "bigger",
    // if the bigger one is negative, that's what the result will be.
    if (i != 0) {
      t3 = jit_insn_lt(f, t1, t2);
      jit_insn_branch_if(f, t3, &switchStringsLabel);
    }
  } 

  // Do the switcharoo
  jit_insn_label(f, &switchStringsLabel);
  jit_insn_store(f, tSrc1, src2);
  jit_insn_store(f, tSrc2, src1);

  // Keep things the same.
  jit_insn_label(f, &keepStringsLabel);

  // Now let's load up the result jit value.
  jit_value_t resJitVal = res->getJitValue(cfg, f, res->getJitType(), block);

  // Now start performing the subs.  Must do it 2-bytes at a time because libjit
  // doesn't support various 64-bit ops yet.
  for (i=0; i < len16; i++)
  {
    //
    // Perform: t6 = ((Int32)src1[i] - (Int32)src2[i]) - (carry)
    //   No need to subtract carry if this is the first time through.
    //
    t1 = jit_insn_load_relative(f, tSrc1, i, jit_type_ushort);
    t2 = jit_insn_load_relative(f, tSrc2, i, jit_type_ushort);
    t3 = jit_insn_convert(f, t1, jit_type_int, 0);
    t4 = jit_insn_convert(f, t2, jit_type_int, 0);
    t5 = jit_insn_sub(f, t3, t4);
    t6 = (i != 0) ? jit_insn_sub(f, t5, carry) : t5;

    // Perform: t4 = ((t6 + 0x10000) & 0xffff)
    t3 = jit_insn_add(f, t6, jitValUpper32);
    t4 = jit_insn_convert(f, t3, jit_type_ushort, 0);

    // If this is not the last short to subtrace, store the result and identify
    // a potential carry.
    if (i != (len16-1)) {
      jit_insn_store_relative(f, resJitVal, i, t4);
      carry = jit_insn_lt(f, t6, zeroJitVal_);
    }
    else {
      // Use "carry" to hold the sign value of src1.
      carry = jit_insn_and(f, t1, jitValMask16);

      // Now insert the sign bit into the final result.
      t6 = jit_insn_or(f, t4, carry);

      // Final result short is stored after source strings are updated with
      // their sign bits (so that we avoid situations like "A = A - B".
    }
  }

  // Reset sign in source
  jit_insn_store_relative(f, src1, bignumSize-1, sign1);
  jit_insn_store_relative(f, src2, bignumSize-1, sign2);

  // Store final res value here.
  jit_insn_store_relative(f, resJitVal, len16-1, t6);
}
#endif /* NA_LINUX_LIBJIT */

#if 1 /* NA_LINUX_LLVMJIT */

// FIX: Overlapped types can have problems too
void PCodeOperand::storeJitValue( PCodeCfg    * cfg
                                , IRBldr_t    * Bldr
                                , jit_type_t    IRtype
                                , jit_value_t   value
                                , PCodeBlock  * b
                                , jit_value_t * len = NULL
                                , NABoolean     noSave = FALSE
                                )
{
#if NExprDbgLvl >= VV_NO
  char  NExBuf[500];
#endif
  CDPT3( "VV0900: ", VV_BD, "In storeJitValue() on PCode Operand at %p, IRtype=%p, "
                      "value=%p\n", this, IRtype, value );

  // Get operand in hash table
  CollIndex i = bvIndex_;
  PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);

  CDPT2( "VV0902: ", VV_BD, "In storeJitValue(): operand=%p, this=%p\n", operand, this );

  if (operand != this)
    return operand->storeJitValue(cfg, Bldr, IRtype, value, b, len, noSave);

  jit_type_t valType = value->getType() ;

  //
  // Are we being asked to perform a memcpy?
  //
  if ( valType->isPointerTy() )
  {
    jit_value_t size =
      ((len) ? *len : ConstantInt::get( cfg->getInt64Ty(), getLen() ) );

    if (jitValuePtr_)
    {
      CDPT0( "VV0904: ", VV_BD, "In storeJitValue, found jitValuePtr_ non-null\n");

      assert(jitValuePtrBlock_ != NULL);

      // If the PCBlock given in jitValuePtrBlock_ dominates PCBlock b,
      // then we are assured that jitValuePtr_ is valid.
      //
      if (!b->onesVector.testBit(jitValuePtrBlock_->getBlockNum()))
        jitValuePtr_ = NULL;
    }

    if (!jitValuePtr_)
    {
      CDPT0( "VV0906: ", VV_BD, "In storeJitValue, found jitValuePtr_ to be NULL\n");

      if (isVar() || isNonNativeTemp())
      {
        CDPT1( "VV0908: ", VV_BD, "In storeJitValue, getting param using stackIndex_ = "
                          "%d\n", stackIndex_);

        jit_value_t parm1 = cfg->getJitParams()[stackIndex_];

        CDPT0( "VV0910: ", VV_BD, 
                   "param  = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() )\n" );
        jit_value_t param  = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() );

////    jitValuePtr_ = jit_insn_add_relative(f, param, offset_); */

        CDPT1( "VV0912: ", VV_BD, "In storeJitValue, getting param using offset_ = "
                                                            "%d\n", offset_);

        jit_value_t tmp1 = ConstantInt::get( cfg->getInt64Ty(), offset_ ) ;

        CDPT1( "VV0914: ", VV_BD,
       "jitValuePtr_ = Bldr->CreateGEP( param, tmp1 = %d )\n", offset_ );
        jitValuePtr_ = Bldr->CreateGEP( param, tmp1 );
      }
      else if ( jitValue_ ) // If space already allocated
      {
        CDPT0( "VV0918: ", VV_BD,
       "jitValuePtr_ = Bldr->CreateGEP( jitValue_, cfg->getZeroJitVal() )\n" );
        jitValuePtr_ = Bldr->CreateGEP( jitValue_, cfg->getZeroJitVal() );
      }
      else
      {
        assert(0==390);    // ZZZZ FIX THIS IF WE EVER GET HERE.
#if 0 /* FIX THIS IF WE EVER GET HERE. */
        // FIXME: This needs to change.  We need to allocate the temp globally
        // so that references are available everywhere.  Best solution is to
        // pass in temp array and use that.
        jitValuePtr_ = jit_insn_alloca(size);
#endif /* FIX THIS */
      }

      CDPT2( "VV0919: ", VV_BD, "In storeJitValue(): setting jitValuePtrBlock_ = %p "
                                           "for PCop = %p\n",    b,    this );
      jitValuePtrBlock_ = b;

    } // End: if (!jitValuePtr_)

    CDPT1( "VV0920: ", VV_BD, "In storeJitValue, calling genUnalignedMemcpy() "
                              "with length=%d\n", getLen() );

    // Generate unaligned memcpy instead
////// jit_insn_memcpy(f, jitValuePtr_, value, size);
////cfg->genUnalignedMemcpy(f, jitValuePtr_, value, NULL, getLen());

    cfg->genUnalignedMemcpy( Bldr, jitValuePtr_, value, NULL, getLen());

    // If we are directly told not to save the jit values, don't!
    if (noSave)
    {
      jitValueBlock_ = NULL;
      jitValuePtrBlock_ = NULL;

      if ( jitValue_ )
         CDPT2( "VV0925: ", VV_BD, "In storeJitValue(): NULLing jitValue_ at %p "
                                   "-- in PCodeOp at %p\n", &jitValue_ , this);

      jitValue_ = jitValuePtr_ = NULL;
    }

    return;

  } // End: if ( valType->isPointerTy() )

  //
  // Peforming standard sized moves
  //

  if (isVar())
  {
    jit_value_t parm1 = cfg->getJitParams()[stackIndex_];

       CDPT0( "VV0940: ", VV_BD,
               "param  = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() )\n" );
    jit_value_t param  = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() );

////jit_insn_store_relative(param, offset_, value);

    CDPT0( "VV0942: ", VV_BD,
   "cfg->IR_StoreRelativeWithType( Bldr, value, param, offset_, IRtype )\n");
    cfg->IR_StoreRelativeWithType( Bldr, value, param, offset_, IRtype );
  }
  else
  {
    assert (isTemp());

#if 0
    // Just set the value to be the new jitValue
    // FIX: this is ripe for error :(
    jitValue_ = value;
#endif

    CDPT2( "VV0943: ", VV_BD, "For PCodeOp at %p, Curr Value of jitValue_ = %p\n",
                                            this,               jitValue_ );
    if (!jitValue_)
    {
////  jitValue_ = value; // SEE 'ripe for error' comment above.

      CDPT0( "VV0944: ", VV_BD,
     "jitValue_ = (llvm::Value *)Bldr->CreateAlloca( valType )\n" );
      jitValue_ = (llvm::Value *)Bldr->CreateAlloca( valType );

      CDPT2( "VV0945: ", VV_BD, "Just set jitValue_ in PCodeOp at %p to %p "
                                "via CreateAlloca()\n", this, jitValue_);
    }
    else
    {
      // If this PC block is not dominated by the previous block containing the
      // first jitValue_, then things like a jitValuePtr_ need to be reset.
      // Note, the definition of jitValue_ does not need to dominate this block
      // since when the value is created (as it is above), it is done so upon
      // entry to the routine (and therefore available everywhere).  Addresses
      // are not, however, and therefore may need to be recalculated.
      if ( jitValuePtr_  &&
           ( ( ! b->onesVector.testBit(jitValuePtrBlock_->getBlockNum()) ) ||
             ( jitValueBlock_ && 
              ( !b->onesVector.testBit(jitValueBlock_->getBlockNum()) ) )
           )
         )
        jitValuePtr_ = NULL;

    }

    CDPT1( "VV0946: ", VV_BD, "Value's Type ID is %d\n", (int) valType->getTypeID() );
    CDPT1( "VV0947: ", VV_BD, "jitValue_'s Type ID is %d\n",
                 (int) jitValue_->getType()->getTypeID() );

#if NExprDbgLvl >= VV_BD
    if ( jitValue_->getType()->isPointerTy() )
       CDPT1( "VV0948: ", VV_BD, "jitValue_ is PTR to type ID %d\n",
                      jitValue_->getType()->getContainedType(0)->getTypeID() );
#endif // NExprDbgLvl >= VV_BD


////jit_insn_store(f, jitValue_, value);

    CDPT0( "VV0949: ", VV_BD,
   "jit_value_t storePtr = Bldr->CreatePointerCast( jitValue_, valType->getPointerTo() )\n" );
    jit_value_t storePtr = Bldr->CreatePointerCast( jitValue_, valType->getPointerTo() );

    CDPT0( "VV0950: ", VV_BD,
   "Bldr->CreateStore( value, storePtr )\n" );
    Bldr->CreateStore( value, storePtr );


    CDPT2( "VV0951: ", VV_BD, "In storeJitValue(): setting jitValueBlock_ = %p "
                                                 "for PCop = %p\n", b, this );
    jitValueBlock_ = b;
  }

  // If we are directly told not to save the jit values, don't!
  if (noSave)
  {
    jitValueBlock_ = NULL;
    jitValuePtrBlock_ = NULL;

    CDPT2( "VV0952: ", VV_BD, "NULLing jitValue_ at %p -- in PCodeOp at %p\n",
                                                 &jitValue_ ,       this );
    jitValue_ = jitValuePtr_ = NULL;
  }
}
#endif /* NA_LINUX_LLVMJIT */

#ifdef NA_LINUX_LIBJIT
// FIX: Overlapped types can have problems too
void PCodeOperand::storeJitValue(PCodeCfg* cfg,
                                 jit_function_t f,
                                 jit_type_t type,
                                 jit_value_t value,
                                 PCodeBlock* b,
                                 jit_value_t* len = NULL,
                                 NABoolean noSave = FALSE)
{
  // Get operand in hash table
  CollIndex i = bvIndex_;
  PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);
  if (operand != this)
    return operand->storeJitValue(cfg, f, type, value, b, len, noSave);

  //
  // Are we being asked to perform a memcpy?
  //
  if (jit_value_get_type(value) == jit_type_void_ptr) {
    jit_value_t size =
      ((len) ? *len : jit_value_create_nint_constant(f, jit_type_int,getLen()));

    if (jitValuePtr_) {
      assert(jitValueBlock_ != NULL);
      if (!b->onesVector.testBit(jitValueBlock_->getBlockNum()))
        jitValuePtr_ = NULL;
    }

    if (!jitValuePtr_) {
      if (isVar() || isNonNativeTemp()) {
        jit_value_t param = cfg->getJitParams()[stackIndex_];
        jitValuePtr_ = jit_insn_add_relative(f, param, offset_);
      }
      else {
        // FIXME: This needs to change.  We need to allocate the temp globally
        // so that references are available everywhere.  Best solution is to
        // pass in temp array and use that.
        jitValuePtr_ = jit_insn_alloca(f, size);
      }

      jitValueBlock_ = b;
    }

    // Generate unaligned memcpy instead
    // jit_insn_memcpy(f, jitValuePtr_, value, size);
    cfg->genUnalignedMemcpy(f, jitValuePtr_, value, NULL, getLen());

    // If we are directly told not to save the jit values, don't!
    if (noSave) {
      jitValueBlock_ = NULL;
      jitValue_ = jitValuePtr_ = NULL;
    }

    return;
  }

  //
  // Peforming standard sized moves
  //

  if (isVar()) {
    jit_value_t param = cfg->getJitParams()[stackIndex_];
    jit_insn_store_relative(f, param, offset_, value);
  }
  else {
    assert (isTemp());

#if 0
    // Just set the value to be the new jitValue
    // FIX: this is ripe for error :(
    jitValue_ = value;
#endif

    if (!jitValue_) {
      jitValue_ = jit_value_create(f, type);
    }
    else {
      // If this block is not dominated by the previous block containing the
      // first jitValue_, then things like a jitValuePtr_ need to be reset.
      // Note, the definition of jitValue_ does not need to dominate this block
      // since when the value is created (as it is above), it is done so upon
      // entry to the routine (and therefore available everywhere).  Addresses
      // are not, however, and therefore may need to be recalculated.
      if (jitValuePtr_ &&
          (!b->onesVector.testBit(jitValueBlock_->getBlockNum())))
        jitValuePtr_ = NULL;
    }

    jit_insn_store(f, jitValue_, value);

    jitValueBlock_ = b;
  }

  // If we are directly told not to save the jit values, don't!
  if (noSave) {
    jitValueBlock_ = NULL;
    jitValue_ = jitValuePtr_ = NULL;
  }
}
#endif /* NA_LINUX_LIBJIT */

#if 1 /* NA_LINUX_LLVMJIT */

//
// IR_insn_branch_if_zero() - generate branch instruction to specified
// target IR block *if* the specified 'value' is equal to 0.
//
// NOTES:
// (1) Works regardless of whether 'value' is an 8-bit, 16-bit,
//     32-bit, or 64-bit value.
// (2) Specified target IR block must have already been created.
// (3) This routine only generates the conditional branch.  It does *not*
//     do the "push_back" on the tgt block to place it in the
//     output "stream".
// (4) This routine always creates an IR block for the "if not zero" condition
//     and does the "push_back" on it as well as setting the "InsertPoint"
//     to the "if not" IR block.
//
void  PCodeCfg::IR_insn_branch_if_zero( IRBldr_t     * Bldr
                                      , jit_value_t    value
                                      , p_IR_block_t * tgt_IR_block
                                      )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   DPT0( "VV1000: ", VV_BD, "GOT into IR_insn_branch_if_zero()\n" );

   llvm::LLVMContext &LLContxt = Bldr->getContext();

   llvm::Function *ExpFn  = Bldr->GetInsertBlock()->getParent();

   // Create an IR block for the "if not zero" case
   p_IR_block_t ifNZ_Blk = BasicBlock::Create( LLContxt, "BrIf_NZ_Blk" );

   DPT1( "VV1001: ", VV_VD, "ifNZ_Blk = %p\n", ifNZ_Blk ); 

   jit_value_t  Zero   = ConstantInt::get( value->getType(), 0 );

   DPT0( "VV1002: ", VV_VD,
               "IsZero = Bldr->CreateICmpEQ( value, Zero, 'check0' )\n" );
   jit_value_t  IsZero = Bldr->CreateICmpEQ( value, Zero, "check0" );

   DPT2( "VV1004: ", VV_VD,
  "Bldr->CreateCondBr( IsZero, *tgt_IR_block = %p, ifNZ_Blk = %p )\n", *tgt_IR_block, ifNZ_Blk );
   Bldr->CreateCondBr( IsZero, *tgt_IR_block, ifNZ_Blk );

   DPT1( "VV1006: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( ifNZ_Blk = %p )\n", ifNZ_Blk );
   ExpFn->getBasicBlockList().push_back( ifNZ_Blk );

   DPT1( "VV1008: ", VV_VD,
  "Bldr->SetInsertPoint( ifNZ_Blk = %p )\n", ifNZ_Blk );
   Bldr->SetInsertPoint( ifNZ_Blk );

}

//
// IR_insn_branch_if_not_zero() - generate branch instruction to specified
// target IR block *if* the specified 'value' is NOT equal to 0.
//
// NOTES:
// (1) Works regardless of whether 'value' is an 8-bit, 16-bit,
//     32-bit, or 64-bit value.
// (2) Specified target IR block must have already been created.
// (3) This routine only generates the conditional branch.  It does *not*
//     do the "push_back" on the tgt block to place it in the
//     output "stream".
// (4) This routine always creates an IR block for the "if Zero" condition
//     and does the "push_back" on it as well as setting the "InsertPoint"
//     to the "if not" IR block.
//
void  PCodeCfg::IR_insn_branch_if_not_zero( IRBldr_t     * Bldr
                                          , jit_value_t    value
                                          , p_IR_block_t * tgt_IR_block
                                          )
{
#if NExprDbgLvl > VV_NO
   char  NExBuf[500];
#endif
   DPT0( "VV1100: ", VV_BD, "GOT into IR_insn_branch_if_not_zero()\n" );

   llvm::LLVMContext &LLContxt = Bldr->getContext();

   llvm::Function *ExpFn  = Bldr->GetInsertBlock()->getParent();

   // Create an IR block for the "if zero" case
   p_IR_block_t if_0_Blk = BasicBlock::Create( LLContxt, "BrIfZeroBlk" );

   DPT1( "VV1101: ", VV_VD, "if_0_Blk = %p\n", if_0_Blk ); 

   jit_value_t  Zero   = ConstantInt::get( value->getType(), 0 );

   DPT0( "VV1102: ", VV_VD,
               "IsZero = Bldr->CreateICmpEQ( value, Zero, 'check0' )\n" );
   jit_value_t  IsZero = Bldr->CreateICmpEQ( value, Zero, "check0" );

   DPT2( "VV1104: ", VV_VD,
  "Bldr->CreateCondBr( IsZero, if_0_Blk = %p, *tgt_IR_block = %p )\n", if_0_Blk, *tgt_IR_block );
   Bldr->CreateCondBr( IsZero, if_0_Blk, *tgt_IR_block );

   DPT1( "VV1106: ", VV_VD,
  "ExpFn->getBasicBlockList().push_back( if_0_Blk = %p )\n", if_0_Blk );
   ExpFn->getBasicBlockList().push_back( if_0_Blk );

   DPT1( "VV1108: ", VV_VD,
  "Bldr->SetInsertPoint( if_0_Blk = %p )\n", if_0_Blk );
   Bldr->SetInsertPoint( if_0_Blk );

}

void PCodeOperand::storeNullJitValueAndBranch( PCodeCfg   * cfg
                                             , IRBldr_t   * Bldr
                                             , jit_value_t  value
                                             , p_IR_block_t tgtLabel
                                             , NABoolean    forComp
                                             , PCodeBlock * b
                                             )
{
#if NExprDbgLvl >= VV_NO
  char  NExBuf[500];
#endif

  jit_value_t res = NULL ;

  CDPT0( "VV1200: ", VV_BD, "GOT into storeNullJitValueAndBranch()\n" );

// Use pCode[2-3] to chk if op2 is NULL
// If it is NULL, set output = NULL
//   and go to next PCode instruction;
// Else set output = NOT NULL
//   and add pCode[7] to pCode ptr

  // If 'value' is non-zero, then   

  // Get operand in hash table
  CollIndex i = bvIndex_;
  PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);

  CDPT2( "VV1205: ", VV_BD, "In storeNullJVaBR(): operand=%p, this=%p\n", operand, this );

  if (operand != this)
    return operand->storeNullJitValueAndBranch(cfg, Bldr, value, tgtLabel,
                                               forComp, b);

//jit_value_t zeroJitVal16=jit_value_create_nint_constant(f, jit_type_short, 0);
  jit_value_t zeroJitVal16 = ConstantInt::get( cfg->getInt16Ty(), 0 );

//jit_value_t neg1JitVal16=jit_value_create_nint_constant(f, jit_type_short,-1);
  jit_value_t neg1JitVal16 = ConstantInt::get( cfg->getInt16Ty(), -1 );

  llvm::Function *ExpFn  = Bldr->GetInsertBlock()->getParent();

  // Is src a null bit value or not (doesn't matter)
  if (TRUE)
  {
    llvm::LLVMContext &LLContxt = Bldr->getContext();
    p_IR_block_t nullLabel    = BasicBlock::Create( LLContxt, "StoreNJ_nullBlk" );

    CDPT1( "VV1210: ", VV_BD, "nullLabel = %p\n", nullLabel );

    //
    // NOTE: We don't need a "merge" block because we will either branch
    // to the tgtLabel or we will use the "nullLabel" block after
    // we are done with this routine.
    //
    CDPT1( "VV1212: ", VV_BD, "In storeNullJitV... Value's Type ID is %d\n",
                                        (int) value->getType()->getTypeID() );

    // Branch away if source is null.
//  jit_insn_branch_if(f, value, &nullLabel);
    cfg->IR_insn_branch_if_not_zero( Bldr, value, &nullLabel );

    // At this point, we know 'value' is zero -- indicating a NON-NULL

    // Is tgt null-indicator just a bit?  If so, we must zero that bit to indicate a non-null
    if (nullBitIndex_ != -1) {
      UInt8 m = ((UInt8)0x1 << (7 - (nullBitIndex_ & 7)));

      // Tgt must be a var for it to have a null bit index.
      jit_value_t parm1 = cfg->getJitParams()[stackIndex_];

      CDPT0( "VV1210: ", VV_BD,
                 "param  = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() )\n" );
      jit_value_t param  = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() );

//    jit_value_t mask = jit_value_create_nint_constant(f, jit_type_ubyte, ~m);
      jit_value_t mask = ConstantInt::get( cfg->getInt8Ty() , ~m );

//    jit_value_t nByte = jit_insn_load_relative(f, param,
//                          offset_ + (nullBitIndex_ >> 3), jit_type_ubyte);
      jit_value_t nByte = cfg->IR_LoadRelativeWithType( Bldr, param,
                            offset_ + (nullBitIndex_ >> 3), cfg->getInt8Ty() );

      // Clear the null bit and store the byte (containing the bit)
//    jit_value_t res = jit_insn_and(f, nByte, mask);

      CDPT1( "VV1214: ", VV_BD,
     "res = Bldr->CreateAnd( nByte, mask = %d )\n", ~m );
      res = Bldr->CreateAnd( nByte, mask );

//    jit_insn_store_relative(f, param, offset_ + (nullBitIndex_ >> 3), res);

      CDPT0( "VV1217: ", VV_BD,
     "cfg->IR_StoreRelativeWithType( Bldr, res, param, offset_ + ..., res->getType() )\n");
      cfg->IR_StoreRelativeWithType( Bldr, res,
                                param, offset_ + (nullBitIndex_ >> 3),
                                res->getType() );

      // Branch to target label
//    jit_insn_branch(f, targetLabel);

      CDPT1( "VV1219: ", VV_BD,
     "Bldr->CreateBr( tgtLabel = %p )\n", tgtLabel );
      Bldr->CreateBr( tgtLabel );

      CDPT1( "VV1220: ", VV_BD, "In storeNullJitVal: CREATING BRANCH TO tgtLabel at "
                         "( %p )\n", tgtLabel );

      // Now handle NULL case.

//    jit_insn_label(f, &nullLabel);

      CDPT1( "VV1220: ", VV_BD,
     "ExpFn->getBasicBlockList().push_back( nullLabel = %p )\n", nullLabel );
      ExpFn->getBasicBlockList().push_back( nullLabel );

      CDPT1( "VV1222: ", VV_BD,
     "Bldr->SetInsertPoint( nullLabel = %p )\n", nullLabel );
      Bldr->SetInsertPoint( nullLabel );

      CDPT1( "VV1223: ", VV_BD,
             "In storeNullJitVal: Setting Insert Point to nullLabel at %p\n",
                                                                 nullLabel );

//    mask = jit_value_create_nint_constant(f, jit_type_ubyte, m);
      mask = ConstantInt::get( cfg->getInt8Ty() , m );

//    nByte = jit_insn_load_relative(f, param,
//                          offset_ + (nullBitIndex_ >> 3), jit_type_ubyte);
      nByte = cfg->IR_LoadRelativeWithType( Bldr, param,
                            offset_ + (nullBitIndex_ >> 3), cfg->getInt8Ty() );

      // Set the null bit and store it back
//    res = jit_insn_or(f, nByte, mask);

      CDPT1( "VV1224: ", VV_BD,
     "res = Bldr->CreateOr( nByte, mask = %d )\n", m );
      res = Bldr->CreateOr( nByte, mask );

//    jit_insn_store_relative(f, param, offset_ + (nullBitIndex_ >> 3), res);

      CDPT0( "VV1224: ", VV_BD,
     "cfg->IR_StoreRelativeWithType( Bldr, res, param, offset_ + ..., res->getType() )\n");
      cfg->IR_StoreRelativeWithType( Bldr, res,
                                param, offset_ + (nullBitIndex_ >> 3),
                                res->getType() );

    } // End: if (nullBitIndex_ != -1)

    else {
      // Tgt is a standard type, so we store a 0 in the null-indicator (to indicate non-null)
      if (isVar()) {
        jit_value_t parm1 = cfg->getJitParams()[stackIndex_];

        CDPT0( "VV1230: ", VV_BD,
                   "param  = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() )\n" );
        jit_value_t param  = Bldr->CreatePointerCast(parm1, cfg->getInt8PtrTy() );

        // Store a zero, indicating non-null
//      jit_insn_store_relative(f, param, offset_,
//        (forComp ? cfg->getZeroJitVal() : zeroJitVal16));

        res = forComp ? cfg->getZeroJitVal() : zeroJitVal16 ;

        CDPT1( "VV1232: ", VV_BD, "In storeNJ-forComp = %d\n", forComp);
        CDPT1( "VV1234: ", VV_BD, "In storeNJ-res=%s\n",
                  res==zeroJitVal16 ? "zeroJitVal16" : "cfg->getZeroJitVal()" );
        CDPT1( "VV1236: ", VV_BD, "In storeNJ-type WIDTH = %d\n",
                  res->getType()->getIntegerBitWidth() );

        CDPT0( "VV1240: ", VV_BD,
       "cfg->IR_StoreRelativeWithType( Bldr, res, param, offset_, res->getType() )\n");
        cfg->IR_StoreRelativeWithType( Bldr, res, param, offset_, res->getType() );

//      jit_insn_branch(f, targetLabel);

        CDPT1( "VV1242: ", VV_BD,
       "Bldr->CreateBr( tgtLabel = %p )\n", tgtLabel );
        Bldr->CreateBr( tgtLabel );

        // Now handle NULL case.

//      jit_insn_label(f, &nullLabel);

        CDPT1( "VV1244: ", VV_BD,
       "ExpFn->getBasicBlockList().push_back( nullLabel = %p )\n", nullLabel );
        ExpFn->getBasicBlockList().push_back( nullLabel );

        CDPT1( "VV1246: ", VV_BD,
       "Bldr->SetInsertPoint( nullLabel = %p )\n", nullLabel );
        Bldr->SetInsertPoint( nullLabel );

//      jit_insn_store_relative(f, param, offset_,
//        (forComp ? cfg->getNeg1JitVal() : neg1JitVal16));

        res      = forComp ? cfg->getNeg1JitVal() : neg1JitVal16 ;

        CDPT1( "VV1247: ", VV_BD, "In storeNJ1-forComp = %d\n", forComp);
        CDPT1( "VV1248: ", VV_BD, "In storeNJ1-res=%s\n",
                   res==neg1JitVal16 ? "neg1JitVal16":"cfg->getNeg1JitVal()");
        CDPT1( "VV1249: ", VV_BD, "In storeNJ1-type WIDTH = %d\n",
                   res->getType()->getIntegerBitWidth() );
       
        CDPT0( "VV1250: ", VV_BD,
       "cfg->IR_StoreRelativeWithType( Bldr, res, param, offset_, res->getType() )\n");
        cfg->IR_StoreRelativeWithType( Bldr, res,
                                  param, offset_,
                                  res->getType() );

      } // End: if (isVar())

      else {
        if ( 1 /* forComp ? */) {
//        storeJitValue(cfg, f, jit_type_int, cfg->getZeroJitVal(), b, NULL);

          CDPT1( "VV1252: ", VV_BD, "In storeNJ2 ... forComp = %d\n", forComp);
          CDPT1( "VV1253: ", VV_BD, "In storeNJ2 ... storetype = %s\n",
                                                        "cfg->getInt32Ty()");
          storeJitValue(cfg, Bldr, cfg->getInt32Ty(), cfg->getZeroJitVal(), b, NULL );

//        jit_insn_branch(f, targetLabel);

          CDPT1( "VV1255: ", VV_BD,
         "Bldr->CreateBr( tgtLabel = %p )\n", tgtLabel );
          Bldr->CreateBr( tgtLabel );

          // Now handle NULL case.
 
//        jit_insn_label(f, &nullLabel);

          CDPT1( "VV1260: ", VV_BD,
         "ExpFn->getBasicBlockList().push_back( nullLabel = %p )\n", nullLabel );
          ExpFn->getBasicBlockList().push_back( nullLabel );

          CDPT1( "VV1261: ", VV_BD,
         "Bldr->SetInsertPoint( nullLabel = %p )\n", nullLabel );
          Bldr->SetInsertPoint( nullLabel );

//        storeJitValue(cfg, f, jit_type_int, cfg->getNeg1JitVal(), b, NULL);
          storeJitValue(cfg, Bldr, cfg->getInt32Ty(), cfg->getNeg1JitVal(), b, NULL );
        }
#if 0 /* The following OPTIMIZATION (over the above section of code) does NOT always work */
      // because sometimes we NEED the call to storeJitValue above even for Temps.
      // Case in point:  Launchpad defect 1328248
        else { // forComp == FALSE

          CDPT1( "VV1262: ", VV_BD, "In storeNJ3 ... forComp = %d\n", forComp);

          jitValue_ = value;

          CDPT2( "VV1263: ", VV_BD,
                 "In storeNullJV(): setting jitValue_ in PCodeOp at %p to %p\n",
                                                              this, jitValue_ );
          CDPT1( "VV1264: ", VV_BD,
                 "In storeNJ- jitValue_'s Type ID is %d\n",
                                       (int)jitValue_->getType()->getTypeID() );
          CDPT2( "VV1264A: ", VV_BD,
                 "In storeNullJV(): setting jitValueBlock_ = %p for PCop = %p\n",
                                                              b,         this );
          jitValueBlock_ = b;

//        jit_insn_branch(f, targetLabel);

          CDPT1( "VV1265: ", VV_BD,
         "Bldr->CreateBr( tgtLabel = %p )\n", tgtLabel );
          Bldr->CreateBr( tgtLabel );

//        jit_insn_label(f, &nullLabel);

          CDPT1( "VV1267: ", VV_BD,
         "ExpFn->getBasicBlockList().push_back( nullLabel = %p )\n", nullLabel );
          ExpFn->getBasicBlockList().push_back( nullLabel );

          CDPT1( "VV1268: ", VV_BD,
         "Bldr->SetInsertPoint( nullLabel = %p )\n", nullLabel );
          Bldr->SetInsertPoint( nullLabel );

        } // End: else
#endif
      } // End: else  [i.e. (isVar()) == FALSE ]
    } // End: else  [ i.e. (nullBitIndex_ == -1) ]
  } // End:  if (TRUE)
}

#endif /* NA_LINUX_LLVMJIT */

#ifdef NA_LINUX_LIBJIT
void PCodeOperand::storeNullJitValueAndBranch(PCodeCfg* cfg,
                                              jit_function_t f,
                                              jit_value_t value,
                                              jit_label_t* targetLabel,
                                              NABoolean forComp,
                                              PCodeBlock* b)
{
  // Get operand in hash table
  CollIndex i = bvIndex_;
  PCodeOperand* operand = cfg->getMap()->getFirstValue(&i);
  if (operand != this)
    return operand->storeNullJitValueAndBranch(cfg, f, value, targetLabel,
                                               forComp, b);

  jit_label_t nullLabel = jit_label_undefined;

  jit_value_t zeroJitVal16=jit_value_create_nint_constant(f, jit_type_short, 0);
  jit_value_t neg1JitVal16=jit_value_create_nint_constant(f, jit_type_short,-1);

  // Is src a null bit value or not (doesn't matter)
  if (TRUE)
  {
    // Branch away if source is null.
    jit_insn_branch_if(f, value, &nullLabel);

    // Is tgt a null bit?
    if (nullBitIndex_ != -1) {
      UInt8 m = ((UInt8)0x1 << (7 - (nullBitIndex_ & 7)));

      // Tgt must be a var for it to have a null bit index.
      jit_value_t param = cfg->getJitParams()[stackIndex_];
      jit_value_t mask = jit_value_create_nint_constant(f, jit_type_ubyte, ~m);
      jit_value_t nByte = jit_insn_load_relative(f, param,
                            offset_ + (nullBitIndex_ >> 3), jit_type_ubyte);

      // Clear value and restore.
      jit_value_t res = jit_insn_and(f, nByte, mask);
      jit_insn_store_relative(f, param, offset_ + (nullBitIndex_ >> 3), res);

      // Branch to target label
      jit_insn_branch(f, targetLabel);

      // Now handle NULL case.

      jit_insn_label(f, &nullLabel);

      mask = jit_value_create_nint_constant(f, jit_type_ubyte, m);
      nByte = jit_insn_load_relative(f, param,
                            offset_ + (nullBitIndex_ >> 3), jit_type_ubyte);

      // Set value and restore.
      res = jit_insn_or(f, nByte, mask);
      jit_insn_store_relative(f, param, offset_ + (nullBitIndex_ >> 3), res);
    }
    else {
      // Tgt is a standard type
      if (isVar()) {
        jit_value_t param = cfg->getJitParams()[stackIndex_];
        jit_insn_store_relative(f, param, offset_,
          (forComp ? cfg->getZeroJitVal() : zeroJitVal16));
        jit_insn_branch(f, targetLabel);

        // Now handle NULL case.

        jit_insn_label(f, &nullLabel);
        jit_insn_store_relative(f, param, offset_,
          (forComp ? cfg->getNeg1JitVal() : neg1JitVal16));
      }
      else {
        if (forComp) {
          storeJitValue(cfg, f, jit_type_int, cfg->getZeroJitVal(), b, NULL);
          jit_insn_branch(f, targetLabel);

          // Now handle NULL case.
 
          jit_insn_label(f, &nullLabel);
          storeJitValue(cfg, f, jit_type_int, cfg->getNeg1JitVal(), b, NULL);
        }
        else { 
          jitValue_ = value;
          jitValueBlock_ = b;
          jit_insn_branch(f, targetLabel);
          jit_insn_label(f, &nullLabel);
        }
      }
    } 
  }
}

void PCodeCfg::jitProcessFloatExceptionCheck(jit_function_t f,
                                             PCodeOperand* fRes,
                                             jit_label_t* errorJitLabel,
                                             PCodeBlock* block)
{
  jit_value_t temp1, temp2, temp3, temp4;

  jit_value_t expShift = jit_value_create_nint_constant(f, jit_type_int, 20);
  jit_value_t expMask = jit_value_create_nint_constant(f, jit_type_int, 0x7ff);

  jit_value_t fVal = fRes->getJitValue(this, f, jit_type_void_ptr, block);

  // Get the upper 32-bits of the double
  temp1 = jit_insn_load_relative(f, fVal, 4, jit_type_uint);

  // Shift the load over so that the last 12 bits are in the lower
  temp2 = jit_insn_ushr(f, temp1, expShift);

  // Mask out exponent and compare to see if 11-bit exponent is all set.
  temp3 = jit_insn_and(f, temp2, expMask);
  temp4 = jit_insn_eq(f, temp3, expMask);

  jit_insn_branch_if(f, temp4, errorJitLabel);
}

#if 0

NABoolean PCodeCfg::jitProcessPredicate(PCodeInst* comp,
                                        jit_value_t compJitVal,
                                        jit_function_t f)
{
  if (comp->next && comp->next->isAnyLogicalBranch())
  {
    PCodeInst* branch = comp->next;

    PCodeOperand* compTgt = comp->getWOps()[0];
    PCodeOperand* branchSrc = branch->getROps()[0];
    PCodeOperand* branchTgt = branch->getWOps()[0];

    PCodeBlock* block = comp->block;

    NABoolean srcLive = FALSE, tgtLive = FALSE;

    if (branchSrc->getBvIndex() == compTgt->getBvIndex()) {
      // Is source or target live after branch?
      srcLive = branchSrc->isVar() || block->isOperandLiveInSuccs(branchSrc);
      tgtLive = branchTgt->isVar() || block->isOperandLiveInSuccs(branchTgt);

      if (srcLive)
        compTgt->storeJitValue(this, f, jit_type_int, compJitVal, block);

      if (tgtLive)
        branchTgt->storeJitValue(this, f, jit_type_int, compJitVal, block);

      if ((branch->getOpcode() == PCIT::BRANCH_OR) ||
          (branch->getOpcode() == PCIT::BRANCH_OR_CNT)) {
        jit_insn_branch(f, block->getTargetBlock()->getJitLabel());
      else
        jit_insn_branch(f, block->getFallThroughBlock()->getJitLabel());
      }
    }
  }
  else if (comp->next && (comp->next->getOpcode() == PCIT::MOVE_MBIN32S))
  {
    PCodeInst* move = comp->next;

    PCodeOperand* compTgt = comp->getWOps()[0];
    PCodeOperand* moveSrc = move->getROps()[0];

    if (compTgt->getBvIndex() == moveSrc->getBvIndex()) {
      // A RETURN is guaranteed to following a MOVE_MBIN32S (verify w/ assert)
      assert (move->next && (move->next->getOpcode() == PCIT::RETURN));
    }
  }
}

#endif

NABoolean PCodeCfg::jitProcessPredicate(PCodeInst* comp,
                                        jit_function_t f,
                                        jit_label_t* falseLabel,
                                        jit_label_t* trueLabel,
                                        NABoolean isFirstBlockTrue)
{
  CollIndex i;

  //
  // Called when generating the TRUE and FALSE blocks first for certain
  // comparisons.  Rather than check the result of the comparison twice (one
  // for the COMP and another for a subsequent BRANCH), we attempt to do it all
  // at once.
  //
  // A boolean called isFirstBlockTrue passed in to tell us if the 1st block
  // to generate is the "true" block or not.
  //

  if (comp->next && comp->next->isAnyLogicalBranch())
  {
    PCodeInst* branch = comp->next;

    PCodeOperand* compTgt = comp->getWOps()[0];
    PCodeOperand* branchSrc = branch->getROps()[0];
    PCodeOperand* branchTgt = branch->getWOps()[0];

    PCodeBlock* block = comp->block;

    NABoolean srcLive = FALSE, tgtLive = FALSE;

    if (branchSrc->getBvIndex() == compTgt->getBvIndex()) {
      // Is source or target live after branch?
      srcLive = branchSrc->isVar() || block->isOperandLiveInSuccs(branchSrc);
      tgtLive = branchTgt->isVar() || block->isOperandLiveInSuccs(branchTgt);

      // Dump out blocks now (either TRUE followed by FALSE, or vice-versa)
      // Use for loop to simplify code (i.e. reduce duplication of code) in
      // laying out the blocks one way or the other.

      for (i=0; i < 2; i++)
      {
        if ((isFirstBlockTrue && (i==0)) ||
            (!isFirstBlockTrue && (i==1)))
        {
          jit_insn_label(f, trueLabel);

          // Dump true block first
          if (srcLive)
            compTgt->storeJitValue(this, f, jit_type_int, oneJitVal_, block);

          if (tgtLive)
            branchTgt->storeJitValue(this, f, jit_type_int, oneJitVal_, block);

          if ((branch->getOpcode() == PCIT::BRANCH_OR) ||
              (branch->getOpcode() == PCIT::BRANCH_OR_CNT))
            jit_insn_branch(f, block->getTargetBlock()->getJitLabel());
          else
            jit_insn_branch(f, block->getFallThroughBlock()->getJitLabel());
        }

        if ((!isFirstBlockTrue && (i==0)) ||
            (isFirstBlockTrue && (i==1)))
        {
          // Dump false block next - layout false block label first.
          jit_insn_label(f, falseLabel);

          if (srcLive)
            compTgt->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);

          if (tgtLive)
            branchTgt->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);

          if ((branch->getOpcode() == PCIT::BRANCH_AND) ||
              (branch->getOpcode() == PCIT::BRANCH_AND_CNT))
            jit_insn_branch(f, block->getTargetBlock()->getJitLabel());
          else
            jit_insn_branch(f, block->getFallThroughBlock()->getJitLabel());
        }
      }

      return TRUE;
    }
  }
  else if (comp->next && (comp->next->getOpcode() == PCIT::MOVE_MBIN32S))
  {
    PCodeInst* move = comp->next;

    PCodeOperand* compTgt = comp->getWOps()[0];
    PCodeOperand* moveSrc = move->getROps()[0];

    if (compTgt->getBvIndex() == moveSrc->getBvIndex()) {
      // A RETURN is guaranteed to following a MOVE_MBIN32S (verify w/ assert)
      assert (move->next && (move->next->getOpcode() == PCIT::RETURN));

      if (isFirstBlockTrue) {
        jit_insn_label(f, trueLabel);
        jit_insn_return(f, tJitVal_);

        // False block next - add label first.
        jit_insn_label(f, falseLabel);
        jit_insn_return(f, fJitVal_);
      }
      else {
        jit_insn_label(f, falseLabel);
        jit_insn_return(f, fJitVal_);

        // True block next - add label first.
        jit_insn_label(f, trueLabel);
        jit_insn_return(f, tJitVal_);
      }

      return TRUE;
    }
  }
  return FALSE;
}
#endif /* NA_LINUX_LIBJIT */

#if 1 /* NA_LINUX_LLVMJIT */

void PCodeCfg::layoutNativeCode()
{
  static pthread_mutex_t Our_LLVM_mutex = PTHREAD_MUTEX_INITIALIZER;

  // List of signal numbers for which LLVM establishes its own signal handlers
  static const int SaveSigs[] = {
    SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGBUS, SIGFPE,
    SIGSEGV, SIGUSR2, SIGPIPE, SIGTERM, SIGXFSZ
  };
  static const int NumSaveSigs = sizeof(SaveSigs) / sizeof(SaveSigs[0]);

  static THREAD_P struct {
    struct sigaction SigAct ;
  } SavedSigInfo[ NumSaveSigs ];

  static struct {
    struct sigaction SigAct ;
  } SavedLLVMhandlers[ NumSaveSigs ];

  static NABoolean LLVMhandlersSaved = FALSE ;


#if NExprDbgLvl > VV_NO
  char  NExBuf[500];
#endif
  Int32   PCI_count = 0  ; //Count of number of PCODE instructions translated.

  expr_->setPCodeNative(FALSE); // For now, assume no native code generated.

  NABoolean debug = FALSE;
  if (getenv("NATIVE_EXPR_DEBUG"))
    debug = TRUE;

  PCodeBinary* pCode = expr_->getPCodeBinary();

  NExTempsList_ = new(heap_) NExTEMPSLIST(heap_);


  // First see if this graph can be compiled natively
  if ( ! canGenerateNativeExpr() )
  {
     delete NExTempsList_ ;
     NExTempsList_ = NULL ;
     expr_->setEvalPtr( (ex_expr::evalPtrType)( (CollIndex) 0 ) );//Ensure NULL!
     return;
  }

#if NExprDbgLvl >= VV_I0
  struct rusage begTime;

  if ( NExprDbgLvl_ >= VV_I0 )
  {
    std::cout << std::flush ; // Flush anything in the data buffer
    (void) getrusage( RUSAGE_THREAD, &begTime );

    char*  StTime = ctime((const time_t*)&begTime.ru_utime.tv_sec);
    Int32 StTimeLn = strlen(StTime);
    StTime[StTimeLn-1] = ' ';

    DPT2( "VV90000: ", VV_I3,
          "STARTING layoutNativeCode() at %s : Microseconds: %d\n",
                                       StTime, (int) begTime.ru_utime.tv_usec );

    if ( NExprDbgLvl_ >= VV_I1  &&
         NExDbgInfoPtr_->getNExStmtPrinted() == FALSE )
    {
       NExDbgInfoPtr_->setNExStmtPrinted( TRUE );

       if ( NExDbgInfoPtr_->getNExStmtSrc() )
       {
          NExLog( "==Orig. SQL Stmt:\n" );
          NExLog( NExDbgInfoPtr_->getNExStmtSrc() );
          NExLog( "\n==\n" );
       }
    }
    std::cout << std::flush ; // Flush anything in the data buffer
  }
#endif // NExprDbgLvl >= VV_I0

  Int32 opc;
  CollIndex i, j, PCBlkIndex;

  Int32 skipInst = 0;

  // First compute the dominator tree
  computeDomTree();

  //
  // Since the LLVM library is not thread-safe, we get a mutex at this point.
  // If the mutex is not immediately available, then another thread is using
  // LLVM right now, so we just fall back to using PCODE and not try to 
  // generate a Native Expression right now.
  //
  int tryVal = pthread_mutex_trylock( &Our_LLVM_mutex );
  if ( tryVal )
  {
     delete NExTempsList_ ;
     NExTempsList_ = NULL ;
     expr_->setEvalPtr( (ex_expr::evalPtrType)( (CollIndex) 0 ) );//Ensure NULL!

#if NExprDbgLvl >= VV_I2
 if ( NExprDbgLvl_ >= VV_I2 ) {
    DPT0( "VV90000A: ", VV_XD, "Not translating to native code - mutex locked.\n");
 }
#endif
     return;
  }

  //
  // Now that we have the mutex, save the current signal handlers for signals
  // for which LLVM has handlers.  Also, if we have previously saved LLVM's
  // sigaction handlers, restore them before we go back into LLVM code.
  //
  for (Int32 ii = 0; ii < NumSaveSigs ; ii++ )
  {
     Int32 ret = sigaction( SaveSigs[ii], 
            ( LLVMhandlersSaved ) ?
            &(SavedLLVMhandlers[ii].SigAct) : (const struct sigaction *)NULL,
            &(SavedSigInfo[ii].SigAct) ) ;
     assert( ret == 0 );
  }

  llvm::InitializeNativeTarget();
  llvm::LLVMContext &LLContxt = llvm::getGlobalContext();

  // Create context to hold the LLVM JIT's primary state

  // Make the module, which holds all the code.
  llvm::Module * TheModule = new llvm::Module("ExpressionJit", LLContxt);

  llvm::IRBuilder<> * Bldr = new llvm::IRBuilder<>( LLContxt );

  std::map<std::string, Value*> NamedValues;


  // Create the "ExecutionEngine"
  std::string ErrStr;
  llvm::TargetOptions target_opts;
  target_opts.PositionIndependentExecutable = 1;

  //
  // NOTE: By specifying "x86-64" in the call to setMArch() below and
  //       specifying only the generic 64-bit attributes and *not* specifying
  //       any chip-specific attributes in the call to setMAttrs() below,
  //       we are telling the JIT compiler to generate machine code for a
  //       generic x86-64 chip rather than letting it default to generating
  //       machine code for the specific chip that the SQL Compiler happens
  //       to be running on at the moment.
  //
  std::vector<std::string>  MAttrs; // Machine Architecture attributes
  MAttrs.push_back("64bit-mode");

  llvm::ExecutionEngine* TheExecutionEngine =
    EngineBuilder(TheModule).setErrorStr(&ErrStr).setMArch("x86-64").setMAttrs(MAttrs).setTargetOptions(target_opts).setRelocationModel(llvm::Reloc::PIC_).setOptLevel(CodeGenOpt::Default).create();
  if ( !TheExecutionEngine )
  {
    std::cout << ErrStr << std::flush;
    printf("EXITING FROM layoutNativeCode() -could not create function !!\n");
    std::cout << std::flush ; // Flush anything in the data buffer

    delete Bldr ;

    //
    // Restore signal handlers to what they were on entry.
    // NOTE: We do NOT try to save the LLVM handlers when going through this
    // code the first time because LLVM has *not* set them up yet.
    //
    for (Int32 ii = 0; ii < NumSaveSigs ; ii++ )
    {
       Int32 ret = sigaction( SaveSigs[ii], &(SavedSigInfo[ii].SigAct),
                                             (struct sigaction *)NULL);
       assert( ret == 0 );
    }
    pthread_mutex_unlock( &Our_LLVM_mutex ); // Other threads could use LLVM now

    delete NExTempsList_ ;
    NExTempsList_ = NULL ;
    expr_->setEvalPtr( (ex_expr::evalPtrType)( (CollIndex) 0 ) );//Ensure NULL!
    return ;
  }

  // Initialize various jit_type_t (llvm::Type) pointers in PCodeCfg object
  // for easy reference later.
  //
  int1PtrTy_  = llvm::Type::getInt1PtrTy(LLContxt); // Used like old JIT's void ptr
  int8Ty_     = llvm::Type::getInt8Ty(LLContxt);
  int16Ty_    = llvm::Type::getInt16Ty(LLContxt);
  int32Ty_    = llvm::Type::getInt32Ty(LLContxt);
  int64Ty_    = llvm::Type::getInt64Ty(LLContxt);
  int8PtrTy_  = llvm::Type::getInt8PtrTy(LLContxt);
  int16PtrTy_ = llvm::Type::getInt16PtrTy(LLContxt);
  int32PtrTy_ = llvm::Type::getInt32PtrTy(LLContxt);
  int64PtrTy_ = llvm::Type::getInt64PtrTy(LLContxt);
  floatPtrTy_ = llvm::Type::getFloatPtrTy(LLContxt);

  DPT3( "VV90000a: ", VV_VD,
 "int1PtrTy_ = %p, int8Ty_ = %p,     int16Ty_ = %p\n", int1PtrTy_ , int8Ty_ , int16Ty_ );

  DPT2( "VV90000b: ", VV_VD,
 "int32Ty_ = %p,   int64Ty_ = %p\n", int32Ty_ , int64Ty_ );

  DPT3( "VV90000c: ", VV_VD,
 "int8PtrTy_  = %p, int16PtrTy_ = %p, int32PtrTy_ = %p\n", int8PtrTy_ , int16PtrTy_ , int32PtrTy_ );

  DPT2( "VV90000d: ", VV_VD,
 "int64PtrTy_ = %p, floatPtrTy_ = %p\n", int64PtrTy_     , floatPtrTy_ );

/************ KEEP IN COMMENTS FOR NOW -- MAY NEED TO PORT THESE IN THE FUTURE
  // Create commonly referenced constants
  JitVal_1_  = jit_value_create_nint_constant(f, jit_type_int, 1);
  zeroJitVal_ = jit_value_create_nint_constant(f, jit_type_int, 0);
  neg1JitVal_ = jit_value_create_nint_constant(f, jit_type_int, -1);
  jit_value_t zeroJitVal16=jit_value_create_nint_constant(f, jit_type_short, 0);
  jit_value_t neg1JitVal16=jit_value_create_nint_constant(f, jit_type_short,-1);
  padJitVal = jit_value_create_nint_constant(f, jit_type_ubyte, ' ');
  jit_value_t shiftRVal = jit_value_create_nint_constant(f, jit_type_int, 31);
  okJitVal_ = jit_value_create_nint_constant(f, jit_type_int,ex_expr::EXPR_OK);
  tJitVal_ = jit_value_create_nint_constant(f, jit_type_int,ex_expr::EXPR_TRUE);
  fJitVal_ = jit_value_create_nint_constant(f,jit_type_int,ex_expr::EXPR_FALSE);
  eJitVal  = jit_value_create_nint_constant(f,jit_type_int,ex_expr::EXPR_ERROR);
************ KEEP IN COMMENTS FOR NOW */

  // Create commonly referenced constants
  IR_Const_1_    = ConstantInt::get( int32Ty_ , 1 );
  IR_Const_0_    = ConstantInt::get( int32Ty_ , 0 );
  IR_Const_neg1_ = ConstantInt::get( int32Ty_ , -1 );
  IR_Const_16bit_0_ = ConstantInt::get( int16Ty_ , 0 );
  IR_Const_64bit_0_ = ConstantInt::get( int64Ty_ , 0 );

  jit_value_t  IR_Const_pad = ConstantInt::get( int8Ty_, ' ' );
 
  IR_Const_OK_    =  ConstantInt::get( int32Ty_ , ex_expr::EXPR_OK    );
  IR_Const_TRUE_  =  ConstantInt::get( int32Ty_ , ex_expr::EXPR_TRUE  );
  IR_Const_FALSE_ =  ConstantInt::get( int32Ty_ , ex_expr::EXPR_FALSE );
  IR_Const_ERR_   =  ConstantInt::get( int32Ty_ , ex_expr::EXPR_ERROR );

  pGlobTab_Val_  =  NamedValues[ "pGlobTab"  ] ;
  atp1_Val_      =  NamedValues[ "atp1"      ] ;
  atp2_Val_      =  NamedValues[ "atp2"      ] ;
  ex_expr_p_Val_ =  NamedValues[ "ex_expr_p" ] ;

  // Build the function signature.
  // Create an "expression" function with 4 parameters
  // and which returns an Int32 [Actually it returns an enum exp_return_type ]
  // 
  // NOTE: The 4 parameters (eventually) passed to the function
  // at runtime will be:
  //
  // param[0] = nativeGlobTable* pGlobTab
  // param[1] = atp_struct*      atp1
  // param[2] = atp_struct*      atp2
  // param[3] = ex_expr *        ex_expr_ptr  [Used to get ptrs to
  //                                           Constants and Temps]

  // NOTE: We declare all 4 arguments as (char *) [i.e. int8PtrTy_ ]
  // because otherwise we would have to cast them to Int8Ptr before
  // we use them since the first thing we want to do with them is to
  // add some *byte* offset.  In other words, it is just plain easier
  // to declare them as Int8Ptr, add the byte offset, and then cast
  // them to be the kind of pointer we really want them to be.
  //
  std::vector<Type*> args(4, int1PtrTy_ );  // Lie!  Say they are "void" ptrs
  FunctionType* functype = FunctionType::get( int32Ty_,
                                             args, false);

  // Now that we have the function signature (i.e. functype), we
  // can tell LLVM to create the "function".
  //
  llvm::Function * ExpFn = llvm::Function::Create(functype,
                                            llvm::Function::ExternalLinkage,
                                            "testExpr", TheModule);

  // Give the parameters names!
  std::vector<std::string> Args;
  Args.push_back("pGlobTab");
  Args.push_back("atp1");
  Args.push_back("atp2");
  Args.push_back("ex_expr_p");

  //
  // Loop through the function arguments (the function type built above
  // says there are 4 args) and create entries in the NamedValues
  // array saying that "pGlobTab" has the value that was passed to the
  // first arg and "atp1" has the value passed to the second arg, etc.
  //
  unsigned Idx = 0;
  for(llvm::Function::arg_iterator AI = ExpFn->arg_begin();
      Idx != Args.size(); ++AI, ++Idx)
  {
      AI->setName(Args[Idx]);
      NamedValues[Args[Idx]] = AI;
  }

  // Create a single IR block to hold instructions
  p_IR_block_t  IRBlk = BasicBlock::Create(LLContxt, "entryBlk", ExpFn);

  DPT1( "VV90001: ", VV_VD,
 "Bldr->SetInsertPoint( IRBlk = %p )\n", IRBlk );
  Bldr->SetInsertPoint(IRBlk);

  jit_value_t globTableJitVal = NamedValues[Args[0]];

  // Allocate incoming parameters
  DPT1( "VV90002: ", VV_XD,
        "SIZING jitParams_[] to array of size 4+pCode[0] == %d\n",
                                              4+pCode[0] );

  jitParams_ = (jit_value_t *) new(heap_) jit_value_t[4 + pCode[0]];

  jitParams_[0] = globTableJitVal ;

  // Generate code for getting tupp pointers
  //
  // 1. Get atp pointer (p) passed in
  // 2. Add bytes to get to tuple we care about
  //    off = &(tempAtp->getTupp(atpIndex)) - (tempAtp)
  //    temp1 = param[atp] + off;
  // 3. Dereference pointer to get tupp_descriptor pointer
  //    temp2 = load(temp1);
  // 4. Add bytes to get to dataTuple
  //    off = &(tempTuppDesc.getTupleAddress()

  atp_struct tempAtp;
  tupp tempTupp;
  tupp_descriptor tempTuppDesc;
  ex_expr Ex_Expr;

  for (i=0, j=1; i < (CollIndex)pCode[0]; i++, j+=2)
  {
    Int64 off1 = 0, off2 = 0;

    DPT3( "VV90004: ", VV_XD,
          "INITIALIZING jitParams_[4+i == %d] where j=%d, pCode[0] = %d\n",
                                   4+i,             j,    pCode[0] );

    // First get the atp we care about
    DPT2( "VV90006: ", VV_XD,
          "SETTING t1 to NamedValues[ Args[ 1 + pCode[j] ] ] "
          "where j=%d and pCode[j]=%d\n",   j,  pCode[j] );

    jit_value_t t1 = NamedValues[ Args[ 1 + pCode[j] ] ] ;

    // Now, at runtime, t1 will point to the atp we care about.
    // Well, except that t1 is of type "Pointer to 64-bit Int".

    // So, now we get the tupp descriptor pointer we care about.
    // We do that by first getting a ptr to the tuppArray entry within the atp_struct

    DPT1( "VV90008: ", VV_XD,
          "Passing pCode[j+1] = %d to getTuppForNativeExpr()\n", pCode[j+1] );
    off1 =
      (char*)(&(tempAtp.getTuppForNativeExpr(pCode[j+1]))) - (char*)(&tempAtp);

    DPT0( "VV90010: ", VV_VD,
               "Int8p_t1 = Bldr->CreatePointerCast(t1, int8PtrTy_ )\n");
    jit_value_t Int8p_t1 = Bldr->CreatePointerCast(t1, int8PtrTy_ );

    DPT1( "VV90012: ", VV_VD,
               "V_tuppArr = IR_LoadRelativeWithType( Bldr, Int8p_t1, off1=%ld, int8PtrTy_ )\n", off1 );
    jit_value_t V_tuppArr = IR_LoadRelativeWithType( Bldr, Int8p_t1, off1, int8PtrTy_ );

    off2 = ((char *)&(tempTuppDesc.tupleAddress_)) - (char *)(&tempTuppDesc);
    jit_value_t t3 = IR_LoadRelativeWithType( Bldr, V_tuppArr, off2, int8PtrTy_ );

    DPT2( "VV90013: ", VV_XD,
      "SETTING jitParams_[%d] = rtnval from IR_LoadRelativeWithType(...,V_tuppArr, %ld, ...)\n",
                          4+i,  off2 );
    jitParams_[4+i] = t3;

  }

  //
  // Allocate incoming constant pointer (needed for strings and floats).
  //
  // Do the same for the temps array pointer.  This array is used to store to
  // those temps which usually don't fit within a native container - e.g.
  // strings and bignums.
  //
  Int64 ConstantsOff = ((char *)&(Ex_Expr.constantsArea_)) - (char *)(&Ex_Expr);

  DPT1( "VV90013: ", VV_VD, "SET ConstantsOff to %ld\n", ConstantsOff);

  jit_value_t exprJitVal   = NamedValues[ Args[3] ] ;

  DPT0( "VV90020: ", VV_VD,
 "jitParams_[1] = IR_LoadRelativeWithType( Bldr, exprJitVal, ConstantsOff, int8PtrTy_ )\n" );
  jitParams_[1] = IR_LoadRelativeWithType( Bldr, exprJitVal,
                                           ConstantsOff, int8PtrTy_ );

  Int64 TempsOff = ((char *)&(Ex_Expr.tempsArea_)) - (char *)(&Ex_Expr);

  DPT1( "VV90022: ", VV_VD,
 "jitParams_[2] = IR_LoadRelativeWithType( Bldr, exprJitVal, TempsOff = %ld, int8PtrTy_ )\n", TempsOff);
  jitParams_[2] = IR_LoadRelativeWithType( Bldr, exprJitVal,
                                           TempsOff, int8PtrTy_ );

  // Allocate and initialize opData array for use with CLAUSE_EVAL instructions
  PCodeOperand * opData[(3*ex_clause::MAX_OPERANDS)];
  PCodeOperand** opDataNulls = &(opData[0]);
  PCodeOperand** opDataVals = &(opData[2*ex_clause::MAX_OPERANDS]);
  str_pad((char*)opData, (3*ex_clause::MAX_OPERANDS)*sizeof(PCodeOperand*), 0);

  // Allocate pointers to global defs available at runtime.  Note, if they are
  // not referenced by the pcode graph, these loads will be deleted by the jit.

// ZZZZ FIX THIS when we add support for something that needs 'nullTable'
//         DBG_C("VV90030: Bldr->CreateLoad(pGlobTab_Val_)\n");
//         DBG_C("VV90031: Bldr->CreateExtractValue(Bldr->CreateLoad(pGlobTab_Val_),0)\n");
//  jit_value_t *nullTable = Bldr->CreateExtractValue(Bldr->CreateLoad(pGlobTab_Val_),0);

  // Allocate all Temps that will be needed!   
  // NOTE: We do this *before* we start creating the native instructions
  // because otherwise LLVM's JIT Compiler can end up complaining that
  // some predecessor paths to an IR block allocate the variable while
  // other predecessor paths to the block don't allocate it.

  DPT1( "VV90034: ", VV_XD, "After CanGEN, NExTempsList_->entries()=%d\n",
                                           NExTempsList_->entries() );
  for (  Int32 tli = 0 ; tli < NExTempsList_->entries() ; tli++ )
  {
      NExTempListEntry * tliEntry = (*NExTempsList_)[tli] ;

      PCIT::AddressingMode OprTyp = tliEntry->getOprTyp() ;
      PCodeOperand       * Oper   = tliEntry->getPCOp()   ;
      Int32                Num    = tliEntry->getNum()    ;

      DPT3( "VV90035: ", VV_XD,
     "Oper->allocJitValue( this, Bldr, OprTyp = %d, Len = %d, Num = %d )\n",
                                       (Int32)OprTyp, Oper->getLen(), Num );
      Oper->allocJitValue( this, Bldr, OprTyp, Oper->getLen(), Num ) ;
  }
  delete NExTempsList_ ; // We are done with this, so free it!
  NExTempsList_ = NULL ;

  // NOW CREATE THE NATIVE INSTRUCTIONS

  // Create the list of pcode basic blocks in physical layout order
  BLOCKLIST physBlockList(heap_);

  createPhysList(physBlockList);

  // First create LLVM BasicBlocks objects and keep track of them.
  // We want one LLVM BasicBlock to start each physBlock.
  // Depending on the instructions in the block, additonal BasicBlocks
  // may get created later, but that's all right.  We just need
  // some initial ones so we can generate branches to them when
  // we encounter a PCODE instruction that branches to a physBlock
  //

  NABoolean justGeneratedRET = FALSE;
  NABoolean justHandledUnconditionBranch = FALSE;

  for ( PCBlkIndex=0;
       (PCBlkIndex < physBlockList.entries()) && !getJitFailureSeen();
        PCBlkIndex++ )
  {
      PCodeBlock* PCBlk = physBlockList[PCBlkIndex];

      p_IR_block_t * IR_Blk_Label = PCBlk->getJitBlkLbl();

      * IR_Blk_Label = BasicBlock::Create( LLContxt, "physBlk"  );

      DPT2( "VV90040: ", VV_XD,
            "In First Loop: Created BB AT ( %p ) for PCBlk = %p\n",
                                            *IR_Blk_Label,   PCBlk );

      if ( * IR_Blk_Label == IR_block_undefined )
         setJitFailureSeen();
  }

  // Branch from the initial IR block to the first IR block with a label.
  // Note: The 'SetInsertPoint' will be done the first time through the
  // following loop ... after the IR block gets push_back() called on it.

  DPT1( "VV90050: ", VV_XD,
 "Bldr->CreateBr( *(physBlockList[0]->getJitBlkLbl()) = %p )\n", *(physBlockList[0]->getJitBlkLbl()) );
  Bldr->CreateBr( *(physBlockList[0]->getJitBlkLbl()) );

  // Loop through each pcode block, generating instructions on a per block basis.
  // We stop immediately if a failure was seen during code gen.

  DPT1( "VV90052: ", VV_XD,
      "Starting loop creating one BLOCK at a time, with BLK COUNT=%d\n",
                                                     physBlockList.entries() );
  DPT1( "VV90054: ", VV_VD, "getJitFailureSeen() == %d \n",
                                                    (int)getJitFailureSeen() );

  for (PCBlkIndex=0;
       (PCBlkIndex < physBlockList.entries()) && !getJitFailureSeen();
       PCBlkIndex++)
  {
    // Must reset these flags for each PCode Block
    justGeneratedRET = FALSE;
    justHandledUnconditionBranch = FALSE;

    DPT0( "VV90056: ", VV_VD, "Top of loop creating one BLOCK at a time\n");

    PCodeBlock* PCBlk = physBlockList[PCBlkIndex];

    if ( *(PCBlk->getJitBlkLbl()) != NULL )
    {
       // Insert the IR block into the function and set the
       // insertion point to start putting instructions
       // into this IR block.
       p_IR_block_t  IR_Blk_Ptr = *( PCBlk->getJitBlkLbl() );

       DPT1( "VV90060: ", VV_VD,
      "ExpFn->getBasicBlockList().push_back( IR_Blk_Ptr= %p )\n", IR_Blk_Ptr );
       ExpFn->getBasicBlockList().push_back( IR_Blk_Ptr );

       DPT1( "VV90062: ", VV_VD,
      "Bldr->SetInsertPoint( IR_Blk_Ptr = %p )\n", IR_Blk_Ptr );
       Bldr->SetInsertPoint( IR_Blk_Ptr );
    }

    FOREACH_INST_IN_BLOCK(PCBlk, PCInst)
    {
      PCI_count++ ;

      DPT0( "VV90100: ", VV_VD,
            "In Main Loop creating one INSTRUCTION at a time\n");
      DPT2( "VV90102: ", VV_XD,
            "In Main Loop: PCInst at %p, PCInst->next = %p \n",
                                 PCInst, PCInst->next );
#if NExprDbgLvl >= VV_VD
      if ( PCInst->next )
         DPT2( "VV90103: ", VV_XD, "In Main Loop: next at %p has opc == %d\n",
                               PCInst->next , (int) PCInst->next->getOpcode());
#endif

      // If a failure occurred, stop translation immediately.
      if (getJitFailureSeen())
      {
        DPT0( "VV90105: ", VV_XD, "getJitFailureSeen() returned FAILURE\n");
        break;
      }

      // Sometimes native code is generated for multiple pcode instructions in
      // one pass, and so "skipped" instructions don't need to be processed.
      if (skipInst > 0)
      {
        DPT0( "VV90107: ", VV_XD,
              "skipInst is > 0 so we are doing a 'continue'\n");
        skipInst--;
        continue;
      }
      //
      // NOTE: The code after the end of the FOREACH_INST_IN_BLOCK loop
      // depends on doing the skipInst check and 'continue' above
      // *BEFORE* changing the value of the variable 'opc'.
      //

      opc = PCInst->getOpcode();

      DPT2( "VV90200: ", VV_I1, "Found opc = %d %s\n", (int) opc, NatExprName(opc) );

      DPT2( "VV90201: ", VV_XD, "PCInst at %p, PCInst->next = %p\n",
                                       PCInst, PCInst->next );
      //
      // LLVM's JIT Compiler gets confused if we generate two RET
      // instructions back-to-back (within the same IR block.)
      // So, here we explicitly *NOT* generate any code for a PCIT::RETURN
      // if the last instruction we generated was a RET instruction.
      //
      if ( opc != PCIT::RETURN )
         justGeneratedRET = FALSE;

      if ( justGeneratedRET == FALSE )
      switch (opc)
      {
        case PCIT::MOVE_MATTR5_MATTR5:
        {
          PCodeOperand *src1,      *res                    ;
          jit_value_t   src1JitVal, resJitVal, vcLenJitVal ;
          jit_type_t    src1IRtype, resIRtype, vcType      ;

          src1 = PCInst->getROps()[0]; 
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_WROp( 0, res );

          if (src1->getVcIndicatorLen() == 2) {
////        vcType = jit_type_ushort;
////        vcLenJitVal = jit_value_create_nint_constant(f, jit_type_int, 2);

            vcType      = int16Ty_ ;
            vcLenJitVal = ConstantInt::get( int16Ty_ , 2 );
            DPT0( "VV91002: ", VV_XD,
               "In case PCIT::MOVE_MATTR5_MATTR5: vcLenJitVal = 2 (16-bit)\n");
          }
          else {
////        vcType = jit_type_uint;
////        vcLenJitVal = jit_value_create_nint_constant(f, jit_type_int, 4);

            vcType      = int32Ty_ ;
            vcLenJitVal = ConstantInt::get( int32Ty_ , 4 );
            DPT0( "VV91003: ", VV_XD,
               "In case PCIT::MOVE_MATTR5_MATTR5: vcLenJitVal = 4 (32-bit)\n");
          }

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), PCBlk);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      resJitVal = res->getJitValue(this, f, res->getJitType(), PCBlk);
          resIRtype = res->getJitType( this );
          resJitVal = res->getJitValue(this, Bldr, resIRtype, PCBlk);

////      jit_insn_store(f, tRes, resJitVal);
////      jit_insn_store(f, tSrc1, src1JitVal);

////      jit_value_t srcLen = jit_insn_load_relative(f, src1JitVal, 0, vcType);
          jit_value_t srcLen = IR_LoadRelativeWithType( Bldr, 
                                                        src1JitVal, 0, vcType );

          DPT2( "VV91010: ", VV_XD, "srcLen      type = %d, num bits = %d\n",
                                    srcLen->getType()->getTypeID(),
                                    srcLen->getType()->getIntegerBitWidth() );
          DPT2( "VV91011: ", VV_XD, "vcLenJitVal type = %d, num bits = %d\n",
                               vcLenJitVal->getType()->getTypeID(),
                               vcLenJitVal->getType()->getIntegerBitWidth() );

////      srcLen = jit_insn_add(f, srcLen, vcLenJitVal);

          DPT0( "VV91014: ", VV_VD,
         "srcLen = Bldr->CreateAdd( srcLen , vcLenJitVal , 'IntAdd' )\n" );
          srcLen = Bldr->CreateAdd( srcLen , vcLenJitVal , "IntAdd" );

////      genUnalignedMemcpy(f, tRes, tSrc1, srcLen);
          DPT0( "VV91016: ", VV_XD,
         "genUnalignedMemcpy( Bldr, resJitVal, src1JitVal, srcLen )\n");
          genUnalignedMemcpy( Bldr, resJitVal, src1JitVal, srcLen );

          break;
        }

        case PCIT::BRANCH:
        {
////      jit_insn_branch(f, PCBlk->getTargetBlock()->getJitLabel());

          p_IR_block_t TgtBlk = *(PCBlk->getTargetBlock()->getJitBlkLbl()) ;

          DPT1( "VV92010: ", VV_VD,
         "Bldr->CreateBr( TgtBlk = %p )\n", TgtBlk );
          Bldr->CreateBr( TgtBlk );
          justHandledUnconditionBranch = TRUE;
          break;
        }

        case PCIT::BRANCH_OR:
        case PCIT::BRANCH_AND:
        {
          PCodeOperand * src1,      * res    ;
          jit_value_t    src1JitVal,  tRes   ;
          p_IR_block_t * IR_Blk_Label = NULL ;

          src1 = PCInst->getROps()[0]; 
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_WROp( 0, res );

          jit_value_t takenJitVal =
            ((opc == PCIT::BRANCH_OR) || (opc == PCIT::BRANCH_OR_CNT))
              ? IR_Const_1_ : IR_Const_0_;

          IR_Blk_Label = PCBlk->getTargetBlock()->getJitBlkLbl();

////      src1JitVal = src1->getJitValue(this, f, jit_type_int, PCBlk);
          src1JitVal = src1->getJitValue(this, Bldr, int32Ty_, PCBlk);

          if (res->isVar() || PCBlk->isOperandLiveInSuccs(res))
////        res->storeJitValue(this, f, jit_type_int, src1JitVal, PCBlk, NULL);
            res->storeJitValue(this, Bldr, int32Ty_, src1JitVal, PCBlk);

////      resJitVal = jit_insn_eq(f, src1JitVal, takenJitVal);
          tRes = jitGenCompare( Bldr, IntCompare_EQ,
                                src1JitVal,   takenJitVal ,
                                IR_Const_1_ , IR_Const_0_  );
////      jit_insn_branch_if(f, resJitVal, jitLabel);
          IR_insn_branch_if_not_zero( Bldr, tRes, IR_Blk_Label );

          break;
        }

        case PCIT::NNB_SPECIAL_NULLS_MBIN32S_MATTR3_MATTR3_IBIN32S_IBIN32S:
        {
          PCodeOperand * src1,      * src2,      * res ;
          jit_value_t    src1JitVal,  src2JitVal       ;
          jit_type_t     src1IRtype,  src2IRtype       ;
          p_IR_block_t * IR_Blk_Label = NULL           ;

////      jit_label_t src1LabelNull = jit_label_undefined;
////      jit_label_t ret1Label = jit_label_undefined;
////      jit_label_t endLabel = jit_label_undefined;
          p_IR_block_t src1LabelNull = BasicBlock::Create( LLContxt, "NNB_SPEC_src1NullBlk" );
          p_IR_block_t ret0Label     = BasicBlock::Create( LLContxt, "NNB_SPEC_ret0Blk" );
          p_IR_block_t endLabel      = BasicBlock::Create( LLContxt, "NNB_SPEC_endBlk" );

          DPT3( "VV93000: ", VV_XD,
                "src1LabelNull = %p, ret0Label = %p, endLabel = %p\n",
                 src1LabelNull,      ret0Label,      endLabel );

////      jitLabel = block->getTargetBlock()->getJitLabel();
          IR_Blk_Label = PCBlk->getTargetBlock()->getJitBlkLbl();

////      src1 = inst->getROps()[0];
          src1 = PCInst->getROps()[0];

////      src2 = inst->getROps()[1];
          src2 = PCInst->getROps()[1];

////      res  = inst->getWOps()[0];
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );
          PRINT_DETAILS_OF_WROp( 0, res  );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

////      jit_insn_branch_if(f, src1JitVal, &src1LabelNull);
          IR_insn_branch_if_not_zero( Bldr, src1JitVal, &src1LabelNull );

////      jit_insn_branch_if(f, src2JitVal, &ret1Label);  <<< RETURNING 1 WAS A BUG
          IR_insn_branch_if_not_zero( Bldr, src2JitVal, &ret0Label );

          // Both are not null - store 0 and take target branch
////      res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
          res->storeJitValue(this, Bldr, int32Ty_, IR_Const_0_, PCBlk);

////      jit_insn_branch(f, jitLabel);
          DPT1( "VV93005: ", VV_VD,
         "Bldr->CreateBr( *IR_Blk_Label = %p )\n", *IR_Blk_Label );
          Bldr->CreateBr( *IR_Blk_Label );

          // src1 is null - what about src2?
////      jit_insn_label(f, &src1LabelNull);

// NOTE: We don't need to "complete the current block" since we just generated
//       an unconditional branch.  In fact, LLVM's JIT Compiler aborts if we do
//       add an additional unconditional branch here.

          DPT1( "VV93020: ", VV_VD,
         "ExpFn->getBasicBlockList().push_back( src1LabelNull = %p )\n", src1LabelNull );
          ExpFn->getBasicBlockList().push_back( src1LabelNull );

          DPT1( "VV93030: ", VV_VD,
         "Bldr->SetInsertPoint( src1LabelNull = %p )\n", src1LabelNull );
          Bldr->SetInsertPoint( src1LabelNull );

////      jit_insn_branch_if(f, src2JitVal, &ret1Label); <<<< RETURNING 1 WAS A BUG
          IR_insn_branch_if_zero( Bldr, src2JitVal, &ret0Label );

          // src2 is also null, so return 1
////      res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
          res->storeJitValue(this, Bldr, int32Ty_, IR_Const_1_, PCBlk);

////      jit_insn_branch(f, &endLabel);

          DPT1( "VV93040: ", VV_VD,
         "Bldr->CreateBr( endLabel = %p )\n", endLabel );
          Bldr->CreateBr( endLabel );

          // Return 1
////      jit_insn_label(f, &ret1Label);

// NOTE: We don't need to "complete the current block" since we just generated
//       an unconditional branch.  In fact, LLVM's JIT Compiler aborts if we do
//       add an additional unconditional branch here.

          DPT1( "VV93060: ", VV_VD,
         "ExpFn->getBasicBlockList().push_back( ret0Label = %p )\n", ret0Label );
          ExpFn->getBasicBlockList().push_back( ret0Label );

          DPT1( "VV93070: ", VV_VD,
         "Bldr->SetInsertPoint( ret0Label = %p )\n", ret0Label );
          Bldr->SetInsertPoint( ret0Label );

////      res->storeJitValue(this, f, jit_type_int, oneJitVal_, block); <<< THIS WAS A BUG
          res->storeJitValue(this, Bldr, int32Ty_, IR_Const_0_, PCBlk);

          // End label to jump to
////      jit_insn_label(f, &endLabel);

          DPT1( "VV93080: ", VV_VD,
         "Bldr->CreateBr( endLabel = %p )\n", endLabel );
          Bldr->CreateBr( endLabel );  // Must complete the current block

          DPT1( "VV93090: ", VV_VD,
         "ExpFn->getBasicBlockList().push_back( endLabel = %p )\n", endLabel );
          ExpFn->getBasicBlockList().push_back( endLabel );

          DPT1( "VV93098: ", VV_VD,
         "Bldr->SetInsertPoint( endLabel = %p )\n", endLabel );
          Bldr->SetInsertPoint( endLabel );

          break;
        }

        case PCIT::NNB_MATTR3_IBIN32S:
        {
          PCodeOperand * src1                ;
          jit_value_t    src1JitVal          ;
          jit_type_t     src1IRtype          ;
          p_IR_block_t * IR_Blk_Label = NULL ;

          src1 = PCInst->getROps()[0]; 
          PRINT_DETAILS_OF_RDOp( 0, src1 );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), PCBlk);

          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      jitLabel = PCBlk->getTargetBlock()->getJitLabel();
          IR_Blk_Label = PCBlk->getTargetBlock()->getJitBlkLbl() ;

////      jit_insn_branch_if_not(f, src1JitVal, jitLabel);
          IR_insn_branch_if_zero( Bldr, src1JitVal, IR_Blk_Label );

          break;
        }

        case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
        {
          PCodeOperand * src1,      * src2,     * res         ;
          jit_type_t     src1IRtype,  src2IRtype              ;
          jit_value_t    src1JitVal,  src2JitVal, orResJitVal ;
          p_IR_block_t * IR_Blk_Label = NULL                  ;

          src1 = PCInst->getROps()[0]; 
          src2 = PCInst->getROps()[1]; 
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );
          PRINT_DETAILS_OF_WROp( 0, res );

          NABoolean forComp = (opc ==
            PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S);

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

////      orRes = jit_insn_or(f, src1JitVal, src2JitVal);

          Int32 src1Width = src1IRtype->getIntegerBitWidth();
          Int32 src2Width = src2IRtype->getIntegerBitWidth();
          if ( src1Width < src2Width )
          {
             DPT2( "VV94102: ", VV_VD,
                   "src1Width=%d < src2Width=%d\n", src1Width, src2Width);

             DPT0( "VV94103: ", VV_VD,
            "src1JitVal = Bldr->CreateZExt( src1JitVal, (IntegerType *)src2IRtype, 'ZExtArg1' )\n" );
             src1JitVal = Bldr->CreateZExt( src1JitVal,
                               (IntegerType *)src2IRtype, "ZExtArg1" ) ;
          }
          if ( src1Width > src2Width )
          {
             DPT2( "VV94105: ", VV_VD, "src1Width=%d > src2Width=%d\n",
                                        src1Width,     src2Width);
             DPT0( "VV94106: ", VV_VD,
            "src2JitVal = Bldr->CreateZExt( src2JitVal, (IntegerType *)src1IRtype, 'ZExtArg2' )\n" );
             src2JitVal = Bldr->CreateZExt( src2JitVal,
                               (IntegerType *)src1IRtype, "ZExtArg2" ) ;
          }

          DPT0( "VV94110: ", VV_VD,
         "orResJitVal = Bldr->CreateOr( src1JitVal, src2JitVal, 'BitwiseOr' )\n" );
          orResJitVal = Bldr->CreateOr( src1JitVal, src2JitVal, "BitwiseOr" );

////      jitLabel = block->getTargetBlock()->getJitLabel();
          IR_Blk_Label = PCBlk->getTargetBlock()->getJitBlkLbl() ;

          if (res->isVar() || PCBlk->isOperandLiveInSuccs(res)) {
////        res->storeNullJitValueAndBranch(this, f, orRes, jitLabel,
////                                        forComp, block);
            res->storeNullJitValueAndBranch(this, Bldr, orResJitVal,
                                      *IR_Blk_Label, forComp, PCBlk);
          }
          else {
////        jit_insn_branch_if_not(f, orRes, jitLabel);
            IR_insn_branch_if_zero( Bldr, orResJitVal, IR_Blk_Label );
          }

          break;
        }

        case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_IATTR3_IBIN32S:
        {
          PCodeOperand * src1,      * res    ;
          jit_type_t     src1IRtype          ;
          p_IR_block_t * IR_Blk_Label = NULL ;

          src1 = PCInst->getROps()[0]; 
          res  = PCInst->getWOps()[0];

          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_WROp( 0, res );

          NABoolean forComp =
            (opc == PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S);

//        src1JitVal = src1->getJitValue(this, f, src1->getJitType(), PCBlk);

          src1IRtype =  src1->getJitType( this );

          DPT1( "VV95010: ", VV_XD,
                "In NOT_NULL_BRANCH_MBIN32S... src1's Type ID is %d\n",
                                       (int) src1IRtype->getTypeID() );
#if NExprDbgLvl >= VV_XD
          if ( src1IRtype->isPointerTy() )
             DPT0( "VV95011: ", VV_XD,
                   "In NOT_NULL_BRANCH_MBIN32S ... src1IRtype->isPointerTy()"
                   " returned TRUE.\n" ) ;

          if ( src1IRtype->isPointerTy() )
             DPT1( "VV95012: ", VV_XD,
               "In NOT_NULL_BRANCH_MBIN32S... src1's Contained Type ID is %d\n",
                           (int) src1IRtype->getContainedType(0)->getTypeID() );
#endif

          jit_value_t src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

          DPT1( "VV95014: ", VV_XD,
                       "In NOT_NULL_BRANCH_MBIN32S... Val32's Type ID is %d\n",
                                    (int) src1JitVal->getType()->getTypeID() );

////      jitLabel = PCBlk->getTargetBlock()->getJitLabel();
          IR_Blk_Label = PCBlk->getTargetBlock()->getJitBlkLbl() ;

          if (res->isVar() || PCBlk->isOperandLiveInSuccs(res)) {
//          res->storeNullJitValueAndBranch(this, f, src1JitVal, jitLabel,
//                                          forComp, PCBlk);
            res->storeNullJitValueAndBranch(this, Bldr, src1JitVal, *IR_Blk_Label,
                                            forComp, PCBlk);
          }
          else {
//          jit_insn_branch_if_not(f, src1JitVal, jitLabel);
            IR_insn_branch_if_zero( Bldr, src1JitVal, IR_Blk_Label );
          }

          break;
        }

        case PCIT::FILL_MEM_BYTES_VARIABLE:
        case PCIT::FILL_MEM_BYTES:
        {
          PCodeOperand *res       ;
          jit_value_t   resJitVal ;
          jit_type_t    resIRtype ;

#ifdef NO_FILL_MEM_BYTES
          break;
#endif
          Int32 fillVal, fillLen;

          res = PCInst->getWOps()[0];

#if NExprDbgLvl >= VV_BD
          PRINT_DETAILS_OF_WROp( 0, res );

          if ( res->getStackIndex() == 2 )
          {
             if ( opc == PCIT::FILL_MEM_BYTES )
             {
                DPT0( "VV95101: ", VV_VD,
                      "found PCIT::FILL_MEM_BYTES: WITH stackIndex_ = 2\n" );
             }
             else
             {
                DPT0( "VV95101: ", VV_VD,
                      "found PCIT::FILL_MEM_BYTES_VARIABLE: WITH stackIndex_ = 2\n" );
             }
           }
#endif

          // Also, no need to zero out temporary operands, since we just care
          // about their values being appropriately nulled out.
          if (res->isTemp())
            break;

////      resJitVal = res->getJitValue(this, f, res->getJitType(), PCBlk);
          resIRtype = res->getJitType( this );
          resJitVal = res->getJitValue(this, Bldr, resIRtype, PCBlk);

          if (opc == PCIT::FILL_MEM_BYTES_VARIABLE)
          {
            jit_value_t lenJitVal;

            Int32 vcLen = res->getVcIndicatorLen();
////        jit_type_t vcType = (vcLen == 2) ? jit_type_ushort : jit_type_uint;
            jit_type_t vcType = (vcLen == 2) ? int16Ty_ : int32Ty_ ;

////        lenJitVal = jit_value_create_nint_constant(f, vcType,inst->code[6]);
            lenJitVal = ConstantInt::get( vcType , PCInst->code[6] );
            
            // Write out vc length first
////        jit_insn_store_relative(f, resJitVal, 0, lenJitVal);

            DPT0( "VV95110: ", VV_XD,
           "IR_StoreRelativeWithType( Bldr, lenJitVal, resJitVal, 0, vcType )\n" );
            IR_StoreRelativeWithType( Bldr, lenJitVal, resJitVal, 0, vcType );

            // Move pointer up
////        resJitVal = jit_insn_add_relative(f, resJitVal, vcLen);

            jit_value_t vcLenVal = ConstantInt::get( int64Ty_ , vcLen ) ;

            DPT1( "VV95112: ", VV_VD,
           "resJitVal = Bldr->CreateGEP( resJitVal, %d )\n", vcLen );
            resJitVal = Bldr->CreateGEP( resJitVal, vcLenVal );

            // Reduce fill length to no longer include vc length indicator
            fillLen = PCInst->code[6] - vcLen;
            fillVal = PCInst->code[7];

            DPT2( "VV95130: ", VV_XD,
                  "FILL_MEM_BYTES_VARIABLE: Fill Value=0x%x, Fill Len = %d\n",
                                                    fillVal, fillLen );
          }
          else {
            fillLen = PCInst->code[3];
            fillVal = PCInst->code[4];

            DPT2( "VV95140: ", VV_XD,
                  "FILL_MEM_BYTES: Fill Value=0x%x, Fill Len = %d\n",
                                           fillVal, fillLen );
          }

          // FIXME: If varchar, we currently set the vc length to the max length
          // of the varchar, but does that make sense if the value is NULL?
          // This only gets called when the the varchar is NULL, and so it's
          // length will always be zero, so why write it out?.

////      genUnalignedMemset(f, resJitVal, fillVal, fillLen);
          genUnalignedMemset( Bldr, resJitVal, fillVal, fillLen );

          break;
        }

        case PCIT::EQ_MBIN32S_MASCII_MASCII:
        case PCIT::NE_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:
        {
          PCodeOperand *src1,      *src2,      *res ;
          jit_value_t   src1JitVal, src2JitVal      ;
          jit_type_t    src1IRtype, src2IRtype      ;

          res  = PCInst->getWOps()[0];
          src1 = PCInst->getROps()[0];
          src2 = PCInst->getROps()[1];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );
          PRINT_DETAILS_OF_WROp( 0, res  );

          p_IR_block_t falseLabel = BasicBlock::Create( LLContxt, "XX_M32_MA_MA_falseBlk" );
          p_IR_block_t trueLabel  = BasicBlock::Create( LLContxt, "XX_M32_MA_MA_trueBlk" );
          p_IR_block_t endLabel   = BasicBlock::Create( LLContxt, "XX_M32_MA_MA_endBlk" );

          DPT0( "VV95150: ", VV_XD, "In Cmp??_MBIN32S_MASCII_MASCII \n" );

          Int32  MaxlenInt32 = src1->getLen() ;
          jit_value_t Maxlen = ConstantInt::get( int32Ty_, MaxlenInt32 );

          enum cmpKind KindOfCmp = ByteCompare_EQ ; 

          switch ( opc )
          {
             case PCIT::EQ_MBIN32S_MASCII_MASCII:
                        { break ; }
             case PCIT::NE_MBIN32S_MASCII_MASCII:
                        { KindOfCmp = ByteCompare_NE ; break ; }
             case PCIT::LT_MBIN32S_MASCII_MASCII:
                        { KindOfCmp = ByteCompare_LT ; break ; }
             case PCIT::LE_MBIN32S_MASCII_MASCII:
                        { KindOfCmp = ByteCompare_LE ; break ; }
             case PCIT::GT_MBIN32S_MASCII_MASCII:
                        { KindOfCmp = ByteCompare_GT ; break ; }
             case PCIT::GE_MBIN32S_MASCII_MASCII:
                        { KindOfCmp = ByteCompare_GE ; break ; }
          }
          // For fixed-length strings, do first few bytes "by hand"
          // so that we use src1JitVal's jitValue_ field!  This is
          // important so LLVM will believe the src fields have been
          // accessed.  Otherwise, subsequent PCODE instructions that
          // reference the same operand value may cause LLVM to abort -- thinking
          // that one path through the PCODE instructions fetched the
          // first few bytes while another path did not.
          // NOTE: We put the result of this comparison in IsZero1, but
          // then we ignore it!  What's important is to generate the fetch!
          // 
          // If src1 has non-null jitValue_
          if ( jit_value_t src1CurrJitVal = src1->getCurrJitVal() )
          {
             if ( ( src1CurrJitVal->getType() == int64Ty_ ) &&
                  ( MaxlenInt32 >= 8 ) )
             {
                jit_value_t Maxlen64 = ConstantInt::get( int64Ty_, MaxlenInt32 );

                DPT0( "VV95154: ", VV_VD,
               "src1JitVal = src1->getJitValue( this, Bldr, int64Ty_, PCBlk )\n");
                src1JitVal = src1->getJitValue( this, Bldr, int64Ty_, PCBlk );

                DPT0( "VV95155: ", VV_VD,
               "jit_value_t IsZero1  = Bldr->CreateICmpEQ( src1JitVal, Maxlen64, 'junkCk' )\n" );
                jit_value_t IsZero1  = Bldr->CreateICmpEQ( src1JitVal, Maxlen64, "junkCk" );
             }
             else if ( ( src1CurrJitVal->getType() == int32Ty_ ) &&
                  ( MaxlenInt32 >= 4 ) )
             {
                DPT0( "VV95156: ", VV_VD,
               "src1JitVal = src1->getJitValue( this, Bldr, int32Ty_, PCBlk )\n");
                src1JitVal = src1->getJitValue( this, Bldr, int32Ty_, PCBlk );

                DPT0( "VV95157: ", VV_VD,
               "jit_value_t IsZero1  = Bldr->CreateICmpEQ( src1JitVal, Maxlen, 'junkCk' )\n" );
                jit_value_t IsZero1  = Bldr->CreateICmpEQ( src1JitVal, Maxlen, "junkCk" );
             }
             else if ( ( src1CurrJitVal->getType() == int16Ty_ ) &&
                  ( MaxlenInt32 >= 2 ) )
             {
                jit_value_t Maxlen16 = ConstantInt::get( int16Ty_, MaxlenInt32 );

                DPT0( "VV95158: ", VV_VD,
               "src1JitVal = src1->getJitValue( this, Bldr, int16Ty_, PCBlk )\n");
                src1JitVal = src1->getJitValue( this, Bldr, int16Ty_, PCBlk );

                DPT0( "VV95159: ", VV_VD,
               "jit_value_t IsZero1  = Bldr->CreateICmpEQ( src1JitVal, Maxlen16, 'junkCk' )\n" );
                jit_value_t IsZero1  = Bldr->CreateICmpEQ( src1JitVal, Maxlen16, "junkCk" );
             }
          }

          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

          jit_value_t IsZero = genMemCmpLoop( Bldr
                                            , KindOfCmp
                                            , src1JitVal
                                            , src2JitVal
                                            , Maxlen
                                            ) ;
          DPT2( "VV95160: ", VV_VD,
         "Bldr->CreateCondBr( IsZero, trueLabel = %p, falseLabel = %p )\n", trueLabel, falseLabel );
          Bldr->CreateCondBr( IsZero, trueLabel, falseLabel );

          DPT1( "VV95162: ", VV_VD,
         "ExpFn->getBasicBlockList().push_back( trueLabel = %p )\n", trueLabel );
          ExpFn->getBasicBlockList().push_back( trueLabel );

          DPT1( "VV95164: ", VV_VD,
         "Bldr->SetInsertPoint( trueLabel = %p )\n", trueLabel );
          Bldr->SetInsertPoint( trueLabel );

          res->storeJitValue(this, Bldr, int32Ty_, IR_Const_1_, PCBlk);

          DPT1( "VV95166: ", VV_VD,
         "Bldr->CreateBr( endLabel = %p )\n", endLabel );
          Bldr->CreateBr( endLabel );

          DPT1( "VV95168: ", VV_VD,
         "ExpFn->getBasicBlockList().push_back( falseLabel = %p )\n", falseLabel );
          ExpFn->getBasicBlockList().push_back( falseLabel );

          DPT1( "VV95170: ", VV_VD,
         "Bldr->SetInsertPoint( falseLabel = %p )\n", falseLabel );
          Bldr->SetInsertPoint( falseLabel );

          res->storeJitValue(this, Bldr, int32Ty_, IR_Const_0_, PCBlk);

          DPT1( "VV95172: ", VV_VD,
         "Bldr->CreateBr( endLabel = %p )\n", endLabel );
          Bldr->CreateBr( endLabel );  // Must complete the current block

          DPT1( "VV95174: ", VV_VD,
         "ExpFn->getBasicBlockList().push_back( endLabel = %p )\n", endLabel );
          ExpFn->getBasicBlockList().push_back( endLabel );

          DPT1( "VV95179: ", VV_VD,
         "Bldr->SetInsertPoint( endLabel = %p )\n", endLabel );
          Bldr->SetInsertPoint( endLabel );

          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_MBIN16U_MBIN16S:
        case PCIT::EQ_MBIN32S_MBIN64S_MBIN64S:
        {
          PCodeOperand *src1,      *src2,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, resJitVal ;
          jit_type_t    src1IRtype, src2IRtype            ;

          src1 = PCInst->getROps()[0];
          src2 = PCInst->getROps()[1];
          res  = PCInst->getWOps()[0];

          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );
          PRINT_DETAILS_OF_WROp( 0, res  );

#if NExprDbgLvl >= VV_VD
          if (src1 == src2)
             DPT0( "VV96002: ", VV_XD,
                   "In EQ_MBIN32S_MBINxxS_MBINxxS: src1 == src2 !!!\n");
#endif

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), PCBlk);
          src1IRtype = src1->getJitType( this );

          DPT1( "VV96004: ", VV_XD,
                "In EQ_MBIN32S_MBINxxS_MBINxxS: src1IRtype Width = %d\n",
                                      src1IRtype->getIntegerBitWidth() );

          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), PCBlk);
          src2IRtype = src2->getJitType( this );

          DPT1( "VV96006: ", VV_XD,
                "In EQ_MBIN32S_MBINxxS_MBINxxS: src2IRtype Width = %d\n",
                                       src2IRtype->getIntegerBitWidth() );

          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

////      resJitVal = jit_insn_eq(f, src1JitVal, src2JitVal);
          if ( opc == PCIT::EQ_MBIN32S_MBIN16S_MBIN32S )
          {
             DPT0( "VV96010: ", VV_VD,
            "src1JitVal = Bldr->CreateSExt(src1JitVal, (IntegerType *)src2IRtype, 'SExt' )\n" );
             src1JitVal = Bldr->CreateSExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "SExt" ) ;
          }
          if ( opc == PCIT::EQ_MBIN32S_MBIN16U_MBIN32U )
          {
             DPT0( "VV96020: ", VV_VD,
            "src1JitVal = Bldr->CreateZExt( src1JitVal, (IntegerType *)src2IRtype, 'ZExt' )\n" );
             src1JitVal = Bldr->CreateZExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "ZExt" ) ;
          }
          resJitVal = jitGenCompare( Bldr, IntCompare_EQ,
                                     src1JitVal,   src2JitVal,
                                     IR_Const_1_ , IR_Const_0_  );

          DPT0( "VV96024: ", VV_XD,
                "In EQ_MBIN32S_MBINxxS_MBINxxS: Returned from jitGenCompare\n");

////      inst->getWOps()[0]->setJitValue(this, f, resJitVal, PCBlk);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);

          DPT0( "VV96026: ", VV_XD,
                "In EQ_MBIN32S_MBINxxS_MBINxxS: Returned from setJitValue\n");
          break;
        }

        case PCIT::LT_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::LT_MBIN32S_MBIN16S_MBIN32S:
        case PCIT::LT_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::LT_MBIN32S_MBIN64S_MBIN64S:
        case PCIT::LT_MBIN32S_MBIN16U_MBIN16U:
        case PCIT::LT_MBIN32S_MBIN16U_MBIN32U:
        case PCIT::LT_MBIN32S_MBIN32U_MBIN32U:
        {
          PCodeOperand *src1,      *src2,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, resJitVal ;
          jit_type_t    src1IRtype, src2IRtype            ;

          src1 = PCInst->getROps()[0];
          src2 = PCInst->getROps()[1];
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );
          PRINT_DETAILS_OF_WROp( 0, res  );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

////      resJitVal = jit_insn_lt(f, src1JitVal, src2JitVal);
          if ( opc == PCIT::LT_MBIN32S_MBIN16S_MBIN32S )
          {
             DPT0( "VV96510: ", VV_VD,
            "src1JitVal = Bldr->CreateSExt( src1JitVal, (IntegerType *)src2IRtype, 'SExt' )\n" );
             src1JitVal = Bldr->CreateSExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "SExt" ) ;
          }
          if ( opc == PCIT::LT_MBIN32S_MBIN16U_MBIN32U )
          {
             DPT0( "VV96520: ", VV_VD,
            "src1JitVal = Bldr->CreateZExt( src1JitVal, (IntegerType *)src2IRtype, 'ZExt' )\n" );
             src1JitVal = Bldr->CreateZExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "ZExt" ) ;
          }

          enum cmpKind KindOfCmp = IntCompare_SLT ; 
          switch (opc)
          {
             case PCIT::LT_MBIN32S_MBIN16U_MBIN16U:
             case PCIT::LT_MBIN32S_MBIN16U_MBIN32U:
             case PCIT::LT_MBIN32S_MBIN32U_MBIN32U:
                  KindOfCmp = IntCompare_ULT ;
                  break;
             default:
                  break;
          }
          resJitVal = jitGenCompare( Bldr, KindOfCmp,
                                     src1JitVal,   src2JitVal,
                                     IR_Const_1_ , IR_Const_0_  );

////      inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);

          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_MBIN64S_MBIN64S:
        {
          PCodeOperand *src1,      *src2,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, resJitVal ;
          jit_type_t    src1IRtype, src2IRtype            ;

          src1 = PCInst->getROps()[0];
          src2 = PCInst->getROps()[1];
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );
          PRINT_DETAILS_OF_WROp( 0, res  );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

////      resJitVal = jit_insn_le(f, src1JitVal, src2JitVal);

          if ( opc == PCIT::LE_MBIN32S_MBIN16S_MBIN32S )
          {
             DPT0( "VV96610: ", VV_VD,
            "src1JitVal = Bldr->CreateSExt( src1JitVal, (IntegerType *)src2IRtype, 'SExt' )\n" );
             src1JitVal = Bldr->CreateSExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "SExt" ) ;
          }
          if ( opc == PCIT::LE_MBIN32S_MBIN16U_MBIN32U )
          {
             DPT0( "VV96620: ", VV_VD,
            "src1JitVal = Bldr->CreateZExt( src1JitVal, (IntegerType *)src2IRtype, 'ZExt' )\n" );
             src1JitVal = Bldr->CreateZExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "ZExt" ) ;
          }

          enum cmpKind KindOfCmp = IntCompare_SLE ; 
          switch (opc)
          {
             case PCIT::LE_MBIN32S_MBIN16U_MBIN16U:
             case PCIT::LE_MBIN32S_MBIN16U_MBIN32U:
             case PCIT::LE_MBIN32S_MBIN32U_MBIN32U:
                  KindOfCmp = IntCompare_ULE ;
                  break;
             default:
                  break;
          }
          resJitVal = jitGenCompare( Bldr, KindOfCmp,
                                     src1JitVal,   src2JitVal,
                                     IR_Const_1_ , IR_Const_0_  );

////      inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);

          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_MBIN64S_MBIN64S:
        {
          PCodeOperand *src1,      *src2,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, resJitVal ;
          jit_type_t    src1IRtype, src2IRtype            ;

          src1 = PCInst->getROps()[0];
          src2 = PCInst->getROps()[1];
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );
          PRINT_DETAILS_OF_WROp( 0, res  );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

////      resJitVal = jit_insn_gt(f, src1JitVal, src2JitVal);
          if ( opc == PCIT::GT_MBIN32S_MBIN16S_MBIN32S )
          {
             DPT0( "VV96710: ", VV_VD,
            "src1JitVal = Bldr->CreateSExt( src1JitVal, (IntegerType *)src2IRtype, 'SExt' )\n" );
             src1JitVal = Bldr->CreateSExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "SExt" ) ;
          }
          if ( opc == PCIT::GT_MBIN32S_MBIN16U_MBIN32U )
          {
             DPT0( "VV96720: ", VV_VD,
            "src1JitVal = Bldr->CreateZExt( src1JitVal, (IntegerType *)src2IRtype, 'ZExt' )\n" );
             src1JitVal = Bldr->CreateZExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "ZExt" ) ;
          }

          enum cmpKind KindOfCmp = IntCompare_SGT ; 
          switch (opc)
          {
             case PCIT::GT_MBIN32S_MBIN16U_MBIN16U:
             case PCIT::GT_MBIN32S_MBIN16U_MBIN32U:
             case PCIT::GT_MBIN32S_MBIN32U_MBIN32U:
                  KindOfCmp = IntCompare_UGT ;
                  break;
             default:
                  break;
          }
          resJitVal = jitGenCompare( Bldr, KindOfCmp,
                                     src1JitVal,   src2JitVal,
                                     IR_Const_1_ , IR_Const_0_  );

////      inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);

          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_MBIN64S_MBIN64S:
        {
          PCodeOperand *src1,      *src2,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, resJitVal ;
          jit_type_t    src1IRtype, src2IRtype            ;

          src1 = PCInst->getROps()[0];
          src2 = PCInst->getROps()[1];
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );
          PRINT_DETAILS_OF_WROp( 0, res  );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

////      resJitVal = jit_insn_ge(f, src1JitVal, src2JitVal);
          if ( opc == PCIT::GE_MBIN32S_MBIN16S_MBIN32S )
          {
             DPT0( "VV96810: ", VV_VD,
            "src1JitVal = Bldr->CreateSExt( src1JitVal, (IntegerType *)src2IRtype, 'SExt' )\n" );
             src1JitVal = Bldr->CreateSExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "SExt" ) ;
          }
          if ( opc == PCIT::GE_MBIN32S_MBIN16U_MBIN32U )
          {
             DPT0( "VV96820: ", VV_VD,
            "src1JitVal = Bldr->CreateZExt( src1JitVal, (IntegerType *)src2IRtype, 'ZExt' )\n" );
             src1JitVal = Bldr->CreateZExt( src1JitVal,
                                    (IntegerType *)src2IRtype, "ZExt" ) ;
          }

          enum cmpKind KindOfCmp = IntCompare_SGE ; 
          switch (opc)
          {
             case PCIT::GE_MBIN32S_MBIN16U_MBIN16U:
             case PCIT::GE_MBIN32S_MBIN16U_MBIN32U:
             case PCIT::GE_MBIN32S_MBIN32U_MBIN32U:
                  KindOfCmp = IntCompare_UGE ;
                  break;
             default:
                  break;
          }
          resJitVal = jitGenCompare( Bldr, KindOfCmp,
                                     src1JitVal,   src2JitVal,
                                     IR_Const_1_ , IR_Const_0_  );

////      inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);

          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:
        {
          PCodeOperand *src1,      *src2,      *src3,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, src3JitVal, resJitVal ;
          jit_type_t    src1IRtype, src2IRtype, src3IRtype, resIRtype ;

////      jit_label_t sumLabel = jit_label_undefined;
////      jit_label_t doneLabel = jit_label_undefined;

          p_IR_block_t sumLabel  = BasicBlock::Create( LLContxt, "SUM_MATTR3sumBlk" );
          p_IR_block_t doneLabel = BasicBlock::Create( LLContxt, "SUM_MATTR3doneBlk" );

          DPT2( "VV96902: ", VV_XD, "sumLabel  = %p, doneLabel = %p\n",
                                     sumLabel,       doneLabel );


          // Must do getJitValue(...) calls *before* we do calls to
          // IR_insn_branch_if_[not]_zero().  If we call getJitValue(...)
          // after such a conditional branch and if a subsequent
          // PCODE instruction in the same PC block references the same
          // PCodeOperand, the jitValue_ member variable will be filled in
          // and we would fail to tell LLVM to generate a "load" instruction
          // for the path when we take the conditional branch.
          //
          // Note: LLVM's JIT Compiler is smart enough to rearrange the code
          // as appropriate to avoid actually doing the 'load' instructions
          // when they are not needed.
          //
          res  = PCInst->getWOps()[(PCInst->getWOps()).entries()-1];
          PRINT_DETAILS_OF_WROp(   (PCInst->getWOps()).entries()-1, res );

          src3 = PCInst->getROps()[(PCInst->getROps()).entries()-1];
          PRINT_DETAILS_OF_RDOp(   (PCInst->getROps()).entries()-1, src3 );

////      resJitVal = res->getJitValue(this, f, res->getJitType(), block);
          resIRtype = res->getJitType( this );
          resJitVal = res->getJitValue(this, Bldr, resIRtype, PCBlk);

////      src3JitVal = src3->getJitValue(this, f, src3->getJitType(), block);
          src3IRtype = src3->getJitType( this );
          src3JitVal = src3->getJitValue(this, Bldr, src3IRtype, PCBlk);

          // NOW, First check if src is null - if so, we just branch out and return.
          src2 = PCInst->getROps()[1];
          PRINT_DETAILS_OF_RDOp( 1, src2 );

          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

          if (!src2->isConst()) {
////        src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
//          For LLVM, do nothing here as we already did this above.

            DPT0( "VV96904: ", VV_XD,
                  "GOT INTO if (!src2->isConst()) section.\n");

////        jit_insn_branch_if(f, src2JitVal, &doneLabel);
            IR_insn_branch_if_not_zero( Bldr, src2JitVal, &doneLabel );
          }
          else {
            // Skip check, since constant will be 0 (assert here to verify).
            DPT0( "VV96906: ", VV_XD,
                  "GOT INTO if (!src2->isConst()) section.\n");
          }


          // Now check if target is null.  If so, we just move the src into tgt.
          src1 = PCInst->getROps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

          //
          // NOTE: MUST sign extend (or truncate) src3JitVal to the size
          // of the number of bits wide that resIRtype specifies.
          // FURTHERMORE, this MUST be done *BEFORE* we test src3JitVal
          // for zero and do any branching.  If we don't, the LLVM JIT
          // Compiler will abort with an assert indicating
          // "Can't find reaching def for virtreg".
          // Hitting that assert indicates that there are two or more paths
          // to an LLVM BasicBlock where not all of the paths have the
          // defined a temp variable (or not defined it in the same way).
          // In this particular case, src3JitVal could have two different
          // definitions (different bit widths) when we got to "sumLabel".
          //
          Int32 src1Width = src1IRtype->getIntegerBitWidth();
          Int32 src3Width = src3IRtype->getIntegerBitWidth();
          Int32 resWidth  =  resIRtype->getIntegerBitWidth();

          DPT3( "VV96910: ", VV_XD, "resWidth=%d, src1Width=%d, src3Width=%d\n",
                                     resWidth,    src1Width,    src3Width );
          if ( src3Width != resWidth )
          {
             DPT0( "VV96915: ", VV_VD,
            "src3JitVal = Bldr->CreateSExtOrTrunc( src3JitVal, (IntegerType *)resIRtype, 'SExtOrTr' )\n" );
             src3JitVal = Bldr->CreateSExtOrTrunc( src3JitVal,
                                           (IntegerType *)resIRtype, "SExtOrTr" ) ;
          }

          // If src1 indicates tgt is not null, take branch to sumLabel
////      jit_insn_branch_if_not(f, src1JitVal, &sumLabel);
          IR_insn_branch_if_zero( Bldr, src1JitVal, &sumLabel );


          // At this point, we know the tgt is null.  So, we set tgt's value to 0
          // and ADD src3's value by simply setting the value of target to src3's
          // value and clearing the null indicator for the tgt.
          // 
////      res->storeJitValue(this, f, res->getJitType(), src3JitVal, block);
          res->storeJitValue(this, Bldr, resIRtype, src3JitVal, PCBlk);

          // Clear null indicator for target (by setting src1's value to 0) & branch to doneLabel
////      src1->storeNullJitValueAndBranch(this, f, zeroJitVal_, &doneLabel,
////                                       FALSE, block);

          jit_value_t            Const_0 = IR_Const_16bit_0_ ;
          if ( src1Width == 32 ) Const_0 = IR_Const_0_ ;

          src1->storeNullJitValueAndBranch(this, Bldr, Const_0,
                                              doneLabel, FALSE, PCBlk);

          // NOTE: At runtime, the only way to get to sumLabel is by taking
          // the branch (above.)

          // Perform the sum here
////      jit_insn_label(f, &sumLabel);

          DPT1( "VV96920: ", VV_VD,
         "Bldr->CreateBr( sumLabel = %p )\n", sumLabel );
          Bldr->CreateBr( sumLabel );  // Must complete the current block

          DPT1( "VV96922: ", VV_VD,
         "ExpFn->getBasicBlockList().push_back( sumLabel = %p )\n", sumLabel );
          ExpFn->getBasicBlockList().push_back( sumLabel );

          DPT1( "VV96924: ", VV_VD,
         "Bldr->SetInsertPoint( sumLabel = %p )\n", sumLabel );
          Bldr->SetInsertPoint( sumLabel );

////      resJitVal = jit_insn_add(f, resJitVal, src3JitVal);

          DPT0( "VV96927: ", VV_VD,
         "resJitVal = Bldr->CreateAdd( resJitVal, src3JitVal, 'IntAdd' )\n" );
          resJitVal = Bldr->CreateAdd( resJitVal, src3JitVal, "IntAdd" );

////      res->setJitValue(this, f, resJitVal, block);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);

////      jit_insn_label(f, &doneLabel);

          DPT1( "VV96930: ", VV_VD,
         "Bldr->CreateBr( doneLabel = %p )\n", doneLabel );
          Bldr->CreateBr( doneLabel );  // Must complete the current block

          DPT1( "VV96932: ", VV_VD,
         "ExpFn->getBasicBlockList().push_back( doneLabel = %p )\n", doneLabel );
          ExpFn->getBasicBlockList().push_back( doneLabel );

          DPT1( "VV96934: ", VV_VD,
         "Bldr->SetInsertPoint( doneLabel = %p )\n", doneLabel );
          Bldr->SetInsertPoint( doneLabel );

          // Lastly, clear out jit values for 32-bit source operand if needed.
          if ( resWidth > src3Width )
            src3->clearJitValues(this);

          break;
        }

        case PCIT::MOVE_MBIN16U_MBIN8:
        case PCIT::MOVE_MBIN32U_MBIN16U:
        case PCIT::MOVE_MBIN32S_MBIN16U:
        case PCIT::MOVE_MBIN64S_MBIN16U:
        case PCIT::MOVE_MBIN64S_MBIN32U:
        {
          PCodeOperand *src1,      *res       ;
          jit_value_t   src1JitVal            ;
          jit_type_t    src1IRtype, resIRtype ;

          src1 = PCInst->getROps()[0];
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_WROp( 0, res );

          src1IRtype = src1->getJitType( this );

//        src1JitVal = src1->getJitValue(this, f, src1->getJitType(), PCBlk);
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);
//        src1JitVal = jit_insn_convert(f, src1JitVal, res->getJitType(), 0);

          resIRtype =  res->getJitType( this );

          // NOTE: We always Zero Extend because the src1 operand is UNSIGNED

          DPT0( "VV97010: ", VV_VD,
         "src1JitVal = Bldr->CreateZExt( src1JitVal, (IntegerType *)resIRtype, 'ZExt' )\n" );
          src1JitVal = Bldr->CreateZExt( src1JitVal,
                                        (IntegerType *)resIRtype, "ZExt" ) ;

//        res->storeJitValue(this, f, res->getJitType(), src1JitVal, PCBlk);
          res->storeJitValue(this, Bldr, resIRtype, src1JitVal, PCBlk);

          // Lastly, clear out jit values for 32-bit source operand if needed.
          if ( (opc == PCIT::MOVE_MBIN64S_MBIN16U) ||
               (opc == PCIT::MOVE_MBIN64S_MBIN32U) )
            src1->clearJitValues(this);

          break;
        }

        case PCIT::MOVE_MBIN32U_MBIN16S:
        case PCIT::MOVE_MBIN32S_MBIN16S:
        case PCIT::MOVE_MBIN64S_MBIN16S:
        case PCIT::MOVE_MBIN64S_MBIN32S:
        {
          PCodeOperand *src1,      *res       ;
          jit_value_t   src1JitVal, resJitVal ;
          jit_type_t    src1IRtype, resIRtype ;

          src1 = PCInst->getROps()[0];
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_WROp( 0, res );

          src1IRtype = src1->getJitType( this );

          DPT1( "VV98010: ", VV_XD, "typeID = %d\n",
                                           (int) src1IRtype->getTypeID() );

#if NExprDbgLvl >= VV_XD
          if ( src1IRtype->getTypeID() == Type::IntegerTyID )
             DPT1( "VV98011: ", VV_XD, "Integer Type - Number of bits = %d\n",
                                        src1IRtype->getIntegerBitWidth() );
#endif

//        src1JitVal = src1->getJitValue(this, f, src1->getJitType(), PCBlk);
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

//        src1JitVal = jit_insn_convert(f, src1JitVal, res->getJitType(), 0);

          resIRtype =  res->getJitType( this );

          DPT1( "VV98012: ", VV_XD, "typeID = %d\n",
                                              (int) resIRtype->getTypeID() );

#if NExprDbgLvl >= VV_XD
          if ( resIRtype->getTypeID() == Type::IntegerTyID )
            DPT1( "VV98013: ", VV_XD,"res Integer Type - Number of bits = %d\n",
                                              resIRtype->getIntegerBitWidth() );
#endif

          llvm::IntegerType * IntTyp = IntegerType::get( LLContxt,
                                       resIRtype->getIntegerBitWidth() );

          DPT1( "VV98014: ", VV_XD, "IntTyp - Number of bits = %d\n",
                                             IntTyp->getIntegerBitWidth() );

          // NOTE: We always Sign Extend because the src1 operand is SIGNED

          DPT0( "VV98016: ", VV_VD,
         "resJitVal = Bldr->CreateSExtOrTrunc( src1JitVal, IntTyp, 'SExt' )\n" );
          resJitVal = Bldr->CreateSExtOrTrunc( src1JitVal, IntTyp, "SExt" ) ;

//        res->storeJitValue(this, f, res->getJitType(), resJitVal, PCBlk);
          res->storeJitValue(this, Bldr, resIRtype, resJitVal, PCBlk);

          // Lastly, clear out jit values for 32-bit source operand if needed.
          if ( (opc == PCIT::MOVE_MBIN64S_MBIN16S) ||
               (opc == PCIT::MOVE_MBIN64S_MBIN32S) )
            src1->clearJitValues(this);

          break;
        }

        case PCIT::MOVE_MBIN16U_IBIN16U:
        case PCIT::MOVE_MBIN32S_IBIN32S:
        {
          PCodeOperand *res        ;
          jit_value_t   src1JitVal ;
          jit_type_t    resIRtype  ;

          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_WROp( 0, res );

//        type = (opc == PCIT::MOVE_MBIN32S_IBIN32S) ? jit_type_int : jit_type_ushort;
          resIRtype = (opc == PCIT::MOVE_MBIN32S_IBIN32S) ? int32Ty_ : int16Ty_;

          Int32 val = PCInst->code[3];

//        src1JitVal = jit_value_create_nint_constant(f, type, val);
//        res->storeJitValue(this, f, type, src1JitVal, PCBlk);

          src1JitVal = ConstantInt::get( resIRtype, val );

          DPT1( "VV99010: ", VV_VD,
         "res->storeJitValue(this, Bldr, resIRtype, src1JitVal=Const of %d, PCBlk)\n", val);
          res->storeJitValue(this, Bldr, resIRtype, src1JitVal, PCBlk);

          break;  
        }

        case PCIT::MOVE_MBIN16U_MBIN16U:
        case PCIT::MOVE_MBIN8_MBIN8:
        case PCIT::MOVE_MBIN8_MBIN8_IBIN32S:
        case PCIT::MOVE_MBIN32U_MBIN32U:
        case PCIT::MOVE_MBIN64S_MBIN64S:
        {
          PCodeOperand *src1,      *res       ;
          jit_value_t   src1JitVal, resJitVal ;
          jit_type_t    src1IRtype            ;

          src1 = PCInst->getROps()[0];
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_WROp( 0, res );

          src1IRtype =  src1->getJitType( this );

          DPT1( "VV9A011: ", VV_XD, "For src1, src1IRtype->getTypeID() == %d\n",
                                               src1IRtype->getTypeID() );

#if NExprDbgLvl >= VV_XD
          if ( src1IRtype->getTypeID()==Type::IntegerTyID )
             DPT1( "VV9A015: ", VV_XD, "BitWidth=%d\n",
                                            src1IRtype->getIntegerBitWidth());
#endif
          if ( src1IRtype == int8PtrTy_ )
              assert (opc == PCIT::MOVE_MBIN8_MBIN8_IBIN32S);

#if NExprDbgLvl >= VV_BD
          if (opc == PCIT::MOVE_MBIN8_MBIN8_IBIN32S)
          {
            DPT1( "VV9A020: ", VV_XD, "src1->stackIndex_ = %d\n",
                                       src1->getStackIndex() );
            DPT1( "VV9A021: ", VV_XD, "res->stackIndex_  = %d\n",
                                       res->getStackIndex() );
            if ( src1IRtype->isPointerTy() )
              DPT1( "VV9A022: ", VV_XD,
                    "src1IRtype->getContainedType(0)->getTypeID() = %d\n",
                           src1IRtype->getContainedType(0)->getTypeID() );
          }
#endif

          DPT0( "VV9A026: ", VV_VD,
         "src1JitVal = src1->getJitValue( this, Bldr, src1IRtype, PCBlk )\n");

          src1JitVal = src1->getJitValue( this, Bldr, src1IRtype, PCBlk );

          DPT1( "VV9A027: ", VV_XD,"src1JitVal->getType()->getTypeID() == %d\n",
                                           src1JitVal->getType()->getTypeID() );
#if NExprDbgLvl >= VV_BD
          if ( src1JitVal->getType()->isPointerTy() )
            DPT1( "VV9A027A: ", VV_XD, "src1JitVal IS PointerType -> %d\n",
                      src1JitVal->getType()->getContainedType(0)->getTypeID() );

          if ( src1JitVal->getType()->getTypeID() == Type::IntegerTyID )
            DPT1( "VV9A027B: ", VV_XD, "src1JitVal IS Int Type. BitWidth = %d\n",
                                  src1JitVal->getType()->getIntegerBitWidth() );
#endif

          DPT2( "VV9A027D: ", VV_XD,
                "src1IRtype is at %p, src1JitVal->getType() is at %p\n",
                          src1IRtype, src1JitVal->getType() );

          DPT1( "VV9A028: ", VV_XD, "src1JitVal is at %p\n", src1JitVal );

          DPT0( "VV9A030: ", VV_VD,
         "res->storeJitValue(this, Bldr, src1IRtype, src1JitVal, PCBlk)\n" );

          res->storeJitValue(this, Bldr, src1IRtype, src1JitVal, PCBlk);

          break;
        }

        case PCIT::NULL_TEST_MBIN32S_MATTR5_IBIN32S_IBIN32S:
        {
          PCodeOperand *src1,      *res       ;
          jit_value_t   src1JitVal, resJitVal ;
          jit_type_t    src1IRtype            ;

          src1 = PCInst->getROps()[0];
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_WROp( 0, res );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

          NABoolean testForNull = (PCInst->code[9] != 0);

          // Generate more efficient code if next instruction is logical branch
          if (PCInst->next && PCInst->next->isAnyLogicalBranch())
          {
            NABoolean srcLive, tgtLive;

            PCodeInst* branch = PCInst->next;

            PCodeOperand* bSrc = branch->getROps()[0];
            PCodeOperand* bTgt = branch->getWOps()[0];

            // Is source or target live after branch?
            srcLive = bSrc->isVar() || PCBlk->isOperandLiveInSuccs(bSrc);
            tgtLive = bTgt->isVar() || PCBlk->isOperandLiveInSuccs(bTgt);

            // Only generate efficient path if the null-test is associated with
            // the branch, and that both the src and tgt of the branch are not
            // live (which would otherwise require one or more stores).
            if ((bSrc->getBvIndex()==res->getBvIndex()) && !srcLive && !tgtLive)
            {
////          jitLabel = PCBlk->getTargetBlock()->getJitLabel();
              p_IR_block_t * IR_Blk_Label =
                                       PCBlk->getTargetBlock()->getJitBlkLbl();

              // Branch to destination according to the test performed.
              switch (branch->getOpcode()) {
                case PCIT::BRANCH_OR:
                case PCIT::BRANCH_OR_CNT:
                  if (testForNull)
////                jit_insn_branch_if(f, src1JitVal, jitLabel);
                    IR_insn_branch_if_not_zero( Bldr, src1JitVal, IR_Blk_Label );
                  else
////                jit_insn_branch_if_not(f, src1JitVal, jitLabel);
                    IR_insn_branch_if_zero(Bldr, src1JitVal, IR_Blk_Label);
                  break;

                case PCIT::BRANCH_AND:
                case PCIT::BRANCH_AND_CNT:
                  if (testForNull)
////                jit_insn_branch_if_not(f, src1JitVal, jitLabel);
                    IR_insn_branch_if_zero(Bldr, src1JitVal, IR_Blk_Label);
                  else
////                jit_insn_branch_if(f, src1JitVal, jitLabel);
                    IR_insn_branch_if_not_zero( Bldr, src1JitVal, IR_Blk_Label );
                  break;
              }

              // Skip the next instruction (branch) since it was handled here.
              skipInst = 1;
              break;
            }
          }
          else if (PCInst->next && PCInst->next->getOpcode() == PCIT::MOVE_MBIN32S)
          {
            PCodeInst* move = PCInst->next;
            if (res->getBvIndex() == move->getROps()[0]->getBvIndex())
            {
////          jit_label_t l1 = jit_label_undefined;

              // A RETURN is guaranteed to following a MOVE_MBIN32S
              assert (move->next && (move->next->getOpcode() == PCIT::RETURN));

              enum cmpKind       KindOfCmp = IntCompare_EQ ; 
              if ( testForNull ) KindOfCmp = IntCompare_NE ; 

              jit_value_t  Zero = ConstantInt::get( src1JitVal->getType(), 0 );
              resJitVal = jitGenCompare( Bldr, KindOfCmp,
                                         src1JitVal,   Zero ,
                                         IR_Const_TRUE_, IR_Const_FALSE_ );

              DPT0( "VV9A360: ", VV_VD, "returned from jitGenCompare()\n");

              DPT0( "VV9A361: ", VV_VD,
             "Bldr->CreateRet( resJitVal )\n" );
              Bldr->CreateRet( resJitVal );

              justGeneratedRET = TRUE;

////          if (testForNull)
////            jit_insn_branch_if(f, src1JitVal, &l1);
////          else
////            jit_insn_branch_if_not(f, src1JitVal, &l1);

////          jit_insn_return(f, fJitVal_);

////          jit_insn_label(f, &l1);
////          jit_insn_return(f, tJitVal_);

              // Skip the next 2 instructions since it was handled here.
              skipInst = 2;
              break;
            }
          }
          
          // Fall-through (default) case to implement NULL_TEST

////      if (testForNull)
////        resJitVal = jit_insn_ne(f, src1JitVal, zeroJitVal_);
////      else
////        resJitVal = jit_insn_eq(f, src1JitVal, zeroJitVal_);

            enum cmpKind       KindOfCmp = IntCompare_EQ ; 
            if ( testForNull ) KindOfCmp = IntCompare_NE ; 

            jit_value_t  Zero = ConstantInt::get( src1JitVal->getType(), 0 );
            resJitVal = jitGenCompare( Bldr , KindOfCmp ,
                                       src1JitVal  , Zero ,
                                       IR_Const_1_ , IR_Const_0_  );

          DPT0( "VV9A380: ", VV_VD, "returned from jitGenCompare()\n");

////      inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);
          res->setJitValue( this, Bldr, resJitVal, PCBlk);

          break;
        }

        case PCIT::MINMAX_MBIN8_MBIN8_MBIN32S_IBIN32S:
        {
          PCodeOperand *src1,      *src2,      *res ;
          jit_value_t   src1JitVal, src2JitVal      ;
          jit_type_t    src1IRtype                  ;

////      jit_type_t type;
////      jit_label_t doneLabel = jit_label_undefined;

          p_IR_block_t doneLabel = BasicBlock::Create( LLContxt, "MinMaxDoneBlk" );

          DPT1( "VV9A501: ", VV_XD, "doneLabel = %p\n", doneLabel );

          src1 = PCInst->getROps()[0]; // Source pointer
          src2 = PCInst->getROps()[1]; // Result of comparison
          res  = PCInst->getWOps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );
          PRINT_DETAILS_OF_WROp( 0, res );

////      src2JitVal = src2->getJitValue(this, f, jit_type_int, block);
          src2JitVal = src2->getJitValue(this, Bldr, int32Ty_, PCBlk);

          // Get type associated with length, since generic MBINS is used to
          // represent source/tgt.  If not, getJitType() is called, and it will
          // assume we're dealing with a void ptr by default.

          switch(src1->getLen()) {
            case 1:
////          type = jit_type_ubyte;
              src1IRtype = int8Ty_;
              break;
            case 2:
////          type = jit_type_ushort;
              src1IRtype = int16Ty_;
              break;
            case 4:
////          type = jit_type_uint;
              src1IRtype = int32Ty_;
              break;
            case 8:
////          type = jit_type_long;
              src1IRtype = int64Ty_;
              break;
            default:
            {
////          type = jit_type_void_ptr;
              src1IRtype = int1PtrTy_;
              break;
            }
          }

////      src1JitVal = src1->getJitValue(this, f, type, block);
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      jit_insn_branch_if_not(f, src2JitVal, &doneLabel);
          IR_insn_branch_if_zero( Bldr, src2JitVal, &doneLabel );


////      res->setJitValue(this, f, src1JitVal, block);
          res->setJitValue( this, Bldr, src1JitVal, PCBlk );

////      jit_insn_label(f, &doneLabel);

          DPT1( "VV9A520: ", VV_VD,
         "Bldr->CreateBr( doneLabel = %p )\n", doneLabel );
          Bldr->CreateBr( doneLabel );  // Must complete the current block

          DPT1( "VV9A522: ", VV_VD,
         "ExpFn->getBasicBlockList().push_back( doneLabel = %p )\n", doneLabel );
          ExpFn->getBasicBlockList().push_back( doneLabel );

          DPT1( "VV9A524: ", VV_VD,
         "Bldr->SetInsertPoint( doneLabel = %p )\n", doneLabel );
          Bldr->SetInsertPoint( doneLabel );

          break;
        }

        case PCIT::OPDATA_MPTR32_IBIN32S:
        case PCIT::OPDATA_MPTR32_IBIN32S_IBIN32S:
        case PCIT::OPDATA_MBIN16U_IBIN32S:
        case PCIT::OPDATA_MATTR5_IBIN32S:
        {
          OPLIST opList = (PCInst->getWOps().entries() ?
                           PCInst->getWOps() : PCInst->getROps() );

          DPT1( "VV9B001: ", VV_XD, "In OPDATA_*, using %s operands!\n",
                               PCInst->getWOps().entries() ? "WRITE": "READ" );

#if NExprDbgLvl >= VV_BD
          for (Int32 iii = 0; iii < opList.entries(); iii++ )
          {
            DPT2( "VV9B002: ", VV_XD,
                  "In OPDATA_*, opList[%d] = %p\n", iii, opList[iii] );

            DPT1( "VV9B002a: ", VV_XD,
                  "Details of opList[%d] *BEFORE setupClauseOperand*  are:\n",
                                     iii );
            PCodeOperand *PCOp = opList[iii];
            if (!PCOp) continue;

            DPT6( "VV9B002b: ", VV_XD,
           "stackIndex_ = %d, offset_ = %d, len_=%d, operandType_=%d, nullBitIdx=%d, CJV=%p\n",
            PCOp->getStackIndex(), PCOp->getOffset(), PCOp->getLen(),
            PCOp->getType(), PCOp->getNullBitIndex(), PCOp->getCurrJitVal() );
 }
#endif

          Int32 index =
            (opc == PCIT::OPDATA_MPTR32_IBIN32S_IBIN32S) ?
                    PCInst->code[4] : ( (opc == PCIT::OPDATA_MATTR5_IBIN32S) ?
                    PCInst->code[6] : PCInst->code[3] );

          DPT1( "VV9B003: ", VV_XD, "OPDATA_* - index = %d\n", index );

#if NExprDbgLvl >= VV_BD
          for ( Int32 jjj = 0; (jjj <= index) && (jjj < opList.entries()); jjj++)
          {
            DPT2( "VV9B004: ", VV_XD, "OPDATA_* BEFORE opData[%d] = %p\n", jjj, opData[jjj]);
            if ( opData[jjj] )
            {
              DPT1( "VV9B005: ", VV_XD,
                    "Details of opData[%d] *BEFORE setupClauseOperand* are:\n",
                                       jjj );

              PCodeOperand *PCOp = opData[jjj];

              DPT6( "VV9B006: ", VV_XD,
             "stackIndex_ = %d, offset_ = %d, len_=%d, operandType_=%d, nullBitIdx=%d, CJV=%p\n",
              PCOp->getStackIndex(), PCOp->getOffset(), PCOp->getLen(),
              PCOp->getType(), PCOp->getNullBitIndex(), PCOp->getCurrJitVal() );
            }
          }
#endif
          // Add the "correct" operand for this opdata instruction, replacing
          // the old one in the operand list used during pcode opts.
          setupClauseOperand(this, opList, opData, index, PCInst->clause_);

          //
          // We must ensure Write Operands have space allocated for them
          // *before* we generated any conditional branches.
          // NOTE: It is possible that a case will be found in the future when
          //       we need to have allocJitValue() called *before* the main loop.
          if ( PCInst->getWOps().entries() )
          {
             for ( Int32 nnn = 0; (nnn <= index) && (nnn < opList.entries()); nnn++)
             {
               PCodeOperand * Oper = opData[nnn] ;
               if ( ! Oper ) continue;

               DPT0( "VV9B006a: ", VV_XD,
              "Oper->allocJitValue( this, Bldr, Oper->getType(), Oper->getLen(), 1 )\n" );
               Oper->allocJitValue( this, Bldr, Oper->getType(), Oper->getLen(), 1 ) ;
             }
          }

#if NExprDbgLvl >= VV_BD
          for (Int32 iii = 0; iii < opList.entries(); iii++ )
          {
            DPT2( "VV9B006b: ", VV_XD, "In OPDATA_*, opList[%d] = %p\n",
                                                            iii, opList[iii] );
            DPT1( "VV9B006c: ", VV_XD,
                  "Details of opList[%d] *BEFORE setupClauseOperand*  are:\n",
                                     iii );
            PCodeOperand *PCOp = opList[iii];
            if (!PCOp) continue;

            DPT6( "VV9B006d: ", VV_XD,
           "stackIndex_ = %d, offset_ = %d, len_=%d, operandType_=%d, nullBitIdx=%d, CJV=%p\n",
            PCOp->getStackIndex(), PCOp->getOffset(), PCOp->getLen(),
            PCOp->getType(), PCOp->getNullBitIndex(), PCOp->getCurrJitVal() );
          }

          for ( Int32 mmm = 0; (mmm <= index) && (mmm < opList.entries()); mmm++)
          {
            DPT2( "VV9B007: ", VV_XD, "OPDATA_* AFTER opData[%d] = %p\n",
                                                            mmm, opData[mmm] );
            if ( opData[mmm] )
            {
              DPT1( "VV9B008: ", VV_XD,
                    "Details of opData[%d] *AFTER setupClauseOperand() are:\n",
                                       mmm );

              PCodeOperand *PCOp = opData[mmm];
              if (!PCOp) continue;

              DPT6( "VV9B009: ", VV_XD,
             "stackIndex_ = %d, offset_ = %d, len_=%d, operandType_=%d, nullBitIdx=%d, CJV=%p\n",
              PCOp->getStackIndex(), PCOp->getOffset(), PCOp->getLen(),
              PCOp->getType(), PCOp->getNullBitIndex(), PCOp->getCurrJitVal() );
            }
          }
#endif /* NExprDbgLvl >= VV_BD */

          break;
        }

        case PCIT::CLAUSE_EVAL:
        {
          PCodeOperand *src1,      *src2,       *res       ;
          jit_value_t   src1JitVal, src2JitVal,  resJitVal ;
          jit_type_t    src1IRtype, resIRtype              ;

////      jit_label_t doneLabel = jit_label_undefined;
////      jit_label_t trueLabel = jit_label_undefined;
////      jit_label_t falseLabel = jit_label_undefined;
////      jit_label_t nullLabel = jit_label_undefined;

          p_IR_block_t doneLabel = BasicBlock::Create( LLContxt, "ClauseEvalDoneBlk" );

          DPT1( "VV9B101: ", VV_XD, "doneLabel = %p\n", doneLabel );

          // on 64-bit the clause pointer is in code[1] and code[2]
          ex_clause* clause = (ex_clause*)*(Long*)&(PCInst->code[1]);
          NABoolean processNulls = PCInst->code[1 + PCODEBINARIES_PER_PTR];

#if NExprDbgLvl >= VV_BD
          for (Int32 iii = 0; iii < 3; iii++ )
          {
            DPT2( "VV9B103: ", VV_XD, "In CLAUSE_EVAL opDataNulls[%d] = %p\n",
                                                      iii, opDataNulls[iii] );
            if ( opDataNulls[iii] )
            {
              DPT1( "VV9B104: ", VV_XD,
             "Details of opDataNulls[%d] *AT Start OF CLAUSE_EVAL*  are:\n", iii );

              PCodeOperand *PCOp = opDataNulls[iii];

              DPT6( "VV9B105: ", VV_XD,
             "stackIndex_ = %d, offset_ = %d, len_=%d, operandType_=%d, nullBitIdx=%d, CJV=%p\n",
              PCOp->getStackIndex(), PCOp->getOffset(), PCOp->getLen(),
              PCOp->getType(), PCOp->getNullBitIndex(), PCOp->getCurrJitVal() );
            }
          }

          for (Int32 jjj = 0; jjj < 3; jjj++ )
          {
            DPT2( "VV9B110: ", VV_XD, "In CLAUSE_EVAL opDataVals[%d] = %p\n",
                                                      jjj, opDataVals[jjj] );
            if ( opDataVals[jjj] )
            {
              DPT1( "VV9B114: ", VV_XD,
           "Details of opDataVals[%d] *AT Start OF CLAUSE_EVAL*  are:\n", jjj );

              PCodeOperand *PCOp = opDataVals[jjj];

              DPT6( "VV9B115: ", VV_XD,
             "stackIndex_ = %d, offset_ = %d, len_=%d, operandType_=%d, nullBitIdx=%d, CJV=%p\n",
              PCOp->getStackIndex(), PCOp->getOffset(), PCOp->getLen(),
              PCOp->getType(), PCOp->getNullBitIndex(), PCOp->getCurrJitVal() );
           }
         }
#endif /* NExprDbgLvl >= VV_BD */

          switch (clause->getClassID()) {
            case ex_clause::AGGR_MIN_MAX_ID:
            {
              DPT0( "VV9B120: ", VV_VD,
                    "CLAUSE_EVAL - found ClassID = AGGR_MIN_MAX_ID \n");
              //
              // Format:
              //
              // attr[0] - Aggregate
              // attr[1] - Column
              // attr[2] - Comparison result
              //

              // First branch away if comp result indicates no update needed. 
              // Note, since this check is always made, the jit value from the
              // null-check can be used outside of the CLAUSE_EVAL.
              src2 = opDataVals[2];
////          src2JitVal = src2->getJitValue(this, f, jit_type_int, block);
              src2JitVal = src2->getJitValue(this, Bldr, int32Ty_ , PCBlk);

////          jit_insn_branch_if_not(f, src2JitVal, &doneLabel);
              IR_insn_branch_if_zero( Bldr, src2JitVal, &doneLabel );

              // We need to copy over source into aggregate.  First take care of
              // the null indicator if the aggregate is nullable.
              if (clause->getOperand(0)->getNullFlag()) {
                // If column is nullable too, then we need to check it.  If it's
                // NULL, we don't do anything.

                if (clause->getOperand(1)->getNullFlag()) {
                  src1 = opDataNulls[1];

////              src1JitVal =
////                src1->getJitValue(this, f, src1->getJitType(), block,
////                                  NULL, TRUE /* no assign jit val */);

                  src1IRtype = src1->getJitType( this );
                  src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk,
                                                 NULL, TRUE /* no assign */);

////              jit_insn_branch_if(f, src1JitVal, &doneLabel);
                  IR_insn_branch_if_not_zero( Bldr, src1JitVal, &doneLabel );
                }

                // Null out the null indicator for the aggregate.  Based on the
                // current code, the null indicator for the aggregate is always
                // in exploded format, so assert that here and then simplify
                // code generation.
                assert(!opDataNulls[0]->forAlignedFormat());

////            opDataNulls[0]->setJitValue(this, f, zeroJitVal16, block, TRUE);
                opDataNulls[0]->setJitValue( this, Bldr, IR_Const_16bit_0_,
                                             PCBlk, TRUE);
              }

              // Now we have to handle moving the data over from column to aggr.
              res = opDataVals[0];
              src1 = opDataVals[1];

////          src1JitVal = src1->getJitValue(this, f, src1->getJitType(),
////                                         block, NULL, TRUE /* no assign */);
              src1IRtype = src1->getJitType( this );
              src1JitVal = src1->getJitValue( this, Bldr, src1IRtype, PCBlk,
                                              NULL, TRUE /* no assign */);

              if (res->isVarchar())
              {
                // The following code was taken from MOVE_MATTR5_MATTR5, but
                // re-formatted here.
                jit_type_t vcType;
                jit_value_t vcLenJitVal;

                if (src1->getVcIndicatorLen() == 2) {
////              vcType = jit_type_ushort;
                  vcType = int16Ty_ ;

////              vcLenJitVal=jit_value_create_nint_constant(f, jit_type_int,2);
                  vcLenJitVal = ConstantInt::get( int32Ty_, 2 );
                }
                else {
////              vcType = jit_type_uint;
                  vcType = int32Ty_ ;

////              vcLenJitVal=jit_value_create_nint_constant(f, jit_type_int,4);
                  vcLenJitVal = ConstantInt::get( int32Ty_, 4 );
                }

////            resJitVal = res->getJitValue(this, f, res->getJitType(), block,
////                                         NULL, TRUE /* no assign */);

                resIRtype = res->getJitType( this );
                resJitVal = res->getJitValue(this, Bldr, resIRtype, PCBlk,
                                             NULL, TRUE /* no assign */);

////            jit_insn_store(f, tRes, resJitVal);
////            jit_insn_store(f, tSrc1, src1JitVal);

////            jit_value_t srcLen =
////              jit_insn_load_relative(f, src1JitVal, 0, vcType);

                jit_value_t srcLen = IR_LoadRelativeWithType( Bldr, 
                                                        src1JitVal, 0, vcType );

////            srcLen = jit_insn_add(f, srcLen, vcLenJitVal);

                DPT0( "VV9B130: ", VV_VD,
               "srcLen = Bldr->CreateAdd( srcLen , vcLenJitVal , 'IntAdd' )\n");
                srcLen = Bldr->CreateAdd( srcLen , vcLenJitVal , "IntAdd" );

////            genUnalignedMemcpy(f, tRes, tSrc1, srcLen);
                genUnalignedMemcpy( Bldr, resJitVal, src1JitVal, srcLen );
              }
              else
              {
////            res->storeJitValue(this, f, res->getJitType(),src1JitVal,
////                               block, NULL, TRUE);
                jit_type_t resIRtype = res->getJitType( this ) ;
                res->storeJitValue(this, Bldr, resIRtype,
                                   src1JitVal, PCBlk, NULL, TRUE );
              }

              // Reached the end point
////          jit_insn_label(f, &doneLabel);

              DPT1( "VV9B134: ", VV_VD,
             "Bldr->CreateBr( doneLabel = %p )\n", doneLabel );
              Bldr->CreateBr( doneLabel );  // Must complete the current block

              DPT1( "VV9B136: ", VV_VD,
             "ExpFn->getBasicBlockList().push_back( doneLabel = %p )\n", doneLabel );
              ExpFn->getBasicBlockList().push_back( doneLabel );

              DPT1( "VV9B138: ", VV_VD,
             "Bldr->SetInsertPoint( doneLabel = %p )\n", doneLabel );
              Bldr->SetInsertPoint( doneLabel );

              break;
            }

            case ex_clause::COMP_TYPE:
            {
              DPT0( "VV9B200: ", VV_VD,
                    "CLAUSE_EVAL - found ClassID = COMP_TYPE \n");

              p_IR_block_t trueLabel  = BasicBlock::Create( LLContxt, "ClauseEvalTrueBlk"  );
              p_IR_block_t falseLabel = BasicBlock::Create( LLContxt, "ClauseEvalFalseBlk" );
              p_IR_block_t nullLabel  = BasicBlock::Create( LLContxt, "ClauseEvalNullBlk" );

              DPT3( "VV9B201: ", VV_VD,
                    "trueLabel = %p, falseLabel = %p, nullLabel = %p\n",
                     trueLabel,      falseLabel,      nullLabel );

              switch (((ex_comp_clause*)clause)->getInstruction()) {
                case NE_DATETIME_DATETIME:
                case EQ_DATETIME_DATETIME:
                case LT_DATETIME_DATETIME:
                case GT_DATETIME_DATETIME:
                case LE_DATETIME_DATETIME:
                case GE_DATETIME_DATETIME:
                {
                  DPT0( "VV9B210: ", VV_VD,
                      "CLAUSE_EVAL - COMP_TYPE - found DATETIME case index\n" );
                  jit_value_t year1, year2;

                  res = opDataVals[0];
                  src1 = opDataVals[1];
                  src2 = opDataVals[2];

                  DPT3( "VV9B211: ", VV_XD,
                        "COMP_TYPE - res = %p, src1 = %p, src2 = %p \n",
                                     res,      src1,      src2 );

////              src1JitVal = src1->getJitValue(this, f, jit_type_void_ptr,
////                                             block, NULL);
                  src1JitVal = src1->getJitValue(this, Bldr, int1PtrTy_,
                                                 PCBlk, NULL );

////              src2JitVal = src2->getJitValue(this, f, jit_type_void_ptr,
////                                             block, NULL);
                  src2JitVal = src2->getJitValue(this, Bldr, int1PtrTy_,
                                                 PCBlk, NULL );
                  DPT2( "VV9B212: ", VV_XD,
                        "COMP_TYPE - src1JitVal at %p, src2JitVal at %p \n",
                                     src1JitVal,       src2JitVal );
                  if (processNulls)
                  {
                    PCodeOperand* nullOp;
                    jit_value_t nullJitVal;

                    if (clause->getOperand(1)->getNullFlag())
                    {
                      DPT1( "VV9B213: ", VV_XD,
                            "COMP_TYPE - opDataNulls[1] == %p\n",
                                         opDataNulls[1] );

                      nullOp = opDataNulls[1];
////                  nullJitVal =
////                  nullOp->getJitValue(this, f, nullOp->getJitType(), block,
////                                      NULL, TRUE /* no assign jit val */);

                      nullJitVal = nullOp->getJitValue(this, Bldr,
                                             nullOp->getJitType( this ),
                                             PCBlk, NULL, TRUE /* no assign */);

                      DPT1( "VV9B214: ", VV_XD,
                            "COMP_TYPE - nullJitVal at %p\n", nullJitVal );

////                  jit_insn_branch_if(f, nullJitVal, &nullLabel);

                      DPT1( "VV9B215: ", VV_XD,
                     "IR_insn_branch_if_not_zero( Bldr, nullJitVal, &nullLabel = %p )\n", nullLabel );
                      IR_insn_branch_if_not_zero( Bldr, nullJitVal, &nullLabel );
                    }

                    if (clause->getOperand(2)->getNullFlag()) {
                      nullOp = opDataNulls[2];

                      DPT1( "VV9B216: ", VV_XD,
                            "COMP_TYPE-opDataNulls[2] == %p\n", opDataNulls[2]);

////                  nullJitVal =
////                  nullOp->getJitValue(this, f, nullOp->getJitType(), block,
////                                      NULL, TRUE /* no assign jit val */);
                      nullJitVal = nullOp->getJitValue(this, Bldr,
                                             nullOp->getJitType( this ),
                                             PCBlk, NULL, TRUE /* no assign */);

                      DPT1( "VV9B217: ", VV_XD,
                            "COMP_TYPE-nullJitVal at %p\n",  nullJitVal );

////                  jit_insn_branch_if(f, nullJitVal, &nullLabel);

                      DPT1( "VV9B218: ", VV_XD,
                     "IR_insn_branch_if_not_zero( Bldr, nullJitVal, &nullLabel = %p )\n", nullLabel );
                      IR_insn_branch_if_not_zero( Bldr, nullJitVal, &nullLabel );
                    }
                  }

                  long dtCode =
                    ((ExpDatetime*)(clause->getOperand(1)))->getPrecision();

                  switch (dtCode)
                  {
                    case REC_DTCODE_TIME:
                    case REC_DTCODE_DATE:
                    case REC_DTCODE_TIMESTAMP:
                    {
                      // Boolean used to indicate whether branch should go to
                      // true block or not.  Assume "not" by default.
                      NABoolean dumpTrueBlockFirst = TRUE;  // May change later

                      Int32 size = (clause->getOperand(1))->getLength();

                      // Cycle through each field in the date-related struct.
                      Int32 typeSize = 0;
                      for (i=0; i < size; i += typeSize)
                      {
                        jit_type_t type;

                        // Are we getting the fractional seconds?
                        if ((i == size-4) && (dtCode == REC_DTCODE_TIMESTAMP)) {
////                      type = jit_type_uint;
                          type = int32Ty_ ;
                          typeSize = 4;
                        }
                        // Are we getting the year?
                        else if ((i==0) && (dtCode != REC_DTCODE_TIME)) {
////                      type = jit_type_ushort;
                          type = int16Ty_ ;
                          typeSize = 2;
                        }
                        // We're just getting some particular byte field
                        else {
////                      type = jit_type_ubyte;
                          type = int8Ty_ ;
                          typeSize = 1;
                        }

                        // Get the fields from both sources.
////                    year1 = jit_insn_load_relative(f, src1JitVal, i, type);
                        year1 = IR_LoadRelativeWithType( Bldr, 
                                                         src1JitVal, i, type );

////                    year2 = jit_insn_load_relative(f, src2JitVal, i, type);
                        year2 = IR_LoadRelativeWithType( Bldr, 
                                                         src2JitVal, i, type );

                        DPT2( "VV9B219: ", VV_XD,
                              "COMP_TYPE-year1 at %p, year2 at %p\n",
                                               year1, year2 );

                        // Depending on the comparison being performed, generate
                        // 1 (or 2) compares and branches.  Also, based on the
                        // comparison, the fall-through may be the "true" block,
                        // or it may be the "false" block - default is TRUE.

                        switch (((ex_comp_clause*)clause)->getInstruction()) {
                          case NE_DATETIME_DATETIME:
////                        resJitVal = jit_insn_ne(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_NE,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );
////                        jit_insn_branch_if(f, resJitVal, &trueLabel);

                            DPT1( "VV9B220: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel = %p)\n", trueLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel );

                            dumpTrueBlockFirst = FALSE;
                            break;
                          case EQ_DATETIME_DATETIME:
////                        resJitVal = jit_insn_ne(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_EQ,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );

////                        jit_insn_branch_if(f, resJitVal, &falseLabel);

                            DPT1( "VV9B222: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel = %p )\n", falseLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel );

                            break;
                          case LT_DATETIME_DATETIME:
////                        resJitVal = jit_insn_lt(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_ULT,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );

////                        jit_insn_branch_if(f, resJitVal, &trueLabel);

                            DPT1( "VV9B224: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel = %p )\n", trueLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel );

////                        resJitVal = jit_insn_gt(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_UGT,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );

////                        jit_insn_branch_if(f, resJitVal, &falseLabel);

                            DPT1( "VV9B226: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel = %p )\n", falseLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel );

                            dumpTrueBlockFirst = FALSE;
                            break;
                          case GT_DATETIME_DATETIME:
////                        resJitVal = jit_insn_gt(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_UGT,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );

////                        jit_insn_branch_if(f, resJitVal, &trueLabel);

                            DPT1( "VV9B230: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel = %p )\n", trueLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel );

////                        resJitVal = jit_insn_lt(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_ULT,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );

////                        jit_insn_branch_if(f, resJitVal, &falseLabel);

                            DPT1( "VV9B232: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel = %p )\n", falseLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel );

                            dumpTrueBlockFirst = FALSE;
                            break;
                          case LE_DATETIME_DATETIME:
////                        resJitVal = jit_insn_lt(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_ULT,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );

////                        jit_insn_branch_if(f, resJitVal, &trueLabel);

                            DPT1( "VV9B234: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel = %p )\n", trueLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel );

////                        resJitVal = jit_insn_gt(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_UGT,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );

////                        jit_insn_branch_if(f, resJitVal, &falseLabel);

                            DPT1( "VV9B236: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel = %p )\n", falseLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel );

                            break;
                          case GE_DATETIME_DATETIME:
////                        resJitVal = jit_insn_gt(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_UGT,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );

////                        jit_insn_branch_if(f, resJitVal, &trueLabel);

                            DPT1( "VV9B238: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel = %p )\n", trueLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &trueLabel );

////                        resJitVal = jit_insn_lt(f, year1, year2);
                            resJitVal = jitGenCompare( Bldr, IntCompare_ULT,
                                                       year1,  year2,
                                                       IR_Const_1_ ,
                                                       IR_Const_0_  );

////                        jit_insn_branch_if(f, resJitVal, &falseLabel);

                            DPT1( "VV9B240: ", VV_XD,
                           "IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel = %p )\n", falseLabel);
                            IR_insn_branch_if_not_zero( Bldr, resJitVal, &falseLabel );

                            break;
                        }
                      }

                      if (!dumpTrueBlockFirst)
                      {
                        DPT1( "VV9B250: ", VV_VD,
                       "Bldr->CreateBr( falseLabel = %p )\n", falseLabel );
                        Bldr->CreateBr( falseLabel );  // Must complete the current block

                        // False label first.
////                    jit_insn_label(f, &falseLabel);

                        DPT1( "VV9B251: ", VV_VD,
                       "ExpFn->getBasicBlockList().push_back( falseLabel = %p )\n", falseLabel );
                        ExpFn->getBasicBlockList().push_back( falseLabel );

                        DPT1( "VV9B252: ", VV_VD,
                       "Bldr->SetInsertPoint( falseLabel = %p )\n", falseLabel );
                        Bldr->SetInsertPoint( falseLabel );

////                    res->storeJitValue(this, f, jit_type_int, zeroJitVal_,
////                                       block);
                        DPT0( "VV9B253: ", VV_XD,
                       "res->storeJitValue(this, Bldr, int32Ty_, IR_Const_0_, PCBlk) \n" );
                        res->storeJitValue(this, Bldr, int32Ty_, IR_Const_0_,
                                           PCBlk );
////                    jit_insn_branch(f, &doneLabel);

                        DPT1( "VV9B254: ", VV_VD,
                       "Bldr->CreateBr( doneLabel = %p )\n", doneLabel );
                        Bldr->CreateBr( doneLabel );

                        // True label next.
////                    jit_insn_label(f, &trueLabel);

                        DPT1( "VV9B256: ", VV_VD,
                       "ExpFn->getBasicBlockList().push_back( trueLabel = %p )\n", trueLabel );
                        ExpFn->getBasicBlockList().push_back( trueLabel );

                        DPT1( "VV9B258: ", VV_VD,
                       "Bldr->SetInsertPoint( trueLabel = %p )\n", trueLabel );
                        Bldr->SetInsertPoint( trueLabel );

////                    res->storeJitValue(this, f, jit_type_int, oneJitVal_,
////                                       block);
                        DPT0( "VV9B259: ", VV_XD,
                       "res->storeJitValue(this, Bldr, int32Ty_, IR_Const_1_, PCBlk )\n" );
                        res->storeJitValue(this, Bldr, int32Ty_, IR_Const_1_,
                                           PCBlk );
////                    jit_insn_branch(f, &doneLabel);

                        DPT1( "VV9B260: ", VV_VD,
                       "Bldr->CreateBr( doneLabel = %p )\n", doneLabel );
                        Bldr->CreateBr( doneLabel );
                      }
                      else {
                        DPT1( "VV9B261: ", VV_VD,
                       "Bldr->CreateBr( trueLabel = %p )\n", trueLabel );
                        Bldr->CreateBr( trueLabel );  // Must complete the current block

                        // True label first.
////                    jit_insn_label(f, &trueLabel);

                        DPT1( "VV9B262: ", VV_VD,
                       "ExpFn->getBasicBlockList().push_back( trueLabel = %p )\n", trueLabel );
                        ExpFn->getBasicBlockList().push_back( trueLabel );

                        DPT1( "VV9B264: ", VV_VD,
                       "Bldr->SetInsertPoint( trueLabel = %p )\n", trueLabel );
                        Bldr->SetInsertPoint( trueLabel );

////                    res->storeJitValue(this, f, jit_type_int, oneJitVal_,
////                                       block);
                        DPT0( "VV9B265: ", VV_XD,
                       "res->storeJitValue(this, Bldr, int32Ty_, IR_Const_1_, ...)\n" );
                        res->storeJitValue(this, Bldr, int32Ty_, IR_Const_1_,
                                           PCBlk );
////                    jit_insn_branch(f, &doneLabel);

                        DPT1( "VV9B266: ", VV_VD,
                       "Bldr->CreateBr( doneLabel = %p )\n", doneLabel );
                        Bldr->CreateBr( doneLabel );

                        // False label next.
////                    jit_insn_label(f, &falseLabel);

                        DPT1( "VV9B268: ", VV_VD,
                       "ExpFn->getBasicBlockList().push_back( falseLabel = %p )\n", falseLabel );
                        ExpFn->getBasicBlockList().push_back( falseLabel );

                        DPT1( "VV9B270: ", VV_VD,
                       "Bldr->SetInsertPoint( falseLabel = %p )\n", falseLabel );
                        Bldr->SetInsertPoint( falseLabel );

////                    res->storeJitValue(this, f, jit_type_int, zeroJitVal_,
////                                       block);

                        DPT0( "VV9B271: ", VV_XD,
                       "res->storeJitValue(this, Bldr, int32Ty_, IR_Const_0_, PCBlk )\n" );
                        res->storeJitValue(this, Bldr, int32Ty_, IR_Const_0_,
                                           PCBlk );
////                    jit_insn_branch(f, &doneLabel);

                        DPT1( "VV9B272: ", VV_VD,
                       "Bldr->CreateBr( doneLabel = %p )\n", doneLabel );
                        Bldr->CreateBr( doneLabel );
                      }

                      // Null label last.
////                  jit_insn_label(f, &nullLabel);

                      DPT1( "VV9B274: ", VV_VD,
                     "ExpFn->getBasicBlockList().push_back( nullLabel = %p )\n", nullLabel );
                      ExpFn->getBasicBlockList().push_back( nullLabel );

                      DPT1( "VV9B276: ", VV_VD,
                     "Bldr->SetInsertPoint( nullLabel = %p )\n", nullLabel );
                      Bldr->SetInsertPoint( nullLabel );

////                  res->storeJitValue(this,f,jit_type_int,neg1JitVal_,block);

                      DPT0( "VV9B277: ", VV_XD,
                     "res->storeJitValue(this, Bldr, int32Ty_, IR_Const_neg1_, PCBlk )\n" );
                      res->storeJitValue(this, Bldr, int32Ty_, IR_Const_neg1_,
                                         PCBlk );

////                  jit_insn_label(f, &doneLabel);

                      DPT1( "VV9B278: ", VV_VD,
                     "Bldr->CreateBr( doneLabel = %p )\n", doneLabel );
                      Bldr->CreateBr( doneLabel );  // Must complete the current block

                      DPT1( "VV9B279: ", VV_VD,
                     "ExpFn->getBasicBlockList().push_back( doneLabel = %p )\n", doneLabel );
                      ExpFn->getBasicBlockList().push_back( doneLabel );

                      DPT1( "VV9B280: ", VV_VD,
                     "Bldr->SetInsertPoint( doneLabel = %p )\n", doneLabel );
                      Bldr->SetInsertPoint( doneLabel );

                      break;
                    }
                      
                    default:
                      assert(FALSE);
                  }
                  break;
                }
              }

              break;
            }
          }

          // Clear out opData for subsequent use.
          str_pad((char*)opData,
                  (3*ex_clause::MAX_OPERANDS)*sizeof(PCodeOperand*), 0);

          break;
        }

        case PCIT::SUM_MBIN32S_MBIN32S:
        case PCIT::SUM_MBIN64S_MBIN64S:
        {
          PCodeOperand *src1,      *src2,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, resJitVal ;

          res  = PCInst->getWOps()[0];
          src1 = res; /* same as write operand */
          src2 = PCInst->getROps()[1];
          PRINT_DETAILS_OF_WROp( 0, res );
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), PCBlk);
          src1JitVal = src1->getJitValue(this, Bldr, src1->getJitType(this), PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), PCBlk);
          src2JitVal = src2->getJitValue(this, Bldr, src2->getJitType(this), PCBlk);

#if NExprDbgLvl >= VV_VD
           if ( src1->isConst() )
              DPT0( "VV9C005: ", VV_VD,
                    "case PCIT::SUM_MB...  src1 is a CONSTANT !\n" );

           if ( src2->isConst() )
              DPT0( "VV9C006: ", VV_VD,
                    "case PCIT::SUM_MB...  src2 is a CONSTANT !\n" );
#endif

////      resJitVal = jit_insn_add(f, src1JitVal, src2JitVal);

          DPT0( "VV9C010: ", VV_VD,
         "resJitVal = Bldr->CreateAdd( src1JitVal , src2JitVal , 'IntAdd' )\n" );
          resJitVal = Bldr->CreateAdd( src1JitVal , src2JitVal , "IntAdd" );

////      res->setJitValue(this, f, resJitVal, PCBlk);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);

          // Lastly, clear out jit values for 32-bit source operand if needed.
          if (opc == PCIT::SUM_MBIN64S_MBIN32S)
            src2->clearJitValues(this);

          break;
        }

        case PCIT::ADD_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::ADD_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::ADD_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::ADD_MBIN64S_MBIN64S_MBIN64S:
        case PCIT::ADD_MBIN32S_MBIN16S_MBIN32S:
        case PCIT::ADD_MBIN64S_MBIN32S_MBIN64S:
        {
          PCodeOperand *src1,      *src2,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, resJitVal ;
          jit_type_t    src1IRtype, src2IRtype, resIRtype ;

          res  = PCInst->getWOps()[0];
          src1 = PCInst->getROps()[0];
          src2 = PCInst->getROps()[1];
          PRINT_DETAILS_OF_WROp( 0, res );
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

          resIRtype  = res->getJitType( this );

          Int32 src1Width = src1IRtype->getIntegerBitWidth();
          Int32 src2Width = src2IRtype->getIntegerBitWidth();
          Int32 resWidth  =  resIRtype->getIntegerBitWidth();

          if ( src1Width < resWidth )
          {
             DPT0( "VV9C100: ", VV_VD,
            "src1JitVal = Bldr->CreateSExt( src1JitVal, (IntegerType *)resIRtype, 'SExt' )\n" );
             src1JitVal = Bldr->CreateSExt( src1JitVal,
                                           (IntegerType *)resIRtype, "SExt" ) ;
          }
          if ( src2Width < resWidth )
          {
             DPT0( "VV9C105: ", VV_VD,
            "src2JitVal = Bldr->CreateSExt( src2JitVal, (IntegerType *)resIRtype, 'SExt' )\n" );
             src2JitVal = Bldr->CreateSExt( src2JitVal,
                                           (IntegerType *)resIRtype, "SExt" ) ;
          }

////      resJitVal = jit_insn_add(f, src1JitVal, src2JitVal);

          DPT0( "VV9C110: ", VV_VD,
         "resJitVal = Bldr->CreateAdd( src1JitVal , src2JitVal , 'IntAdd' )\n" );
          resJitVal = Bldr->CreateAdd( src1JitVal , src2JitVal , "IntAdd" );

////      res->setJitValue(this, f, resJitVal, block);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);

////      if (opc == PCIT::ADD_MFLT64_MFLT64_MFLT64)
////        jitProcessFloatExceptionCheck(f, res, &errorJitLabel, block);

          // Lastly, clear out jit values for 32-bit source operand if needed.
          if (opc == PCIT::ADD_MBIN64S_MBIN32S_MBIN64S)
            src1->clearJitValues(this);

          break;
        }

        case PCIT::SUB_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::SUB_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::SUB_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::SUB_MBIN64S_MBIN64S_MBIN64S:
        case PCIT::SUB_MBIN32S_MBIN16S_MBIN32S:
        case PCIT::SUB_MBIN32S_MBIN32S_MBIN16S:
        {
          PCodeOperand *src1,      *src2,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, resJitVal ;
          jit_type_t    src1IRtype, src2IRtype, resIRtype ;

          res  = PCInst->getWOps()[0];
          src1 = PCInst->getROps()[0];
          src2 = PCInst->getROps()[1];
          PRINT_DETAILS_OF_WROp( 0, res );
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

          resIRtype  = res->getJitType( this );

          Int32 src1Width = src1IRtype->getIntegerBitWidth();
          Int32 src2Width = src2IRtype->getIntegerBitWidth();
          Int32 resWidth  =  resIRtype->getIntegerBitWidth();

          if ( src1Width < resWidth )
          {
             DPT0( "VV9C200: ", VV_VD,
            "src1JitVal = Bldr->CreateSExt( src1JitVal, (IntegerType *)resIRtype, 'SExt' )\n" );
             src1JitVal = Bldr->CreateSExt( src1JitVal,
                                           (IntegerType *)resIRtype, "SExt" ) ;
          }
          if ( src2Width < resWidth )
          {
             DPT0( "VV9C205: ", VV_VD,
            "src2JitVal = Bldr->CreateSExt( src2JitVal, (IntegerType *)resIRtype, 'SExt' )\n" );
             src2JitVal = Bldr->CreateSExt( src2JitVal,
                                           (IntegerType *)resIRtype, "SExt" ) ;
          }

////      resJitVal = jit_insn_sub(f, src1JitVal, src2JitVal);

          DPT0( "VV9C210: ", VV_VD,
         "resJitVal = Bldr->CreateSub( src1JitVal , src2JitVal , 'IntSub' )\n" );
          resJitVal = Bldr->CreateSub( src1JitVal , src2JitVal , "IntSub" );

////      res->setJitValue(this, f, resJitVal, block);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);

////      if (opc == PCIT::SUB_MFLT64_MFLT64_MFLT64)
////        jitProcessFloatExceptionCheck(f, res, &errorJitLabel, block);

////      // No opt support for this instruction
////      if (opc == PCIT::SUB_MBIN64S_MBIN64S_MBIN64S)
////        lowerOptLevel = TRUE;


          break;
        }

        case PCIT::MUL_MBIN64S_MBIN64S_MBIN64S:
        case PCIT::MUL_MBIN64S_MBIN32S_MBIN32S:
        case PCIT::MUL_MBIN64S_MBIN16S_MBIN32S:
        case PCIT::MUL_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::MUL_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::MUL_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::MUL_MBIN32S_MBIN16S_MBIN32S:
        {
          PCodeOperand *src1,      *src2,      *res       ;
          jit_value_t   src1JitVal, src2JitVal, resJitVal ;
          jit_type_t    src1IRtype, src2IRtype, resIRtype ;

          res  = PCInst->getWOps()[0];
          src1 = PCInst->getROps()[0];
          src2 = PCInst->getROps()[1];
          PRINT_DETAILS_OF_WROp( 0, res );
          PRINT_DETAILS_OF_RDOp( 0, src1 );
          PRINT_DETAILS_OF_RDOp( 1, src2 );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1IRtype = src1->getJitType( this );
          src1JitVal = src1->getJitValue(this, Bldr, src1IRtype, PCBlk);

////      src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          src2IRtype = src2->getJitType( this );
          src2JitVal = src2->getJitValue(this, Bldr, src2IRtype, PCBlk);

          resIRtype  = res->getJitType( this );

          Int32 src1Width = src1IRtype->getIntegerBitWidth();
          Int32 src2Width = src2IRtype->getIntegerBitWidth();
          Int32 resWidth  =  resIRtype->getIntegerBitWidth();

          if ( src1Width < resWidth )
          {
             DPT0( "VV9C300: ", VV_VD,
            "src1JitVal = Bldr->CreateSExt( src1JitVal, (IntegerType *)resIRtype, 'SExt' )\n" );
             src1JitVal = Bldr->CreateSExt( src1JitVal,
                                           (IntegerType *)resIRtype, "SExt" ) ;
          }
          if ( src2Width < resWidth )
          {
             DPT0( "VV9C305: ", VV_VD,
            "src2JitVal = Bldr->CreateSExt( src2JitVal, (IntegerType *)resIRtype, 'SExt' )\n" );
             src2JitVal = Bldr->CreateSExt( src2JitVal,
                                           (IntegerType *)resIRtype, "SExt" ) ;
          }

////      resJitVal = jit_insn_mul(f, src1JitVal, src2JitVal);

          DPT0( "VV9C310: ", VV_VD,
         "resJitVal = Bldr->CreateMul( src1JitVal , src2JitVal , 'IntMul' )\n" );
          resJitVal = Bldr->CreateMul( src1JitVal , src2JitVal , "IntMul" );

////      res->setJitValue(this, f, resJitVal, block);
          res->setJitValue(this, Bldr, resJitVal, PCBlk);


////      if (opc == PCIT::MUL_MFLT64_MFLT64_MFLT64)
////        jitProcessFloatExceptionCheck(f, res, &errorJitLabel, block);

          break;
        }

        case PCIT::MOVE_MBIN32S:
        {
          PCodeOperand *src1 ;
          jit_value_t   src1JitVal ;

          // RETURN instruction must follow
          assert (PCInst->next && (PCInst->next->code[0] == PCIT::RETURN));

////      jit_label_t l1 = jit_label_undefined;
////      jit_label_t l2 = jit_label_undefined;

          src1 = PCInst->getROps()[0];
          PRINT_DETAILS_OF_RDOp( 0, src1 );

          DPT1( "VV9D002: ", VV_XD,
                "Processing MOVE_MBIN32S - 1, src1 = PCodeOp at %p\n", src1 );

////      src1JitVal = src1->getJitValue(this, f, src1->getJitType(), PCBlk);
          src1JitVal = src1->getJitValue(this, Bldr, src1->getJitType(this), PCBlk);

          DPT1( "VV9D003: ", VV_XD,
                "Processing MOVE_MBIN32S - 1, src1JitVal at %p\n", src1JitVal );

////      jit_value_t t1 = jit_insn_eq(f, src1JitVal, oneJitVal_);
////      jit_insn_branch_if(f, t1, &l1);
////      jit_insn_label(f, &l2);
////      jit_insn_return(f, fJitVal_);
////      jit_insn_label(f, &l1);
////      jit_insn_return(f, tJitVal_);

          jit_value_t Rslt = jitGenCompare( Bldr, IntCompare_EQ,
                                            src1JitVal,   IR_Const_1_ ,
                                            IR_Const_TRUE_, IR_Const_FALSE_ );

          DPT0( "VV9D005: ", VV_VD, "returned from jitGenCompare()\n");

          DPT0( "VV9D010: ", VV_VD,
         "Bldr->CreateRet( Rslt )\n" );
          Bldr->CreateRet( Rslt );

          justGeneratedRET = TRUE;
          break;
        }

        case PCIT::RETURN_IBIN32S:
        {
          jit_value_t  resJitVal ;

//        if (inst->code[1] == 1) jit_insn_return(f, tJitVal_);
//        else                    jit_insn_return(f, fJitVal_);

          if (PCInst->code[1] == 1)
                resJitVal = IR_Const_TRUE_  ;
          else
                resJitVal = IR_Const_FALSE_ ;

          DPT0( "VV9E010: ", VV_VD,
         "Bldr->CreateRet( resJitVal )\n");
          Bldr->CreateRet( resJitVal );

          justGeneratedRET = TRUE;
          break;
        }

        case PCIT::RETURN:
        {
           DPT0( "VV9F001: ", VV_VD,
          "Bldr->CreateRet( IR_Const_OK_ )\n");
           Bldr->CreateRet( IR_Const_OK_ );

           justGeneratedRET = TRUE;
           break;
        }
      }  // end of switch (opc)

#if NExprDbgLvl >= VV_VD
      if ( PCInst )
         DPT2( "VVzz000: ", VV_VD, 
               "At end of Main Loop : PCInst at %p, PCInst->next = %p \n",
                                      PCInst,       PCInst->next );

      if ( PCInst && PCInst->next )
         DPT2( "VVzz001: ", VV_VD, 
               "At end of Main Loop: next at %p has opc == %d\n",
                          PCInst->next , (int) PCInst->next->getOpcode());
#endif

    } ENDFE_INST_IN_BLOCK

    if ( ( opc != PCIT::BRANCH         ) &&  // if last one was not a BRANCH
         ( opc != PCIT::RETURN         ) &&  // and was not a RETURN
         ( opc != PCIT::RETURN_IBIN32S ) &&  // of any sort, and if 
         ( (PCBlkIndex + 1) < physBlockList.entries() ) // there are more blocks
       )
    {
       PCodeBlock* nxtBlock = physBlockList[ PCBlkIndex + 1 ];
       assert( nxtBlock );

       //
       // IMPORTANT NOTE:
       // LLVM's verifyFunction() routine absolutely requires that *every*
       // llvm::BasicBlock be terminated with either a Branch or a Return.
       // If there is a BasicBlock that is not terminated, either 
       // verifyFunction() will complain or, worse yet, it may simply
       // never return (because it calls 'exit' instead.)
       // So here we "complete" the current block.
       //
       p_IR_block_t TgtBlk = *( nxtBlock->getJitBlkLbl() );

       DPT1( "VVzzz00: ", VV_VD, 
      "Bldr->CreateBr( TgtBlk = %p )\n", TgtBlk );
       Bldr->CreateBr( TgtBlk );
    }

    DPT0( "VVzzz09: ", VV_VD, "Finished the FOREACH_INST_IN_BLOCK loop\n");

  } // END: for (PCBlkIndex=0; ...

  DPT0( "VVzzz10: ", VV_VD, "FINISHED the MAIN loop\n");

  if ( justGeneratedRET == FALSE && justHandledUnconditionBranch == FALSE )
  {
     //
     // The last block should *always* end with a Return or Unconditional Br.
     //
     DPT0( "VVzzz12: ", VV_VD, 
    "Bldr->CreateRet( IR_Const_OK_ )\n");
     Bldr->CreateRet( IR_Const_OK_ );
  }

  DPT0( "VVzzz99: ", VV_BD, "GOT PAST the final CreateRet\n");

#if NExprDbgLvl >= VV_BD
  if ( NExprDbgLvl_ >= VV_BD )
     std::cout << std::flush ; // Flush anything in the data buffer
#endif

  std::stringstream myBuffer;
  std::streambuf * old = std::cerr.rdbuf( myBuffer.rdbuf() );

#if NExprDbgLvl >= VV_BD
  if ( NExprDbgLvl_ >= VV_BD )
  {
     std::cerr << std::flush ; // Flush anything in the data buffer
     std::cerr << "QRST\n"  ; // Put out marker so we can see that we got here

     DPT0( "VVzzz08: ", VV_BD, "CALLING verifyFunction() !!! \n");
     std::cerr << std::flush ; // Flush anything in the data buffer
  }
#endif // NExprDbgLvl >= VV_BD


// LLVM Requires this function be called!
//NABoolean VF_rtn = llvm::verifyFunction(*ExpFn) ;
  NABoolean VF_rtn = llvm::verifyFunction(*ExpFn, PrintMessageAction) ;


#if NExprDbgLvl >= VV_BD
  if ( NExprDbgLvl_ >= VV_BD )
  {
    DPT0( "VVzzz10: ", VV_VD, "RETURNED FROM verifyFunction() !!! \n");
    std::cerr << std::flush ; // Flush anything in the data buffer
    if ( VF_rtn )
    {
       DPT0( "VVzzz12: ", VV_VD, "llvm::verifyFunction returned TRUE -- "
                                 "meaning function is corrupt ???\n" );
       std::string myText = myBuffer.str();
       DPT2( "VVzzz14: ", VV_VD, "%ld bytes of text:\n %s\n",
                                  myText.length(),     myText.data() );
    }
    else
    {
       DPT0( "VVzzz16: ", VV_VD, "llvm::verifyFunction returned FALSE -- "
                                 "meaning function verifies OK !\n" );
    }
  }
#endif // NExprDbgLvl >= VV_BD

  std::cerr.rdbuf(old); // Restore stderr

  // *********************************************************************
  // Perform Optimizations
  // *********************************************************************

  //
  // Change the following "if (1)" to "if (0)" when debugging future
  // changes to Native Expressions and you would like the generated
  // native expression to be more easily understood code ... OR if you 
  // suspect that these LLVM optimizations might be resulting in 
  // incorrect generated code.
  //
  if ( 1 )
  {
    FunctionPassManager ExprFPM(TheModule);

    // Set up the optimizer pipeline.  Start with registering info about
    // how the target lays out data structures.
    ExprFPM.add(new DataLayout(*TheExecutionEngine->getDataLayout()));
    // Provide basic AliasAnalysis support for GVN.
    ExprFPM.add(createBasicAliasAnalysisPass());
    // Do simple "peephole" optimizations and bit-twiddling optzns.
    ExprFPM.add(createInstructionCombiningPass());
    // Reassociate expressions.
    ExprFPM.add(createReassociatePass());
    // Eliminate Common SubExpressions.
    ExprFPM.add(createGVNPass());
    // Simplify the control flow graph (deleting unreachable blocks, etc).
    ExprFPM.add(createCFGSimplificationPass());

    ExprFPM.doInitialization();

    // Set the global so the code gen can use this.
    // static FunctionPassManager * TheFPM = &ExprFPM;

    // Optimize the function.
    ExprFPM.run(*ExpFn);
  }

#if NExprDbgLvl >= VV_BD
  if ( NExprDbgLvl_ >= VV_BD )
  {
     // ********************************************************************
     //  Dump the Intermediate Representation (IR)
     // ********************************************************************

     NExLog("\nIntermediate Representation (IR) dump:");
     NExLog("\n======================================\n\n");

     // Dump the module/function

     // If CQD set to dump NE debug stuff to a file, then:
     if ( NExDbgInfoPtr_->getNExLogPath() &&
          NExDbgInfoPtr_->getNExLogPath()[0] != '\0' )
     {
        std::string myErrorInfoStr;
        raw_fd_ostream *myOuts = new raw_fd_ostream(
                       (const char *)NExDbgInfoPtr_->getNExLogPath(),
                       myErrorInfoStr,
                       (unsigned) llvm::raw_fd_ostream::F_Append
                       );

        TheModule->print( *myOuts, (llvm::AssemblyAnnotationWriter*)NULL );
     }
     else // Dump it to stdout
        TheModule->print( outs(), (llvm::AssemblyAnnotationWriter*)NULL );

  }
#endif // NExprDbgLvl >= VV_BD

  // *********************************************************************
  // jit -- and copy binary into buffer
  // *********************************************************************


  // JIT the function, returning a function pointer.

  MachineCodeInfo myMachineCodeInfo;

  TheExecutionEngine->runJITOnFunction( ExpFn, &myMachineCodeInfo );

  void *FPtr = myMachineCodeInfo.address();
  size_t funcBufLen = myMachineCodeInfo.size() ;

  //
  // DON'T NEED THIS IN PRODUCT, but something like this might be
  // useful in debugging.
  //
#if 0
#define MAX_EXEC_BUF_LEN 65536  /* Arbitrary maximum length - pick your own */
  if ( funcBufLen >= MAX_EXEC_BUF_LEN )
  {
     printf( "MACHINE CODE LENGTH BIGGER THAN 65536 -- consequently questionable\n");
     delete Bldr;
     //delete TheModule;
     delete TheExecutionEngine;

     //
     // Restore signal handlers to what they were on entry.  ALSO, if this is
     // the first time LLVM was called, save the LLVM handlers!
     //
     for (Int32 ii = 0; ii < NumSaveSigs ; ii++ )
     {
       Int32 ret = sigaction( SaveSigs[ii], &(SavedSigInfo[ii].SigAct),
                    (LLVMhandlersSaved == FALSE) ?
                   &(SavedLLVMhandlers[ii].SigAct) : (struct sigaction *)NULL);
       assert( ret == 0 );
     }
     LLVMhandlersSaved = TRUE ;
     pthread_mutex_unlock( &Our_LLVM_mutex ); // Other threads could use LLVM now


     printf("EXITING FROM layoutNativeCode() - funcBufLen >= 65536 \n");
     std::cout << std::flush ; // Flush anything in the data buffer
     expr_->setEvalPtr( (ex_expr::evalPtrType)( (CollIndex) 0 ) );//Ensure NULL!
     return;
  }
#endif

#if NExprDbgLvl >= VV_BD
  if ( ( NExprDbgLvl_ >= VV_BD ) &&
       ( 
         ( ( NExDbgInfoPtr_->getNExStmtSrc() != NULL ) &&
           ( NExDbgInfoPtr_->getNExStmtSrc()[0] != '\0' ) )
       )
     )
  {
     // ********************************************************************
     //  Dump the assembly code
     // ********************************************************************

     char insnLine[256];
     char insnLine2[256];

     char * NExLogPth    = NULL ;

     if ( NExDbgInfoPtr_  &&  NExDbgInfoPtr_ > (NExDbgInfo *)4096 ) // May be offset
          NExLogPth = NExDbgInfoPtr_->getNExLogPath() ;

     sprintf( insnLine, "\nNative Expr (Length: %ld bytes)", funcBufLen );
     NExLog(  insnLine );
     NExLog( "\n======================================\n" );

     if ( funcBufLen <= 0 )
     {
        NExLog( "MACHINE CODE LENGTH <= 0\n");
        NExLog("EXITING FROM layoutNativeCode() - funcBufLen <= 0 !!\n");
        std::cout << std::flush ; // Flush anything in the data buffer
        delete Bldr;
        //delete TheModule;
        delete TheExecutionEngine;

        //
        // Restore signal handlers to what they were on entry.  ALSO, if this is
        // the first time LLVM was called, save the LLVM handlers!
        //
        for (Int32 ii = 0; ii < NumSaveSigs ; ii++ )
        {
          Int32 ret = sigaction( SaveSigs[ii], &(SavedSigInfo[ii].SigAct),
                       (LLVMhandlersSaved == FALSE) ?
                      &(SavedLLVMhandlers[ii].SigAct) : (struct sigaction *)NULL);
          assert( ret == 0 );
        }
        LLVMhandlersSaved = TRUE ;
        pthread_mutex_unlock( &Our_LLVM_mutex ); // Other threads could use LLVM now

        expr_->setEvalPtr( (ex_expr::evalPtrType)( (CollIndex) 0 ) );//Ensure NULL!
        return;
     }

     ud_t ud_obj;
     ud_init(&ud_obj);
     ud_set_input_buffer(&ud_obj, (uint8_t*)FPtr, (size_t) funcBufLen);
     ud_set_mode(&ud_obj, 64);
     ud_set_syntax(&ud_obj, UD_SYN_ATT);
     ud_set_vendor(&ud_obj, UD_VENDOR_INTEL);

     while (ud_disassemble(&ud_obj))
     {
       if ( 0xcd == * ud_insn_ptr(&ud_obj) ) break; // end of data bug workaround

       // Find length of next assembler language instruction
       sprintf( insnLine, "%s", ud_insn_asm(&ud_obj) ) ;
       Int32 insnLen = str_len( insnLine );

       if ( insnLen >= 26 )
       {
          str_pad(&insnLine[insnLen], 1, ' ');
          insnLine[insnLen+1] ='\0' ;
       }
       else
       {
          str_pad(&insnLine[insnLen],(26-insnLen+1), ' ');
          insnLine[27] ='\0' ;
       }
       insnLen = str_len( insnLine ); //Increase insnLen for added spaces

       Int32 ooo = 0;
       for (Int32 jjj = 0; jjj < insnLen; jjj++ , ooo++)
       {
          // If output will be going to stdout (via printf)
          // then we must double any '%' chars in the Assembler Language
          //
          if ( ( ! NExLogPth || *NExLogPth == '\0' ) &&
               (insnLine[jjj] == '%') )
          {
             insnLine2[ooo] = '%';
             ooo++;
          }
          insnLine2[ooo] = insnLine[jjj] ;
       }
       insnLine2[ooo] = '\0'; // Ensure termination
       sprintf( NExBuf, "\t%s%s\n", insnLine2, ud_insn_hex(&ud_obj) );
       NExLog(  NExBuf );
     }
  }
#endif // NExprDbgLvl >= VV_BD
  // Get entry point into function and add code into constants array
  ex_expr::evalPtrType entry = (ex_expr::evalPtrType)FPtr;
  CollIndex* offPtr = addConstant((void*)entry, funcBufLen, 8);

#if NExprDbgLvl >= VV_I0
  if ( NExprDbgLvl_ >= VV_I0 )
  {
     struct rusage endTime;
     (void) getrusage( RUSAGE_THREAD, &endTime );

     Int64 totalTime = ( endTime.ru_utime.tv_sec - begTime.ru_utime.tv_sec   ) * 1000000 +
                       ( endTime.ru_utime.tv_usec - begTime.ru_utime.tv_usec ) ;

     DPT2( "VVzzz99: ", VV_I0, "NORMAL EXIT from layoutNativeCode(): "
           "%ld microseconds to translate %d PCODE instructions\n",
                                            totalTime, PCI_count );
  }
#endif // NExprDbgLvl >= VV_I0

#if 1 /* Use #if 0 to generate/compile, but NOT actually execute generated code */
  // Store offset into evalPtr_
  expr_->setEvalPtr((ex_expr::evalPtrType)(*offPtr));

  // Mark this expression appropriately so that the native function gets called
  expr_->setPCodeMoveFastpath(TRUE);
  expr_->setPCodeNative(TRUE);
#endif

  TheExecutionEngine->freeMachineCodeForFunction( ExpFn );
  delete Bldr;
  //delete TheModule;
  delete TheExecutionEngine;

  //
  // Restore signal handlers to what they were on entry.  ALSO, if this is
  // the first time LLVM was called, save the LLVM handlers!
  //
  for (Int32 ii = 0; ii < NumSaveSigs ; ii++ )
  {
     Int32 ret = sigaction( SaveSigs[ii], &(SavedSigInfo[ii].SigAct),
                  (LLVMhandlersSaved == FALSE) ?
                 &(SavedLLVMhandlers[ii].SigAct) : (struct sigaction *)NULL);
     assert( ret == 0 );
  }
  LLVMhandlersSaved = TRUE ;
  pthread_mutex_unlock( &Our_LLVM_mutex ); // Other threads could use LLVM now
  return ;
}

void PCodeCfg::layoutNativeCode(Space* showplanSpace)
{
  if (expr_->getPCodeNative())
  {
    NABoolean firstTimeSeen = TRUE;
    char line[256];
    char insnLine[256];
    Int32 i;
    void *FPtr =  expr_->getConstantsArea() + expr_->getEvalPtrOffset();
    Long nativeCodeLen = expr_->getConstsLength() - expr_->getEvalPtrOffset();

    // First print out a header for the native expr dump
    sprintf( line, "Native Expr (Length: %ld bytes)", nativeCodeLen );
    showplanSpace->allocateAndCopyToAlignedSpace(line, str_len(line),
                                                 sizeof(short));

    ud_t ud_obj;
    ud_init(&ud_obj);
    ud_set_input_buffer(&ud_obj, (uint8_t*)(FPtr), (size_t) nativeCodeLen);
    ud_set_mode(&ud_obj, 64);
    ud_set_syntax(&ud_obj, UD_SYN_ATT);
    ud_set_vendor(&ud_obj, UD_VENDOR_INTEL);

    while (ud_disassemble(&ud_obj))
    {
       if ( 0xcd == * ud_insn_ptr(&ud_obj) ) break; // end of data bug workaround

       // Find length of next assembler language instruction
       sprintf( insnLine, "%s", ud_insn_asm(&ud_obj) ) ;
       Int32 insnLen = str_len( insnLine );

       if ( insnLen >= 26 )
       {
          str_pad(&insnLine[insnLen], 1, ' ');
          insnLine[insnLen+1] ='\0' ;
       }
       else
       {
          str_pad(&insnLine[insnLen],(26-insnLen+1), ' ');
          insnLine[27] ='\0' ;
       }

       sprintf( line, "\t%s%s", insnLine, ud_insn_hex(&ud_obj) );
       showplanSpace->allocateAndCopyToAlignedSpace(line, str_len(line), sizeof(short));
    }
    system(line);

    // Add a newline to start the next expression off cleanly.
    showplanSpace->allocateAndCopyToAlignedSpace("\n", 1, sizeof(short));
  }

}

#endif /* NA_LINUX_LLVMJIT */

#ifdef NA_LINUX_LIBJIT

void PCodeCfg::layoutNativeCode(Space* showplanSpace = NULL)
{
  NABoolean debug = FALSE;
  NABoolean lowerOptLevel = FALSE; // Used to reduce jit opt level.

//#if defined(_DEBUG) && !defined(NA_NO_C_RUNTIME)
  if (getenv("NATIVE_EXPR_DEBUG"))
    debug = TRUE;
//#endif

  PCodeOperand *src1, *src2, *res;

  jit_value_t resJitVal, src1JitVal, src2JitVal;
  jit_value_t tRes, tSrc1, tSrc2, loopIndex;
  jit_value_t eJitVal;
  jit_label_t* jitLabel = NULL;
  jit_label_t errorJitLabel = jit_label_undefined;
  jit_type_t type;

  jit_value_t padJitVal;

  Int32 opc;
  CollIndex i, j, blockIndex;

  Int32 skipInst = 0;

  PCodeBinary* pCode = expr_->getPCodeBinary();

  // First see if this graph can be compiled natively
  if (!canGenerateNativeExpr())
    return;

  // First compute the dominator tree
  computeDomTree();

  // Create context to hold the JIT's primary state
  jit_context_t context = jit_context_create();

  // Lock the context while we build and compile the function.  This is only
  // really necessary in a multithreaded environment.
  jit_context_build_start(context);

  // Generate code for getting tupp pointers
  //
  // 1. Get atp pointer (p) passed in
  // 2. Add bytes to get to tuple we care about
  //    off = &(tempAtp->getTupp(atpIndex)) - (tempAtp)
  //    temp1 = param[atp] + off;
  // 3. Dereference pointer to get tupp_descriptor pointer
  //    temp2 = load(temp1);
  // 4. Add bytes to get to dataTuple
  //    off = &(tempTuppDesc.getTupleAddress()

  atp_struct tempAtp;
  tupp tempTupp;
  tupp_descriptor tempTuppDesc;

/*
  ex_cri_desc criDesc;
  tempAtp.setCriDesc(&criDesc);
*/

  // Build the function signature.
  jit_type_t params[4];
  params[0] = jit_type_void_ptr;  // Int32*      pCode32
  params[1] = jit_type_void_ptr;  // atp_struct* atp2
  params[2] = jit_type_void_ptr;  // atp_struct* atp2
  params[3] = jit_type_void_ptr;  // Int32*      constants

  jit_type_t signature =
    jit_type_create_signature(jit_abi_cdecl, jit_type_int, params, 4, 1);

  // Create function
  jit_function_t f = jit_function_create(context, signature);

  // Create commonly referenced constants
  oneJitVal_  = jit_value_create_nint_constant(f, jit_type_int, 1);
  zeroJitVal_ = jit_value_create_nint_constant(f, jit_type_int, 0);
  neg1JitVal_ = jit_value_create_nint_constant(f, jit_type_int, -1);
  jit_value_t zeroJitVal16=jit_value_create_nint_constant(f, jit_type_short, 0);
  jit_value_t neg1JitVal16=jit_value_create_nint_constant(f, jit_type_short,-1);
  padJitVal = jit_value_create_nint_constant(f, jit_type_ubyte, ' ');
  jit_value_t shiftRVal = jit_value_create_nint_constant(f, jit_type_int, 31);
  okJitVal_ = jit_value_create_nint_constant(f, jit_type_int,ex_expr::EXPR_OK);
  tJitVal_ = jit_value_create_nint_constant(f, jit_type_int,ex_expr::EXPR_TRUE);
  fJitVal_ = jit_value_create_nint_constant(f,jit_type_int,ex_expr::EXPR_FALSE);
  eJitVal  = jit_value_create_nint_constant(f,jit_type_int,ex_expr::EXPR_ERROR);

  // Used for bignum related ops when manipulating sign bit.
  jit_value_t jitVal16 = jit_value_create_nint_constant(f, jit_type_uint, 16);
  jit_value_t jitValMask16 =
    jit_value_create_nint_constant(f, jit_type_ushort, 0x8000);
  jit_value_t jitValMask32 =
    jit_value_create_nint_constant(f, jit_type_ushort, 0x80000000);
  jit_value_t jitValNotMask16 =
    jit_value_create_nint_constant(f, jit_type_ushort, 0x7fff);
  jit_value_t jitValNotMask32 =
    jit_value_create_nint_constant(f, jit_type_ushort, 0x7fffffff);

  // Allocate pointers to global defs available at runtime.  Note, if they are
  // not referenced by the pcode graph, these loads will be deleted by the jit.
  jit_value_t globTableJitVal = jit_value_get_param(f, 0);
  jit_value_t nullTable = jit_insn_load_relative(f, globTableJitVal,
                                                 JIT_GLOB_NULL_TABLE,
                                                 jit_type_void_ptr);

  hashTableJitVal_ = jit_insn_load_relative(f, globTableJitVal,
                                            JIT_GLOB_RANDOM_HASH_VALS_TABLE,
                                            jit_type_void_ptr);

  jit_value_t compareWithPadJitVal = jit_insn_load_relative(f, globTableJitVal,
                                       JIT_GLOB_COMPARE_WITH_PAD_FUNC,
                                       jit_type_void_ptr);

  jit_value_t strcmpJitVal = jit_insn_load_relative(f, globTableJitVal,
                                       JIT_GLOB_STRCMP_FUNC, jit_type_void_ptr);

  jit_value_t strcpyJitVal = jit_insn_load_relative(f, globTableJitVal,
                                       JIT_GLOB_STRCPY_FUNC, jit_type_void_ptr);

  jit_value_t dblLeJitVal = jit_insn_load_relative(f, globTableJitVal,
                                 JIT_GLOB_DBL_LE_CMP_FUNC, jit_type_void_ptr);
  jit_value_t dblGeJitVal = jit_insn_load_relative(f, globTableJitVal,
                                 JIT_GLOB_DBL_GE_CMP_FUNC, jit_type_void_ptr);
  jit_value_t dblLtJitVal = jit_insn_load_relative(f, globTableJitVal,
                                 JIT_GLOB_DBL_LT_CMP_FUNC, jit_type_void_ptr);
  jit_value_t dblGtJitVal = jit_insn_load_relative(f, globTableJitVal,
                                 JIT_GLOB_DBL_GT_CMP_FUNC, jit_type_void_ptr);
  jit_value_t dblEqJitVal = jit_insn_load_relative(f, globTableJitVal,
                                 JIT_GLOB_DBL_EQ_CMP_FUNC, jit_type_void_ptr);
  jit_value_t dblNeJitVal = jit_insn_load_relative(f, globTableJitVal,
                                 JIT_GLOB_DBL_NE_CMP_FUNC, jit_type_void_ptr);
  jit_value_t reportErrJitVal = jit_insn_load_relative(f, globTableJitVal,
                                 JIT_GLOB_REPORT_ERR_FUNC, jit_type_void_ptr);
  jit_value_t bigSubJitVal = jit_insn_load_relative(f, globTableJitVal,
                               JIT_GLOB_BIG_SUB_FUNC, jit_type_void_ptr);


  jit_type_t compareParams[5] = {jit_type_void_ptr, jit_type_int,
                                 jit_type_void_ptr, jit_type_int,
                                 jit_type_ubyte};
  jit_type_t strcmpParams[5] = {jit_type_void_ptr, jit_type_void_ptr,
                                jit_type_uint};
  jit_type_t strcpyParams[5] = {jit_type_void_ptr, jit_type_void_ptr,
                                jit_type_uint};
  jit_type_t dblParams[2] = {jit_type_float64, jit_type_float64};
  jit_type_t reportErrParams[2] = {jit_type_void_ptr, jit_type_void_ptr};
  jit_type_t bigParams[4] = {jit_type_void_ptr, jit_type_void_ptr,
                             jit_type_void_ptr, jit_type_uint};


  jit_type_t compareSig = jit_type_create_signature (jit_abi_cdecl,
                            jit_type_int, compareParams, 5, 1);

  jit_type_t strcmpSig = jit_type_create_signature (jit_abi_cdecl,
                            jit_type_int, strcmpParams, 3, 1);
  jit_type_t strcpySig = jit_type_create_signature (jit_abi_cdecl,
                            jit_type_int, strcpyParams, 3, 1);
  jit_type_t dblSig = jit_type_create_signature (jit_abi_cdecl,
                          jit_type_int, dblParams, 2, 1);
  jit_type_t reportErrSig = jit_type_create_signature (jit_abi_cdecl,
                              jit_type_int, reportErrParams, 2, 1);
  jit_type_t bigSig = jit_type_create_signature (jit_abi_cdecl,
                        jit_type_int, bigParams, 4, 1);


  // Allocate incoming parameters
  jitParams_ = (jit_value_t*) new(heap_) jit_value_t[4 + pCode[0]];
  for (i=0, j=1; i < (CollIndex)pCode[0]; i++, j+=2)
  {
    Int32 off1, off2;

    // First get the atp we care about
    jit_value_t t1 = jit_value_get_param(f, 1 + pCode[j]);

    // Get the tupp descriptor pointer we care about
    off1 =
      (char*)(&(tempAtp.getTuppForNativeExpr(pCode[j+1]))) - (char*)(&tempAtp);
    jit_value_t t2 = jit_insn_load_relative(f, t1, off1, jit_type_void_ptr);

#if NULL_TUPLE_PTRS
    jit_label_t storeNullLabel = jit_label_undefined;
    jit_value_t res = jit_value_create(f, jit_type_void_ptr);

    jit_value_t t4 = jit_insn_eq(f, t2, zeroJitVal_);
    jit_insn_branch_if(f, t4, &storeNullLabel);
#endif

    // Lastly, get the tuple pointer
    off2 = 12; // (&(tempTuppDesc.getTupleAddress())) - (&tempTuppDesc);
    jit_value_t t3 = jit_insn_load_relative(f, t2, off2, jit_type_void_ptr);

#if NULL_TUPLE_PTRS
  // Set tuple pointers to nullData if they are NULL.  Only need to do this for
  // 2.4.2 and below.
    jit_insn_store(f, res, t3);

    jit_label_t storeLabel = jit_label_undefined;

    t4 = jit_insn_eq(f, t3, zeroJitVal_);
    jit_insn_branch_if_not(f, t4, &storeLabel);

    jit_insn_label(f, &storeNullLabel);
    jit_insn_store(f, res, nullTable);

    jit_insn_label(f, &storeLabel);

    // Make t3 the result so that we properly store (internally) what the tuple
    // pointer is.
    t3 = res;
#endif

    jitParams_[4+i] = t3;
  }

  //
  // Allocate incoming constant pointer (needed for strings and floats).  The
  // constantsArea_ pointer is 88 bytes from the object (note, we hardcode this
  // since access to the member variables are protected, and therefore not
  // accessible for use in calculating this automatically).  The 88 byte offset
  // comes from "20" being the offset to the "eyeCatcher_" field, plus "56" to
  // the constants area;
  //
  // Do the same for the temps array pointer.  This array is used to store to
  // those temps which usually don't fit within a native container - e.g.
  // strings and bignums.  The temps array is just above the constants area in
  // the expr - i.e. at "64" bytes from the eyeCatcher_.
  //
  jit_value_t exprJitVal = jit_value_get_param(f,3);
  jitParams_[1] = jit_insn_load_relative(f, exprJitVal, 88, jit_type_void_ptr);
  jitParams_[2] = jit_insn_load_relative(f, exprJitVal, 96, jit_type_void_ptr);

  // Create temp values used for strings (or data in general)
  tRes = jit_value_create(f, jit_type_void_ptr);  // ptr to walk string
  tSrc1 = jit_value_create(f, jit_type_void_ptr);  // ptr to walk string
  tSrc2 = jit_value_create(f, jit_type_void_ptr);  // ptr to walk string
  loopIndex = jit_value_create(f, jit_type_int);   // loop index for strcmp

  // Allocate and initialize opData array for use with CLAUSE_EVAL instructions
  PCodeOperand* opData[(3*ex_clause::MAX_OPERANDS)];
  PCodeOperand** opDataNulls = &(opData[0]);
  PCodeOperand** opDataVals = &(opData[2*ex_clause::MAX_OPERANDS]);
  str_pad((char*)opData, (3*ex_clause::MAX_OPERANDS)*sizeof(PCodeOperand*), 0);

  // Create the list of basic blocks in physical layout order
  BLOCKLIST physBlockList(heap_);

  createPhysList(physBlockList);

  // Loop through each block, generating instructions on a per block basis.  We
  // stop immediately if a failure was seen during code gen.

  for (blockIndex=0;
       (blockIndex < physBlockList.entries()) && !getJitFailureSeen();
       blockIndex++)
  {
    PCodeBlock* block = physBlockList[blockIndex];

    // Lay out the label for this block.
    jit_insn_label(f, block->getJitLabel());

    FOREACH_INST_IN_BLOCK(block, inst) {

      // If a failure occurred, stop translation immediately.
      if (getJitFailureSeen())
        break;

      // Sometimes native code is generated for multiple pcode instructions in
      // one pass, and so "skipped" instructions don't need to be processed.
      if (skipInst > 0) {
        skipInst--;
        continue;
      }

      opc = inst->getOpcode();
      switch (opc) {

        case PCIT::MOVE_MATTR5_MATTR5:
        {
          jit_type_t vcType;
          jit_value_t vcLenJitVal;

          src1 = inst->getROps()[0]; 
          res = inst->getWOps()[0];

          if (src1->getVcIndicatorLen() == 2) {
            vcType = jit_type_ushort;
            vcLenJitVal = jit_value_create_nint_constant(f, jit_type_int, 2);
          }
          else {
            vcType = jit_type_uint;
            vcLenJitVal = jit_value_create_nint_constant(f, jit_type_int, 4);
          }

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          resJitVal = res->getJitValue(this, f, res->getJitType(), block);

          jit_insn_store(f, tRes, resJitVal);
          jit_insn_store(f, tSrc1, src1JitVal);

          jit_value_t srcLen = jit_insn_load_relative(f, src1JitVal, 0, vcType);
          srcLen = jit_insn_add(f, srcLen, vcLenJitVal);

          genUnalignedMemcpy(f, tRes, tSrc1, srcLen);

#if 0
          jit_value_t tgtLen = jit_insn_load_relative(f, resJitVal, 0, vcType);

          // Just store in length for now.
          jit_insn_store_relative(f, resJitVal, 0, srcLen);

          src1JitVal =
            jit_insn_add_relative(f, src1JitVal, src1->getVcIndicatorLen());
          resJitVal =
            jit_insn_add_relative(f, resJitVal, src1->getVcIndicatorLen());

          jit_insn_store(f, tSrc1, src1JitVal);
          jit_insn_store(f, tSrc2, src2JitVal);

          // Now copy string
          jit_insn_memcpy(f, resJitVal, src1JitVal, srcLen);
#endif

          break;
        }

        case PCIT::BRANCH:
        {
          jit_insn_branch(f, block->getTargetBlock()->getJitLabel());
          break;
        }


        case PCIT::BRANCH_OR:
        case PCIT::BRANCH_AND:
        case PCIT::BRANCH_OR_CNT:
        case PCIT::BRANCH_AND_CNT:
        {
          src1 = inst->getROps()[0]; 
          res = inst->getWOps()[0];

          jit_value_t takenJitVal =
            ((opc == PCIT::BRANCH_OR) || (opc == PCIT::BRANCH_OR_CNT))
              ? oneJitVal_ : zeroJitVal_;

          jitLabel = block->getTargetBlock()->getJitLabel();

          src1JitVal = src1->getJitValue(this, f, jit_type_int, block);

          if (res->isVar() || block->isOperandLiveInSuccs(res))
            res->storeJitValue(this, f, jit_type_int, src1JitVal, block, NULL);

          resJitVal = jit_insn_eq(f, src1JitVal, takenJitVal);
          jit_insn_branch_if(f, resJitVal, jitLabel);

          break;
        }

        case PCIT::NNB_SPECIAL_NULLS_MBIN32S_MATTR3_MATTR3_IBIN32S_IBIN32S:
        {
          jit_label_t src1LabelNull = jit_label_undefined;
          jit_label_t ret1Label = jit_label_undefined;
          jit_label_t endLabel = jit_label_undefined;

          jitLabel = block->getTargetBlock()->getJitLabel();

          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

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

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          jit_insn_branch_if(f, src1JitVal, &src1LabelNull);
          jit_insn_branch_if(f, src2JitVal, &ret1Label);

          // Both are not null - store 0 and take target branch
          res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
          jit_insn_branch(f, jitLabel);

          // Src1 is null - what about src2?
          jit_insn_label(f, &src1LabelNull);
          jit_insn_branch_if(f, src2JitVal, &ret1Label);

          // Src2 is not null, so return 0
          res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
          jit_insn_branch(f, &endLabel);

          // Return 1
          jit_insn_label(f, &ret1Label);
          res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);

          // End label to jump to
          jit_insn_label(f, &endLabel);

          break;
        }

        case PCIT::NNB_MATTR3_IBIN32S:
        {
          src1 = inst->getROps()[0]; 
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);

          jitLabel = block->getTargetBlock()->getJitLabel();
          jit_insn_branch_if_not(f, src1JitVal, jitLabel);

          break;
        }

        case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S:
        {
          jit_value_t orRes;

          src1 = inst->getROps()[0]; 
          src2 = inst->getROps()[1]; 

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

          NABoolean forComp = (opc ==
            PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_MBIN32S_IATTR4_IBIN32S);

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          orRes = jit_insn_or(f, src1JitVal, src2JitVal);

          jitLabel = block->getTargetBlock()->getJitLabel();

          if (res->isVar() || block->isOperandLiveInSuccs(res)) {
            res->storeNullJitValueAndBranch(this, f, orRes, jitLabel,
                                            forComp, block);
          }
          else {
            jit_insn_branch_if_not(f, orRes, jitLabel);
          }

          break;
        }

        case PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S:
        case PCIT::NOT_NULL_BRANCH_MBIN32S_MBIN32S_IATTR3_IBIN32S:
        {
          src1 = inst->getROps()[0]; 
          res = inst->getWOps()[0];

          NABoolean forComp =
            (opc == PCIT::NOT_NULL_BRANCH_COMP_MBIN32S_MBIN32S_IATTR3_IBIN32S);

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          jitLabel = block->getTargetBlock()->getJitLabel();

          if (res->isVar() || block->isOperandLiveInSuccs(res)) {
            res->storeNullJitValueAndBranch(this, f, src1JitVal, jitLabel,
                                            forComp, block);
          }
          else {
            jit_insn_branch_if_not(f, src1JitVal, jitLabel);
          }

          break;
        }

        case PCIT::FILL_MEM_BYTES_VARIABLE:
        case PCIT::FILL_MEM_BYTES:
        {
#ifdef NO_FILL_MEM_BYTES
          break;
#endif
          Int32 fillVal, fillLen;

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

          // Also, no need to zero out temporary operands, since we just care
          // about their values being appropriately nulled out.
          if (res->isTemp())
            break;

          resJitVal = res->getJitValue(this, f, res->getJitType(), block);

          if (opc == PCIT::FILL_MEM_BYTES_VARIABLE)
          {
            jit_value_t lenJitVal;

            Int32 vcLen = res->getVcIndicatorLen();
            jit_type_t vcType = (vcLen == 2) ? jit_type_ushort : jit_type_uint;

            lenJitVal = jit_value_create_nint_constant(f, vcType,inst->code[6]);
            
            // Write out vc length first
            jit_insn_store_relative(f, resJitVal, 0, lenJitVal);

            // Move pointer up
            resJitVal = jit_insn_add_relative(f, resJitVal, vcLen);

            // Reduce fill length to no longer include vc length indicator
            fillLen = inst->code[6] - vcLen;
            fillVal = inst->code[7];
          }
          else {
            fillLen = inst->code[3];
            fillVal = inst->code[4];
          }

          // FIXME: If varchar, we currently set the vc length to the max length
          // of the varchar, but does that make sense if the value is NULL?
          // This only gets called when the the varchar is NULL, and so it's
          // length will always be zero, so why write it out?.

          genUnalignedMemset(f, resJitVal, fillVal, fillLen);

          break;
        }

        case PCIT::COMP_MBIN32S_MASCII_MASCII_IBIN32S_IBIN32S_IBIN32S:
        case PCIT::COMP_MBIN32S_MATTR5_MATTR5_IBIN32S:
        {
          jit_value_t len1, len2;

          src1 = inst->getROps()[0]; 
          src2 = inst->getROps()[1];

          // Need to get pointer to operands
          src1JitVal = src1->getJitValue(this, f, jit_type_void_ptr, block);
          src2JitVal = src2->getJitValue(this, f, jit_type_void_ptr, block);

          // Setup for varchar and return length (if we're varchar)
          if (src1->isVarchar())
            len1 = genStringSetup(f, &src1JitVal, src1);
          else
            len1= jit_value_create_nint_constant(f,jit_type_int,src1->getLen());

          if (src2->isVarchar())
            len2 = genStringSetup(f, &src2JitVal, src2);
          else
            len2= jit_value_create_nint_constant(f,jit_type_int,src2->getLen());


          // Set up arguments and make indirect call to compare routine.
          jit_value_t args[5] = {src1JitVal, len1, src2JitVal, len2, padJitVal};
          resJitVal = jit_insn_call_indirect(f, compareWithPadJitVal,
                                             compareSig, args, 5, 0);

          Int32 subOpc = (opc == PCIT::COMP_MBIN32S_MATTR5_MATTR5_IBIN32S)
              ? inst->code[13] : inst->code[9];

          // Generate code for the appropriate compare operation.
          switch (subOpc) {
            case ITM_EQUAL:
              resJitVal = jit_insn_eq(f, resJitVal, zeroJitVal_);
              break;
            case ITM_NOT_EQUAL:
              resJitVal = jit_insn_ne(f, resJitVal, zeroJitVal_);
              break;
            case ITM_LESS:
              resJitVal = jit_insn_lt(f, resJitVal, zeroJitVal_);
              break;
            case ITM_LESS_EQ:
              resJitVal = jit_insn_le(f, resJitVal, zeroJitVal_);
              break;
            case ITM_GREATER:
              resJitVal = jit_insn_gt(f, resJitVal, zeroJitVal_);
              break;
            case ITM_GREATER_EQ:
              resJitVal = jit_insn_ge(f, resJitVal, zeroJitVal_);
              break;
          }

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          break;
        }

        case PCIT::LE_MBIN32S_MFLT64_MFLT64:
        case PCIT::GE_MBIN32S_MFLT64_MFLT64:
        case PCIT::LT_MBIN32S_MFLT64_MFLT64:
        case PCIT::GT_MBIN32S_MFLT64_MFLT64:
        case PCIT::EQ_MBIN32S_MFLT64_MFLT64:
        case PCIT::NE_MBIN32S_MFLT64_MFLT64:
        {
          src1 = inst->getROps()[0]; 
          src2 = inst->getROps()[1];

          // Need to get pointer to operands
          src1JitVal = src1->getJitValue(this, f, jit_type_float64, block);
          src2JitVal = src2->getJitValue(this, f, jit_type_float64, block);

          // Set up arguments and make indirect call to compare routine.
          jit_value_t args[2] = {src1JitVal, src2JitVal};

          switch (opc) {
            case PCIT::LE_MBIN32S_MFLT64_MFLT64:
              resJitVal = jit_insn_call_indirect(f,dblLeJitVal,dblSig,args,2,0);
              break;
            case PCIT::GE_MBIN32S_MFLT64_MFLT64:
              resJitVal = jit_insn_call_indirect(f,dblGeJitVal,dblSig,args,2,0);
              break;
            case PCIT::LT_MBIN32S_MFLT64_MFLT64:
              resJitVal = jit_insn_call_indirect(f,dblLtJitVal,dblSig,args,2,0);
              break;
            case PCIT::GT_MBIN32S_MFLT64_MFLT64:
              resJitVal = jit_insn_call_indirect(f,dblGtJitVal,dblSig,args,2,0);
              break;
            case PCIT::EQ_MBIN32S_MFLT64_MFLT64:
              resJitVal = jit_insn_call_indirect(f,dblEqJitVal,dblSig,args,2,0);
              break;
            case PCIT::NE_MBIN32S_MFLT64_MFLT64:
              resJitVal = jit_insn_call_indirect(f,dblNeJitVal,dblSig,args,2,0);
              break;
          }

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          break;
        }

        case PCIT::COMP_MBIN32S_MBIGS_MBIGS_IBIN32S_IBIN32S:
        {
          jit_label_t loopLabel = jit_label_undefined;
          jit_label_t falseLabel = jit_label_undefined;
          jit_label_t trueLabel = jit_label_undefined;
          jit_label_t endLabel = jit_label_undefined;
          jit_label_t negLabel = jit_label_undefined;
          jit_label_t resolveLabel = jit_label_undefined;
          jit_label_t diffSignsLabel = jit_label_undefined;
          jit_label_t loopDiffLabel = jit_label_undefined;
          jit_label_t emitFalseLabel = jit_label_undefined;
          jit_label_t emitTrueLabel = jit_label_undefined;

          jit_value_t t1, t2, size, cmpRes, cmpRes2, src1Sign, src2Sign;

          // Get operands
          res = inst->getWOps()[0];
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          CollIndex len = src1->getLen();

          jit_value_t lenJitVal = 
            jit_value_create_nint_constant(f, jit_type_int, len);

          // Declare variables as if bignum will be processed in shorts
          jit_type_t bignumMaxType = jit_type_ushort;
          CollIndex startPos = len - 2;
          jit_value_t mask = jitValMask16;
          jit_value_t decrJitVal = 
            jit_value_create_nint_constant(f, jit_type_int, 2);

          // If bignum length is a multiple of 4, why not do 4 bytes at a time?
          // Alignment traps may occur, but they have been shown to have a
          // minimal impact on x86.

          if ((len % 4) == 0) {
            bignumMaxType = jit_type_uint;
            startPos = len - 4;
            mask = jitValMask32;
            decrJitVal = jit_value_create_nint_constant(f, jit_type_int, 4);
          }

          // Get pointers to the source operands.
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          // Get the short/int containing the sign bits.
          t1 = jit_insn_load_relative(f, src1JitVal, startPos, bignumMaxType);
          t2 = jit_insn_load_relative(f, src2JitVal, startPos, bignumMaxType);

          // Get the sign bits
          src1Sign = jit_insn_and(f, t1, mask);
          src2Sign = jit_insn_and(f, t2, mask);

          // If signs don't match, branch to a fast path
          cmpRes = jit_insn_ne(f, src1Sign, src2Sign);
          jit_insn_branch_if(f, cmpRes, &diffSignsLabel);

          // Prepare for loop
          size = jit_value_create_nint_constant(f, jit_type_int, startPos);

          t1 = jit_insn_add(f, src1JitVal, size);
          t2 = jit_insn_add(f, src2JitVal, size);
          jit_insn_store(f, tSrc1, t1);
          jit_insn_store(f, tSrc2, t2);

          // Loop header: "loop index = length"
          jit_insn_store(f, loopIndex, lenJitVal);

          // Body: "while()"
          jit_insn_label(f, &loopLabel);

          // Get byte in string to compare 
          t1 = jit_insn_load_relative(f, tSrc1, 0, bignumMaxType);
          t2 = jit_insn_load_relative(f, tSrc2, 0, bignumMaxType);

          // Perform comparison(s) and branch.  For eq/ne we just do one
          // comparison.  For all others we do 2 comparisons.  The 2 compares
          // are done together, since libjit otherwise spills and restores the
          // arguments before each compare and branch!

          Int32 subOpc = inst->code[8];
          switch (subOpc) {
            case ITM_EQUAL:
              cmpRes = jit_insn_ne(f, t1, t2);
              // Jump directly to "return false" code
              jit_insn_branch_if(f, cmpRes, &resolveLabel);
              break;
            case ITM_NOT_EQUAL:
              cmpRes = jit_insn_ne(f, t1, t2);
              // Jump directly to "return true" code
              jit_insn_branch_if(f, cmpRes, &resolveLabel);
              break;
            case ITM_LESS:
              cmpRes = jit_insn_gt(f, t1, t2);
              jit_insn_branch_if(f, cmpRes, &falseLabel);
              cmpRes2 = jit_insn_lt(f, t1, t2);
              jit_insn_branch_if(f, cmpRes2, &trueLabel);
              break;
            case ITM_LESS_EQ:
              cmpRes = jit_insn_gt(f, t1, t2);
              jit_insn_branch_if(f, cmpRes, &falseLabel);
              cmpRes2 = jit_insn_lt(f, t1, t2);
              jit_insn_branch_if(f, cmpRes2, &trueLabel);
              break;
            case ITM_GREATER:
              cmpRes = jit_insn_lt(f, t1, t2);
              jit_insn_branch_if(f, cmpRes, &falseLabel);
              cmpRes2 = jit_insn_gt(f, t1, t2);
              jit_insn_branch_if(f, cmpRes2, &trueLabel);
              break;
            case ITM_GREATER_EQ:
              cmpRes = jit_insn_lt(f, t1, t2);
              jit_insn_branch_if(f, cmpRes, &falseLabel);
              cmpRes2 = jit_insn_gt(f, t1, t2);
              jit_insn_branch_if(f, cmpRes2, &trueLabel);
              break;
          }

          // Decrement loop index
          t1 = jit_insn_sub(f, loopIndex, decrJitVal);
          jit_insn_store(f, loopIndex, t1);

          // Increment string pointers
          t1 = jit_insn_sub(f, tSrc1, decrJitVal);
          t2 = jit_insn_sub(f, tSrc2, decrJitVal);
          jit_insn_store(f, tSrc1, t1);
          jit_insn_store(f, tSrc2, t2);

          // Branch back if loop index <> 0
          jit_insn_branch_if(f, loopIndex, &loopLabel);

          // If we reach this point, the two sources are equal to each other.
          if (subOpc == ITM_EQUAL)
          {
            res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);
            jit_insn_branch(f, &endLabel);
          }
          else if (subOpc == ITM_NOT_EQUAL) {
            res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
            jit_insn_branch(f, &endLabel);
          }
          else
          {
            // GE or LE will return TRUE right away.
            if ((subOpc == ITM_GREATER_EQ) || (subOpc == ITM_LESS_EQ)) {
              res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);
              jit_insn_branch(f, &endLabel);
            }

            // False block emitted first, since we fall-through to it.
            jit_insn_label(f, &falseLabel);

            // If sources are negative, then return the opposite.
            jit_insn_branch_if(f, src1Sign, &emitTrueLabel);

            jit_insn_label(f, &emitFalseLabel);
            res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
            jit_insn_branch(f, &endLabel);

            // True block
            jit_insn_label(f, &trueLabel);

            // If sources are negative, then return the opposite.
            jit_insn_branch_if(f, src1Sign, &emitFalseLabel);

            jit_insn_label(f, &emitTrueLabel);
            res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);
            jit_insn_branch(f, &endLabel);
          }

          // Handle difference in signs here.  Normally a difference in signs
          // is enough to make the comparison, but because we can have both -0
          // and +0 (which are both equivalent), we have to make this code a
          // little lengthy.

          jit_insn_label(f, &diffSignsLabel);

          // Loop header: "loop index = 0"
          jit_insn_store(f, loopIndex, zeroJitVal_);

          // Body: "while()"
          jit_insn_label(f, &loopDiffLabel);

          // Get byte in string to compare 
          t1 = jit_insn_load_elem(f, src1JitVal, loopIndex, bignumMaxType);
          t2 = jit_insn_load_elem(f, src2JitVal, loopIndex, bignumMaxType);

          // Are the two different from each other?
          cmpRes = jit_insn_ne(f, t1, t2);
          jit_insn_branch_if(f, cmpRes, &resolveLabel);

          // Are the two equal to 0?
          cmpRes = jit_insn_ne(f, t1, zeroJitVal_);
          jit_insn_branch_if(f, cmpRes, &resolveLabel);

          // Increment loop index
          t1 = jit_insn_add(f, loopIndex, decrJitVal);
          jit_insn_store(f, loopIndex, t1);

          // Branch back if loop index == length 
          t1 = jit_insn_ne(f, loopIndex, lenJitVal);
          jit_insn_branch_if(f, loopIndex, &loopDiffLabel);

          if ((subOpc == ITM_EQUAL) || (subOpc == ITM_LESS_EQ) ||
              (subOpc == ITM_GREATER_EQ))
            res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);
          else
            res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);

          jit_insn_branch(f, &endLabel);
          
          // We arrive here if 1) the signs are different, 2) we verified that
          // we don't have a +0/-0 situation.  In this case, EQ & NE can do a
          // fast return.  The other comparisons must check the sign directly
          // before making a decision on what to do.

          jit_insn_label(f, &resolveLabel);

          switch (subOpc) {
            case ITM_EQUAL:
              res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
              break;
            case ITM_NOT_EQUAL:
              res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);
              break;

            default:
            {
              jit_insn_branch_if(f, src1Sign, &negLabel);
              if ((subOpc == ITM_GREATER) || (subOpc == ITM_GREATER_EQ))
                res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);
              else
                res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);

              jit_insn_branch(f, &endLabel);

              // Negative label
              jit_insn_label(f, &negLabel);
              if ((subOpc == ITM_GREATER) || (subOpc == ITM_GREATER_EQ))
                res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
              else
                res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);

              break;
            }
          }

          // End label
          jit_insn_label(f, &endLabel);

          break;
        }


        case PCIT::EQ_MBIN32S_MASCII_MASCII:
        case PCIT::NE_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:
        {
          jit_value_t size, b1, b2, cmpRes, cmpRes2;
          jit_value_t temp1, temp2, temp3;
          jit_label_t loopLabel = jit_label_undefined;
          jit_label_t falseLabel = jit_label_undefined;
          jit_label_t trueLabel = jit_label_undefined;
          jit_label_t endLabel = jit_label_undefined;

          NABoolean isEqOrNe = (opc == PCIT::EQ_MBIN32S_MASCII_MASCII) ||
                                 (opc == PCIT::NE_MBIN32S_MASCII_MASCII);

          NABoolean dumpTrueBlockFirst = TRUE;  // May change later

          res = inst->getWOps()[0];
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          jit_insn_store(f, tSrc1, src1JitVal);
          jit_insn_store(f, tSrc2, src2JitVal);

          // Loop header: "loop index = length"
          size = jit_value_create_nint_constant(f, jit_type_int,src1->getLen());
          jit_insn_store(f, loopIndex, size);

          // Body: "while()"
          jit_insn_label(f, &loopLabel);

          // Get byte in string to compare 
          b1 = jit_insn_load_relative(f, tSrc1, 0, jit_type_ubyte);
          b2 = jit_insn_load_relative(f, tSrc2, 0, jit_type_ubyte);

          // Perform comparison(s) and branch.  For eq/ne we just do one
          // comparison.  For all others we do 2 comparisons.  The 2 compares
          // are done together, since libjit otherwise spills and restores the
          // arguments before each compare and branch!

          if (opc == PCIT::EQ_MBIN32S_MASCII_MASCII) {
            cmpRes = jit_insn_ne(f, b1, b2);
            jit_insn_branch_if(f, cmpRes, &falseLabel);
          }
          else if (opc == PCIT::NE_MBIN32S_MASCII_MASCII) {
            cmpRes = jit_insn_ne(f, b1, b2);
            jit_insn_branch_if(f, cmpRes, &trueLabel);
            dumpTrueBlockFirst = FALSE;
          }
          else if (opc == PCIT::LT_MBIN32S_MASCII_MASCII) {
            cmpRes = jit_insn_gt(f, b1, b2);
            cmpRes2 = jit_insn_lt(f, b1, b2);
            jit_insn_branch_if(f, cmpRes, &falseLabel);
            jit_insn_branch_if(f, cmpRes2, &trueLabel);
            dumpTrueBlockFirst = FALSE;
          }
          else if (opc == PCIT::GT_MBIN32S_MASCII_MASCII) {
            cmpRes = jit_insn_lt(f, b1, b2);
            cmpRes2 = jit_insn_gt(f, b1, b2);
            jit_insn_branch_if(f, cmpRes, &falseLabel);
            jit_insn_branch_if(f, cmpRes2, &trueLabel);
            dumpTrueBlockFirst = FALSE;
          }
          else if (opc == PCIT::LE_MBIN32S_MASCII_MASCII) {
            cmpRes = jit_insn_gt(f, b1, b2);
            cmpRes2 = jit_insn_lt(f, b1, b2);
            jit_insn_branch_if(f, cmpRes, &falseLabel);
            jit_insn_branch_if(f, cmpRes2, &trueLabel);
          }
          else /* (opc == PCIT::GE_MBIN32S_MASCII_MASCII) */ {
            cmpRes = jit_insn_lt(f, b1, b2);
            cmpRes2 = jit_insn_gt(f, b1, b2);
            jit_insn_branch_if(f, cmpRes, &falseLabel);
            jit_insn_branch_if(f, cmpRes2, &trueLabel);
          }

          // Decrement loop index
          temp1 = jit_insn_sub(f, loopIndex, oneJitVal_);
          jit_insn_store(f, loopIndex, temp1);

          // Increment string pointers
          temp2 = jit_insn_add(f, tSrc1, oneJitVal_);
          temp3 = jit_insn_add(f, tSrc2, oneJitVal_);
          jit_insn_store(f, tSrc1, temp2);
          jit_insn_store(f, tSrc2, temp3);

          // Branch back if loop index <> 0
          jit_insn_branch_if(f, loopIndex, &loopLabel);

          // Usually comparison is followed by branch.  Attempt to combine
          // branches here, so as avoid overhead cost from logical branch.
          if (!jitProcessPredicate(inst, f, &falseLabel, &trueLabel,
                                   dumpTrueBlockFirst))
          {
            if (dumpTrueBlockFirst) {
              // True block
              jit_insn_label(f, &trueLabel);
              res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);
              jit_insn_branch(f, &endLabel);

              // False block
              jit_insn_label(f, &falseLabel);
              res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
            }
            else {
              // False block
              jit_insn_label(f, &falseLabel);
              res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);
              jit_insn_branch(f, &endLabel);

              // True block
              jit_insn_label(f, &trueLabel);
              res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);
            }

            // End label
            jit_insn_label(f, &endLabel);
          }
          else
            skipInst = 1;

          break; }

        case PCIT::EQ_MBIN32S_MBIN64S_MBIN64S:
        case PCIT::NE_MBIN32S_MBIN64S_MBIN64S:
        {
          jit_value_t temp1, temp2, temp3;

          jit_label_t trueLabel = jit_label_undefined;
          jit_label_t falseLabel = jit_label_undefined;
          jit_label_t doneLabel = jit_label_undefined;

          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          // Need to get pointer to 64-bit vals, since we'll need to perform 2
          // 4-byte comparisons.  This is done because libjit does not support
          // comparison of 64-bit types.  We can work around this here for EQ/NE
          // since a memcmp is sufficient to give an answer.
          src1JitVal = src1->getJitValue(this, f, jit_type_void_ptr, block);
          src2JitVal = src2->getJitValue(this, f, jit_type_void_ptr, block);

          for (i=0; i < 8; i += 4) {
            temp1 = jit_insn_load_relative(f, src1JitVal, i, jit_type_uint);
            temp2 = jit_insn_load_relative(f, src2JitVal, i, jit_type_uint);
            temp3 = jit_insn_ne(f, temp1, temp2);

            if (opc == PCIT::EQ_MBIN32S_MBIN64S_MBIN64S)
              jit_insn_branch_if(f, temp3, &falseLabel);
            else
              jit_insn_branch_if(f, temp3, &trueLabel);
          }

          // Fall-through implies that the two operands are equal.  Generate
          // the appropriate code, given opc.
          if (opc == PCIT::EQ_MBIN32S_MBIN64S_MBIN64S)
          {
            inst->getWOps()[0]->setJitValue(this, f, oneJitVal_, block);
            jit_insn_branch(f, &doneLabel);
            jit_insn_label(f, &falseLabel);
            inst->getWOps()[0]->setJitValue(this, f, zeroJitVal_, block);
          }
          else
          {
            inst->getWOps()[0]->setJitValue(this, f, zeroJitVal_, block);
            jit_insn_branch(f, &doneLabel);
            jit_insn_label(f, &trueLabel);
            inst->getWOps()[0]->setJitValue(this, f, oneJitVal_, block);
          }

          jit_insn_label(f, &doneLabel);

          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_MBIN16U_MBIN16S:
        {
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_eq(f, src1JitVal, src2JitVal);

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          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_MBIN16U_MBIN16S:
        case PCIT::LT_MBIN32S_MBIN64S_MBIN64S:
        {
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_lt(f, src1JitVal, src2JitVal);

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          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_MBIN16U_MBIN16S:
        case PCIT::LE_MBIN32S_MBIN64S_MBIN64S:
        {
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_le(f, src1JitVal, src2JitVal);

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          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_MBIN16U_MBIN16S:
        case PCIT::GT_MBIN32S_MBIN64S_MBIN64S:
        {
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_gt(f, src1JitVal, src2JitVal);

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          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_MBIN16U_MBIN16S:
        case PCIT::GE_MBIN32S_MBIN64S_MBIN64S:
        {
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_ge(f, src1JitVal, src2JitVal);

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          break;
        }

        case PCIT::NE_MBIN32S_MBIN16S_MBIN16S:
        {
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_ne(f, src1JitVal, src2JitVal);

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          break;
        }

        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:
        {
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          assert (src1->isConst());

          // Use the jit type for src2 in both cases, since we checked
          // before-hand that the type for both are MBIN32U
          src1JitVal = src1->getJitValue(this, f, src2->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          switch (opc) {
            case PCIT::EQ_MBIN32S_MBIN16S_MBIN32U:
              resJitVal = jit_insn_eq(f, src1JitVal, src2JitVal);
              break;
            case PCIT::LT_MBIN32S_MBIN16S_MBIN32U:
              resJitVal = jit_insn_lt(f, src1JitVal, src2JitVal);
              break;
            case PCIT::GT_MBIN32S_MBIN16S_MBIN32U:
              resJitVal = jit_insn_gt(f, src1JitVal, src2JitVal);
              break;
            case PCIT::LE_MBIN32S_MBIN16S_MBIN32U:
              resJitVal = jit_insn_le(f, src1JitVal, src2JitVal);
              break;
            case PCIT::GE_MBIN32S_MBIN16S_MBIN32U:
              resJitVal = jit_insn_ge(f, src1JitVal, src2JitVal);
              break;
          }

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          break;
        }

        case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MFLT64_MFLT64:
        case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN32S_MBIN32S:
        case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN64S:
        case PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN32S:
        {
          jit_label_t sumLabel = jit_label_undefined;
          jit_label_t doneLabel = jit_label_undefined;

          // First check if src is null - if so, we just branch out and return.
          src2 = inst->getROps()[1];
          if (!src2->isConst()) {
            src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
            jit_insn_branch_if(f, src2JitVal, &doneLabel);
          }
          else {
            // Skip check, since constant will be 0 (assert here to verify).
          }


          // Let's get the operands now.
          res = inst->getWOps()[(inst->getWOps()).entries()-1];
          src2 = inst->getROps()[(inst->getROps()).entries()-1];

          resJitVal = res->getJitValue(this, f, res->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);


#if 0
          // Now check if target is null.  If so, we just move the src into tgt.
          src1 = inst->getROps()[0];
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          jit_insn_branch_if_not(f, src1JitVal, &sumLabel);


          // Clear null value of target and clear out it's value.
          res->storeJitValue(this, f, res->getJitType(), src2JitVal, block);
          src1->storeNullJitValueAndBranch(this, f, zeroJitVal_, &doneLabel,
                                           FALSE, block);


          // Perform the sum here
          jit_insn_label(f, &sumLabel);

          resJitVal = jit_insn_add(f, resJitVal, src2JitVal);
          res->setJitValue(this, f, resJitVal, block);
#else
          // In an effort to work around a libjit register allocation bug where
          // the register for the source is overwritten before being added to
          // the aggregate, we perform the add first (since that's the likely
          // scenario) and then do the check for null of the aggregate.

          jit_value_t addJitVal = jit_insn_add(f, resJitVal, src2JitVal);

          // Now check if target is null.  If so, we just move the src into tgt.
          src1 = inst->getROps()[0];
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          jit_insn_branch_if_not(f, src1JitVal, &sumLabel);


          // Clear null value of target and clear out it's value.
          res->storeJitValue(this, f, res->getJitType(), src2JitVal, block);
          src1->storeNullJitValueAndBranch(this, f, zeroJitVal_, &doneLabel,
                                           FALSE, block);

          // Store the sum here.
          jit_insn_label(f, &sumLabel);
          res->setJitValue(this, f, addJitVal, block);
#endif

          jit_insn_label(f, &doneLabel);

          // Lastly, clear out jit values for 32-bit source operand if needed.
          if (opc == PCIT::SUM_MATTR3_MATTR3_IBIN32S_MBIN64S_MBIN32S)
            src2->clearJitValues(this);

          break;
        }


        case PCIT::SUM_MFLT64_MFLT64:
        case PCIT::SUM_MBIN32S_MBIN32S:
        case PCIT::SUM_MBIN64S_MBIN64S:
        case PCIT::SUM_MBIN64S_MBIN32S:
        {
          res = inst->getWOps()[0];
          src1 = res; /* same as write operand */
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_add(f, src1JitVal, src2JitVal);
          res->setJitValue(this, f, resJitVal, block);

          // Lastly, clear out jit values for 32-bit source operand if needed.
          if (opc == PCIT::SUM_MBIN64S_MBIN32S)
            src2->clearJitValues(this);

          break;
        }

        case PCIT::ADD_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::ADD_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::ADD_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::ADD_MBIN64S_MBIN64S_MBIN64S:
        case PCIT::ADD_MBIN32S_MBIN16S_MBIN32S:
        case PCIT::ADD_MBIN64S_MBIN32S_MBIN64S:
        case PCIT::ADD_MFLT64_MFLT64_MFLT64:
        {
          res = inst->getWOps()[0];
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_add(f, src1JitVal, src2JitVal);
          res->setJitValue(this, f, resJitVal, block);

          if (opc == PCIT::ADD_MFLT64_MFLT64_MFLT64)
            jitProcessFloatExceptionCheck(f, res, &errorJitLabel, block);

          // Lastly, clear out jit values for 32-bit source operand if needed.
          if (opc == PCIT::ADD_MBIN64S_MBIN32S_MBIN64S)
            src1->clearJitValues(this);

          break;
        }

        /*case PCIT::SUB_MBIN32S_MBIN16S_MBIN16S:*/
        case PCIT::SUB_MBIN16S_MBIN16S_MBIN16S:
        case PCIT::SUB_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::SUB_MBIN64S_MBIN64S_MBIN64S:
        case PCIT::SUB_MBIN32S_MBIN16S_MBIN32S:
        case PCIT::SUB_MBIN32S_MBIN32S_MBIN16S:
        case PCIT::SUB_MFLT64_MFLT64_MFLT64:
        {
          res = inst->getWOps()[0];
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_sub(f, src1JitVal, src2JitVal);
          res->setJitValue(this, f, resJitVal, block);

          if (opc == PCIT::SUB_MFLT64_MFLT64_MFLT64)
            jitProcessFloatExceptionCheck(f, res, &errorJitLabel, block);

          // No opt support for this instruction
          if (opc == PCIT::SUB_MBIN64S_MBIN64S_MBIN64S)
            lowerOptLevel = TRUE;


          break;
        }

        case PCIT::MUL_MBIN32S_MBIN32S_MBIN32S:
        case PCIT::MUL_MBIN32S_MBIN16S_MBIN16S:
        case PCIT::MUL_MBIN32S_MBIN16S_MBIN32S:
        case PCIT::MUL_MFLT64_MFLT64_MFLT64:
        {
          res = inst->getWOps()[0];
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_mul(f, src1JitVal, src2JitVal);
          res->setJitValue(this, f, resJitVal, block);

          if (opc == PCIT::MUL_MFLT64_MFLT64_MFLT64)
            jitProcessFloatExceptionCheck(f, res, &errorJitLabel, block);

          break;
        }

        case PCIT::DIV_MFLT64_MFLT64_MFLT64:
        {
          res = inst->getWOps()[0];
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);

          resJitVal = jit_insn_div(f, src1JitVal, src2JitVal);
          res->setJitValue(this, f, resJitVal, block);

          if (opc == PCIT::DIV_MFLT64_MFLT64_MFLT64)
            jitProcessFloatExceptionCheck(f, res, &errorJitLabel, block);

          break;
        }

        case PCIT::MOVE_MBIN32S:
        {
          // RETURN instruction must follow
          assert (inst->next && (inst->next->code[0] == PCIT::RETURN));

          jit_label_t l1 = jit_label_undefined;
          jit_label_t l2 = jit_label_undefined;

          src1 = inst->getROps()[0];
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);

          jit_value_t t1 = jit_insn_eq(f, src1JitVal, oneJitVal_);
          jit_insn_branch_if(f, t1, &l1);

          jit_insn_label(f, &l2);
          jit_insn_return(f, fJitVal_);

          jit_insn_label(f, &l1);
          jit_insn_return(f, tJitVal_);

          break;
        }

        case PCIT::RETURN_IBIN32S:
        {
          if (inst->code[1] == 1)
            jit_insn_return(f, tJitVal_);
          else
            jit_insn_return(f, fJitVal_);
          break;
        }

        case PCIT::RETURN:
        {
          jit_insn_return(f, okJitVal_);
          break;
        }

        // FIX: Bulk instructions can sometimes redefine the operand (because
        // two moves can be combined into one).  So when storeJitValue or
        // getJitValue is called, the original operand is retrieved, and it's
        // length is used.  Perhaps that should be fixed from the get-go.
        case PCIT::MOVE_BULK:
        {
          CollIndex j, rOps=0, wOps=0;
          Int32 length = inst->code[1];

          // Reload operands to get rid of potential overlapping ones.
          inst->reloadOperands(this);

          for (j=3; j != (length-1); j+=3)
          {
            Int32 opc = inst->code[j+1];

            res = inst->getWOps()[wOps++];

            switch(opc) {
              case PCIT::MOVE_MBIN8_MBIN8_IBIN32S:
                // This instruction has one more entry (length) in MOVE_BULK.
                // Advance and then fall-through.
                j++;

              case PCIT::MOVE_MBIN64S_MBIN64S:
              case PCIT::MOVE_MBIN32U_MBIN32U:
              case PCIT::MOVE_MBIN16U_MBIN16U:
              case PCIT::MOVE_MBIN8_MBIN8:
              {
                src1 = inst->getROps()[rOps++];

                src1JitVal =
                  src1->getJitValue(this, f, src1->getJitType(), block);
                res->storeJitValue(this,f,res->getJitType(),src1JitVal,block);

                break;
              }

              case PCIT::MOVE_MBIN16U_IBIN16U:
              case PCIT::MOVE_MBIN32S_IBIN32S:
              {
                type = (opc == PCIT::MOVE_MBIN32S_IBIN32S)
                         ? jit_type_int : jit_type_ushort;

                Int32 val = inst->code[j+3];

                src1JitVal = jit_value_create_nint_constant(f, type, val);
                res->storeJitValue(this, f, type, src1JitVal, block);

                break;
              }

              default:
                assert(FALSE);
                break;
            }
          }

          break;
        }

        case PCIT::MOVE_MFLT64_MBIN16S:
        case PCIT::MOVE_MFLT64_MBIN32S:
        case PCIT::MOVE_MBIN16U_MBIN8:
        case PCIT::MOVE_MBIN32U_MBIN16U:
        case PCIT::MOVE_MBIN32S_MBIN16U:
        case PCIT::MOVE_MBIN64S_MBIN16U:
        case PCIT::MOVE_MBIN32U_MBIN16S:
        case PCIT::MOVE_MBIN32S_MBIN16S:
        case PCIT::MOVE_MBIN64S_MBIN16S:
        case PCIT::MOVE_MBIN64S_MBIN32U:
        case PCIT::MOVE_MBIN64S_MBIN32S:
        {
          res = inst->getWOps()[0];
          src1 = inst->getROps()[0];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src1JitVal = jit_insn_convert(f, src1JitVal, res->getJitType(), 0);
          res->storeJitValue(this, f, res->getJitType(), src1JitVal, block);

          // Lastly, clear out jit values for 32-bit source operand if needed.
          if ((opc == PCIT::MOVE_MBIN64S_MBIN16U) ||
              (opc == PCIT::MOVE_MBIN64S_MBIN16S) ||
              (opc == PCIT::MOVE_MBIN64S_MBIN32U) ||
              (opc == PCIT::MOVE_MBIN64S_MBIN32S))
            src1->clearJitValues(this);

          break;
        }

        case PCIT::MOVE_MBIN16U_IBIN16U:
        case PCIT::MOVE_MBIN32S_IBIN32S:
        {
          res = inst->getWOps()[0];
          type = (opc == PCIT::MOVE_MBIN32S_IBIN32S)
                   ? jit_type_int : jit_type_ushort;

          Int32 val = inst->code[3];

          src1JitVal = jit_value_create_nint_constant(f, type, val);
          res->storeJitValue(this, f, type, src1JitVal, block);

          break;  
        }

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

          switch(src1->getLen()) {
            case 1:
              type = jit_type_ubyte;
              break;
            case 2:
              type = jit_type_ushort;
              break;
            case 4:
              type = jit_type_uint;
              break;
            case 8:
              type = jit_type_long;
              break;
            default:
            {
              assert (opc == PCIT::MOVE_MBIN8_MBIN8_IBIN32S);
              type = jit_type_void_ptr;
              break;
            }
          }

          src1JitVal = src1->getJitValue(this, f, type, block);
          res->storeJitValue(this, f, type, src1JitVal, block);

          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:
        {
          jit_label_t doneLabel = jit_label_undefined;
          jit_label_t nullLabel = jit_label_undefined;

          type = (inst->code[10] == 2) ? jit_type_short : jit_type_int;

          res = inst->getWOps()[0];
          src1 = inst->getROps()[0];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);

          // Branch if NULL
          jit_insn_branch_if(f, src1JitVal, &nullLabel);

          // not null case
          src2JitVal = inst->getROps()[1]->getJitValue(this, f, type, block);
          res->storeJitValue(this, f, type, src2JitVal, block);
          jit_insn_branch(f, &doneLabel);

          // not null case
          jit_insn_label(f, &nullLabel);
          src2JitVal = inst->getROps()[2]->getJitValue(this, f, type, block);
          res->storeJitValue(this, f, type, src2JitVal, block);

          jit_insn_label(f, &doneLabel);

          break;
        }

        case PCIT::NULL_TEST_MBIN32S_MATTR5_IBIN32S_IBIN32S:
        {
          src1 = inst->getROps()[0];
          res = inst->getWOps()[0];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);

          NABoolean testForNull = (inst->code[9] != 0);

          // Generate more efficient code if next instruction is logical branch
          if (inst->next && inst->next->isAnyLogicalBranch())
          {
            NABoolean srcLive, tgtLive;

            PCodeInst* branch = inst->next;

            PCodeOperand* bSrc = branch->getROps()[0];
            PCodeOperand* bTgt = branch->getWOps()[0];

            // Is source or target live after branch?
            srcLive = bSrc->isVar() || block->isOperandLiveInSuccs(bSrc);
            tgtLive = bTgt->isVar() || block->isOperandLiveInSuccs(bTgt);

            // Only generate efficient path if the null-test is associated with
            // the branch, and that both the src and tgt of the branch are not
            // live (which would otherwise require one or more stores).
            if ((bSrc->getBvIndex()==res->getBvIndex()) && !srcLive && !tgtLive)
            {
              jitLabel = block->getTargetBlock()->getJitLabel();

              // Branch to destination according to the test performed.
              switch (branch->getOpcode()) {
                case PCIT::BRANCH_OR:
                case PCIT::BRANCH_OR_CNT:
                  if (testForNull)
                    jit_insn_branch_if(f, src1JitVal, jitLabel);
                  else
                    jit_insn_branch_if_not(f, src1JitVal, jitLabel);
                  break;

                case PCIT::BRANCH_AND:
                case PCIT::BRANCH_AND_CNT:
                  if (testForNull)
                    jit_insn_branch_if_not(f, src1JitVal, jitLabel);
                  else
                    jit_insn_branch_if(f, src1JitVal, jitLabel);
                  break;
              }

              // Skip the next instruction (branch) since it was handled here.
              skipInst = 1;
              break;
            }
          }
          else if (inst->next && inst->next->getOpcode() == PCIT::MOVE_MBIN32S)
          {
            PCodeInst* move = inst->next;
            if (res->getBvIndex() == move->getROps()[0]->getBvIndex())
            {
              jit_label_t l1 = jit_label_undefined;

              // A RETURN is guaranteed to following a MOVE_MBIN32S
              assert (move->next && (move->next->getOpcode() == PCIT::RETURN));

              if (testForNull)
                jit_insn_branch_if(f, src1JitVal, &l1);
              else
                jit_insn_branch_if_not(f, src1JitVal, &l1);

              jit_insn_return(f, fJitVal_);

              jit_insn_label(f, &l1);
              jit_insn_return(f, tJitVal_);

              // Skip the next 2 instructions since it was handled here.
              skipInst = 2;
              break;
            }
          }
          
          // Fall-through (default) case to implement NULL_TEST

          if (testForNull)
            resJitVal = jit_insn_ne(f, src1JitVal, zeroJitVal_);
          else
            resJitVal = jit_insn_eq(f, src1JitVal, zeroJitVal_);

          inst->getWOps()[0]->setJitValue(this, f, resJitVal, block);

          break;
        }

        case PCIT::STRLEN_MBIN32U_MATTR5:
        {
          jit_type_t vcType;
          jit_value_t vcLenJitVal;

          src1 = inst->getROps()[0]; 
          res = inst->getWOps()[0];

          if (src1->getVcIndicatorLen() == 2) {
            vcType = jit_type_ushort;
            vcLenJitVal = jit_value_create_nint_constant(f, jit_type_int, 2);
          }
          else {
            vcType = jit_type_uint;
            vcLenJitVal = jit_value_create_nint_constant(f, jit_type_int, 4);
          }

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          resJitVal = jit_insn_load_relative(f, src1JitVal, 0, vcType);

          // If length is 2 bytes, then convert it to 4 bytes before storage
          if (src1->getVcIndicatorLen() == 2)
            resJitVal = jit_insn_convert(f, resJitVal, jit_type_int, 0);

          res->storeJitValue(this, f, jit_type_int, resJitVal, block);

          break;
        }

        case PCIT::POS_MBIN32S_MATTR5_MATTR5:
        {
          break;
        }

        case PCIT::AND_MBIN32S_MBIN32S_MBIN32S:
        {
          jit_label_t ret0Label = jit_label_undefined;
          jit_label_t endLabel = jit_label_undefined;

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

          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, jit_type_int, block);
          src2JitVal = src2->getJitValue(this, f, jit_type_int, block);

          resJitVal = jit_insn_and(f, src1JitVal, src2JitVal);
          jit_insn_branch_if_not(f, resJitVal, &ret0Label);

          resJitVal = jit_insn_or(f, src1JitVal, src2JitVal);
          res->storeJitValue(this, f, jit_type_int, resJitVal, block);
          jit_insn_branch(f, &endLabel);

          jit_insn_label(f, &ret0Label);
          res->storeJitValue(this, f, jit_type_int, zeroJitVal_, block);

          jit_insn_label(f, &endLabel);

          break;
        }

        case PCIT::OR_MBIN32S_MBIN32S_MBIN32S:
        {
          jit_value_t t1, t2;

          jit_label_t ret1Label = jit_label_undefined;
          jit_label_t endLabel = jit_label_undefined;

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

          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];

          src1JitVal = src1->getJitValue(this, f, jit_type_int, block);
          t1 = jit_insn_eq(f, src1JitVal, oneJitVal_);

          src2JitVal = src2->getJitValue(this, f, jit_type_int, block);
          t2 = jit_insn_eq(f, src2JitVal, oneJitVal_);

          resJitVal = jit_insn_or(f, t1, t2);
          jit_insn_branch_if(f, resJitVal, &ret1Label);

          resJitVal = jit_insn_or(f, src1JitVal, src2JitVal);
          res->storeJitValue(this, f, jit_type_int, resJitVal, block);
          jit_insn_branch(f, &endLabel);

          jit_insn_label(f, &ret1Label);
          res->storeJitValue(this, f, jit_type_int, oneJitVal_, block);

          jit_insn_label(f, &endLabel);

          break;
        }

        case PCIT::MINMAX_MBIN8_MBIN8_MBIN32S_IBIN32S:
        {
          jit_type_t type;
          jit_label_t doneLabel = jit_label_undefined;

          src1 = inst->getROps()[0]; // Source pointer
          src2 = inst->getROps()[1]; // Result of comparison

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

          src2JitVal = src2->getJitValue(this, f, jit_type_int, block);

          jit_insn_branch_if_not(f, src2JitVal, &doneLabel);

          // Get type associated with length, since generic MBINS is used to
          // represent source/tgt.  If not, getJitType() is called, and it will
          // assume we're dealing with a void ptr by default.

          switch(src1->getLen()) {
            case 1:
              type = jit_type_ubyte;
              break;
            case 2:
              type = jit_type_ushort;
              break;
            case 4:
              type = jit_type_uint;
              break;
            case 8:
              type = jit_type_long;
              break;
            default:
            {
              type = jit_type_void_ptr;
              break;
            }
          }

          src1JitVal = src1->getJitValue(this, f, type, block);
          res->setJitValue(this, f, src1JitVal, block);

          jit_insn_label(f, &doneLabel);

          break;
        }

        case PCIT::SWITCH_MBIN32S_MBIN64S_MPTR32_IBIN32S_IBIN32S:
        {
          jit_value_t t1, t2, t3, t4, t5, t6, t7, tableEnd;

          jit_label_t startLoop = jit_label_undefined;
          jit_label_t trueLabel = jit_label_undefined;
          jit_label_t falseLabel = jit_label_undefined;

          jit_value_t hashTableJitVal;

          jit_value_t invalidInt32JitVal =
            jit_value_create_nint_constant(f, jit_type_uint, INVALID_INT32);

          jit_value_t hashTableSizeJitVal =
            jit_value_create_nint_constant(f, jit_type_uint, inst->code[7]);

          // 1. Get the 64-bit value and hash it.
          // 2. Take result and mod it by size of hash table.
          // 3. Start loop
          // 4.  Get element and compare to INVALID_INT64 (maybe just INT32?)
          // 5.    If EQUAL - compare value with source
          // 6.      If EQUAL - store 1
          // 7.      ELSE: Increment index by 1 and compare with size
          // 8.        If beyond table size, store 0
          // 9.        ELSE: Jump back to loop header
          // 9.    ELSE: store 0 

          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];
          res = inst->getWOps()[0];

          // Step 1
          src1JitVal = src1->getJitValue(this, f, jit_type_void_ptr, block);
          resJitVal = genHash(f, src1JitVal, NULL, loopIndex, 8);

          // Step 2
          resJitVal = jit_insn_rem(f, resJitVal, hashTableSizeJitVal);

          // Step 3-4
          hashTableJitVal=src2->getJitValue(this, f, src2->getJitType(), block);
          resJitVal = jit_insn_load_elem_address(f, hashTableJitVal, resJitVal,
                                                 jit_type_ulong);

          // End of table is basically "size" * "sizeof(Int64)".
          tableEnd = jit_insn_add_relative(f, hashTableJitVal, 8*inst->code[7]);

          // Load the 8 bytes associated with the source before the loop
          t6 = jit_insn_load_relative(f, src1JitVal, 0, jit_type_uint);
          t7 = jit_insn_load_relative(f, src1JitVal, 4, jit_type_uint);

          jit_insn_label(f, &startLoop);

          t1 = jit_insn_load_relative(f, resJitVal, 0, jit_type_uint);
          t2 = jit_insn_load_relative(f, resJitVal, 4, jit_type_uint);
          t3 = jit_insn_eq(f, t1, invalidInt32JitVal);
          t4 = jit_insn_eq(f, t2, invalidInt32JitVal);
          t5 = jit_insn_and(f, t3, t4);

          jit_insn_branch_if(f, t5, &falseLabel);

          // Step 5-6

          t3 = jit_insn_eq(f, t1, t6);
          t4 = jit_insn_eq(f, t2, t7);
          t5 = jit_insn_and(f, t3, t4);
          jit_insn_branch_if(f, t5, &trueLabel);

          // Step 7
          t6 = jit_insn_add_relative(f, resJitVal, 8);
          jit_insn_store(f, resJitVal, t6);

          t4 = jit_insn_eq(f, t6, tableEnd);
          jit_insn_branch_if_not(f, t4, &startLoop);

          if (!jitProcessPredicate(inst, f, &falseLabel, &trueLabel, FALSE)) {
            assert(FALSE);
          } else
            skipInst = 1;

          // Libjit bad -O2 code gen when remainder generated with constants.
          lowerOptLevel = TRUE;

          break;
        }


        case PCIT::SWITCH_MBIN32S_MATTR5_MPTR32_IBIN32S_IBIN32S:
        {
          jit_value_t t1, t2, t3, t4, t5, tableEnd;
          jit_value_t len = NULL;

          jit_label_t startLoop = jit_label_undefined;
          jit_label_t trueLabel = jit_label_undefined;
          jit_label_t falseLabel = jit_label_undefined;
          jit_label_t tryAgainLabel = jit_label_undefined;

          jit_value_t hashTableJitVal;

          jit_value_t invalidInt32JitVal =
            jit_value_create_nint_constant(f, jit_type_uint, INVALID_INT32);

          jit_value_t hashTableSizeJitVal =
            jit_value_create_nint_constant(f, jit_type_uint, inst->code[10]);

          // 1. Get the string value (minus any padding) and hash it.
          // 2. Take result and mod it by size of hash table.
          // 3. Start loop
          // 4.  Get element and compare to INVALID_INT32
          // 5.    If EQUAL - compare string with source
          // 6.      If EQUAL - store 1
          // 7.      ELSE: Increment index by 1 and compare with size
          // 8.        If beyond table size, store 0
          // 9.        ELSE: Jump back to loop header
          // 9.    ELSE: store 0

          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];
          res = inst->getWOps()[0];

          // Step 1
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          len = genStringSetup(f, &src1JitVal, src1, TRUE);

          jit_insn_store(f, tSrc1, src1JitVal);
          resJitVal = genHash(f, tSrc1, len, loopIndex, src1->getLen());

          // Step 2
          resJitVal = jit_insn_rem(f, resJitVal, hashTableSizeJitVal);

          // Step 3-4
          hashTableJitVal=src2->getJitValue(this, f, src2->getJitType(), block);
          resJitVal = jit_insn_load_elem_address(f, hashTableJitVal, resJitVal,
                                                 jit_type_ulong);

          // End of table is basically "size" * "sizeof(Int64)".
          tableEnd = jit_insn_add_relative(f, hashTableJitVal,8*inst->code[10]);

          jit_insn_label(f, &startLoop);

          t1 = jit_insn_load_relative(f, resJitVal, 0, jit_type_uint);
          t3 = jit_insn_eq(f, t1, invalidInt32JitVal);
          jit_insn_branch_if(f, t3, &falseLabel);

          // Step 5-6
          t4 = jit_insn_ne(f, t1, len);
          jit_insn_branch_if(f, t4, &tryAgainLabel);

          // Set up arguments and make indirect call to str_cmp routine.
          t2 = jit_insn_load_relative(f, resJitVal, 4, jit_type_uint);
          src2JitVal =
            jit_insn_load_elem_address(f, jitParams_[1], t2, jit_type_ubyte);

          jit_value_t args[3] = {src1JitVal, src2JitVal, len};
          t1 = jit_insn_call_indirect(f, strcmpJitVal,
                                      strcmpSig, args, 3, 0);

          jit_insn_branch_if_not(f, t1, &trueLabel);

          // Step 7
          jit_insn_label(f, &tryAgainLabel);

          t5 = jit_insn_add_relative(f, resJitVal, 8);
          jit_insn_store(f, resJitVal, t5);

          t4 = jit_insn_eq(f, t5, tableEnd);
          jit_insn_branch_if_not(f, t4, &startLoop);

          if (!jitProcessPredicate(inst, f, &falseLabel, &trueLabel, FALSE)) {
            assert(FALSE);
          } else {
            //FIXME: we may skip more than 1 inst if next inst is a MOVE_MBIN32S
            skipInst = 1;
          }

          // Libjit bad -O2 code gen when remainder generated with constants.
          lowerOptLevel = TRUE;

          break;
        }

        case PCIT::HASHCOMB_BULK_MBIN32U:
        {
          jit_value_t t3, t4, t5, oldResJitVal = NULL;

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

          // The list of source operands come in potentially rearranged, so that
          // the parallel hash algorithm could run through this faster.  But
          // with native exprs, we do not call hashP, and so we need to hash
          // the source operands in order.  Re-re-arrange them :).

          OPLIST origList;                  // List of operands in order.

          Int32 min = 0;                    // first position to start off is 0.
          CollIndex length = inst->code[1]; // Total length of instruction.

          // Walk through instruction (skipping header stuff) and identify the
          // source operand having the "min" position.  Once found, insert it
          // into the origList, and then restart check with "min" set to the
          // next position.

          for (j=4; j < length;) {
            if (inst->code[j+3] == min) {
              // Add the appropriate source to the list
              origList.insert(inst->getROps()[(j >> 2) - 1]);

              // Get the next min position, and restart by setting j to 4;
              min++;
              j = 4;
            }
            else {
              // Move to the next source.
              j += 4;
            }
          }

          assert (inst->getROps().entries() == origList.entries());

          for (j=0; j < origList.entries(); j++) {
            src1 = origList[j];
            Int32 len = src1->getLen();

            // If the source length is 0, then the source represents the result
            // of a previously computed hash instruction.  Otherwise, get the
            // source as a pointer and call genHash to get the result.
            if (len > 0) {
              src1JitVal = src1->getJitValue(this, f, jit_type_void_ptr, block);
              resJitVal = genHash(f, src1JitVal, NULL, loopIndex, len);
            }
            else
              resJitVal = src1->getJitValue(this, f, jit_type_uint, block);
  
            // Combine previous hash results if this is not the 1st run through.
            if (j > 0) {
              //
              // Hashcomb is performed similarly to how Hash is performed - see
              // PCodeCfg::genHash()
              //
              // Compute: t3 = oldResJitVal << 1
              //          t4 = oldResJitVal >> 31
              //          t5 = (t3 | t4)
              //          resJitVal = t5 ^ resJitVal
              //

              t3 = jit_insn_shl(f, oldResJitVal, oneJitVal_);
              t4 = jit_insn_ushr(f, oldResJitVal, shiftRVal);
              t5 = jit_insn_or(f, t3, t4);

              resJitVal = jit_insn_xor(f, t5, resJitVal);
            }

            oldResJitVal = resJitVal;
          }

          res->storeJitValue(this, f, jit_type_uint, resJitVal, block);

          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:
        {
          jit_value_t len = NULL;

          src1 = inst->getROps()[0]; 
          res = inst->getWOps()[0];

          // Need to get pointer to operands
          src1JitVal = src1->getJitValue(this, f, jit_type_void_ptr, block);

          // Get length and setup string if we're hashing a varchar.
          if (opc == PCIT::HASH_MBIN32U_MATTR5)
            len = genStringSetup(f, &src1JitVal, src1, TRUE);

          resJitVal = genHash(f, src1JitVal, len, loopIndex, src1->getLen());

          res->storeJitValue(this, f, jit_type_uint, resJitVal, block);

          break;
        }

        case PCIT::RANGE_MFLT64:
        {
          break;
        }

#if 0
        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:
        {
          jit_value_t t1, t2, t3, t4, t5;

          src1 = inst->getROps()[0]; 
          res = inst->getWOps()[0];

          Int32 j, len = src1->getLen();

          // Need to get pointers to operands
          src1JitVal = src1->getJitValue(this, f, jit_type_void_ptr, block);

          // Handles fixed-length strings, but let's not do all of them now.
          if (len > 2000)
            assert(FALSE);

          t1 = jit_insn_load_relative(f, src1JitVal, 0, jit_type_ubyte);
          resJitVal = jit_insn_load_elem(f, hashTableJitVal_, t1,
                                         jit_type_uint);

          // Unroll hash using known length
          for (j=1; j < len; j++)
          {
            //
            // Compute: t1 = src[j]
            //          t2 = randomHashValues[t1]
            //          t3 = resJitVal << 1
            //          t4 = resJitVal >> 31
            //          t5 = (t3 | t4)
            //    resJitVal = t5 ^ resJitVal
            //
            t1 = jit_insn_load_relative(f, src1JitVal, j, jit_type_ubyte);
            t2 = jit_insn_load_elem(f, hashTableJitVal_, t1, jit_type_uint);
            t3 = jit_insn_shl(f, resJitVal, oneJitVal_);
            t4 = jit_insn_ushr(f, resJitVal, shiftRVal);
            t5 = jit_insn_or(f, t3, t4);
            resJitVal = jit_insn_xor(f, t5, t2);
          }

          res->storeJitValue(this, f, jit_type_uint, resJitVal, block);

          break;
        }
#endif

        case PCIT::SUB_MBIGS_MBIGS_MBIGS_IBIN32S:
        {
          res = inst->getWOps()[0];
          src1 = inst->getROps()[0]; 
          src2 = inst->getROps()[1]; 

          jit_value_t lenJitVal =
            jit_value_create_nint_constant(f, jit_type_int, src1->getLen());

          // Need to get pointers to operands
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          resJitVal = res->getJitValue(this, f, res->getJitType(), block);

          // Set up arguments and make indirect call to compare routine.
          jit_value_t args[4] = {resJitVal, src1JitVal, src2JitVal, lenJitVal};
          resJitVal = jit_insn_call_indirect(f, bigSubJitVal,
                                             bigSig, args, 4, 0);

          jit_insn_branch_if(f, resJitVal, &errorJitLabel);

          break;
        }

        case PCIT::ADD_MBIGS_MBIGS_MBIGS_IBIN32S:
        {
          jit_label_t fastPathLabel = jit_label_undefined;
          jit_label_t endLabel = jit_label_undefined;
          jit_value_t t1, t2, t3, t4, t5, carry = NULL;

          res = inst->getWOps()[0];
          src1 = inst->getROps()[0]; 
          src2 = inst->getROps()[1]; 

          Int32 len = src1->getLen();

          // Need to get pointers to operands
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          resJitVal = res->getJitValue(this, f, res->getJitType(), block);

          // Get sign bits.  No need to clear (I think)
          if ((len % 4) == 0) {
            t1=jit_insn_load_relative(f, src1JitVal, (len>>2)-1,jit_type_uint);
            t2=jit_insn_load_relative(f, src2JitVal, (len>>2)-1,jit_type_uint);
            t3=jit_insn_and(f, t1, jitValMask32);
            t4=jit_insn_and(f, t2, jitValMask32);
          }
          else {
            t1=jit_insn_load_relative(f, src1JitVal,(len>>1)-1,jit_type_ushort);
            t2=jit_insn_load_relative(f, src2JitVal,(len>>1)-1,jit_type_ushort);
            t3=jit_insn_and(f, t1, jitValMask16);
            t4=jit_insn_and(f, t2, jitValMask16);
          }
          t5 = jit_insn_eq(f, t3, t4);
          jit_insn_branch_if(f, t5, &fastPathLabel);

          // Call subtract function here.
          genBignumSub(this, f, res, src1JitVal, src2JitVal, t1, t2, tSrc1,
                       tSrc2, block);

          jit_insn_branch(f, &endLabel);


          //
          // Fast path.  Here's the algorithm:
          //
          // 1. Add each 16-bit value of the bignum and carry over remainder
          // 2. Ignore (and don't record) remainder for last addition
          // 3. Get sign of src1/src2 and use it to set sign of target.
          //

          jit_insn_label(f, &fastPathLabel);

          for (i=0; i < len; i+=2)
          {
            t1 = jit_insn_load_relative(f, src1JitVal, i, jit_type_ushort);
            t2 = jit_insn_load_relative(f, src2JitVal, i, jit_type_ushort);
            t3 = jit_insn_add(f, t1, t2);

            if (i != 0)
              t3 = jit_insn_add(f, t3, carry);

            t4 = jit_insn_convert(f, t3, jit_type_ushort, 0);

            // Process the last short with the sign bit differently.
            if (i == (len - 2)) {
              jit_value_t clear1 = jit_insn_and(f, t4, jitValNotMask16);
              jit_value_t get1  = jit_insn_and(f, t1, jitValMask16);
              t4 = jit_insn_or(f, clear1, get1);
              jit_insn_store_relative(f, resJitVal, i, t4);
            }
            else {
              jit_insn_store_relative(f, resJitVal, i, t4);
              carry = jit_insn_ushr(f, t3, jitVal16);
            } 
          }

          jit_insn_label(f, &endLabel);

          break;
        }

        case PCIT::OPDATA_MPTR32_IBIN32S:
        case PCIT::OPDATA_MPTR32_IBIN32S_IBIN32S:
        case PCIT::OPDATA_MBIN16U_IBIN32S:
        case PCIT::OPDATA_MATTR5_IBIN32S:
        {
          OPLIST opList =
            (inst->getWOps().entries() ? inst->getWOps() : inst->getROps());

          Int32 index =
            (opc == PCIT::OPDATA_MPTR32_IBIN32S_IBIN32S) ? inst->code[4] 
            : ((opc == PCIT::OPDATA_MATTR5_IBIN32S) ? inst->code[6]
               : inst->code[3]);

          // Add the "correct" operand for this opdata instruction, replacing
          // the old one in the operand list used during pcode opts.
          setupClauseOperand(this, opList, opData, index, inst->clause_);

          break;
        }

        case PCIT::CLAUSE_EVAL:
        {
          jit_label_t doneLabel = jit_label_undefined;
          jit_label_t trueLabel = jit_label_undefined;
          jit_label_t falseLabel = jit_label_undefined;
          jit_label_t nullLabel = jit_label_undefined;

          // on 64-bit the clause pointer is in code[1] and code[2]
          ex_clause* clause = (ex_clause*)*(Long*)&(inst->code[1]);
          NABoolean processNulls = inst->code[1 + PCODEBINARIES_PER_PTR];

          switch (clause->getClassID()) {
            case ex_clause::AGGR_MIN_MAX_ID:
            {
              //
              // Format:
              //
              // attr[0] - Aggregate
              // attr[1] - Column
              // attr[2] - Comparison result
              //

              // First branch away if comp result indicates no update needed. 
              // Note, since this check is always made, the jit value from the
              // null-check can be used outside of the CLAUSE_EVAL.
              src2 = opDataVals[2];
              src2JitVal = src2->getJitValue(this, f, jit_type_int, block);
              jit_insn_branch_if_not(f, src2JitVal, &doneLabel);

              // We need to copy over source into aggregate.  First take care of
              // the null indicator if the aggregate is nullable.
              if (clause->getOperand(0)->getNullFlag()) {
                // If column is nullable too, then we need to check it.  If it's
                // NULL, we don't do anything.

                if (clause->getOperand(1)->getNullFlag()) {
                  src1 = opDataNulls[1];
                  src1JitVal =
                    src1->getJitValue(this, f, src1->getJitType(), block,
                                      NULL, TRUE /* no assign jit val */);

                  jit_insn_branch_if(f, src1JitVal, &doneLabel);
                }

                // Null out the null indicator for the aggregate.  Based on the
                // current code, the null indicator for the aggregate is always
                // in exploded format, so assert that here and then simplify
                // code generation.
                assert(!opDataNulls[0]->forAlignedFormat());

                opDataNulls[0]->setJitValue(this, f, zeroJitVal16, block, TRUE);
              }

              // Now we have to handle moving the data over from column to aggr.
              res = opDataVals[0];
              src1 = opDataVals[1];

              src1JitVal = src1->getJitValue(this, f, src1->getJitType(),
                                             block, NULL, TRUE /* no assign */);

              if (res->isVarchar())
              {
                // The following code was taken from MOVE_MATTR5_MATTR5, but
                // re-formatted here.
                jit_type_t vcType;
                jit_value_t vcLenJitVal;

                if (src1->getVcIndicatorLen() == 2) {
                  vcType = jit_type_ushort;
                  vcLenJitVal=jit_value_create_nint_constant(f, jit_type_int,2);
                }
                else {
                  vcType = jit_type_uint;
                  vcLenJitVal=jit_value_create_nint_constant(f, jit_type_int,4);
                }

                resJitVal = res->getJitValue(this, f, res->getJitType(), block,
                                             NULL, TRUE /* no assign */);

                jit_insn_store(f, tRes, resJitVal);
                jit_insn_store(f, tSrc1, src1JitVal);

                jit_value_t srcLen =
                  jit_insn_load_relative(f, src1JitVal, 0, vcType);

                srcLen = jit_insn_add(f, srcLen, vcLenJitVal);

                genUnalignedMemcpy(f, tRes, tSrc1, srcLen);
              }
              else
                res->storeJitValue(this, f, res->getJitType(),src1JitVal,
                                   block, NULL, TRUE);

              // Reached the end point
              jit_insn_label(f, &doneLabel);

              break;
            }

            case ex_clause::COMP_TYPE:
            {
              switch (((ex_comp_clause*)clause)->getInstruction()) {
                case NE_DATETIME_DATETIME:
                case EQ_DATETIME_DATETIME:
                case LT_DATETIME_DATETIME:
                case GT_DATETIME_DATETIME:
                case LE_DATETIME_DATETIME:
                case GE_DATETIME_DATETIME:
                {
                  jit_value_t year1, year2;

                  res = opDataVals[0];
                  src1 = opDataVals[1];
                  src2 = opDataVals[2];

                  src1JitVal = src1->getJitValue(this, f, jit_type_void_ptr,
                                                 block, NULL);
                  src2JitVal = src2->getJitValue(this, f, jit_type_void_ptr,
                                                 block, NULL);
                  if (processNulls) {
                    PCodeOperand* nullOp;
                    jit_value_t nullJitVal;

                    if (clause->getOperand(1)->getNullFlag()) {
                      nullOp = opDataNulls[1];
                      nullJitVal =
                      nullOp->getJitValue(this, f, nullOp->getJitType(), block,
                                          NULL, TRUE /* no assign jit val */);

                      jit_insn_branch_if(f, nullJitVal, &nullLabel);
                    }

                    if (clause->getOperand(2)->getNullFlag()) {
                      nullOp = opDataNulls[2];
                      nullJitVal =
                      nullOp->getJitValue(this, f, nullOp->getJitType(), block,
                                          NULL, TRUE /* no assign jit val */);

                      jit_insn_branch_if(f, nullJitVal, &nullLabel);
                    }
                  }

                  long dtCode =
                    ((ExpDatetime*)(clause->getOperand(1)))->getPrecision();

                  switch (dtCode)
                  {
                    case REC_DTCODE_TIME:
                    case REC_DTCODE_DATE:
                    case REC_DTCODE_TIMESTAMP:
                    {
                      // Boolean used to indicate whether branch should go to
                      // true block or not.  Assume "not" by default.
                      NABoolean dumpTrueBlockFirst = TRUE;  // May change later

                      Int32 size = (clause->getOperand(1))->getLength();

                      // Cycle through each field in the date-related struct.
                      Int32 typeSize = 0;
                      for (i=0; i < size; i += typeSize)
                      {
                        jit_type_t type;

                        // Are we getting the fractional seconds?
                        if ((i == size-4) && (dtCode == REC_DTCODE_TIMESTAMP)) {
                          type = jit_type_uint;
                          typeSize = 4;
                        }
                        // Are we getting the year?
                        else if ((i==0) && (dtCode != REC_DTCODE_TIME)) {
                          type = jit_type_ushort;
                          typeSize = 2;
                        }
                        // We're just getting some particular byte field
                        else {
                          type = jit_type_ubyte;
                          typeSize = 1;
                        }

                        // Get the fields from both sources.
                        year1 = jit_insn_load_relative(f, src1JitVal, i, type);
                        year2 = jit_insn_load_relative(f, src2JitVal, i, type);

                        // Depending on the comparison being performed, generate
                        // 1 (or 2) compares and branches.  Also, based on the
                        // comparison, the fall-through may be the "true" block,
                        // or it may be the "false" block - default is TRUE.

                        switch (((ex_comp_clause*)clause)->getInstruction()) {
                          case NE_DATETIME_DATETIME:
                            resJitVal = jit_insn_ne(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &trueLabel);
                            dumpTrueBlockFirst = FALSE;
                            break;
                          case EQ_DATETIME_DATETIME:
                            resJitVal = jit_insn_ne(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &falseLabel);
                            break;
                          case LT_DATETIME_DATETIME:
                            resJitVal = jit_insn_lt(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &trueLabel);
                            resJitVal = jit_insn_gt(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &falseLabel);
                            dumpTrueBlockFirst = FALSE;
                            break;
                          case GT_DATETIME_DATETIME:
                            resJitVal = jit_insn_gt(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &trueLabel);
                            resJitVal = jit_insn_lt(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &falseLabel);
                            dumpTrueBlockFirst = FALSE;
                            break;
                          case LE_DATETIME_DATETIME:
                            resJitVal = jit_insn_lt(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &trueLabel);
                            resJitVal = jit_insn_gt(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &falseLabel);
                            break;
                          case GE_DATETIME_DATETIME:
                            resJitVal = jit_insn_gt(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &trueLabel);
                            resJitVal = jit_insn_lt(f, year1, year2);
                            jit_insn_branch_if(f, resJitVal, &falseLabel);
                            break;
                        }
                      }

                      if (!dumpTrueBlockFirst)
                      {
                        // False label first.
                        jit_insn_label(f, &falseLabel);
                        res->storeJitValue(this, f, jit_type_int, zeroJitVal_,
                                           block);
                        jit_insn_branch(f, &doneLabel);

                        // True label next.
                        jit_insn_label(f, &trueLabel);
                        res->storeJitValue(this, f, jit_type_int, oneJitVal_,
                                           block);
                        jit_insn_branch(f, &doneLabel);
                      }
                      else {
                        // True label first.
                        jit_insn_label(f, &trueLabel);
                        res->storeJitValue(this, f, jit_type_int, oneJitVal_,
                                           block);
                        jit_insn_branch(f, &doneLabel);

                        // False label next.
                        jit_insn_label(f, &falseLabel);
                        res->storeJitValue(this, f, jit_type_int, zeroJitVal_,
                                           block);
                        jit_insn_branch(f, &doneLabel);
                      }

                      // Null label last.
                      jit_insn_label(f, &nullLabel);
                      res->storeJitValue(this,f,jit_type_int,neg1JitVal_,block);

                      jit_insn_label(f, &doneLabel);

                      break;
                    }
                      
                    default:
                      assert(FALSE);
                  }
                  break;
                }
              }

              break;
            }
          }

          // Clear out opData for subsequent use.
          str_pad((char*)opData,
                  (3*ex_clause::MAX_OPERANDS)*sizeof(PCodeOperand*), 0);

          break;
        }

#if 0
        //
        // SUBSTR should be completely implemented, but I don't recall if it
        // was properly tested.  Also, SUBSTR should be improved such that if
        // the result is to a temp operand, then modify the temp such that it
        // serves really as a pointer to a string, and not the string itself,
        // such that the computation needed would just be a) storage of the
        // variable length (if varchar), and b) the pointer to the start of the
        // substring.  This will save on unnecessary string copies.
        case PCIT::SUBSTR_MATTR5_MATTR5_MBIN32S_MBIN32S:
        {
          jit_value_t strLen, tgtLen, cmpVal, startPosVal, forLenVal;
          jit_label_t legitStartLabel = jit_label_undefined;
          jit_label_t startCopyLabel = jit_label_undefined;
          jit_label_t doneLabel = jit_label_undefined;
          Int32 startPos, totalLen=0, forLen=0;

          // Get operands
          src1 = inst->getROps()[0];
          res = inst->getWOps()[0];

          // Get start position and forLen (if provided)
          startPos = getIntConstValue(inst->getROps()[1]);
          if (inst->getROps().entries() == 3)
            forLen = getIntConstValue(inst->getROps()[2]);

          // Set up src1 string and length
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          strLen = genStringSetup(f, &src1JitVal, src1);

          // Let's set up the src1JitVal pointer to the start position.
          startPosVal =
            jit_value_create_nint_constant(f, jit_type_int, startPos-1);
          src1JitVal = jit_insn_add(f, src1JitVal, startPosVal);

          // If we're dealing with a varchar, do checks at run-time, and then
          // generate copy to completion.
          if (src1->isVarchar())
          {
            // Set up value that is used to record length to copy
            jit_value_t subLenVal = jit_value_create(f, jit_type_int);

            // 1. If start > strLen, return empty string.
            cmpVal = jit_insn_lt(f, startPosVal, strLen);
            jit_insn_branch_if(f, cmpVal, &legitStartLabel);

            jit_insn_store(f, subLenVal, zeroJitVal_);
            jit_insn_branch(f, &startCopyLabel);

            jit_insn_label(f, &legitStartLabel);

            // 2. Calculate max # of chars to copy
            if (startPos == 1)
              tgtLen = strLen;
            else {
              jit_value_t tVal =
                jit_value_create_nint_constant(f, jit_type_int, 1-startPos);
              tgtLen = jit_insn_add(f, strLen, tVal);
            }

            jit_insn_store(f, subLenVal, tgtLen);

            // 3. If a forLen was provided, tgtLen = min (tgtLen, forLen)
            if (forLen) {
              forLenVal = jit_value_create_nint_constant(f,jit_type_int,forLen);

              cmpVal = jit_insn_ge(f, forLenVal, tgtLen);
              jit_insn_branch_if(f, cmpVal, &startCopyLabel);

              jit_insn_store(f, subLenVal, forLenVal);
            }

            jit_insn_label(f, &startCopyLabel);

            // Get result string.  Store length first before setting the string
            // up.  The result length does not need to be retrieved.
            resJitVal = res->getJitValue(this, f, res->getJitType(), block);
            if (res->getVcIndicatorLen() == 2)
              tgtLen = jit_insn_convert(f, subLenVal, jit_type_ushort, 0);
            else
              tgtLen = jit_insn_convert(f, subLenVal, jit_type_uint, 0);

            jit_insn_store_relative(f, resJitVal, 0, tgtLen);

            // If the length to copy is zero, bail out
            jit_insn_branch_if_not(f, subLenVal, &doneLabel);

            // Set up the target string, without asking for the length.
            genStringSetup(f, &resJitVal, res, FALSE /* pad */, FALSE /*len*/);

            jit_insn_store(f, tRes, resJitVal);
            genUnalignedMemcpy(f, tRes, src1JitVal, subLenVal);
          }
          else {
            // Do compile-time checks here, and then generate copy to completion
            Int32 maxLen = src1->getLen();
            if (startPos > maxLen)
              totalLen = 0;
            else {
              totalLen = (maxLen - startPos + 1);
              if (forLen) {
                if (forLen < totalLen)
                  totalLen = forLen;
              }
            }

            // Store the vc indicator length
            tgtLen = jit_value_create_nint_constant(f,jit_type_ushort,totalLen);
            if (res->getVcIndicatorLen() == 4) {
              tgtLen =
                jit_value_create_nint_constant(f, jit_type_uint, totalLen);
            }
            resJitVal = res->getJitValue(this, f, res->getJitType(), block);
            jit_insn_store_relative(f, resJitVal, 0, tgtLen);

            // Nothing to write out after length if length itself is 0.
            if (totalLen > 0)
            {
              // Set up the target string, without asking for the length.
              genStringSetup(f, &resJitVal, res, FALSE /*pad*/, FALSE /*len*/);

              tgtLen = jit_value_create_nint_constant(f,jit_type_uint,totalLen);

              jit_insn_store(f, loopIndex, tgtLen);
              jit_insn_store(f, tRes, resJitVal);
              genUnalignedMemcpy(f, tRes, src1JitVal, loopIndex);
            }
          }

          // Done!  resJitVal already attached to result, so just break.
          jit_insn_label(f, &doneLabel);

          break;
        }
#endif

        case PCIT::CONCAT_MATTR5_MATTR5_MATTR5:
        {
          jit_value_t len1, len2, totalLen;

          // Get operands
          src1 = inst->getROps()[0];
          src2 = inst->getROps()[1];
          res = inst->getWOps()[0];

          // Check previously made check that src1->len + src2->len <= tgt->len
          assert((src1->getVcMaxLen() + src2->getVcMaxLen() <=
                 res->getVcMaxLen()));

          // Set up src1 string and length
          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          len1 = genStringSetup(f, &src1JitVal, src1);

          // Set up src2 string and length
          src2JitVal = src2->getJitValue(this, f, src2->getJitType(), block);
          len2 = genStringSetup(f, &src2JitVal, src2);

          // Calculate what the final length should be for target.
          totalLen = jit_insn_add(f, len1, len2);

          // Get result string.  Store length (if varchar) first before setting
          // the string up.  The result length does not need to be retrieved.
          resJitVal = res->getJitValue(this, f, res->getJitType(), block);
          if (res->isVarchar()) {
            if (res->getVcIndicatorLen() == 2)
              totalLen = jit_insn_convert(f, totalLen, jit_type_ushort, 0);
            else
              totalLen = jit_insn_convert(f, totalLen, jit_type_uint, 0);

            jit_insn_store_relative(f, resJitVal, 0, totalLen);
          }
          genStringSetup(f, &resJitVal, res, FALSE /* pad */, FALSE /* len */);

          // If all operands are fixed strings, then call genUnalignedMemcpy
          // such that the moves are inlined.
          if (!res->isVarchar() && !src1->isVarchar() && !src2->isVarchar()) {
            genUnalignedMemcpy(f, resJitVal, src1JitVal, NULL, src1->getLen());
            resJitVal = jit_insn_add(f, resJitVal, len1);
            genUnalignedMemcpy(f, resJitVal, src2JitVal, NULL, src2->getLen());
          }
          else {
            // Call genUnalignedMemcpy such that a loop is generated to perform
            // each of the moves.
            jit_insn_store(f, tRes, resJitVal);
            jit_insn_store(f, tSrc1, src1JitVal);

            // If src1 is not a varchar, length must be stored in variable first
            if (src1->isVarchar())
              genUnalignedMemcpy(f, tRes, tSrc1, len1);
            else {
              jit_insn_store(f, loopIndex, len1);
              genUnalignedMemcpy(f, tRes, tSrc1, loopIndex);
            }

            // Set up next source string.  Note, tRes will already be in pos
            // for storage.
            jit_insn_store(f, tSrc1, src2JitVal);

            // If src2 is not a varchar, length must be stored in variable first
            if (src2->isVarchar())
              genUnalignedMemcpy(f, tRes, tSrc1, len2);
            else {
              jit_insn_store(f, loopIndex, len2);
              genUnalignedMemcpy(f, tRes, tSrc1, loopIndex);
            }
          }

          // Nothing more to be done - resJitVal already attached to result.

          break;
        }

        case PCIT::GENFUNC_MATTR5_MATTR5_IBIN32S:
        {
          jit_value_t len, cmp, addVal, minVal, maxVal, changeVal, b1;
          jit_value_t temp1, temp2, temp3;
          jit_label_t loopLabel = jit_label_undefined;
          jit_label_t endLabel = jit_label_undefined;
          jit_label_t noChangeLabel = jit_label_undefined;
          Int32 subOpc = inst->code[11];

          src1 = inst->getROps()[0];
          res = inst->getWOps()[0];

          src1JitVal = src1->getJitValue(this, f, src1->getJitType(), block);
          len = genStringSetup(f, &src1JitVal, src1);

          // Get result string.  Store length (if varchar) first before setting
          // the string up.
          resJitVal = res->getJitValue(this, f, res->getJitType(), block);
          if (res->isVarchar()) {
            jit_value_t newLen;
            if (res->getVcIndicatorLen() == 2)
              newLen = jit_insn_convert(f, len, jit_type_ushort, 0);
            else
              newLen = jit_insn_convert(f, len, jit_type_uint, 0);

            jit_insn_store_relative(f, resJitVal, 0, newLen);
          }
          genStringSetup(f, &resJitVal, res, FALSE /* pad */, FALSE /* len */);

          if (subOpc == ITM_UPPER) {
            minVal = jit_value_create_nint_constant(f, jit_type_sbyte, 'a');
            maxVal = jit_value_create_nint_constant(f, jit_type_sbyte, 'z');
            changeVal = jit_value_create_nint_constant(f, jit_type_sbyte, -32);
          } else {
            minVal = jit_value_create_nint_constant(f, jit_type_sbyte, 'A');
            maxVal = jit_value_create_nint_constant(f, jit_type_sbyte, 'Z');
            changeVal = jit_value_create_nint_constant(f, jit_type_sbyte, 32);
          }

          // Set up pointers to be used and modified inside of loop.
          jit_insn_store(f, tRes, resJitVal);
          jit_insn_store(f, tSrc1, src1JitVal);
          jit_insn_store(f, loopIndex, len);

          // Branch away if we're at end of string
          jit_insn_branch_if_not(f, loopIndex, &endLabel);

          // Loop start
          jit_insn_label(f, &loopLabel);

          // Get byte in source string to compare and inc/dec (if needed)
          b1 = jit_insn_load_relative(f, tSrc1, 0, jit_type_sbyte);

          // Perform comparison(s) and branch.  For eq/ne we just do one
          cmp = jit_insn_lt(f, b1, minVal);
          jit_insn_branch_if(f, cmp, &noChangeLabel);
          cmp = jit_insn_gt(f, b1, maxVal);
          jit_insn_branch_if(f, cmp, &noChangeLabel);

          // Transform byte to upper/lower case and re-save.
          addVal = jit_insn_add(f, b1, changeVal);
          jit_insn_store(f, b1, addVal);

          // Store byte into result.
          jit_insn_label(f, &noChangeLabel);
          jit_insn_store_relative(f, tRes, 0, b1);

          // Decrement loop index
          temp1 = jit_insn_sub(f, loopIndex, oneJitVal_);
          jit_insn_store(f, loopIndex, temp1);

          // Increment string pointers
          temp2 = jit_insn_add(f, tSrc1, oneJitVal_);
          temp3 = jit_insn_add(f, tRes, oneJitVal_);
          jit_insn_store(f, tSrc1, temp2);
          jit_insn_store(f, tRes, temp3);

          // Branch back if loop index <> 0
          jit_insn_branch_if(f, loopIndex, &loopLabel);

          // Nothing more to do since result written inside loop.
          jit_insn_label(f, &endLabel);

          break;
        }
      }
    } ENDFE_INST_IN_BLOCK
  }

  // Lastly, emit an error label where we return ex_expr::ERROR, if such a
  // label was generated.
  if (errorJitLabel != jit_label_undefined) {
    jit_insn_label(f, &errorJitLabel);

    // Set up arguments and make indirect call to compare routine.
    jit_value_t atp1JitVal = jit_value_get_param(f,1);
    jit_value_t args[2] = {atp1JitVal, exprJitVal};
    resJitVal = jit_insn_call_indirect(f, reportErrJitVal,
                                       reportErrSig, args, 2, 0);
    jit_insn_return(f, resJitVal);
  }

  if (getJitFailureSeen()) {
    jit_context_destroy(context);
    return;
  }

  if (debug)
    printBlocks("NativeExpr", FALSE);

  // Set optimization level for jit compilation.
  if (!lowerOptLevel)
    jit_function_set_optimization_level(f, 2);

  // Dump IL for function
  if (debug)
    jit_dump_function(stdout, f, "IL:");

  // Compile the function
  Int32 size = jit_function_compile(f);

  // Get entry point into function and add code into constants array
  ex_expr::evalPtrType entry = (ex_expr::evalPtrType)jit_function_to_closure(f);
  CollIndex* offPtr = addConstant((void*)entry, size, 8);

  // Dump function 
  if (debug)
    jit_dump_function(stdout, f, "X86:");

  // Store offset into evalPtr_
  expr_->setEvalPtr((ex_expr::evalPtrType)(*offPtr));

  // Mark this expression appropriately so that the native function gets called
  expr_->setPCodeMoveFastpath(TRUE);
  expr_->setPCodeNative(TRUE);

  if (showplanSpace)
  {
    NABoolean firstTimeSeen = TRUE;
    char line[256];
    char* linePtr;
    char fileName[50];
    Int32 i;

    // Indicates how much to indent each line.
    const int INDENT_START = 4;

    // Filename for use in dumping text should have process pid in it.
    sprintf(fileName, "/tmp/%d%s", getpid(), "dump1.txt");

    // Use the jit's dump interface to generate the x86 instructions.
    FILE* out = fopen(fileName, "w");
    jit_dump_function(out, f, "eval:");
    fclose(out);
    
    // First print out a header for the native expr dump
    sprintf(line, "Native Expr (Length: %d, Opt: %d)", *offPtr, optLevel);
    showplanSpace->allocateAndCopyToAlignedSpace(line, str_len(line),
                                                 sizeof(short));

    // Start each line with some indentation.
    for (i=0; i < INDENT_START; i++)
      line[i] = ' ';

    // Now read from the jit dump file and feed the lines into our space
    // object.  Is there a better way of doing all of this?
    out = fopen(fileName, "r");
    while (fgets(&(line[INDENT_START]), sizeof line, out) != NULL) {
      // All lines we're interested in begin with "f", as in the address
      // starting as "fffff..".
      if (line[INDENT_START] != 'f')
        continue;

      if (firstTimeSeen) {
        // The first string is just a header that starts the dump off - we can
        // ignore this.
        firstTimeSeen = FALSE;
        continue;
      }

      // Remove newline char (if exists) since call to insert into space object
      // automatically puts in a newline character.
      Int32 len = str_len(line);
      if ((len >= 1) && (line[len-1] = '\n')) {
        len--;
        line[len] = 0;
      }

      showplanSpace->allocateAndCopyToAlignedSpace(line, len, sizeof(short));
    }

    // Close the file out and remove temporary file created.
    fclose(out);
    sprintf(line, "rm %s", fileName);
    system(line);

    // Add a newline to start the next expression off cleanly.
    showplanSpace->allocateAndCopyToAlignedSpace("\n", 1, sizeof(short));
  }

  // Destroy context and cleanup
  jit_context_destroy(context);
}
#endif /* NA_LINUX_LIBJIT */

#endif /* __EID */