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

/**
 * @author Intel, Pavel A. Ozhdikhin
 */

#include "CodeSelectors.h"

namespace Jitrino {

void _VarCodeSelector::genCode(Callback& callback) {
    VarOpnd * v0 = varOpnds;
    if (v0) {
        VarOpnd * v = v0;
        do {
            if (!(v->isDead())) {  // currently need to check, though dead items should be removed in future
                assert(!(v->isDead()));
                varIdMap[v->getId()] = 
                    callback.defVar(v->getType(),v->isAddrTaken(),
                    v->isPinned());
                if(Log::isEnabled()) {
                    Log::out() << "Opt var ";
                    v->print(Log::out());
                    Log::out() << " is CG var " << (int) varIdMap[v->getId()] << ::std::endl;
                }
            }
            v=v->getNextVarOpnd();
        } while (v != v0);
    }

    GCBasePointerMap::iterator i;
    for(i = gcMap.begin(); i != gcMap.end(); ++i) {
        if(Log::isEnabled()) {
            Log::out() << "Set GC base of ";
            i->first->print(Log::out());
            Log::out() << "(" << (int) varIdMap[i->first->getId()] << ") to ";
            i->second->print(Log::out());
            Log::out() << "(" << (int) varIdMap[i->second->getId()] << ")" << ::std::endl;
        }
        callback.setManagedPointerBase(varIdMap[i->first->getId()], varIdMap[i->second->getId()]);
    }
}

U_32 _VarCodeSelector::getNumVarOpnds() {
    VarOpnd* v0 = varOpnds;
    U_32 numVars = 0;
    if (v0) {
        VarOpnd* v = v0;
        do {
            if (!(v->isDead())) { // currently need to check, though in future dead items should be removed
                assert(!(v->isDead()));
                numVars++;
            }
            v = v->getNextVarOpnd();
        } while (v != v0);
    }
    return numVars;
}

//
// maps type and overflow modifier to a ArithmeticOp::Types
//
ArithmeticOp::Types _BlockCodeSelector::mapToArithmOpType(Inst* inst) {
    Type::Tag type = inst->getType();
    OverflowModifier modifier = inst->getOverflowModifier();
    ExceptionModifier excModifier = inst->getExceptionModifier();
    switch (type) {
        case Type::Int32:
            if ((modifier == Overflow_None) || (excModifier == Exception_Never))
                return ArithmeticOp::I4;
            if (modifier == Overflow_Signed)
                return ArithmeticOp::I4_Ovf;
            return ArithmeticOp::U4_Ovf;
        case Type::Int64:
            if ((modifier == Overflow_None) || (excModifier == Exception_Never))
                return ArithmeticOp::I8;
            if (modifier == Overflow_Signed)
                return ArithmeticOp::I8_Ovf;
            return ArithmeticOp::U8_Ovf;
        case Type::IntPtr:
        case Type::UIntPtr:
            if ((modifier == Overflow_None) || (excModifier == Exception_Never))
                return ArithmeticOp::I;
            if (modifier == Overflow_Signed)
                return ArithmeticOp::I_Ovf;
            return ArithmeticOp::U_Ovf;
        case Type::Float:
            return ArithmeticOp::F;
        case Type::Single:
            return ArithmeticOp::S;
        case Type::Double:
            return ArithmeticOp::D;
        default: assert(0);
    }
    assert(0);
    return ArithmeticOp::I;    // to keep the compiler quiet
}
 
//
//  maps type and overflow modifier to a RefArithmeticOp::Type
//
RefArithmeticOp::Types _BlockCodeSelector::mapToRefArithmOpType(Inst* inst, Opnd *src) {
    Type::Tag type = src->getType()->tag;
    OverflowModifier modifier = inst->getOverflowModifier();
    ExceptionModifier excModifier = inst->getExceptionModifier();
    assert(modifier != Overflow_Signed);
    switch (type) {
        case Type::Int32:
            if ((modifier == Overflow_None) || (excModifier == Exception_Never))
                return RefArithmeticOp::I4;
            return RefArithmeticOp::U4_Ovf;
        case Type::IntPtr:
            if ((modifier == Overflow_None) || (excModifier == Exception_Never))
                return RefArithmeticOp::I;
            return RefArithmeticOp::U_Ovf;
        default: assert(0);
    }
    assert(0);
    return RefArithmeticOp::I;    // to keep the compiler quiet
}

//
//  checks if instruction has an overflow modifier
//
bool _BlockCodeSelector::isOverflow(Inst* inst) {
    Modifier mod = inst->getModifier();
    if (mod.hasOverflowModifier()) {
        OverflowModifier modifier = mod.getOverflowModifier();
        return modifier != Overflow_None;
    } else
        return false;
}

//
//  checks if instruction has an exception modifier that can never except
//
bool _BlockCodeSelector::isExceptionNever(Inst* inst) {
    Modifier mod = inst->getModifier();
    if (mod.hasExceptionModifier()) {
        ExceptionModifier modifier = mod.getExceptionModifier();
        return modifier == Exception_Never;
    } else
        return false;
}

//
//  checks if instruction is unsigned
//
bool _BlockCodeSelector::isUnsigned(Inst *inst) {
    Modifier mod = inst->getModifier();
    if (mod.hasSignedModifier()) {
        SignedModifier modifier = mod.getSignedModifier();
        return modifier == UnsignedOp;
    } else {
        assert(0);
        return false;
    }
}

//
// checks if shift instruction needs shift mask
//
bool _BlockCodeSelector::isShiftMask(Inst *inst) {
    assert(inst->getModifier().hasShiftMaskModifier());
    ShiftMaskModifier modifier = inst->getModifier().getShiftMaskModifier();
    return modifier == ShiftMask_Masked;
}

DivOp::Types _BlockCodeSelector::mapToDivOpType(Inst* inst) {
    Type::Tag type = inst->getType();
    SignedModifier modifier = inst->getSignedModifier();
    bool unsignedDiv = (modifier == UnsignedOp);

    switch (type) {
        case Type::Int32: 
            return unsignedDiv ? DivOp::U4 : DivOp::I4;
        case Type::Int64:
            return unsignedDiv ? DivOp::U8 : DivOp::I8;
        case Type::IntPtr:
            return unsignedDiv ? DivOp::U  : DivOp::I;
        case Type::Float:
            return DivOp::F;
        case Type::Single:
            return DivOp::S;
        case Type::Double:
            return DivOp::D;
        default: assert(0);
    }
    assert(0);
    return DivOp::I; // to keep compiler quiet
}

MulHiOp::Types _BlockCodeSelector::mapToMulHiOpType(Inst * inst) {
    Type::Tag type = inst->getType();
    SignedModifier modifier = inst->getSignedModifier();
    bool unsignedMulhi = (modifier == UnsignedOp);

    switch (type) {
        case Type::Int32: 
            return unsignedMulhi ? MulHiOp::U4 : MulHiOp::I4;
        case Type::Int64:
            return unsignedMulhi ? MulHiOp::U8 : MulHiOp::I8;
        case Type::IntPtr:
            return unsignedMulhi ? MulHiOp::U  : MulHiOp::I;
        default: assert(0);
    }
    assert(0);
    return MulHiOp::I; // to keep compiler quiet
}
    
NegOp::Types _BlockCodeSelector::mapToNegOpType(Inst* inst) {
    Type::Tag type = inst->getType();
    switch(type) {
        case Type::Int32:
            return NegOp::I4;
        case Type::Int64:
            return NegOp::I8;
        case Type::IntPtr:
            return NegOp::I;
        case Type::Float:
            return NegOp::F;
        case Type::Single:
            return NegOp::S;
        case Type::Double:
            return NegOp::D;
        default: assert(0);
    }
    assert(0);
    return NegOp::I; // to keep compiler quiet
}

//
//  Maps instruction type to IntegerOp::Types
//
IntegerOp::Types _BlockCodeSelector::mapToIntegerOpType(Inst* inst) {
    Type::Tag type = inst->getType();
    switch (type) {
        case Type::Int32: 
            return IntegerOp::I4;
        case Type::Int64:
            return IntegerOp::I8;
        case Type::IntPtr:
        case Type::UIntPtr:
            return IntegerOp::I;
        default: assert(0);
    }
    assert(0);
    return IntegerOp::I; // to keep compiler quiet
}

//
//  maps type to CompareOp::Types
//
CompareOp::Types _BlockCodeSelector::mapToCompareOpType(Inst* inst) {
    Type::Tag type = inst->getType();
    switch (type) {
        case Type::Int32: 
            return CompareOp::I4;
        case Type::Int64:
            return CompareOp::I8;
        case Type::IntPtr:
        case Type::UIntPtr:
            return CompareOp::I;
        case Type::Float:
            return CompareOp::F;
        case Type::Single:
            return CompareOp::S;
        case Type::Double:
            return CompareOp::D;
        default: 

            assert(Type::isReference(type));
            return CompareOp::Ref;
    }
}

//
//  maps type to CompareZeroOp::Types
//
CompareZeroOp::Types _BlockCodeSelector::mapToCompareZeroOpType(Inst *inst) {
    Type::Tag type = inst->getType();
    switch (type) {
        case Type::Int32:
            return CompareZeroOp::I4;
        case Type::Int64:
            return CompareZeroOp::I8;
        case Type::IntPtr:
            return CompareZeroOp::I;
        default:
            assert(Type::isReference(type));
            return CompareZeroOp::Ref;
    }
}

//
//  Maps compare inst to the CompareOp::Operator
//
CompareOp::Operators _BlockCodeSelector::mapToComparisonOp(Inst* inst) {
    ComparisonModifier modifier = inst->getComparisonModifier();
    switch (modifier) {
        case    Cmp_EQ:     return CompareOp::Eq;
        case    Cmp_NE_Un:    return CompareOp::Ne;
        case    Cmp_GT:        return CompareOp::Gt;
        case    Cmp_GT_Un:    return CompareOp::Gtu;
        case    Cmp_GTE:    return CompareOp::Ge;
        case    Cmp_GTE_Un:    return CompareOp::Geu;
            // unary boolean comparisons
        case    Cmp_Zero:
        case    Cmp_NonZero:
        default:
            assert(0);
    }
    return CompareOp::Eq;    // to keep compiler quiet
}

//
//  Maps instruction to ConvertToFpOp::Types
//
ConvertToFpOp::Types _BlockCodeSelector::mapToFpConvertOpType(Inst *inst) {
    Type::Tag type = inst->getType();
    switch (type) {
        case Type::Single: return ConvertToFpOp::Single;
        case Type::Double: return ConvertToFpOp::Double;
        case Type::Float:  return ConvertToFpOp::FloatFromUnsigned;
        default: assert(0);
    }
    assert(0);
    return ConvertToFpOp::Single;   // to keep the compiler quiet
}

//
//  Maps instruction to ConvertToIntOp::Types
//
ConvertToIntOp::Types _BlockCodeSelector::mapToIntConvertOpType(Inst *inst) {
    Type::Tag type = inst->getType();
    switch (type) {
        case Type::Int8: 
        case Type::UInt8: 
            return ConvertToIntOp::I1;
        case Type::Int16: 
        case Type::UInt16: 
            return ConvertToIntOp::I2;
        case Type::Int32: 
        case Type::UInt32: 
            return ConvertToIntOp::I4;
        case Type::Int64: 
        case Type::UInt64: 
            return ConvertToIntOp::I8;
        case Type::IntPtr: 
        case Type::UIntPtr: 
            return ConvertToIntOp::I;
        default: assert(0);
    }
    assert(0);
    return ConvertToIntOp::I;    // to keep the compiler quiet
}

//
//  Maps instruction to ConvertToIntOp::OverflowMod
//  
ConvertToIntOp::OverflowMod _BlockCodeSelector::mapToIntConvertOvfMod(Inst *inst) {
    if (isExceptionNever(inst)) { return ConvertToIntOp::NoOvf; };
    OverflowModifier modifier = inst->getOverflowModifier();
    switch (modifier) {
    case Overflow_None:
        return ConvertToIntOp::NoOvf;
    case Overflow_Signed:
        return ConvertToIntOp::SignedOvf;
    case Overflow_Unsigned:
        return ConvertToIntOp::UnsignedOvf;
default: assert(0);
    }
    return ConvertToIntOp::NoOvf;    // to keep the compiler quiet
}

JitHelperCallOp::Id _BlockCodeSelector::convertJitHelperId(JitHelperCallId callId) {
    switch(callId) {
        case Prefetch:                  return JitHelperCallOp::Prefetch;
        case Memset0:                   return JitHelperCallOp::Memset0;
        case InitializeArray:           return JitHelperCallOp::InitializeArray;
        case SaveThisState:             return JitHelperCallOp::SaveThisState;
        case ReadThisState:             return JitHelperCallOp::ReadThisState;
        case LockedCompareAndExchange:  return JitHelperCallOp::LockedCompareAndExchange;
        case AddValueProfileValue:      return JitHelperCallOp::AddValueProfileValue;
        case FillArrayWithConst:        return JitHelperCallOp::FillArrayWithConst;
        case ArrayCopyDirect:           return JitHelperCallOp::ArrayCopyDirect;
        case ArrayCopyReverse:          return JitHelperCallOp::ArrayCopyReverse;
        case StringCompareTo:           return JitHelperCallOp::StringCompareTo;
        case StringRegionMatches:       return JitHelperCallOp::StringRegionMatches;
        case StringIndexOf:             return JitHelperCallOp::StringIndexOf;
        default: break;
    }
    crash("\n JIT helper in not supported in LIR : %d\n", callId);

    return JitHelperCallOp::InitializeArray; // to keep compiler quiet
}
    
CG_OpndHandle ** _BlockCodeSelector::genCallArgs(Inst * call, U_32 arg0Pos) {
    U_32 nSrc = call->getNumSrcOperands();
    CG_OpndHandle ** args = new(memManager) CG_OpndHandle*[nSrc - arg0Pos];
    for (U_32 i = arg0Pos; i < nSrc; i++)
        args[i - arg0Pos] = getCGInst(call->getSrc(i));
    return args;
}
    
CG_OpndHandle ** _BlockCodeSelector::genCallArgs(Opnd *extraArg, Inst * call, U_32 arg0Pos) {
    U_32 nSrc = call->getNumSrcOperands();
    CG_OpndHandle ** args = new(memManager) CG_OpndHandle*[nSrc - arg0Pos + 1];
    args[0] = getCGInst(extraArg);
    for (U_32 i = arg0Pos; i < nSrc; i++)
        args[i - arg0Pos + 1] = getCGInst(call->getSrc(i));
    return args;
}

void _BlockCodeSelector::genInstCode(InstructionCallback& instructionCallback, Inst *inst, bool genConsts) 
{
    uint16 bcOffset = inst->getBCOffset();
    instructionCallback.setCurrentHIRInstBCOffset(bcOffset);

    if(Log::isEnabled()) {
        Log::out() << "genInstCode ";
        inst->print(Log::out());
        if (genConsts) {
            Log::out() << "; genConsts=true" << ::std::endl;
        } else {
            Log::out() << "; genConsts=false" << ::std::endl;
        }
    }

    CG_OpndHandle* cgInst = NULL;
    Opnd *dst = inst->getDst();
    bool isConstant = false;
    switch(inst->getOpcode()) {
        case Op_Add:
            {
                assert(inst->getNumSrcOperands() == 2);
                Opnd* src1 = inst->getSrc(0);
                Opnd* src2 = inst->getSrc(1);
                CG_OpndHandle* src1CGInst = getCGInst(src1);
                CG_OpndHandle* src2CGInst = getCGInst(src2);
                if (src1->getType()->isReference()) {
                    cgInst = instructionCallback.addRef(mapToRefArithmOpType(inst,src2),
                        src1CGInst,src2CGInst);
                } else {
                    cgInst = instructionCallback.add(mapToArithmOpType(inst),
                        src1CGInst,src2CGInst);
                }
            }
            break;
        case Op_Mul:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.mul(mapToArithmOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_Sub:
            {
                assert(inst->getNumSrcOperands() == 2);
                Opnd *src1 = inst->getSrc(0);
                Opnd *src2 = inst->getSrc(1);
                CG_OpndHandle* src1CGInst = getCGInst(src1);
                CG_OpndHandle* src2CGInst = getCGInst(src2);

                if (src1->getType()->isReference()) {
                    if (src2->getType()->isReference()) {
                        cgInst = instructionCallback.diffRef(isOverflow(inst) && !isExceptionNever(inst),
                            src1CGInst,
                            src2CGInst);
                    }
                    else {
                        cgInst = instructionCallback.subRef(mapToRefArithmOpType(inst,src2),
                            src1CGInst,
                            src2CGInst);
                    }
                }
                else {
                    cgInst = instructionCallback.sub(mapToArithmOpType(inst),
                        src1CGInst,
                        src2CGInst);
                }
            }
            break;
        case Op_TauDiv:
            {
                assert(inst->getNumSrcOperands() == 3);
                Opnd *tauOpnd = inst->getSrc(2);
                assert(tauOpnd->getType()->tag == Type::Tau);
                cgInst = instructionCallback.tau_div(mapToDivOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)),
                    getCGInst(tauOpnd));
            }
            break;
        case Op_TauRem:
            {
                assert(inst->getNumSrcOperands() == 3);
                Opnd *tauOpnd = inst->getSrc(2);
                assert(tauOpnd->getType()->tag == Type::Tau);

                cgInst = instructionCallback.tau_rem(mapToDivOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)),
                    getCGInst(tauOpnd));
            }
            break;
        case Op_Neg:
            {
                assert(inst->getNumSrcOperands() == 1);
                cgInst = instructionCallback.neg(mapToNegOpType(inst),
                    getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_MulHi:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.mulhi(mapToMulHiOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_Min:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.min_op(mapToNegOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_Max:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.max_op(mapToNegOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_Abs:
            {
                assert(inst->getNumSrcOperands() == 1);
                cgInst = instructionCallback.abs_op(mapToNegOpType(inst),
                    getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_TauCheckFinite:
            {
                assert(inst->getNumSrcOperands() == 1);
                cgInst = instructionCallback.tau_ckfinite(getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_And:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.and_(mapToIntegerOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_Or:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.or_(mapToIntegerOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_Xor:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.xor_(mapToIntegerOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_Not:
            {
                assert(inst->getNumSrcOperands() == 1);
                cgInst = instructionCallback.not_(mapToIntegerOpType(inst),
                    getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_Select:
            {
                assert(inst->getNumSrcOperands() == 3);
                cgInst = instructionCallback.select(mapToCompareOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)),
                    getCGInst(inst->getSrc(2)));
            }
            break;
        case Op_Conv:
        case Op_ConvZE:
        case Op_ConvUnmanaged:
            {
                assert(inst->getNumSrcOperands() == 1);
                Type * dstType = inst->getDst()->getType();
                if (dstType->isFP()) {
                    cgInst = instructionCallback.convToFp(mapToFpConvertOpType(inst),
                        dstType,
                        getCGInst(inst->getSrc(0)));
                } else if (dstType->isObject()){
                    cgInst = instructionCallback.convUPtrToObject(dstType->asObjectType(), getCGInst(inst->getSrc(0)));
                } else if (dstType->isUnmanagedPtr()) {
                    cgInst = instructionCallback.convToUPtr(dstType->asPtrType(), getCGInst(inst->getSrc(0)));
                } else {
                    bool isSigned = Type::isSignedInteger(inst->getType());
                    bool isZeroExtend = inst->getOpcode() == Op_ConvZE;
                    cgInst = instructionCallback.convToInt(mapToIntConvertOpType(inst),
                        isSigned, 
                        isZeroExtend,
                        mapToIntConvertOvfMod(inst), 
                        dstType,
                        getCGInst(inst->getSrc(0)));
                }
            }
            break;    
        case Op_Shladd:
            {
                assert(inst->getNumSrcOperands() == 3);
                Opnd *op1 = inst->getSrc(1);
                ConstInst *op1ci = op1->getInst()->asConstInst();
                assert(op1ci);
                assert(op1ci->getType() == Type::Int32);
                I_32 shiftby = op1ci->getValue().i4;
                cgInst = instructionCallback.shladd(mapToIntegerOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    shiftby,
                    getCGInst(inst->getSrc(2)));
            }
            break;
        case Op_Shl:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.shl(mapToIntegerOpType(inst),
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_Shr:
            {
                assert(inst->getNumSrcOperands() == 2);
                IntegerOp::Types opType = mapToIntegerOpType(inst);
                CG_OpndHandle* src1CGInst = getCGInst(inst->getSrc(0));
                CG_OpndHandle* src2CGInst = getCGInst(inst->getSrc(1));

                if (isUnsigned(inst))
                    cgInst = instructionCallback.shru(opType,src1CGInst,src2CGInst);
                else
                    cgInst = instructionCallback.shr(opType,src1CGInst,src2CGInst); 
            }
            break;
        case Op_Cmp:
            {
                if (inst->getNumSrcOperands() == 2) {
                    // binary comparison
                    CompareOp::Operators cmpOp = mapToComparisonOp(inst);
                    CompareOp::Types opType = mapToCompareOpType(inst);
                    cgInst = instructionCallback.cmp(cmpOp, opType,
                        getCGInst(inst->getSrc(0)),
                        getCGInst(inst->getSrc(1)));
                } else {
                    assert(inst->getNumSrcOperands() == 1);
                    // unary comparison against zero
                    if (inst->getComparisonModifier() == Cmp_Zero) {
                        cgInst = instructionCallback.czero(mapToCompareZeroOpType(inst),
                            getCGInst(inst->getSrc(0)));
                    } else {
                        // Nonzero
                        cgInst = instructionCallback.cnzero(mapToCompareZeroOpType(inst),
                            getCGInst(inst->getSrc(0)));
                    }
                }
            }
            break;
        case Op_Cmp3:
            {
#ifndef BACKEND_HAS_CMP3                

                // always binary comparison
                CompareOp::Types opType = mapToCompareOpType(inst);
                CompareOp::Operators cmpOp = mapToComparisonOp(inst);
                CompareOp::Operators cmpOp2 = cmpOp;

                int ifNaNResult = -1;
                if (cmpOp == CompareOp::Gtu || cmpOp == CompareOp::Geu)
                    ifNaNResult = 1;

                CG_OpndHandle* cgInst1 = 
                    instructionCallback.cmp(cmpOp, opType,
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)), ifNaNResult);

                // second operator has opposite NaN behavior for Floats
                if ((opType==CompareOp::F) ||
                    (opType==CompareOp::S) ||
                    (opType==CompareOp::D)) {
                        switch (cmpOp) {
                        case CompareOp::Gt: cmpOp2 = CompareOp::Gtu; ifNaNResult = 1; break;
                        case CompareOp::Gtu: cmpOp2 = CompareOp::Gt; ifNaNResult = -1; break;
                        case CompareOp::Ge: cmpOp2 = CompareOp::Geu; ifNaNResult = 1; break;
                        case CompareOp::Geu: cmpOp2 = CompareOp::Ge; ifNaNResult = -1; break;
                        default: break;
                        };
                    }

                    CG_OpndHandle* cgInst2 = 
                        instructionCallback.cmp(cmpOp2, opType, 
                        getCGInst(inst->getSrc(1)),
                        getCGInst(inst->getSrc(0)), ifNaNResult);
                    cgInst = 
                        instructionCallback.sub(ArithmeticOp::I4,
                        cgInst1,
                        cgInst2);
#else
                // always binary comparison
                CompareOp::Operators cmpOp = mapToComparisonOp(inst);
                CompareOp::Types opType = mapToCompareOpType(inst);
                cgInst = instructionCallback.cmp3(cmpOp, opType,
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
#endif
            }
            break;
        case Op_Branch:
            {
                if (inst->getNumSrcOperands() == 2) {
                    // binary comparison
                    instructionCallback.branch(mapToComparisonOp(inst),
                        mapToCompareOpType(inst),
                        getCGInst(inst->getSrc(0)),
                        getCGInst(inst->getSrc(1)));
                } else {
                    assert(inst->getNumSrcOperands() == 1);
                    // unary comparison against zero
                    if (inst->getComparisonModifier() == Cmp_Zero) {
                        instructionCallback.bzero(mapToCompareZeroOpType(inst),
                            getCGInst(inst->getSrc(0)));
                    } else {
                        // Nonzero
                        instructionCallback.bnzero(mapToCompareZeroOpType(inst),
                            getCGInst(inst->getSrc(0)));
                    }
                }
            }
            break;
        case Op_Jump: 
            {    
                instructionCallback.jump();
            }
            break; 
        case Op_Switch: 
            {
                assert(inst->getNumSrcOperands() == 1);
                SwitchInst *swInst = (SwitchInst *)inst;
                instructionCallback.tableSwitch(getCGInst(inst->getSrc(0)),
                    swInst->getNumTargets());
            }
            break; 
        case Op_DirectCall:
            {
                assert(inst->getNumSrcOperands() >= 2);
                Opnd *tauNullChecked = inst->getSrc(0);
                assert(tauNullChecked->getType()->tag == Type::Tau);
                Opnd *tauTypesChecked = inst->getSrc(1);
                assert(tauTypesChecked->getType()->tag == Type::Tau);

                MethodCallInst * call = (MethodCallInst *)inst;
                MethodDesc * methodDesc = call->getMethodDesc();
                CG_OpndHandle ** args = genCallArgs(call,2); // omit tau operands
                U_32 numArgs = inst->getNumSrcOperands()-2; // also omit from count
                cgInst = 
                    instructionCallback.tau_call(numArgs,
                                                 args,
                                                 inst->getDst()->getType(),
                                                 methodDesc,
                                                 getCGInst(tauNullChecked),
                                                 getCGInst(tauTypesChecked));
            }
            break;
        case Op_TauVirtualCall:
            {
                assert(inst->getNumSrcOperands() >= 3);
                Opnd *tauNullChecked = inst->getSrc(0);
                Opnd *tauTypesChecked = inst->getSrc(1);
                assert(tauNullChecked->getType()->tag == Type::Tau);
                assert(tauTypesChecked->getType()->tag == Type::Tau);

                MethodCallInst * call = (MethodCallInst *)inst;
                MethodDesc * methodDesc = call->getMethodDesc();
                cgInst = 
                    instructionCallback.tau_callvirt(inst->getNumSrcOperands()-2, // omit taus
                                                     genCallArgs(call, 2), // omit taus
                                                     inst->getDst()->getType(),
                                                     methodDesc,
                                                     getCGInst(tauNullChecked),
                                                     getCGInst(tauTypesChecked));
            }
            break;
        case Op_IndirectCall:
            {
                assert(inst->getNumSrcOperands() >= 3);
                Opnd *fnAddr = inst->getSrc(0);
                Opnd *tauNullChecked = inst->getSrc(1);
                Opnd *tauTypesChecked = inst->getSrc(2);
                assert(tauNullChecked->getType()->tag == Type::Tau);
                assert(tauTypesChecked->getType()->tag == Type::Tau);
                assert(inst->isCall());
                cgInst = 
                    instructionCallback.tau_calli(inst->getNumSrcOperands() - 3, // omit taus and fnAddr
                                                  genCallArgs(inst, 3), // omit taus and fnAddr
                                                  inst->getDst()->getType(),
                                                  getCGInst(fnAddr),
                                                  getCGInst(tauNullChecked),
                                                  getCGInst(tauTypesChecked));
            }
            break;
        case Op_IndirectMemoryCall:
            {
                assert(inst->getNumSrcOperands() >= 3);
                Opnd *fnAddr = inst->getSrc(0);
                Opnd *tauNullChecked = inst->getSrc(1);
                Opnd *tauTypesChecked = inst->getSrc(2);
                assert(tauNullChecked->getType()->tag == Type::Tau);
                assert(tauTypesChecked->getType()->tag == Type::Tau);
                assert(inst->isCall());
                cgInst = 
                    instructionCallback.tau_calli(inst->getNumSrcOperands() - 3, // omit taus andfnAddr
                                                  genCallArgs(inst, 3), // omit taus and fnAddr
                                                  inst->getDst()->getType(),
                                                  getCGInst(fnAddr),
                                                  getCGInst(tauNullChecked),
                                                  getCGInst(tauTypesChecked));
            }
            break;
        case Op_JitHelperCall:
            {
                JitHelperCallInst* call = inst->asJitHelperCallInst();
                JitHelperCallId callId = call->getJitHelperId();
                if (callId == ArrayCopyDirect || callId == ArrayCopyReverse)                
                    cgInst = 
                    instructionCallback.callhelper(inst->getNumSrcOperands()-2, // omit taus
                                                   genCallArgs(call,2), // omit taus
                                                   inst->getDst()->getType(),
                                                   convertJitHelperId(callId));
                else                    
                    cgInst = 
                    instructionCallback.callhelper(inst->getNumSrcOperands(),
                                                   genCallArgs(call,0),
                                                   inst->getDst()->getType(),
                                                   convertJitHelperId(callId));
            }
            break;
        case Op_VMHelperCall:
            {
                VMHelperCallInst* call = inst->asVMHelperCallInst();
                VM_RT_SUPPORT callId = call->getVMHelperId();
                cgInst = 
                    instructionCallback.callvmhelper(inst->getNumSrcOperands(),
                                                     genCallArgs(call,0),
                                                     inst->getDst()->getType(),
                                                     callId);
            }
            break;
        case Op_Return:
            {
                if (inst->getType() == Type::Void) {
                    instructionCallback.ret();
                } else {
                    instructionCallback.ret(getCGInst(inst->getSrc(0)));
                }
            }
            break;
        case Op_Throw:
            {
                instructionCallback.throwException(getCGInst(inst->getSrc(0)), inst->getThrowModifier() == Throw_CreateStackTrace);
            }
            break;
        case Op_PseudoThrow:
            instructionCallback.pseudoInst();
            break;
        case Op_ThrowSystemException:
            {
                TokenInst *tokenInst = (TokenInst *)inst;
                U_32 token = tokenInst->getToken();
                CompilationInterface::SystemExceptionId id 
                    = (CompilationInterface::SystemExceptionId)token;
                instructionCallback.throwSystemException(id);
            }
            break;
        case Op_ThrowLinkingException:
            {
                LinkingExcInst *linkExcInst = (LinkingExcInst *)inst;
                Class_Handle encClass = linkExcInst->getEnclosingClass();
                U_32 constPoolIndex = linkExcInst->getCPIndex();
                U_32 opcode = linkExcInst->getOperation();
                instructionCallback.throwLinkingException(encClass, constPoolIndex, opcode);
            }
            break;
        case Op_Catch:
            cgInst = instructionCallback.catchException(inst->getDst()->getType());
            break;
        case Op_Copy:
            {
                cgInst = instructionCallback.copy(getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_DefArg:
            {
                cgInst = instructionCallback.defArg(argCount,
                    inst->getDst()->getType());
                argCount += 1;
            }
            break;
        case Op_LdConstant:
            {
                if (!genConsts) break;
                ConstInst* constInst = (ConstInst*)inst;
                switch (inst->getType()) {
#ifdef _IA32_
        case Type::UIntPtr:
        case Type::IntPtr:
        case Type::UnmanagedPtr:
#endif
        case Type::Int32:
            cgInst = instructionCallback.ldc_i4(constInst->getValue().i4);
            break;
#ifdef _EM64T_
        case Type::UIntPtr:
        case Type::IntPtr:
        case Type::UnmanagedPtr:
#endif
        case Type::Int64:
            cgInst = instructionCallback.ldc_i8(constInst->getValue().i8);
            break;
        case Type::Single:
            cgInst = instructionCallback.ldc_s(constInst->getValue().s);
            break;
        case Type::Double:
            cgInst = instructionCallback.ldc_d(constInst->getValue().d);
            break;
        case Type::NullObject:
            cgInst = instructionCallback.ldnull(false);
            break;
        case Type::CompressedNullObject:
            cgInst = instructionCallback.ldnull(true);
            break;
        default: assert(0);
                }
                isConstant = true;
            }
            break;
        case Op_LdRef:
            {
                if (!genConsts) break;

                AutoCompressModifier acmod = inst->getAutoCompressModifier();

                TokenInst *tokenInst = (TokenInst *)inst;
                U_32 token = tokenInst->getToken();
                cgInst = instructionCallback.ldRef(inst->getDst()->getType(),
                    tokenInst->getEnclosingMethod(),
                    token, acmod==AutoCompress_Yes);
                isConstant = true;
            }
            break;
        case Op_LdVar:
            {
                VarAccessInst * varInst = (VarAccessInst *)inst;
                cgInst = instructionCallback.ldVar(inst->getDst()->getType(),
                    getVarHandle(varInst->getVar()));
            }
            break;
        case Op_LdVarAddr:
            {
                if (!genConsts) break;
                VarAccessInst * varInst = (VarAccessInst *)inst;
                cgInst = instructionCallback.ldVarAddr(getVarHandle(varInst->getVar()));
                isConstant = true;
            }
            break;
        case Op_TauLdInd:
            {
                assert(inst->getNumSrcOperands() == 3);
                AutoCompressModifier acmod = inst->getAutoCompressModifier();
                SpeculativeModifier   smod = inst->getSpeculativeModifier();

                instructionCallback.setCurrentPersistentId(inst->getPersistentInstructionId());
                Opnd *ptr = inst->getSrc(0);
                Opnd *tauNonNullBase = inst->getSrc(1);
                Opnd *tauAddressInRange = inst->getSrc(2);

                assert(tauNonNullBase->getType()->tag == Type::Tau);
                assert(tauAddressInRange->getType()->tag == Type::Tau);

                cgInst = instructionCallback.tau_ldInd(inst->getDst()->getType(),
                    getCGInst(ptr),
                    inst->getType(),
                    acmod == AutoCompress_Yes,
                    smod == Speculative_Yes,
                    getCGInst(tauNonNullBase),
                    getCGInst(tauAddressInRange));
                instructionCallback.clearCurrentPersistentId();
            }
            break;
        case Op_TauLdField:
            {
                assert(inst->getNumSrcOperands() == 3);
                AutoCompressModifier acmod = inst->getAutoCompressModifier();

                FieldAccessInst* fieldInst = (FieldAccessInst*)inst;
                FieldDesc* fieldDesc = fieldInst->getFieldDesc();
                Opnd *base = inst->getSrc(0);
                Opnd *tauNonNullBase = inst->getSrc(1);
                Opnd *tauObjectTypeChecked = inst->getSrc(2);

                assert(tauNonNullBase->getType()->tag == Type::Tau);
                assert(tauObjectTypeChecked->getType()->tag == Type::Tau);

                cgInst = instructionCallback.tau_ldField(inst->getDst()->getType(),
                    getCGInst(base),
                    inst->getType(),
                    fieldDesc,
                    acmod == AutoCompress_Yes,
                    getCGInst(tauNonNullBase),
                    getCGInst(tauObjectTypeChecked));
            }
            break;
        case Op_LdStatic:
            {
                AutoCompressModifier acmod = inst->getAutoCompressModifier();

                FieldAccessInst* fieldInst = (FieldAccessInst *)inst;
                FieldDesc* fieldDesc = fieldInst->getFieldDesc();
                cgInst = instructionCallback.ldStatic(inst->getDst()->getType(),
                    fieldDesc,
                    inst->getType(),
                    acmod == AutoCompress_Yes);
            }
            break;
        case Op_TauLdElem:
            {
                assert(inst->getNumSrcOperands() == 4);
                AutoCompressModifier acmod = inst->getAutoCompressModifier();

                Opnd *array = inst->getSrc(0);
                Opnd *index = inst->getSrc(1);
                Opnd *tauNonNullBase = inst->getSrc(2);
                Opnd *tauAddressInRange = inst->getSrc(3);

                assert(tauNonNullBase->getType()->tag == Type::Tau);
                assert(tauAddressInRange->getType()->tag == Type::Tau);

                cgInst = instructionCallback.tau_ldElem(inst->getDst()->getType(),
                    getCGInst(array),
                    getCGInst(index),
                    acmod == AutoCompress_Yes,
                    getCGInst(tauNonNullBase),
                    getCGInst(tauAddressInRange));
            }
            break;
        case Op_LdFieldAddr:
            {
                assert(inst->getNumSrcOperands() == 1);
                FieldAccessInst* fieldInst = (FieldAccessInst*)inst;
                FieldDesc* fieldDesc = fieldInst->getFieldDesc();
                cgInst = instructionCallback.ldFieldAddr(inst->getDst()->getType(),
                    getCGInst(inst->getSrc(0)),
                    fieldDesc);
            }
            break;
        case Op_LdStaticAddr:
            {
                assert(inst->getNumSrcOperands() == 0);
                FieldAccessInst* fieldInst = (FieldAccessInst *)inst;
                FieldDesc* fieldDesc = fieldInst->getFieldDesc();
                cgInst = instructionCallback.ldStaticAddr(inst->getDst()->getType(),
                    fieldDesc);
            }
            break;
        case Op_LdElemAddr:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.ldElemAddr(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_LdFunAddr:
            {
                assert(inst->getNumSrcOperands() == 0);
                MethodInst * methodInst = (MethodInst *)inst;
                MethodDesc * methodDesc = methodInst->getMethodDesc();
                cgInst = 
                    instructionCallback.ldFunAddr(inst->getDst()->getType(),
                    methodDesc);
            }
            break;
        case Op_TauLdVirtFunAddr:
            {
                assert(inst->getNumSrcOperands() == 2);
                MethodInst * methodInst = (MethodInst *)inst;
                MethodDesc * methodDesc = methodInst->getMethodDesc();
                Opnd *vtable = inst->getSrc(0);
                Opnd *tauBaseHasMethod = inst->getSrc(1);

                assert(tauBaseHasMethod->getType()->tag == Type::Tau);

                cgInst = 
                    instructionCallback.tau_ldVirtFunAddr(inst->getDst()->getType(),
                    getCGInst(vtable),
                    methodDesc,
                    getCGInst(tauBaseHasMethod));
            }
            break;
        case Op_LdFunAddrSlot:
            {
                assert(inst->getNumSrcOperands() == 0);
                MethodInst * methodInst = (MethodInst *)inst;
                MethodDesc * methodDesc = methodInst->getMethodDesc();
                cgInst = 
                    instructionCallback.ldFunAddr(inst->getDst()->getType(),
                    methodDesc);
            }
            break;
        case Op_TauLdVirtFunAddrSlot:
            {
                assert(inst->getNumSrcOperands() == 2);
                MethodInst * methodInst = (MethodInst *)inst;
                MethodDesc * methodDesc = methodInst->getMethodDesc();
                Opnd *vtable = inst->getSrc(0);
                Opnd *tauBaseHasMethod = inst->getSrc(1);

                assert(tauBaseHasMethod->getType()->tag == Type::Tau);

                cgInst = 
                    instructionCallback.tau_ldVirtFunAddr(inst->getDst()->getType(),
                    getCGInst(vtable),
                    methodDesc,
                    getCGInst(tauBaseHasMethod));
            }
            break;
        case Op_TauLdVTableAddr:
            {
                assert(inst->getNumSrcOperands() == 2);
                instructionCallback.setCurrentPersistentId(inst->getPersistentInstructionId());
                Type * dstType = inst->getDst()->getType();
                assert(dstType->isVTablePtr() || dstType->isVTablePtrObj());
                Opnd *base = inst->getSrc(0);
                Opnd *tauBaseNonNull = inst->getSrc(1);

                assert(tauBaseNonNull->getType()->tag == Type::Tau);

                cgInst = instructionCallback.tau_ldVTableAddr(dstType,
                    getCGInst(base),
                    getCGInst(tauBaseNonNull));
                instructionCallback.clearCurrentPersistentId();
            }
            break;
        case Op_GetVTableAddr:
            {
                assert(inst->getNumSrcOperands() == 0);
                if (!genConsts) break;
                Type *type = ((TypeInst*)inst)->getTypeInfo();
                assert(type->isObject());
                Type * dstType = inst->getDst()->getType();
                assert(dstType->isVTablePtr());
                cgInst = instructionCallback.getVTableAddr( dstType,(ObjectType*)type);
                isConstant = true;
            }
            break;
        case Op_GetClassObj:
            {
                assert(inst->getNumSrcOperands() == 0);
                Type *type = ((TypeInst*)inst)->getTypeInfo();
                assert(type->isObject() || type->isUserValue());
                Type * dstType = inst->getDst()->getType();
                assert(type->isObject());
                cgInst = instructionCallback.getClassObj( dstType,(ObjectType*)type);
            }
            break;
        case Op_TauLdIntfcVTableAddr:
            {
                assert(inst->getNumSrcOperands() == 1);
                TypeInst *typeInst = (TypeInst*)inst;
                Type * vtableType = typeInst->getTypeInfo();
                assert(vtableType->isUserObject());
                Opnd *base = inst->getSrc(0);
                cgInst = instructionCallback.tau_ldIntfTableAddr(inst->getDst()->getType(),
                    getCGInst(base),
                    (NamedType*)vtableType);
            }
            break;
        case Op_TauArrayLen:
            {
                assert(inst->getNumSrcOperands() == 3);
                Opnd *array = inst->getSrc(0);
                Opnd *tauNonNullArray = inst->getSrc(1);
                Opnd *tauIsArray = inst->getSrc(2);

                assert(tauNonNullArray->getType()->tag == Type::Tau);

                Type* dstType = inst->getDst()->getType();
                Type* arrayType = inst->getSrc(0)->getType();
                assert(arrayType->isArrayType());
                Type* arrayLenType = dstType;
                instructionCallback.setCurrentPersistentId(inst->getPersistentInstructionId());
                cgInst = instructionCallback.tau_arrayLen(dstType, 
                    (ArrayType*)arrayType,  
                    arrayLenType,
                    getCGInst(array),
                    getCGInst(tauNonNullArray),
                    getCGInst(tauIsArray));
                instructionCallback.clearCurrentPersistentId();
            }
            break;
            // load the base (zero element) address of array
        case Op_LdArrayBaseAddr:
            {
                assert(inst->getNumSrcOperands() == 1);
                cgInst = instructionCallback.ldElemBaseAddr(getCGInst(inst->getSrc(0)));
            }
            break;
            // Add a scaled index to an array element address
        case Op_AddScaledIndex:    
            {
                PtrType* arrType = (PtrType*) inst->getSrc(0)->getType();
                Type*    refType = arrType->getPointedToType();

                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.addElemIndex(refType,
                    getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_UncompressRef:
            {
                assert(inst->getNumSrcOperands() == 1);
                cgInst = instructionCallback.uncompressRef(getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_CompressRef:
            {
                assert(inst->getNumSrcOperands() == 1);
                cgInst = instructionCallback.compressRef(getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_LdFieldOffset:
            {
                assert(inst->getNumSrcOperands() == 0);
                if (!genConsts) break;
                FieldAccessInst* fieldInst = (FieldAccessInst*)inst;
                FieldDesc* fieldDesc = fieldInst->getFieldDesc();
                cgInst = instructionCallback.ldFieldOffset(fieldDesc);
                isConstant = true;
            }
            break;
        case Op_LdFieldOffsetPlusHeapbase:
            {
                assert(inst->getNumSrcOperands() == 0);
                if (!genConsts) break;
                FieldAccessInst* fieldInst = (FieldAccessInst*)inst;
                FieldDesc* fieldDesc = fieldInst->getFieldDesc();
                cgInst = instructionCallback.ldFieldOffsetPlusHeapbase(fieldDesc);
                isConstant = true;
            }
            break;
        case Op_LdArrayBaseOffset:
            {
                assert(inst->getNumSrcOperands() == 0);
                if (!genConsts) break;
                TypeInst *typeInst = (TypeInst*)inst;
                Type *elemType = typeInst->getTypeInfo();
                cgInst = instructionCallback.ldArrayBaseOffset(elemType);
                isConstant = true;
            }
            break;
        case Op_LdArrayBaseOffsetPlusHeapbase:
            {
                assert(inst->getNumSrcOperands() == 0);
                if (!genConsts) break;
                TypeInst *typeInst = (TypeInst*)inst;
                Type *elemType = typeInst->getTypeInfo();
                cgInst = instructionCallback.ldArrayBaseOffsetPlusHeapbase(elemType);
                isConstant = true;
            }
            break;
        case Op_LdArrayLenOffset:
            {
                assert(inst->getNumSrcOperands() == 0);
                if (!genConsts) break;
                TypeInst *typeInst = (TypeInst*)inst;
                Type *elemType = typeInst->getTypeInfo();
                cgInst = instructionCallback.ldArrayLenOffset(elemType);
                isConstant = true;
            }
            break;
        case Op_LdArrayLenOffsetPlusHeapbase:
            {
                assert(inst->getNumSrcOperands() == 0);
                if (!genConsts) break;
                TypeInst *typeInst = (TypeInst*)inst;
                Type *elemType = typeInst->getTypeInfo();
                cgInst = instructionCallback.ldArrayLenOffsetPlusHeapbase(elemType);
                isConstant = true;
            }
            break;
        case Op_AddOffset:
            {
                assert(inst->getNumSrcOperands() == 2);
                Opnd *dstop = inst->getDst();
                Opnd *ref = inst->getSrc(0);
                Opnd *offset = inst->getSrc(1);
                Type *dstType = dstop->getType();
                cgInst = instructionCallback.addOffset(dstType, getCGInst(ref), getCGInst(offset));
            }
            break;
        case Op_AddOffsetPlusHeapbase:
            {
                assert(inst->getNumSrcOperands() == 2);
                Opnd *dstop = inst->getDst();
                Opnd *ref = inst->getSrc(0);
                Opnd *offset = inst->getSrc(1);
                Type *dstType = dstop->getType();
                cgInst = instructionCallback.addOffsetPlusHeapbase(dstType, 
                    getCGInst(ref), 
                    getCGInst(offset));
            }
            break;
        case Op_StVar:
            {
                assert(inst->getNumSrcOperands() == 1);
                VarAccessInst * varInst = (VarAccessInst *)inst;
                instructionCallback.stVar(getCGInst(inst->getSrc(0)), 
                    getVarHandle(varInst->getVar()));  

            }
            break;
        case Op_TauStInd:
            {
                assert(inst->getNumSrcOperands() == 5);
                Opnd *src = inst->getSrc(0);
                Opnd *ptr = inst->getSrc(1);
                Opnd *tauNonNullBase = inst->getSrc(2);
                Opnd *tauAddressInRange = inst->getSrc(3);
                Opnd *tauElemTypeChecked = inst->getSrc(4);

                assert(tauNonNullBase->getType()->tag == Type::Tau);
                assert(tauAddressInRange->getType()->tag == Type::Tau);
                assert(tauElemTypeChecked->getType()->tag == Type::Tau);

                AutoCompressModifier acmod = inst->getAutoCompressModifier();
                bool autocompress = (acmod == AutoCompress_Yes);
                Type::Tag type = inst->getType();
                if (acmod == AutoCompress_Yes) {
                    assert(Type::isReference(type));
                    assert(!Type::isCompressedReference(type));
                }
                instructionCallback.tau_stInd(getCGInst(src),
                    getCGInst(ptr),
                    type,
                    autocompress,
                    getCGInst(tauNonNullBase),
                    getCGInst(tauAddressInRange),
                    getCGInst(tauElemTypeChecked));
            }
            break;
        case Op_TauStField:
            {
                assert(inst->getNumSrcOperands() == 5);
                Opnd *src = inst->getSrc(0);
                Opnd *base = inst->getSrc(1);
                Opnd *tauNonNullBase = inst->getSrc(2);
                Opnd *tauTypeHasField = inst->getSrc(3);
                Opnd *tauFieldTypeChecked = inst->getSrc(4);

                assert(tauNonNullBase->getType()->tag == Type::Tau);
                assert(tauTypeHasField->getType()->tag == Type::Tau);
                assert(tauFieldTypeChecked->getType()->tag == Type::Tau);

                AutoCompressModifier acmod = inst->getAutoCompressModifier();

                FieldAccessInst* fieldInst = (FieldAccessInst*)inst;
                FieldDesc* fieldDesc = fieldInst->getFieldDesc();

                bool autocompress = (acmod == AutoCompress_Yes);
                Type::Tag type = inst->getType();
                if (acmod == AutoCompress_Yes) {
                    assert(Type::isReference(type));
                    assert(!Type::isCompressedReference(type));
                }
                instructionCallback.tau_stField(getCGInst(src),
                    getCGInst(base),
                    type,
                    fieldDesc,
                    autocompress,
                    getCGInst(tauNonNullBase),
                    getCGInst(tauTypeHasField),
                    getCGInst(tauFieldTypeChecked));
            }
            break;

        case Op_TauStStatic: 
            {
                assert(inst->getNumSrcOperands() == 2);
                Opnd *src = inst->getSrc(0);
                Opnd *tauFieldTypeOk = inst->getSrc(1);

                AutoCompressModifier acmod = inst->getAutoCompressModifier();
                bool autocompress = (acmod == AutoCompress_Yes);
                Type::Tag type = inst->getType();
                if (acmod == AutoCompress_Yes) {
                    assert(Type::isReference(type));
                    assert(!Type::isCompressedReference(type));
                }
                FieldAccessInst* fieldInst = (FieldAccessInst *)inst;
                FieldDesc* fieldDesc = fieldInst->getFieldDesc();
                instructionCallback.tau_stStatic(getCGInst(src),
                    fieldDesc,
                    type,
                    autocompress,
                    getCGInst(tauFieldTypeOk));
            }
            break;
        case Op_TauStElem:
            {
                assert(inst->getNumSrcOperands() == 6);
                Opnd *src = inst->getSrc(0);
                Opnd *array = inst->getSrc(1);
                Opnd *index = inst->getSrc(2);
                AutoCompressModifier acmod = inst->getAutoCompressModifier();
                Opnd *tauNonNullBase = inst->getSrc(3);
                Opnd *tauAddressInRange = inst->getSrc(4);
                Opnd *tauElemTypeChecked = inst->getSrc(5);

                assert(tauNonNullBase->getType()->tag == Type::Tau);
                assert(tauAddressInRange->getType()->tag == Type::Tau);
                assert(tauElemTypeChecked->getType()->tag == Type::Tau);


                instructionCallback.tau_stElem(getCGInst(src),
                    getCGInst(array),
                    getCGInst(index),
                    acmod == AutoCompress_Yes,
                    getCGInst(tauNonNullBase),
                    getCGInst(tauAddressInRange),
                    getCGInst(tauElemTypeChecked));
            }
            break;
        case Op_TauStRef:
            {
                assert(inst->getNumSrcOperands() == 6);

                Opnd *src = inst->getSrc(0);
                Opnd *ptr = inst->getSrc(1);
                Opnd *base = inst->getSrc(2);

                Opnd *tauNonNullBase = inst->getSrc(3);
                Opnd *tauTypeHasField = inst->getSrc(4);
                Opnd *tauFieldTypeChecked = inst->getSrc(5);

                assert(tauNonNullBase->getType()->tag == Type::Tau);
                assert(tauTypeHasField->getType()->tag == Type::Tau);
                assert(tauFieldTypeChecked->getType()->tag == Type::Tau);

                AutoCompressModifier acmod = inst->getAutoCompressModifier();
                StoreModifier UNUSED stmod = inst->getStoreModifier();

                bool autocompress = (acmod == AutoCompress_Yes);
                Type::Tag type = inst->getType();
                if (acmod == AutoCompress_Yes) {
                    assert(Type::isReference(type));
                    assert(!Type::isCompressedReference(type));
                }
                assert(stmod == Store_WriteBarrier);
                instructionCallback.tau_stRef(getCGInst(src),
                    getCGInst(ptr),
                    getCGInst(base),
                    type,
                    autocompress,
                    getCGInst(tauNonNullBase),
                    getCGInst(tauTypeHasField),
                    getCGInst(tauFieldTypeChecked));
            }
            break;
        case Op_TauCheckBounds:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.tau_checkBounds(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_TauCheckLowerBound:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst =
                    instructionCallback.tau_checkLowerBound(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_TauCheckUpperBound:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst =
                    instructionCallback.tau_checkUpperBound(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_TauCheckNull:
            {
                assert(inst->getNumSrcOperands() == 1);
                if ( inst->getDefArgModifier() == NonNullThisArg ) {
                    if(Log::isEnabled()) {
                        Log::out() << " chknull_NonNullThisArg_check" << ::std::endl;
                    }
                    cgInst = instructionCallback.tau_checkNull(getCGInst(inst->getSrc(0)), true);
                }else{
                    cgInst = instructionCallback.tau_checkNull(getCGInst(inst->getSrc(0)), false);
                    assert(inst->getDefArgModifier() == DefArgNoModifier);
                }
            }
            break;
        case Op_TauCheckZero:
            {
                assert(inst->getNumSrcOperands() == 1);
                cgInst = instructionCallback.tau_checkZero(getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_TauCheckDivOpnds:
            {
                assert(inst->getNumSrcOperands() == 2);
                cgInst = instructionCallback.tau_checkDivOpnds(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_TauCheckElemType:
            {
                assert(inst->getNumSrcOperands() == 4);
                Opnd *array = inst->getSrc(0);
                Opnd *src = inst->getSrc(1);
                Opnd *tauCheckedNull = inst->getSrc(2);
                Opnd *tauIsArray = inst->getSrc(3);
                assert(tauCheckedNull->getType()->tag == Type::Tau);
                cgInst = instructionCallback.tau_checkElemType(getCGInst(array),
                    getCGInst(src),
                    getCGInst(tauCheckedNull),
                    getCGInst(tauIsArray));
            }
            break;
        case Op_NewObj:
            {
                assert(inst->getNumSrcOperands() == 0);
                TypeInst *typeInst = (TypeInst*)inst;
                Type * objType = typeInst->getTypeInfo();
                assert(objType->isObject());
                cgInst = instructionCallback.newObj((ObjectType*)objType);
            }
            break;
        case Op_NewArray:
            {
                assert(inst->getNumSrcOperands() == 1);
                Type * arrayType = inst->getDst()->getType();
                assert(arrayType->isArrayType());
                cgInst = instructionCallback.newArray((ArrayType *)arrayType,
                    getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_NewMultiArray:
            {
                Type * arrayType = inst->getDst()->getType();
                assert(arrayType->isArrayType());
                U_32 numDims = inst->getNumSrcOperands();
                CG_OpndHandle ** dims = new(memManager) CG_OpndHandle*[numDims];
                for (U_32 i = 0; i < numDims; i++) 
                    dims[i] = getCGInst(inst->getSrc(i));
                cgInst = instructionCallback.newMultiArray((ArrayType*)arrayType,
                    numDims,
                    dims);
            }
            break;
        case Op_TauMonitorEnter:
            {
                assert(inst->getNumSrcOperands() == 2);
                Opnd *tauOpnd = inst->getSrc(1);
                instructionCallback.tau_monitorEnter(getCGInst(inst->getSrc(0)),
                    getCGInst(tauOpnd));
            }
            break;
        case Op_TauMonitorExit:
            {
                assert(inst->getNumSrcOperands() == 2);
                Opnd *tauOpnd = inst->getSrc(1);
                instructionCallback.tau_monitorExit(getCGInst(inst->getSrc(0)),
                    getCGInst(tauOpnd));
            }
            break;
        case Op_LdLockAddr:
            {
                assert(inst->getNumSrcOperands() == 1);
                cgInst = instructionCallback.ldLockAddr(getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_IncRecCount:
            {
                assert(inst->getNumSrcOperands() == 2);
                instructionCallback.incRecursionCount(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)));
            }
            break;
        case Op_TauBalancedMonitorEnter:
            {
                assert(inst->getNumSrcOperands() == 3);
                Opnd *tauOpnd = inst->getSrc(2);
                cgInst = instructionCallback.tau_balancedMonitorEnter(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)),
                    getCGInst(tauOpnd));
            }
            break;
        case Op_BalancedMonitorExit:
            {
                assert(inst->getNumSrcOperands() == 3);
                instructionCallback.balancedMonitorExit(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)),
                    getCGInst(inst->getSrc(2)));
            }
            break;
        case Op_TauOptimisticBalancedMonitorEnter:
            {
                assert(inst->getNumSrcOperands() == 3);
                Opnd *tauOpnd = inst->getSrc(2);
                cgInst = instructionCallback.tau_optimisticBalancedMonitorEnter(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)),
                    getCGInst(tauOpnd));
            }
            break;
        case Op_OptimisticBalancedMonitorExit:
            {
                assert(inst->getNumSrcOperands() == 3);
                instructionCallback.optimisticBalancedMonitorExit(getCGInst(inst->getSrc(0)),
                    getCGInst(inst->getSrc(1)),
                    getCGInst(inst->getSrc(2)));
            }
            break;
        case Op_MonitorEnterFence:
            {
                assert(inst->getNumSrcOperands() == 1);
                instructionCallback.monitorEnterFence(getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_MonitorExitFence:
            {
                assert(inst->getNumSrcOperands() == 1);
                instructionCallback.monitorExitFence(getCGInst(inst->getSrc(0)));
            }
            break;
        case Op_TypeMonitorEnter:
            {
                assert(inst->getNumSrcOperands() == 0);
                Type * type = ((TypeInst*)inst)->getTypeInfo();
                assert(type->isObject() || type->isUserValue());
                instructionCallback.typeMonitorEnter((NamedType *)type);
            }
            break;
        case Op_TypeMonitorExit:
            {
                assert(inst->getNumSrcOperands() == 0);
                Type * type = ((TypeInst*)inst)->getTypeInfo();
                assert(type->isObject() || type->isUserValue());
                instructionCallback.typeMonitorExit((NamedType *)type);
            }
            break;
        case Op_TauStaticCast:
            {
                assert(inst->getNumSrcOperands() == 2);
                Opnd *src = inst->getSrc(0);
                Opnd *tauCastChecked = inst->getSrc(1);
                assert(tauCastChecked->getType()->tag == Type::Tau);
                Type * toType = ((TypeInst*)inst)->getTypeInfo();
                assert(toType->isObject());
                cgInst = instructionCallback.tau_staticCast((ObjectType *)toType,
                    getCGInst(src),
                    getCGInst(tauCastChecked));
            }
            break;
        case Op_TauCast:
            {
                assert(inst->getNumSrcOperands() == 2);
                Type * toType = ((TypeInst*)inst)->getTypeInfo();
                assert(toType->isObject());
                Opnd *src = inst->getSrc(0);
                Opnd *tauCheckedNull = inst->getSrc(1);
                assert(tauCheckedNull->getType()->tag == Type::Tau);
                cgInst = instructionCallback.tau_cast((ObjectType *)toType,
                    getCGInst(src),
                    getCGInst(tauCheckedNull));
            }
            break;
        case Op_TauAsType:
            {
                assert(inst->getNumSrcOperands() == 2);
                Type * toType = ((TypeInst*)inst)->getTypeInfo();
                assert(toType->isObject());
                Opnd *src = inst->getSrc(0);
                Opnd *tauCheckedNull = inst->getSrc(1);
                assert(tauCheckedNull->getType()->tag == Type::Tau);
                cgInst = instructionCallback.tau_asType((ObjectType *)toType,
                    getCGInst(src),
                    getCGInst(tauCheckedNull));
            }
            break;
        case Op_TauInstanceOf:
            {
                assert(inst->getNumSrcOperands() == 2);
                Type * toType = ((TypeInst*)inst)->getTypeInfo();
                assert(toType->isObject());
                Opnd *src = inst->getSrc(0);
                Opnd *tauCheckedNull = inst->getSrc(1);
                assert(tauCheckedNull->getType()->tag == Type::Tau);
                cgInst = instructionCallback.tau_instanceOf((ObjectType *)toType,
                    getCGInst(src),
                    getCGInst(tauCheckedNull));
            }
            break;
        case Op_InitType:
            {
                assert(inst->getNumSrcOperands() == 0);
                TypeInst *typeInst = (TypeInst*)inst;
                instructionCallback.initType(typeInst->getTypeInfo());
            }
            break;
        case Op_Label:
            break;      // nothing to do
        case Op_MethodEntry:
            {  
                assert(inst->isMethodMarker());
                MethodMarkerInst* methEntryInst = inst->asMethodMarkerInst();
                instructionCallback.methodEntry(methEntryInst->getMethodDesc());
            }
            break;      // nothing to do
        case Op_MethodEnd:
            {  
                assert(inst->isMethodMarker());
                MethodMarkerInst* methEntryInst = inst->asMethodMarkerInst();
                // check that inst->getSrc(0) is really retOpnd and not thisOpnd
                CG_OpndHandle* ret_val = inst->getNumSrcOperands()==0 ? NULL : 
                getCGInst(inst->getSrc(0));
                instructionCallback.methodEnd(methEntryInst->getMethodDesc(), 
                    ret_val);
            }
            break;      // nothing to do
        case Op_Phi:
            {
                assert(0); // Phi nodes should be eliminated by deSSAing
            }
            break;
        case Op_TauPi:
            {
                assert(0);
            }
            break;
        case Op_IncCounter:
            {
                TokenInst *counterInst = (TokenInst *)inst;
                U_32 counter = counterInst->getToken();
                instructionCallback.incCounter(irmanager.getTypeManager().getUInt32Type(), counter);
            }
            break;
        case Op_Prefetch:
            {
                assert(inst->getNumSrcOperands() == 1);
                Opnd* addr= inst->getSrc(0);
                instructionCallback.prefetch(getCGInst(addr));
            }
            break;
        case Op_TauPoint:
            {
                assert(inst->getNumSrcOperands() == 0);
                cgInst = instructionCallback.tauPoint();
            }
            break;
        case Op_TauEdge:
            {
                assert(inst->getNumSrcOperands() == 0);
                cgInst = instructionCallback.tauEdge();
            }
            break;
        case Op_TauAnd:
            {
                U_32 numSrcs = inst->getNumSrcOperands();
                CG_OpndHandle **args = genCallArgs(inst, 0);
                cgInst = instructionCallback.tauAnd(numSrcs, args);
            }
            break;
        case Op_TauUnsafe:
            {
                assert(inst->getNumSrcOperands() == 0);
                cgInst = instructionCallback.tauUnsafe();
            }
            break;
        case Op_TauSafe:
            {
                assert(inst->getNumSrcOperands() == 0);
                cgInst = instructionCallback.tauSafe();
            }
            break;
        case Op_TauCheckCast:
            {
                assert(inst->getNumSrcOperands() == 2);
                Opnd *src = inst->getSrc(0);
                Opnd *tauCheckedNull = inst->getSrc(1);
                assert(tauCheckedNull->getType()->tag == Type::Tau);
                Type * toType = ((TypeInst*)inst)->getTypeInfo();
                assert(toType->isObject());
                cgInst = instructionCallback.tau_checkCast((ObjectType *)toType,
                    getCGInst(src),
                    getCGInst(tauCheckedNull));
            }
            break;
        case Op_TauHasType:
            {
                cgInst = instructionCallback.tauPoint();
            }
            break;
        case Op_TauHasExactType:
            {
                cgInst = instructionCallback.tauPoint();
            }
            break;
        case Op_TauIsNonNull:
            {
                cgInst = instructionCallback.tauPoint();
            }
            break;
        default:
            assert(0);
    } // end switch

    if (cgInst) { // record mapping from dst
        if(Log::isEnabled()) {
            Log::out() << "genInstCode ";
            inst->print(Log::out());
            if (genConsts) {
                Log::out() << "; genConsts=true";
            } else {
                Log::out() << "; genConsts=false";
            }
            Log::out() << " has cgInst"  << ::std::endl;
        }

        assert(dst);
        if (isConstant) {
            if(Log::isEnabled()) {
                Log::out() << " isConstant" << ::std::endl;
            }
            assert(genConsts);
            if (sinkConstants) {
                if(Log::isEnabled()) {
                    Log::out() << " sinkConstants=true" << ::std::endl;
                }
                setLocalCGInst(cgInst, dst);
            } else {
                if(Log::isEnabled()) {
                    Log::out() << " sinkConstants=false" << ::std::endl;
                }
                setCGInst(cgInst, dst);
            }
        } else {
            if(Log::isEnabled()) {
                Log::out() << " isConstant=false" << ::std::endl;
            }
            setCGInst(cgInst, dst);
            if (sinkConstants && sinkConstantsOne) {
                // we just finished a non-constant inst, clear the constant inst map
                clearLocalCGInsts();
            }
        }            
    } else {
        if(Log::isEnabled()) {
            Log::out() << "genInstCode ";
            inst->print(Log::out());
            if (genConsts) {
                Log::out() << "; genConsts=true";
            } else {
                Log::out() << "; genConsts=false";
            }
            Log::out() << " has NO cgInst"  << ::std::endl;
        }
    }
}

void _BlockCodeSelector::genCode(InstructionCallback& instructionCallback) {
    callback = &instructionCallback;
    //
    // go through instructions
    //
    Inst*    labelInst = (Inst*)block->getFirstInst();
    Inst*    inst = labelInst->getNextInst();
    while (inst != NULL) {
        if(Log::isEnabled()) {
            Log::out() << "Code select ";
            inst->print(Log::out());
            Log::out() << ::std::endl;
        }
        genInstCode(instructionCallback, inst, !sinkConstants);
        inst = inst->getNextInst();
    }
}

CG_OpndHandle* _BlockCodeSelector::getCGInst(Opnd* opnd) {
    CG_OpndHandle *res = opndToCGInstMap[opnd->getId()];
    if (!res) {
        assert(sinkConstants);
        res = localOpndToCGInstMap[opnd->getId()];
        if (!res) {
            uint16 savedBCOffset = callback->getCurrentHIRInstBCOffset();
            genInstCode(*callback, opnd->getInst(), true); // generate code for the constant
            res = localOpndToCGInstMap[opnd->getId()];
            assert(res);
            callback->setCurrentHIRInstBCOffset(savedBCOffset);
        }
    }
    return res;
}
    
void _BlockCodeSelector::setLocalCGInst(CG_OpndHandle* inst, Opnd* opnd) {
    assert(sinkConstants);
    localOpndToCGInstMap[opnd->getId()] = inst;
}
    
void _BlockCodeSelector::clearLocalCGInsts() {
    assert(sinkConstants && sinkConstantsOne);
    localOpndToCGInstMap.clear();
}

void _BlockCodeSelector::setCGInst(CG_OpndHandle* inst,Opnd* opnd) {
    opndToCGInstMap[opnd->getId()] = inst;
    if (opnd->isGlobal()) 
        callback->opndMaybeGlobal(inst);
}

U_32 _BlockCodeSelector::getVarHandle(VarOpnd *var) {
    return varIdMap[var->getId()];
}


void _CFGCodeSelector::genCode(Callback& callback) {
    bool    hasEdgeProfile = flowGraph->hasEdgeProfile();
    //
    // go through nodes in flow graph and call genDispatchNode for nodes
    // that are handlers (dispatchers) and genBlock for nodes that are blocks.
    // record the integer id that is returned and map it to the node.
    //

    //
    // this table maps from a node's depth-first number to the 
    // node id returned by the code selector
    //
    StlVector<MethodDesc*> inlineEndMarkers(memManager);
    U_32*    nodeMapTable = new (memManager) U_32[numNodes];
    
    // Compute postorder list to get only reachable nodes.
    const Nodes& nodes = flowGraph->getNodesPostOrder();

    assert(flowGraph->getExitNode()->getTraversalNum() == flowGraph->getTraversalNum());
    Node* unwind = flowGraph->getUnwindNode();
    Node* exit = flowGraph->getExitNode();
    // Use reverse iterator to generate nodes in reverse postorder.
    Nodes::const_reverse_iterator niter;
    for(niter = nodes.rbegin(); niter != nodes.rend(); ++niter) {
        Node* node = *niter;
        //
        // Count in and out edges
        //
        U_32 numOutEdges = node->getOutDegree();
        U_32 numInEdges = node->getInDegree();
        U_32 nodeId = MAX_UINT32;
        double cnt = (hasEdgeProfile? node->getExecCount() : -1.0);

        if (node == exit) {
            nodeId = callback.genExitNode(numInEdges,cnt);
        }
        else if (node == unwind) {
            nodeId = callback.genUnwindNode(numInEdges,numOutEdges,cnt);
        }
        else if (node->isBlockNode()) {
            _BlockCodeSelector    blockCodeSelector(memManager,
                irmanager,
                node,
                opndToCGInstMap,
                varIdMap,
                sinkConstants,
                sinkConstantsOne);


            //
            //  Derive the block kind (prolog, epilog, inner block)
            //
            CFGCodeSelector::Callback::BlockKind blockKind;
            if (node == flowGraph->getEntryNode())
                blockKind = CFGCodeSelector::Callback::Prolog;
            else if (node == flowGraph->getReturnNode())
                blockKind = CFGCodeSelector::Callback::Epilog;
            else
                blockKind = CFGCodeSelector::Callback::InnerBlock;
            nodeId = callback.genBlock(numInEdges,
                numOutEdges,
                blockKind,
                blockCodeSelector,
                cnt);

        } else if (node->isDispatchNode()) {
            if(node->getSecondInst()!=NULL) {
                for (Inst* inst = (Inst*)node->getSecondInst(); inst!=NULL; inst = inst->getNextInst()) {
                    assert(inst->isMethodMarker());
                    MethodMarkerInst* marker = inst->asMethodMarkerInst();
                    assert(marker->getOpcode() == Op_MethodEnd);
                    inlineEndMarkers.push_back(marker->getMethodDesc());
                }
            }
            nodeId = callback.genDispatchNode(numInEdges,numOutEdges,inlineEndMarkers, cnt);
            inlineEndMarkers.clear();
        }
        assert(nodeId < numNodes);
        callback.setPersistentId(nodeId, node->getId());
        nodeMapTable[node->getDfNum()] = nodeId;
    }
    //
    // go through edges in flow graph 
    //
    for(niter = nodes.rbegin(); niter != nodes.rend(); ++niter) {
        double    prob;
        Node* tailNode = *niter;
        U_32 tailNodeId = nodeMapTable[tailNode->getDfNum()];
        if (((Inst*)tailNode->getLastInst())->isSwitch()) { 
            //
            //  Generate switch edges
            //
            SwitchInst* sw = (SwitchInst *)tailNode->getLastInst();
            Node *defaultNode = sw->getDefaultTarget()->getNode();
            U_32 defaultNodeId = nodeMapTable[defaultNode->getDfNum()];
            U_32 numTargets = sw->getNumTargets();
            U_32 * targetNodeIds = new (memManager) U_32[numTargets];
            double * targetProbs = new (memManager) double[numTargets];
            U_32 i;
            for (i = 0; i < numTargets; i++) {
                Node *headNode = sw->getTarget(i)->getNode();
                Edge *edge = (Edge *) tailNode->findTargetEdge(headNode);
                targetNodeIds[i] = nodeMapTable[headNode->getDfNum()];
                targetProbs[i] = (hasEdgeProfile? edge->getEdgeProb() : -1.0);
            }
            callback.genSwitchEdges(tailNodeId,numTargets,targetNodeIds, 
                targetProbs, defaultNodeId);
            //
            //  Generate an exception edge if it exists
            //
            Edge* throwEdge = (Edge*) tailNode->getExceptionEdge();
            if(throwEdge != NULL) {
                assert(0);
                Node *succNode = throwEdge->getTargetNode();
                assert(succNode->isDispatchNode());
                U_32 headNodeId = nodeMapTable[succNode->getDfNum()];
                prob = (hasEdgeProfile? throwEdge->getEdgeProb() : -1.0);
                callback.genExceptionEdge(tailNodeId,headNodeId,prob);
            }
        }
        else { 
            //
            // Gen edges for a node that does not end with a switch
            //
            const Edges& edges = tailNode->getOutEdges();
            Edges::const_iterator eiter;
            for(eiter = edges.begin(); eiter != edges.end(); ++eiter) {
                Edge* edge = *eiter;
                prob = (hasEdgeProfile? edge->getEdgeProb() : -1.0);
                Node * headNode = edge->getTargetNode();
                U_32 headNodeId = nodeMapTable[headNode->getDfNum()];
                Edge::Kind edgeKind = edge->getKind();
                switch (edgeKind) {
                    case Edge::Kind_Unconditional:
                        callback.genUnconditionalEdge(tailNodeId,headNodeId,prob);
                        break;
                    case Edge::Kind_True:
                        callback.genTrueEdge(tailNodeId,headNodeId,prob);
                        break;
                    case Edge::Kind_False:
                        callback.genFalseEdge(tailNodeId,headNodeId,prob);
                        break;
                    case Edge::Kind_Dispatch:
                        callback.genExceptionEdge(tailNodeId,headNodeId,prob);
                        break;
                    case Edge::Kind_Catch:
                        {
                            Inst* first = (Inst*)headNode->getFirstInst();
                            assert(first->isLabel() && 
                                ((LabelInst*)first)->isCatchLabel());
                            CatchLabelInst * label = (CatchLabelInst *)first;
                            callback.genCatchEdge(tailNodeId,headNodeId,
                                label->getOrder(),
                                label->getExceptionType(),
                                prob);
                            break;
                        }
                    default:
                        assert(0);
                }
            }
        }
    }
}

void _MethodCodeSelector::selectCode(Callback& callback) {
    MemoryManager localMemManager("_MethodCodeSelector::genCode.localMemManager"); 

    callback.setMethodDesc(methodDesc);

    U_32 *varIdMap = new (localMemManager) U_32[numVars];
    U_32 i;
    for (i = 0; i < numVars; i++) {
        varIdMap[i] = 0;
    }
    _VarCodeSelector varCodeSelector(varOpnds,varIdMap,irmanager.getGCBasePointerMap());
    callback.genVars(varCodeSelector.getNumVarOpnds(),varCodeSelector);

    CG_OpndHandle** opndToCGInstMap = new (localMemManager) CG_OpndHandle*[numOpnds];
    for (i=0; i<numOpnds; i++) { 
        opndToCGInstMap[i] = NULL;
    }
    _CFGCodeSelector    cfgCodeSelector(localMemManager,irmanager,flowGraph,opndToCGInstMap,
        varIdMap, sinkConstants, sinkConstantsOne);

    bool    hasEdgeProfile = flowGraph->hasEdgeProfile();

    callback.genCFG(cfgCodeSelector.getNumNodes(),cfgCodeSelector, hasEdgeProfile);
}

} //namespace Jitrino