/*
 *  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 Vyacheslav P. Shakin
 */

#include "Ia32IRManager.h"
#include "Ia32Encoder.h"
#include "Ia32Printer.h"
#include "Log.h"
#include "EMInterface.h"
#include "Ia32Printer.h"
#include "Ia32CodeGenerator.h"
#include "Dominator.h"
#include <math.h>

namespace Jitrino
{
namespace Ia32
{

using namespace std;

//=========================================================================================================
static void appendToInstList(Inst *& head, Inst * listToAppend) {
    if (head==NULL) {
        head=listToAppend;
    } else if (listToAppend!=NULL){
        listToAppend->insertBefore(head);
    }
}

//_________________________________________________________________________________________________
const char * newString(MemoryManager& mm, const char * str, U_32 length)
{
    assert(str!=NULL);
    if (length==EmptyUint32)
        length=(U_32)strlen(str);
    char * psz=new(mm) char[length+1];
    strncpy(psz, str, length);
    psz[length]=0;
    return psz;
}


//_____________________________________________________________________________________________
IRManager::IRManager(MemoryManager& memManager, TypeManager& tm, MethodDesc& md, CompilationInterface& compIface)
    :memoryManager(memManager), typeManager(tm), methodDesc(md), compilationInterface(compIface),
        opndId(0), instId(0),
        opnds(memManager), gpTotalRegUsage(0), entryPointInst(NULL), _hasLivenessInfo(false),
        internalHelperInfos(memManager), infoMap(memManager), verificationLevel(0),
        hasCalls(false), hasNonExceptionCalls(false), laidOut(false), codeStartAddr(NULL),
        refsCompressed(VMInterface::areReferencesCompressed())

{  
    for (U_32 i=0; i<lengthof(regOpnds); i++) regOpnds[i]=NULL;
    fg = new (memManager) ControlFlowGraph(memManager, this);
    fg->setEntryNode(fg->createBlockNode());
    fg->setLoopTree(new (memManager) LoopTree(memManager, fg));
    initInitialConstraints();
    registerInternalHelperInfo("printRuntimeOpndInternalHelper", IRManager::InternalHelperInfo((void*)&printRuntimeOpndInternalHelper, &CallingConvention_STDCALL));
}


//_____________________________________________________________________________________________
void IRManager::addOpnd(Opnd * opnd)
{ 
    assert(opnd->id>=opnds.size());
    opnds.push_back(opnd);
    opnd->id=(U_32)opnds.size()-1;
}

//_____________________________________________________________________________________________
Opnd * IRManager::newOpnd(Type * type)
{
    Opnd * opnd=new(memoryManager) Opnd(opndId++, type, getInitialConstraint(type));
    addOpnd(opnd);
    return opnd;
}

//_____________________________________________________________________________________________
Opnd * IRManager::newOpnd(Type * type, Constraint c)
{
    c.intersectWith(Constraint(OpndKind_Any, getTypeSize(type)));
    assert(!c.isNull());
    Opnd * opnd=new(memoryManager) Opnd(opndId++, type, c);
    addOpnd(opnd);
    return opnd;
}

//_____________________________________________________________________________________________
Opnd * IRManager::newImmOpnd(Type * type, int64 immediate)
{
    Opnd * opnd = newOpnd(type);
    opnd->assignImmValue(immediate);
    return opnd;
}

//____________________________________________________________________________________________
Opnd * IRManager::newImmOpnd(Type * type, Opnd::RuntimeInfo::Kind kind, void * arg0, void * arg1, void * arg2, void * arg3)
{
    Opnd * opnd=newImmOpnd(type, 0);
    opnd->setRuntimeInfo(new(memoryManager) Opnd::RuntimeInfo(kind, arg0, arg1, arg2, arg3));
    return opnd;
}

//_____________________________________________________________________________________________
ConstantAreaItem * IRManager::newConstantAreaItem(float f)
{
    return new(memoryManager) ConstantAreaItem(
        ConstantAreaItem::Kind_FPSingleConstantAreaItem, sizeof(float), 
        new(memoryManager) float(f)
    );
}

//_____________________________________________________________________________________________
ConstantAreaItem *  IRManager::newConstantAreaItem(double d)
{
    return new(memoryManager) ConstantAreaItem(
        ConstantAreaItem::Kind_FPDoubleConstantAreaItem, sizeof(double), 
        new(memoryManager) double(d)
    );
}

//_____________________________________________________________________________________________
ConstantAreaItem *  IRManager::newSwitchTableConstantAreaItem(U_32 numTargets)
{
    return new(memoryManager) ConstantAreaItem(
        ConstantAreaItem::Kind_SwitchTableConstantAreaItem, sizeof(BasicBlock*)*numTargets, 
        new(memoryManager) BasicBlock*[numTargets]
    );
}

//_____________________________________________________________________________________________
ConstantAreaItem *  IRManager::newInternalStringConstantAreaItem(const char * str)
{
    if (str==NULL)
        str="";
    return new(memoryManager) ConstantAreaItem(
        ConstantAreaItem::Kind_InternalStringConstantAreaItem, (U_32)strlen(str)+1, 
        (void*)newInternalString(str)
    );
}

//_____________________________________________________________________________________________
ConstantAreaItem * IRManager::newBinaryConstantAreaItem(U_32 size, const void * pv)
{
    return new(memoryManager) ConstantAreaItem(ConstantAreaItem::Kind_BinaryConstantAreaItem, size, pv);
}

//_____________________________________________________________________________________________
Opnd * IRManager::newFPConstantMemOpnd(float f, Opnd * baseOpnd, BasicBlock* bb)
{
    ConstantAreaItem * item=newConstantAreaItem(f);
    Opnd * addr=newImmOpnd(typeManager.getUnmanagedPtrType(typeManager.getSingleType()), Opnd::RuntimeInfo::Kind_ConstantAreaItem, item);
#ifdef _EM64T_
    bb->appendInst(newCopyPseudoInst(Mnemonic_MOV, baseOpnd, addr));
    return newMemOpndAutoKind(typeManager.getSingleType(), MemOpndKind_ConstantArea, baseOpnd);
#else
    return newMemOpndAutoKind(typeManager.getSingleType(), MemOpndKind_ConstantArea, addr);
#endif
}

//_____________________________________________________________________________________________
Opnd * IRManager::newFPConstantMemOpnd(double d, Opnd * baseOpnd, BasicBlock* bb)
{
    ConstantAreaItem * item=newConstantAreaItem(d);
    Opnd * addr=newImmOpnd(typeManager.getUnmanagedPtrType(typeManager.getDoubleType()), Opnd::RuntimeInfo::Kind_ConstantAreaItem, item);
#ifdef _EM64T_
    bb->appendInst(newCopyPseudoInst(Mnemonic_MOV, baseOpnd, addr));
    return newMemOpndAutoKind(typeManager.getDoubleType(), MemOpndKind_ConstantArea, baseOpnd);
#else
    return newMemOpndAutoKind(typeManager.getDoubleType(), MemOpndKind_ConstantArea, addr);
#endif
}

//_____________________________________________________________________________________________
Opnd * IRManager::newInternalStringConstantImmOpnd(const char * str)
{
    ConstantAreaItem * item=newInternalStringConstantAreaItem(str);
    return newImmOpnd(typeManager.getUnmanagedPtrType(typeManager.getIntPtrType()), Opnd::RuntimeInfo::Kind_ConstantAreaItem, item);
}

//_____________________________________________________________________________________________
Opnd * IRManager::newBinaryConstantImmOpnd(U_32 size, const void * pv)
{
    ConstantAreaItem * item=newBinaryConstantAreaItem(size, pv);
    return newImmOpnd(typeManager.getUnmanagedPtrType(typeManager.getIntPtrType()), Opnd::RuntimeInfo::Kind_ConstantAreaItem, item);
}

//_____________________________________________________________________________________________
SwitchInst * IRManager::newSwitchInst(U_32 numTargets, Opnd * index)
{
    assert(numTargets>0);
    assert(index!=NULL);
    Inst * instList = NULL;
    ConstantAreaItem * item=newSwitchTableConstantAreaItem(numTargets);
    // This tableAddress in SwitchInst is kept separately [from getOpnd(0)]
    // so it allows to replace an Opnd (used in SpillGen) and keep the table 
    // itself intact.
    Opnd * tableAddr=newImmOpnd(typeManager.getIntPtrType(), Opnd::RuntimeInfo::Kind_ConstantAreaItem, item);
#ifndef _EM64T_
    Opnd * targetOpnd = newMemOpnd(typeManager.getIntPtrType(), 
        MemOpndKind_ConstantArea, 0, index, newImmOpnd(typeManager.getInt32Type(), sizeof(POINTER_SIZE_INT)), tableAddr);
#else
    // on EM64T immediate displacement cannot be of 64 bit size, so move it to a register first
    Opnd * baseOpnd = newOpnd(typeManager.getInt64Type());
    appendToInstList(instList, newCopyPseudoInst(Mnemonic_MOV, baseOpnd, tableAddr));
    Opnd * targetOpnd = newMemOpnd(typeManager.getUnmanagedPtrType(typeManager.getIntPtrType()), 
        MemOpndKind_ConstantArea, baseOpnd, index, newImmOpnd(typeManager.getInt32Type(), sizeof(POINTER_SIZE_INT)), 0);
#endif
    SwitchInst * inst=new(memoryManager, 1) SwitchInst(Mnemonic_JMP, instId++, tableAddr);
    inst->insertOpnd(0, targetOpnd, Inst::OpndRole_Explicit);
    inst->assignOpcodeGroup(this);
    appendToInstList(instList, inst);
    return (SwitchInst *)instList;
}

//_____________________________________________________________________________________________
Opnd * IRManager::newRegOpnd(Type * type, RegName reg)
{
    Opnd * opnd = newOpnd(type, Constraint(getRegKind(reg)));
    opnd->assignRegName(reg);
    return opnd;
}

//_____________________________________________________________________________________________
Opnd * IRManager::newMemOpnd(Type * type, MemOpndKind k, Opnd * base, Opnd * index, Opnd * scale, Opnd * displacement, RegName segReg)
{
    Opnd * opnd = newOpnd(type);
    opnd->assignMemLocation(k,base,index,scale,displacement);
        if (segReg != RegName_Null)
            opnd->setSegReg(segReg);
    return opnd;
}

//_________________________________________________________________________________________________
Opnd * IRManager::newMemOpnd(Type * type, Opnd * base, Opnd * index, Opnd * scale, Opnd * displacement, RegName segReg)
{
    return newMemOpnd(type, MemOpndKind_Heap, base, index, scale, displacement, segReg);
}

//_____________________________________________________________________________________________
Opnd * IRManager::newMemOpnd(Type * type, MemOpndKind k, Opnd * base, I_32 displacement, RegName segReg)
{
    return newMemOpnd(type, k, base, 0, 0, newImmOpnd(typeManager.getInt32Type(), displacement), segReg);
}

//_____________________________________________________________________________________________
Opnd * IRManager::newMemOpndAutoKind(Type * type, MemOpndKind k, Opnd * opnd0, Opnd * opnd1, Opnd * opnd2)
{  
    Opnd * base=NULL, * displacement=NULL;

    Constraint c=opnd0->getConstraint(Opnd::ConstraintKind_Current);
    if (!(c&OpndKind_GPReg).isNull()){
        base=opnd0;
    }else if (!(c&OpndKind_Imm).isNull()){
        displacement=opnd0;
    }else
        assert(0);

    if (opnd1!=NULL){
        c=opnd1->getConstraint(Opnd::ConstraintKind_Current);
        if (!(c&OpndKind_GPReg).isNull()){
            base=opnd1;
        }else if (!(c&OpndKind_Imm).isNull()){
            displacement=opnd1;
        }else
            assert(0);
    }

    return newMemOpnd(type, k, base, 0, 0, displacement);
}

//_____________________________________________________________________________________________
void IRManager::initInitialConstraints()
{
    for (U_32 i=0; i<lengthof(initialConstraints); i++)
        initialConstraints[i] = createInitialConstraint((Type::Tag)i);
}

//_____________________________________________________________________________________________
Constraint IRManager::createInitialConstraint(Type::Tag t)const
{
    OpndSize sz=getTypeSize(t);
    if (t==Type::Single||t==Type::Double||t==Type::Float)
        return Constraint(OpndKind_XMMReg, sz)|Constraint(OpndKind_Mem, sz);
    if (sz<=Constraint::getDefaultSize(OpndKind_GPReg))
        return Constraint(OpndKind_GPReg, sz)|Constraint(OpndKind_Mem, sz)|Constraint(OpndKind_Imm, sz);
    if (sz==OpndSize_64)
        return Constraint(OpndKind_Mem, sz)|Constraint(OpndKind_Imm, sz); // imm before lowering
    return Constraint(OpndKind_Memory, sz);
}

//_____________________________________________________________________________________________
Inst * IRManager::newInst(Mnemonic mnemonic, Opnd * opnd0, Opnd * opnd1, Opnd * opnd2)
{
    Inst * inst = new(memoryManager, 4) Inst(mnemonic, instId++, Inst::Form_Native);
    U_32 i=0;
    Opnd ** opnds = inst->getOpnds();
    U_32 * roles = inst->getOpndRoles();
    if (opnd0!=NULL){ opnds[i] = opnd0; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd1!=NULL){ opnds[i] = opnd1; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd2!=NULL){ opnds[i] = opnd2; roles[i] = Inst::OpndRole_Explicit; i++;
    }}}
    inst->opndCount = i;
    inst->assignOpcodeGroup(this);
    return inst;
}

//_____________________________________________________________________________________________
Inst * IRManager::newInst(Mnemonic mnemonic, 
        Opnd * opnd0, Opnd * opnd1, Opnd * opnd2, Opnd * opnd3, 
        Opnd * opnd4, Opnd * opnd5, Opnd * opnd6, Opnd * opnd7
    )
{
    Inst * inst = new(memoryManager, 8) Inst(mnemonic, instId++, Inst::Form_Native);
    U_32 i=0;
    Opnd ** opnds = inst->getOpnds();
    U_32 * roles = inst->getOpndRoles();
    if (opnd0!=NULL){ opnds[i] = opnd0; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd1!=NULL){ opnds[i] = opnd1; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd2!=NULL){ opnds[i] = opnd2; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd3!=NULL){ opnds[i] = opnd3; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd4!=NULL){ opnds[i] = opnd4; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd5!=NULL){ opnds[i] = opnd5; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd6!=NULL){ opnds[i] = opnd6; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd7!=NULL){ opnds[i] = opnd7; roles[i] = Inst::OpndRole_Explicit; i++;
    }}}}}}}};   
    inst->opndCount = i;
    inst->assignOpcodeGroup(this);
    return inst;
}

//_____________________________________________________________________________________________
Inst * IRManager::newInstEx(Mnemonic mnemonic, U_32 defCount, Opnd * opnd0, Opnd * opnd1, Opnd * opnd2)
{
    Inst * inst = new(memoryManager, 4) Inst(mnemonic, instId++, Inst::Form_Extended);
    U_32 i=0;
    Opnd ** opnds = inst->getOpnds();
    U_32 * roles = inst->getOpndRoles();
    if (opnd0!=NULL){ 
        opnds[i] = opnd0; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd1!=NULL){ 
        opnds[i] = opnd1; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd2!=NULL){ 
        opnds[i] = opnd2; roles[i] = Inst::OpndRole_Explicit; i++;
    }}}
    inst->opndCount = i;
    inst->defOpndCount=defCount;
    inst->assignOpcodeGroup(this);
    return inst;
}

//_____________________________________________________________________________________________
Inst * IRManager::newInstEx(Mnemonic mnemonic, U_32 defCount, 
        Opnd * opnd0, Opnd * opnd1, Opnd * opnd2, Opnd * opnd3, 
        Opnd * opnd4, Opnd * opnd5, Opnd * opnd6, Opnd * opnd7
    )
{
    Inst * inst = new(memoryManager, 8) Inst(mnemonic, instId++, Inst::Form_Extended);
    U_32 i=0;
    Opnd ** opnds = inst->getOpnds();
    U_32 * roles = inst->getOpndRoles();
    if (opnd0!=NULL){ 
        opnds[i] = opnd0; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd1!=NULL){ 
        opnds[i] = opnd1; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd2!=NULL){ 
        opnds[i] = opnd2; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd3!=NULL){ 
        opnds[i] = opnd3; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd4!=NULL){ 
        opnds[i] = opnd4; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd5!=NULL){ 
        opnds[i] = opnd5; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd6!=NULL){ 
        opnds[i] = opnd6; roles[i] = Inst::OpndRole_Explicit; i++;
    if (opnd7!=NULL){ 
        opnds[i] = opnd7; roles[i] = Inst::OpndRole_Explicit; i++;
    }}}}}}}};   
    inst->opndCount = i;
    inst->defOpndCount=defCount;
    inst->assignOpcodeGroup(this);
    return inst;
}

//_________________________________________________________________________________________________
Inst * IRManager::newI8PseudoInst(Mnemonic mnemonic, U_32 defCount,
            Opnd * opnd0, Opnd * opnd1, Opnd * opnd2, Opnd * opnd3
        )
{
    Inst * inst=new  (memoryManager, 4) Inst(mnemonic, instId++, Inst::Form_Extended);
    inst->kind = Inst::Kind_I8PseudoInst;
    U_32 i=0;
    Opnd ** opnds = inst->getOpnds();
    assert(opnd0->getType()->isInteger() ||opnd0->getType()->isPtr());
    if (opnd0!=NULL){       opnds[i] = opnd0; i++;
    if (opnd1!=NULL){       opnds[i] = opnd1; i++;
    if (opnd2!=NULL){       opnds[i] = opnd2; i++;
    if (opnd3!=NULL){       opnds[i] = opnd3; i++;
    }}}};   
    inst->defOpndCount=defCount;
    inst->opndCount = i;
    inst->assignOpcodeGroup(this);
    return inst;
}

//_____________________________________________________________________________________________
SystemExceptionCheckPseudoInst * IRManager::newSystemExceptionCheckPseudoInst(CompilationInterface::SystemExceptionId exceptionId, Opnd * opnd0, Opnd * opnd1, bool checksThisForInlinedMethod)
{
    SystemExceptionCheckPseudoInst * inst=new  (memoryManager, 8) SystemExceptionCheckPseudoInst(exceptionId, instId++, checksThisForInlinedMethod);
    U_32 i=0;
    Opnd ** opnds = inst->getOpnds();
    if (opnd0!=NULL){ opnds[i++] = opnd0; 
    if (opnd1!=NULL){ opnds[i++] = opnd1;
    }}      
    inst->opndCount = i;
    inst->assignOpcodeGroup(this);
    return inst;
}


//_________________________________________________________________________________________________
BranchInst * IRManager::newBranchInst(Mnemonic mnemonic, Node* trueTarget, Node* falseTarget,  Opnd * targetOpnd)
{
    BranchInst * inst=new(memoryManager, 2) BranchInst(mnemonic, instId++);
    if (targetOpnd==0)
        targetOpnd=newImmOpnd(typeManager.getInt32Type(), 0);
    inst->insertOpnd(0, targetOpnd, Inst::OpndRole_Explicit);
    inst->assignOpcodeGroup(this);
    inst->setFalseTarget(falseTarget);
    inst->setTrueTarget(trueTarget);
    return inst;
}

//_________________________________________________________________________________________________
JumpInst * IRManager::newJumpInst(Opnd * targetOpnd)
{
    JumpInst * inst=new(memoryManager, 2) JumpInst(instId++);
    if (targetOpnd==0) {
        targetOpnd=newImmOpnd(typeManager.getInt32Type(), 0);
    }
    inst->insertOpnd(0, targetOpnd, Inst::OpndRole_Explicit);
    inst->assignOpcodeGroup(this);
    return inst;
}

//_________________________________________________________________________________________________
EntryPointPseudoInst * IRManager::newEntryPointPseudoInst(const CallingConvention * cc)
{
    // there is nothing wrong with calling this method several times.
    // it's just a self-check, as the currently assumed behaviour is that this method is invoked only once.
    assert(NULL == entryPointInst);

    EntryPointPseudoInst * inst=new(memoryManager, methodDesc.getNumParams() * 2) EntryPointPseudoInst(this, instId++, cc);
    fg->getEntryNode()->appendInst(inst);

    inst->assignOpcodeGroup(this);
    entryPointInst = inst;

    if (getCompilationInterface().getCompilationParams().exe_notify_method_entry) {
        Opnd **hlpArgs = new (memoryManager) Opnd* [1];
        hlpArgs[0] = newImmOpnd(typeManager.getIntPtrType(), 
            Opnd::RuntimeInfo::Kind_MethodRuntimeId, &methodDesc);
            Node* prolog = getFlowGraph()->getEntryNode();
            prolog->appendInst(newRuntimeHelperCallInst(VM_RT_JVMTI_METHOD_ENTER_CALLBACK,
                    1, (Opnd**)hlpArgs, NULL));
    }


    return inst;
}

//_________________________________________________________________________________________________
CallInst * IRManager::newCallInst(Opnd * targetOpnd, const CallingConvention * cc, 
        U_32 argCount, Opnd ** args, Opnd * retOpnd)
{
    CallInst * callInst=new(memoryManager, (argCount + (retOpnd ? 1 : 0)) * 2 + 1) CallInst(this, instId++, cc, targetOpnd->getRuntimeInfo());
    CallingConventionClient & ccc = callInst->callingConventionClient;
    U_32 i=0;
    if (retOpnd!=NULL){
        ccc.pushInfo(Inst::OpndRole_Def, retOpnd->getType()->tag);
        callInst->insertOpnd(i++, retOpnd, Inst::OpndRole_Auxilary|Inst::OpndRole_Def);
    }
    callInst->defOpndCount = i;
    callInst->insertOpnd(i++, targetOpnd, Inst::OpndRole_Explicit|Inst::OpndRole_Use);

    if (argCount>0){
        for (U_32 j=0; j<argCount; j++){
            ccc.pushInfo(Inst::OpndRole_Use, args[j]->getType()->tag);
            callInst->insertOpnd(i++, args[j], Inst::OpndRole_Auxilary|Inst::OpndRole_Use);
        }
    }
    callInst->opndCount = i;
    callInst->assignOpcodeGroup(this);
    return callInst;
}

//_________________________________________________________________________________________________
CallInst * IRManager::newRuntimeHelperCallInst(VM_RT_SUPPORT helperId, 
    U_32 numArgs, Opnd ** args, Opnd * retOpnd)
{
    Inst * instList = NULL;
    Opnd * target=newImmOpnd(typeManager.getInt32Type(), Opnd::RuntimeInfo::Kind_HelperAddress, (void*)helperId);
    const CallingConvention * cc=getCallingConvention(helperId);
    appendToInstList(instList,newCallInst(target, cc, numArgs, args, retOpnd));
    return (CallInst *)instList;
}

//_________________________________________________________________________________________________
CallInst * IRManager::newInternalRuntimeHelperCallInst(const char * internalHelperID, U_32 numArgs, Opnd ** args, Opnd * retOpnd)
{
    const InternalHelperInfo * info=getInternalHelperInfo(internalHelperID);
    assert(info!=NULL);
    Inst * instList = NULL;
    Opnd * target=newImmOpnd(typeManager.getInt32Type(), Opnd::RuntimeInfo::Kind_InternalHelperAddress, (void*)newInternalString(internalHelperID));
    const CallingConvention * cc=info->callingConvention;
    appendToInstList(instList,newCallInst(target, cc, numArgs, args, retOpnd));
    return (CallInst *)instList;
}
//_________________________________________________________________________________________________
Inst* IRManager::newEmptyPseudoInst() {
    return new(memoryManager, 0) EmptyPseudoInst(instId++);
}
//_________________________________________________________________________________________________
MethodMarkerPseudoInst* IRManager::newMethodEntryPseudoInst(MethodDesc* mDesc) {
    return new(memoryManager, 0) MethodMarkerPseudoInst(mDesc, instId++, Inst::Kind_MethodEntryPseudoInst);
}
//_________________________________________________________________________________________________
MethodMarkerPseudoInst* IRManager::newMethodEndPseudoInst(MethodDesc* mDesc) {
    return new(memoryManager, 0) MethodMarkerPseudoInst(mDesc, instId++, Inst::Kind_MethodEndPseudoInst);
}
//_________________________________________________________________________________________________
void IRManager::registerInternalHelperInfo(const char * internalHelperID, const InternalHelperInfo& info)
{
    assert(internalHelperID!=NULL && internalHelperID[0]!=0);
    internalHelperInfos[newInternalString(internalHelperID)]=info;
}

//_________________________________________________________________________________________________
RetInst * IRManager::newRetInst(Opnd * retOpnd)
{
    RetInst * retInst=new  (memoryManager, 4) RetInst(this, instId++);
    assert( NULL != entryPointInst && NULL != entryPointInst->getCallingConventionClient().getCallingConvention() );
    retInst->insertOpnd(0, newImmOpnd(typeManager.getInt16Type(), 0), Inst::OpndRole_Explicit|Inst::OpndRole_Use);
    if (retOpnd!=NULL){
        retInst->insertOpnd(1, retOpnd, Inst::OpndRole_Auxilary|Inst::OpndRole_Use);
        retInst->getCallingConventionClient().pushInfo(Inst::OpndRole_Use, retOpnd->getType()->tag);
        retInst->opndCount = 2;
    } else  retInst->opndCount = 1;

    retInst->assignOpcodeGroup(this);
    return retInst;
}


//_________________________________________________________________________________________________
void IRManager::applyCallingConventions()
{
    const Nodes& nodes = fg->getNodes();
    for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) {
        Node* node = *it;
        if (node->isBlockNode()){
            for (Inst * inst= (Inst*)node->getFirstInst(); inst!=NULL; inst=inst->getNextInst()){
                if (inst->hasKind(Inst::Kind_EntryPointPseudoInst)){
                    EntryPointPseudoInst * eppi=(EntryPointPseudoInst*)inst;
                    eppi->callingConventionClient.finalizeInfos(Inst::OpndRole_Def, CallingConvention::ArgKind_InArg);
                    eppi->callingConventionClient.layoutAuxilaryOpnds(Inst::OpndRole_Def, OpndKind_Memory);
                }else if (inst->hasKind(Inst::Kind_CallInst)){
                    CallInst * callInst=(CallInst*)inst;

                    callInst->callingConventionClient.finalizeInfos(Inst::OpndRole_Use, CallingConvention::ArgKind_InArg);
                    callInst->callingConventionClient.layoutAuxilaryOpnds(Inst::OpndRole_Use, OpndKind_Any);

                    callInst->callingConventionClient.finalizeInfos(Inst::OpndRole_Def, CallingConvention::ArgKind_RetArg);
                    callInst->callingConventionClient.layoutAuxilaryOpnds(Inst::OpndRole_Def, OpndKind_Null);
                    
                }else if (inst->hasKind(Inst::Kind_RetInst)){
                    RetInst * retInst=(RetInst*)inst;
                    retInst->callingConventionClient.finalizeInfos(Inst::OpndRole_Use, CallingConvention::ArgKind_RetArg);
                    retInst->callingConventionClient.layoutAuxilaryOpnds(Inst::OpndRole_Use, OpndKind_Null);

                    if (retInst->getCallingConventionClient().getCallingConvention()->calleeRestoresStack()){
                        U_32 stackDepth=getEntryPointInst()->getArgStackDepth();
                        retInst->getOpnd(0)->assignImmValue(stackDepth);
                    }
                }
            }
        }
    }
}

//_________________________________________________________________________________________________
CatchPseudoInst * IRManager::newCatchPseudoInst(Opnd * exception)
{
    CatchPseudoInst * inst=new  (memoryManager, 1) CatchPseudoInst(instId++);
    inst->insertOpnd(0, exception, Inst::OpndRole_Def);
    inst->setConstraint(0, RegName_EAX);
    inst->defOpndCount = 1;
    inst->opndCount = 1;
    inst->assignOpcodeGroup(this);
    return inst;
}

//_________________________________________________________________________________________________
GCInfoPseudoInst* IRManager::newGCInfoPseudoInst(const StlVector<Opnd*>& basesAndMptrs) {
#ifdef _DEBUG
    for (StlVector<Opnd*>::const_iterator it = basesAndMptrs.begin(), end = basesAndMptrs.end(); it!=end; ++it) {
        Opnd* opnd = *it;
        assert(opnd->getType()->isObject() || opnd->getType()->isManagedPtr());
    }
#endif
    GCInfoPseudoInst* inst = new(memoryManager, (U_32)basesAndMptrs.size()) GCInfoPseudoInst(this, instId++);
    Opnd ** opnds = inst->getOpnds();
    Constraint * constraints = inst->getConstraints();
    for (U_32 i = 0, n = (U_32)basesAndMptrs.size(); i < n; i++){
        Opnd * opnd = basesAndMptrs[i];
        opnds[i] = opnd;
        constraints[i] = Constraint(OpndKind_Any, opnd->getSize());
    }
    inst->opndCount = (U_32)basesAndMptrs.size();
    inst->assignOpcodeGroup(this);
    return inst;
}

//_________________________________________________________________________________________________
CMPXCHG8BPseudoInst * IRManager::newCMPXCHG8BPseudoInst(Opnd* mem, Opnd* edx, Opnd* eax, Opnd* ecx, Opnd* ebx)
{ 
    CMPXCHG8BPseudoInst* inst = new  (memoryManager, 8) CMPXCHG8BPseudoInst(instId++);

    Opnd** opnds = inst->getOpnds();
    Constraint* opndConstraints = inst->getConstraints();

    // we do not set mem as a use in the inst
    // just to cheat cg::verifier (see IRManager::verifyOpnds() function)
    opnds[0] = mem;
    opnds[1] = edx;
    opnds[2] = eax;
    opnds[3] = getRegOpnd(RegName_EFLAGS);
    opnds[4] = edx;
    opnds[5] = eax;
    opnds[6] = ecx;
    opnds[7] = ebx;
    opndConstraints[0] = Constraint(OpndKind_Memory, OpndSize_64);
    opndConstraints[1] = Constraint(RegName_EDX);
    opndConstraints[2] = Constraint(RegName_EAX);
    opndConstraints[3] = Constraint(RegName_EFLAGS);
    opndConstraints[4] = Constraint(RegName_EDX);
    opndConstraints[5] = Constraint(RegName_EAX);
    opndConstraints[6] = Constraint(RegName_ECX);
    opndConstraints[7] = Constraint(RegName_EBX);

    inst->opndCount = 8;
    inst->defOpndCount = 4;

    inst->assignOpcodeGroup(this);
    return inst;
}

//_________________________________________________________________________________________________
Inst * IRManager::newCopyPseudoInst(Mnemonic mn, Opnd * opnd0, Opnd * opnd1)
{ 
    assert(mn==Mnemonic_MOV||mn==Mnemonic_PUSH||mn==Mnemonic_POP);
    U_32 allOpndCnt = opnd0->getType()->isInt8() ? 4 : 2;
    Inst * inst=new  (memoryManager, allOpndCnt) Inst(mn, instId++, Inst::Form_Extended);
    inst->kind = Inst::Kind_CopyPseudoInst;
    assert(opnd0!=NULL);
    assert(opnd1==NULL||opnd0->getSize()<=opnd1->getSize());

    Opnd ** opnds = inst->getOpnds();
    Constraint * opndConstraints = inst->getConstraints();

    opnds[0] = opnd0;
    opndConstraints[0] = Constraint(OpndKind_Any, opnd0->getSize());
    if (opnd1!=NULL){
        opnds[1] = opnd1;
        opndConstraints[1] = Constraint(OpndKind_Any, opnd0->getSize());
        inst->opndCount = 2;
    }else
        inst->opndCount = 1;
    if (mn != Mnemonic_PUSH)
        inst->defOpndCount = 1;
    inst->assignOpcodeGroup(this);
    return inst;
}

//_________________________________________________________________________________________________
AliasPseudoInst * IRManager::newAliasPseudoInst(Opnd * targetOpnd, Opnd * sourceOpnd, U_32 offset)
{
    assert(sourceOpnd->isPlacedIn(OpndKind_Memory));
    assert(!targetOpnd->hasAssignedPhysicalLocation());
    assert(targetOpnd->canBePlacedIn(OpndKind_Memory));

    Type * sourceType=sourceOpnd->getType();
    OpndSize sourceSize=getTypeSize(sourceType);

    Type * targetType=targetOpnd->getType();
    OpndSize targetSize=getTypeSize(targetType);

#ifdef _DEBUG
    U_32 sourceByteSize=getByteSize(sourceSize);
    U_32 targetByteSize=getByteSize(targetSize);
    assert(getByteSize(sourceSize)>0 && getByteSize(targetSize)>0);
    assert(offset+targetByteSize<=sourceByteSize);
#endif

    U_32 allocOpndNum = sourceOpnd->getType()->isInt8() ? 3 : 2;
    AliasPseudoInst * inst=new  (memoryManager, allocOpndNum) AliasPseudoInst(instId++);

    inst->getOpnds()[0] = targetOpnd;
    inst->getConstraints()[0] = Constraint(OpndKind_Mem, targetSize);

    inst->getOpnds()[1] = sourceOpnd;
    inst->getConstraints()[1] = Constraint(OpndKind_Mem, sourceSize);
    if (sourceOpnd->getType()->isInt8()) {
        inst->getConstraints()[2] = Constraint(OpndKind_Mem, targetSize);
    }

    inst->defOpndCount = 1;
    inst->opndCount = 2;

    inst->offset=offset;

    layoutAliasPseudoInstOpnds(inst);

    inst->assignOpcodeGroup(this);
    return inst;
}

//_________________________________________________________________________________________________
AliasPseudoInst * IRManager::newAliasPseudoInst(Opnd * targetOpnd, U_32 sourceOpndCount, Opnd ** sourceOpnds)
{
    assert(targetOpnd->isPlacedIn(OpndKind_Memory));

    Type * targetType=targetOpnd->getType();
    OpndSize targetSize=getTypeSize(targetType);
    assert(getByteSize(targetSize)>0);
    U_32 allocOpnNum = 0;
    for (U_32 i=0; i<sourceOpndCount; i++) allocOpnNum += getByteSize(getTypeSize(sourceOpnds[i]->getType()));

    allocOpnNum += getByteSize(getTypeSize(targetOpnd->getType()));
    AliasPseudoInst * inst=new  (memoryManager, allocOpnNum) AliasPseudoInst(instId++);

    Opnd ** opnds = inst->getOpnds();
    Constraint * opndConstraints = inst->getConstraints();

    opnds[0] = targetOpnd;
    opndConstraints[0] = Constraint(OpndKind_Mem, targetSize);


    U_32 offset=0;
    for (U_32 i=0; i<sourceOpndCount; i++){
        assert(!sourceOpnds[i]->hasAssignedPhysicalLocation() || 
            (sourceOpnds[i]->isPlacedIn(OpndKind_Memory) && 
            sourceOpnds[i]->getMemOpndKind() == targetOpnd->getMemOpndKind())
            );
        assert(sourceOpnds[i]->canBePlacedIn(OpndKind_Memory));
        Type * sourceType=sourceOpnds[i]->getType();
        OpndSize sourceSize=getTypeSize(sourceType);
        U_32 sourceByteSize=getByteSize(sourceSize);
        assert(sourceByteSize>0);
        assert(offset+sourceByteSize<=getByteSize(targetSize));

        opnds[1 + i] = sourceOpnds[i];
        opndConstraints[1 + i] = Constraint(OpndKind_Mem, sourceSize);

        offset+=sourceByteSize;
    }
    inst->defOpndCount = 1;
    inst->opndCount = sourceOpndCount + 1;

    layoutAliasPseudoInstOpnds(inst);
    inst->assignOpcodeGroup(this);
    return inst;
}

//_________________________________________________________________________________________________
void IRManager::layoutAliasPseudoInstOpnds(AliasPseudoInst * inst)
{
    assert(inst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Def) == 1);
    Opnd * const * opnds = inst->getOpnds();
    Opnd * defOpnd=opnds[0];
    Opnd * const * useOpnds = opnds + 1; 
    U_32 useCount = inst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Use);
    assert(useCount > 0);
    if (inst->offset==EmptyUint32){
        U_32 offset=0;
        for (U_32 i=0; i<useCount; i++){
            Opnd * innerOpnd=useOpnds[i];
            assignInnerMemOpnd(defOpnd, innerOpnd, offset);
            offset+=getByteSize(innerOpnd->getSize());
        }
    }else
        assignInnerMemOpnd(useOpnds[0], defOpnd, inst->offset);
}

//_________________________________________________________________________________________________
void IRManager::addAliasRelation(AliasRelation * relations, Opnd * outerOpnd, Opnd * innerOpnd, U_32 offset)
{
    if (outerOpnd==innerOpnd){
        assert(offset==0);
        return;
    }

    const AliasRelation& outerRel=relations[outerOpnd->getId()];
    if (outerRel.outerOpnd!=NULL){
        addAliasRelation(relations, outerRel.outerOpnd, innerOpnd, outerRel.offset+offset);
        return;
    }

    AliasRelation& innerRel=relations[innerOpnd->getId()];
    if (innerRel.outerOpnd!=NULL){
        addAliasRelation(relations, outerOpnd, innerRel.outerOpnd, offset-(int)innerRel.offset);
    }

#ifdef _DEBUG
    Type * outerType=outerOpnd->getType();
    OpndSize outerSize=getTypeSize(outerType);
    U_32 outerByteSize=getByteSize(outerSize);
    assert(offset<outerByteSize);

    Type * innerType=innerOpnd->getType();
    OpndSize innerSize=getTypeSize(innerType);
    U_32 innerByteSize=getByteSize(innerSize);
    assert(outerByteSize>0 && innerByteSize>0);
    assert(offset+innerByteSize<=outerByteSize);
#endif

    innerRel.outerOpnd=outerOpnd;
    innerRel.offset=offset;

}

//_________________________________________________________________________________________________
void IRManager::getAliasRelations(AliasRelation * relations)
{
    const Nodes& nodes = fg->getNodes();
    for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) {
        Node* node = *it;
        if (node->isBlockNode()) {
            for (Inst * inst=(Inst*)node->getFirstInst(); inst!=NULL; inst=inst->getNextInst()) {
                if (inst->hasKind(Inst::Kind_AliasPseudoInst)){
                    AliasPseudoInst * aliasInst=(AliasPseudoInst *)inst;
                    Opnd * const * opnds = inst->getOpnds();
                    U_32 useCount = inst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Use);
                    assert(inst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_Def) == 1 && useCount > 0);
                    Opnd * defOpnd=opnds[0];
                    Opnd * const * useOpnds = opnds + 1; 
                    if (aliasInst->offset==EmptyUint32){
                        U_32 offset=0;
                        for (U_32 i=0; i<useCount; i++){
                            Opnd * innerOpnd=useOpnds[i];
                            addAliasRelation(relations, defOpnd, innerOpnd, offset);
                            offset+=getByteSize(innerOpnd->getSize());
                        }
                    }else{
                        addAliasRelation(relations, useOpnds[0], defOpnd, aliasInst->offset);
                    }
                }
            }
        }
    }
}

//_________________________________________________________________________________________________
void IRManager::layoutAliasOpnds() 
{
    MemoryManager mm("layoutAliasOpnds");
    U_32 opndCount=getOpndCount();
    AliasRelation * relations=new  (memoryManager) AliasRelation[opndCount];
    getAliasRelations(relations);
    for (U_32 i=0; i<opndCount; i++){
        if (relations[i].outerOpnd!=NULL){
            Opnd * innerOpnd=getOpnd(i);
            assert(innerOpnd->isPlacedIn(OpndKind_Mem));
            assert(relations[i].outerOpnd->isPlacedIn(OpndKind_Mem));
            Opnd * innerDispOpnd=innerOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement);
            if (innerDispOpnd==NULL){
                innerDispOpnd=newImmOpnd(typeManager.getInt32Type(), 0);
                innerOpnd->setMemOpndSubOpnd(MemOpndSubOpndKind_Displacement, innerDispOpnd);
            }
            Opnd * outerDispOpnd=relations[i].outerOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement);
            U_32 outerDispValue=(U_32)(outerDispOpnd!=NULL?outerDispOpnd->getImmValue():0);
            innerDispOpnd->assignImmValue(outerDispValue+relations[i].offset);
        }
    }
}

//_________________________________________________________________________________________________
U_32 IRManager::assignInnerMemOpnd(Opnd * outerOpnd, Opnd* innerOpnd, U_32 offset)
{
    assert(outerOpnd->isPlacedIn(OpndKind_Memory));

    Opnd * outerDisp=outerOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement);
    MemOpndKind outerMemOpndKind=outerOpnd->getMemOpndKind();
    Opnd::RuntimeInfo * outerDispRI=outerDisp!=NULL?outerDisp->getRuntimeInfo():NULL;
    uint64 outerDispValue=outerDisp!=NULL?outerDisp->getImmValue():0;

    Opnd * outerBase=outerOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Base);
    Opnd * outerIndex=outerOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Index);
    Opnd * outerScale=outerOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Scale);

    OpndSize innerSize = innerOpnd->getSize();
    U_32 innerByteSize = getByteSize(innerSize);
        
    Opnd * innerDisp=newImmOpnd(outerDisp!=NULL?outerDisp->getType():typeManager.getInt32Type(), outerDispValue+offset);
    if (outerDispRI){
        Opnd::RuntimeInfo * innerDispRI=new(memoryManager) 
            Opnd::RuntimeInfo(
                outerDispRI->getKind(),
                outerDispRI->getValue(0),
                outerDispRI->getValue(1),
                outerDispRI->getValue(2),
                outerDispRI->getValue(3),
                offset
            );
        innerDisp->setRuntimeInfo(innerDispRI);
    }
    innerOpnd->assignMemLocation(outerMemOpndKind, outerBase, outerIndex, outerScale, innerDisp);
    return innerByteSize;
}

//_________________________________________________________________________________________________
void IRManager::assignInnerMemOpnds(Opnd * outerOpnd, Opnd** innerOpnds, U_32 innerOpndCount)
{
#ifdef _DEBUG
    U_32 outerByteSize = getByteSize(outerOpnd->getSize());
#endif
    for (U_32 i=0, offset=0; i<innerOpndCount; i++){
        offset+=assignInnerMemOpnd(outerOpnd, innerOpnds[i], offset);
        assert(offset<=outerByteSize);
    }
}

//_________________________________________________________________________________________________
U_32 getLayoutOpndAlignment(Opnd * opnd)
{
    OpndSize size=opnd->getSize();
    if (size==OpndSize_80 || size==OpndSize_128)
        return 16;
    if (size==OpndSize_64)
        return 8;
    else
        return 4;
}


//_________________________________________________________________________________________________

Inst * IRManager::newCopySequence(Mnemonic mn, Opnd * opnd0, Opnd * opnd1, U_32 gpRegUsageMask, U_32 flagsRegUsageMask)
{
    if (mn==Mnemonic_MOV)
        return newCopySequence(opnd0, opnd1, gpRegUsageMask, flagsRegUsageMask);
    else if (mn==Mnemonic_PUSH||mn==Mnemonic_POP)
        return newPushPopSequence(mn, opnd0, gpRegUsageMask);
    assert(0);
    return NULL;
}


//_________________________________________________________________________________________________

Inst * IRManager::newMemMovSequence(Opnd * targetOpnd, Opnd * sourceOpnd, U_32 regUsageMask, bool checkSource)
{
    Inst * instList=NULL;
    RegName tmpRegName=RegName_Null, unusedTmpRegName=RegName_Null;
    bool registerSetNotLocked = !isRegisterSetLocked(OpndKind_GPReg);

#ifdef _EM64T_
    for (U_32 reg = RegName_RAX; reg<=RegName_R15/*(U_32)(targetOpnd->getSize()<OpndSize_64?RegName_RBX:RegName_RDI)*/; reg++) {
#else
    for (U_32 reg = RegName_EAX; reg<=(U_32)(targetOpnd->getSize()<OpndSize_32?RegName_EBX:RegName_EDI); reg++) {
#endif
        RegName regName = (RegName) reg;
        if (regName == STACK_REG)
            continue;
        Opnd * subOpnd = targetOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Base);
        if(subOpnd && subOpnd->isPlacedIn(regName))
            continue;
        subOpnd = targetOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Index);
        if(subOpnd && subOpnd->isPlacedIn(regName))
            continue;

        if (checkSource){
            subOpnd = sourceOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Base);
            if(subOpnd && subOpnd->isPlacedIn(regName))
                continue;
            subOpnd = sourceOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Index);
            if(subOpnd && subOpnd->isPlacedIn(regName))
                continue;
        }

        tmpRegName=regName;
        if (registerSetNotLocked || (getRegMask(tmpRegName)&regUsageMask)==0){
            unusedTmpRegName=tmpRegName;
            break;
        }
    }

    assert(tmpRegName!=RegName_Null);
    Opnd * tmp=getRegOpnd(tmpRegName);
    Opnd * tmpAdjusted=newRegOpnd(targetOpnd->getType(), tmpRegName);
    Opnd * tmpRegStackOpnd = newMemOpnd(tmp->getType(), MemOpndKind_StackAutoLayout, getRegOpnd(STACK_REG), 0); 


    if (unusedTmpRegName==RegName_Null)
        appendToInstList(instList, newInst(Mnemonic_MOV, tmpRegStackOpnd, tmp));

    appendToInstList(instList, newInst(Mnemonic_MOV, tmpAdjusted, sourceOpnd)); // must satisfy constraints
    appendToInstList(instList, newInst(Mnemonic_MOV, targetOpnd, tmpAdjusted)); // must satisfy constraints

    if (unusedTmpRegName==RegName_Null)
        appendToInstList(instList, newInst(Mnemonic_MOV, tmp, tmpRegStackOpnd));

    return instList;
}


//_________________________________________________________________________________________________

Inst * IRManager::newCopySequence(Opnd * targetBOpnd, Opnd * sourceBOpnd, U_32 regUsageMask, U_32 flagsRegUsageMask)

{ 
    Opnd * targetOpnd=(Opnd*)targetBOpnd, * sourceOpnd=(Opnd*)sourceBOpnd;

    Constraint targetConstraint = targetOpnd->getConstraint(Opnd::ConstraintKind_Location);
    Constraint sourceConstraint = sourceOpnd->getConstraint(Opnd::ConstraintKind_Location);
    
    if (targetConstraint.isNull() || sourceConstraint.isNull()){
        return newCopyPseudoInst(Mnemonic_MOV, targetOpnd, sourceOpnd);
    }

    OpndSize sourceSize=sourceConstraint.getSize();
    U_32 sourceByteSize=getByteSize(sourceSize);
    OpndKind targetKind=(OpndKind)targetConstraint.getKind();
    OpndKind sourceKind=(OpndKind)sourceConstraint.getKind();

#if defined(_DEBUG) || !defined(_EM64T_)
    OpndSize targetSize=targetConstraint.getSize();
    assert(targetSize<=sourceSize); // only same size or truncating conversions are allowed
#endif

    if (targetKind&OpndKind_Reg) {
        if(sourceOpnd->isPlacedIn(OpndKind_Imm) && sourceOpnd->getImmValue()==0 && targetKind==OpndKind_GPReg && 
            !sourceOpnd->getRuntimeInfo() && !(getRegMask(RegName_EFLAGS)&flagsRegUsageMask)) {
            return newInst(Mnemonic_XOR,targetOpnd, targetOpnd);
        }
        else if (targetKind==OpndKind_XMMReg && sourceOpnd->getMemOpndKind()==MemOpndKind_ConstantArea) {
#ifdef _EM64T_
            Opnd * addr = NULL;
            Opnd * base = sourceOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Base);
            if(base) {
                Inst * defInst = base->getDefiningInst();
                if(defInst && defInst->getMnemonic() == Mnemonic_MOV) {
                    addr = defInst->getOpnd(1);
                    if(!addr->getRuntimeInfo()) {
                        // addr opnd may be spilled. Let's try deeper
                        defInst = addr->getDefiningInst();
                        if(defInst && defInst->getMnemonic() == Mnemonic_MOV) {
                            addr = defInst->getOpnd(1);
                        } else {
                            addr = NULL;
                        }
                    }
                }
            }
#else
            Opnd * addr = sourceOpnd->getMemOpndSubOpnd(MemOpndSubOpndKind_Displacement);
#endif
            Opnd::RuntimeInfo* addrRI = addr == NULL ? NULL : addr->getRuntimeInfo();

            if( addrRI && addrRI->getKind()==Opnd::RuntimeInfo::Kind_ConstantAreaItem) {
                void * fpPtr = (void *)((ConstantAreaItem *)addrRI->getValue(0))->getValue();
                if (sourceByteSize==4) {
                    float val = *(float *)fpPtr;
                    if(val == 0 && !signbit(val)) {
                        return newInst(Mnemonic_XORPS,targetOpnd, targetOpnd);
                    }
                }else if (sourceByteSize==8) {
                    double val = *(double *)fpPtr;
                    if(val == 0 && !signbit(val)) {
                        return newInst(Mnemonic_XORPD,targetOpnd, targetOpnd);
                    }
                }
            }
        }
    }

    if ( (targetKind==OpndKind_GPReg||targetKind==OpndKind_Mem) && 
         (sourceKind==OpndKind_GPReg||sourceKind==OpndKind_Mem||sourceKind==OpndKind_Imm)
    ){
        if (sourceKind==OpndKind_Mem && targetKind==OpndKind_Mem){
            Inst * instList=NULL;
#ifndef _EM64T_
            U_32 targetByteSize=getByteSize(targetSize);
            if (sourceByteSize<=4){
                instList=newMemMovSequence(targetOpnd, sourceOpnd, regUsageMask);
            }else{
                Opnd * targetOpnds[IRMaxOperandByteSize/4]; // limitation because we are currently don't support large memory operands
                U_32 targetOpndCount = 0;
                for (U_32 cb=0; cb<sourceByteSize && cb<targetByteSize; cb+=4)
                    targetOpnds[targetOpndCount++] = newOpnd(typeManager.getInt32Type());
                AliasPseudoInst * targetAliasInst=newAliasPseudoInst(targetOpnd, targetOpndCount, targetOpnds);
                layoutAliasPseudoInstOpnds(targetAliasInst);
                for (U_32 cb=0, targetOpndSlotIndex=0; cb<sourceByteSize && cb<targetByteSize; cb+=4, targetOpndSlotIndex++){  
                    Opnd * sourceOpndSlot=newOpnd(typeManager.getInt32Type());
                    appendToInstList(instList, newAliasPseudoInst(sourceOpndSlot, sourceOpnd, cb));
                    Opnd * targetOpndSlot=targetOpnds[targetOpndSlotIndex];
                    appendToInstList(instList, newMemMovSequence(targetOpndSlot, sourceOpndSlot, regUsageMask, true));
                }
                appendToInstList(instList, targetAliasInst);
            }
#else
            instList=newMemMovSequence(targetOpnd, sourceOpnd, regUsageMask);
#endif
            assert(instList!=NULL);
            return instList;
        }else{
#ifdef _EM64T_
            if((targetOpnd->getMemOpndKind() == MemOpndKind_StackAutoLayout) && (sourceKind==OpndKind_Imm) && (sourceOpnd->getSize() == OpndSize_64)) 
                return newMemMovSequence(targetOpnd, sourceOpnd, regUsageMask, false);
            else 
#else
            assert(sourceByteSize<=4);
#endif
            return newInst(Mnemonic_MOV, targetOpnd, sourceOpnd); // must satisfy constraints
        }
    }else if ( 
        (targetKind==OpndKind_XMMReg||targetKind==OpndKind_Mem) && 
        (sourceKind==OpndKind_XMMReg||sourceKind==OpndKind_Mem)
    ){
        targetOpnd->setMemOpndAlignment(Opnd::MemOpndAlignment_16);
        sourceOpnd->setMemOpndAlignment(Opnd::MemOpndAlignment_16);
        if (sourceByteSize==4){
            return newInst(Mnemonic_MOVSS,targetOpnd, sourceOpnd);
        }else if (sourceByteSize==8){
            bool regsOnly = targetKind==OpndKind_XMMReg && sourceKind==OpndKind_XMMReg;
            if (regsOnly && CPUID::isSSE2Supported()) {
                return newInst(Mnemonic_MOVAPD, targetOpnd, sourceOpnd);
            } else  {
                return newInst(Mnemonic_MOVSD, targetOpnd, sourceOpnd);
            }
        }
    }else if (targetKind==OpndKind_FPReg && sourceKind==OpndKind_Mem){
        sourceOpnd->setMemOpndAlignment(Opnd::MemOpndAlignment_16);
        return newInst(Mnemonic_FLD, targetOpnd, sourceOpnd);
    }else if (targetKind==OpndKind_Mem && sourceKind==OpndKind_FPReg){
        targetOpnd->setMemOpndAlignment(Opnd::MemOpndAlignment_16);
        return newInst(Mnemonic_FSTP, targetOpnd, sourceOpnd);
    }else if (targetKind==OpndKind_XMMReg && (sourceKind==OpndKind_Mem || sourceKind==OpndKind_GPReg)){
        if (sourceKind==OpndKind_Mem)
            sourceOpnd->setMemOpndAlignment(Opnd::MemOpndAlignment_16);
        return newInst(Mnemonic_MOVD, targetOpnd, sourceOpnd);
    }else if ((targetKind==OpndKind_Mem || targetKind==OpndKind_GPReg) && sourceKind==OpndKind_XMMReg){
        if (targetKind==OpndKind_Mem)
            targetOpnd->setMemOpndAlignment(Opnd::MemOpndAlignment_16);
        return newInst(Mnemonic_MOVD, targetOpnd, sourceOpnd);
    }else if (
        (targetKind==OpndKind_FPReg && sourceKind==OpndKind_XMMReg)||
        (targetKind==OpndKind_XMMReg && sourceKind==OpndKind_FPReg)
    ){
        Inst * instList=NULL;
        Opnd * tmp = newMemOpnd(targetOpnd->getType(), MemOpndKind_StackAutoLayout, getRegOpnd(STACK_REG), 0);
        tmp->setMemOpndAlignment(Opnd::MemOpndAlignment_16);
        appendToInstList(instList, newCopySequence(tmp, sourceOpnd, regUsageMask));
        appendToInstList(instList, newCopySequence(targetOpnd, tmp, regUsageMask));
        return instList;
    }
    assert(0);
    return NULL;
}


//_________________________________________________________________________________________________

Inst * IRManager::newPushPopSequence(Mnemonic mn, Opnd * opnd, U_32 regUsageMask)
{
    assert(opnd!=NULL);

    Constraint constraint = opnd->getConstraint(Opnd::ConstraintKind_Location);
    if (constraint.isNull())
        return newCopyPseudoInst(mn, opnd);

    OpndKind kind=(OpndKind)constraint.getKind();
    OpndSize size=constraint.getSize();

    Inst * instList=NULL;

#ifdef _EM64T_
    if ( ((kind==OpndKind_GPReg ||kind==OpndKind_Mem)&& size!=OpndSize_32)||(kind==OpndKind_Imm && size<OpndSize_32)){
            return newInst(mn, opnd);
#else
    if ( kind==OpndKind_GPReg||kind==OpndKind_Mem||kind==OpndKind_Imm ){
        if (size==OpndSize_32){
            return newInst(mn, opnd);
        }else if (size<OpndSize_32){ 
        }else if (size==OpndSize_64){
            if (mn==Mnemonic_PUSH){
                Opnd * opndLo=newOpnd(typeManager.getUInt32Type());
                appendToInstList(instList, newAliasPseudoInst(opndLo, opnd, 0)); 
                Opnd * opndHi=newOpnd(typeManager.getIntPtrType());
                appendToInstList(instList, newAliasPseudoInst(opndHi, opnd, 4)); 
                appendToInstList(instList, newInst(Mnemonic_PUSH, opndHi));
                appendToInstList(instList, newInst(Mnemonic_PUSH, opndLo));
            }else{
                Opnd * opnds[2]={ newOpnd(typeManager.getUInt32Type()), newOpnd(typeManager.getInt32Type()) };
                appendToInstList(instList, newInst(Mnemonic_POP, opnds[0])); 
                appendToInstList(instList, newInst(Mnemonic_POP, opnds[1]));
                appendToInstList(instList, newAliasPseudoInst(opnd, 2, opnds));
            }
            return instList;
        }
#endif
    }
    Opnd * espOpnd=getRegOpnd(STACK_REG);
    Opnd * tmp=newMemOpnd(opnd->getType(), MemOpndKind_StackManualLayout, espOpnd, 0); 
#ifdef _EM64T_
    Opnd * sizeOpnd=newImmOpnd(typeManager.getInt32Type(), sizeof(POINTER_SIZE_INT));
    if(kind==OpndKind_Imm) {
        assert(mn==Mnemonic_PUSH);
        appendToInstList(instList, newInst(Mnemonic_SUB, espOpnd, sizeOpnd));
        appendToInstList(instList, newMemMovSequence(tmp, opnd, regUsageMask));
    } else if (kind == OpndKind_GPReg){
        assert(mn==Mnemonic_PUSH);
        appendToInstList(instList, newInst(Mnemonic_SUB, espOpnd, sizeOpnd));
        appendToInstList(instList, newInst(Mnemonic_MOV, tmp, opnd));
    } else {
        if (mn==Mnemonic_PUSH){
            appendToInstList(instList, newInst(Mnemonic_SUB, espOpnd, sizeOpnd));
            appendToInstList(instList, newCopySequence(tmp, opnd, regUsageMask));
        }else{
            appendToInstList(instList, newCopySequence(opnd, tmp, regUsageMask));
            appendToInstList(instList, newInst(Mnemonic_ADD, espOpnd, sizeOpnd));
        }
    }
#else
    U_32 cb=getByteSize(size);
    U_32 slotSize=4; 
    cb=(cb+slotSize-1)&~(slotSize-1);
    Opnd * sizeOpnd=newImmOpnd(typeManager.getInt32Type(), cb);
    if (mn==Mnemonic_PUSH){
        appendToInstList(instList, newInst(Mnemonic_SUB, espOpnd, sizeOpnd));
        appendToInstList(instList, newCopySequence(tmp, opnd, regUsageMask));
    }else{
        appendToInstList(instList, newCopySequence(opnd, tmp, regUsageMask));
        appendToInstList(instList, newInst(Mnemonic_ADD, espOpnd, sizeOpnd));
    }
#endif
    return instList;
}

//_________________________________________________________________________________________________
const CallingConvention * IRManager::getCallingConvention(VM_RT_SUPPORT helperId)const
{
    HELPER_CALLING_CONVENTION callConv = compilationInterface.getRuntimeHelperCallingConvention(helperId);
    switch (callConv){
        case CALLING_CONVENTION_DRL:
            return &CallingConvention_Managed;
        case CALLING_CONVENTION_STDCALL:
            return &CallingConvention_STDCALL;
        case CALLING_CONVENTION_CDECL:
            return &CallingConvention_CDECL;
        case CALLING_CONVENTION_MULTIARRAY:
            return &CallingConvention_MultiArray;
        default:
            assert(0);
            return NULL;
    }
}

//_________________________________________________________________________________________________
const CallingConvention * IRManager::getCallingConvention(MethodDesc * methodDesc)const
{
    return &CallingConvention_Managed;
}

//_________________________________________________________________________________________________
Opnd * IRManager::defArg(Type * type, U_32 position)
{
    assert(NULL != entryPointInst);
    Opnd * opnd=newOpnd(type);
    entryPointInst->insertOpnd(position, opnd, Inst::OpndRole_Auxilary|Inst::OpndRole_Def);
    entryPointInst->callingConventionClient.pushInfo(Inst::OpndRole_Def, type->tag);
    return opnd;
}

//_________________________________________________________________________________________________
Opnd * IRManager::getRegOpnd(RegName regName)
{
    assert(getRegSize(regName)==Constraint::getDefaultSize(getRegKind(regName))); // are we going to change this?
    U_32 idx=( (getRegKind(regName) & 0x1f) << 4 ) | ( getRegIndex(regName)&0xf );
    if (!regOpnds[idx]){
#ifdef _EM64T_
        Type * t = (getRegSize(regName) == OpndSize_64 ? typeManager.getUInt64Type() : typeManager.getUInt32Type());
        regOpnds[idx]=newRegOpnd(t, regName);
#else
        regOpnds[idx]=newRegOpnd(typeManager.getUInt32Type(), regName);
#endif
    }
    return regOpnds[idx];
}
void IRManager::calculateTotalRegUsage(OpndKind regKind) {
    assert(regKind == OpndKind_GPReg);
    U_32 opndCount=getOpndCount();
    for (U_32 i=0; i<opndCount; i++){
        Opnd * opnd=getOpnd(i);
        if (opnd->isPlacedIn(regKind)) {
            RegName reg = opnd->getRegName();
            unsigned mask = getRegMask(reg);
#if !defined(_EM64T_)
            if ((reg == RegName_AH) || (reg == RegName_CH) || (reg == RegName_DH) || (reg == RegName_BH))
                mask >>= 4;
#endif
            gpTotalRegUsage |= mask;
        }
    }
}
//_________________________________________________________________________________________________
U_32 IRManager::getTotalRegUsage(OpndKind regKind)const {
    return gpTotalRegUsage;
}
//_________________________________________________________________________________________________
bool IRManager::isPreallocatedRegOpnd(Opnd * opnd)
{
    RegName regName=opnd->getRegName();
    if (regName==RegName_Null || getRegSize(regName)!=Constraint::getDefaultSize(getRegKind(regName)))
        return false;
    U_32 idx=( (getRegKind(regName) & 0x1f) << 4 ) | ( getRegIndex(regName)&0xf );
    return regOpnds[idx]==opnd;
}

//_______________________________________________________________________________________________________________
Type * IRManager::getManagedPtrType(Type * sourceType)
{
    return typeManager.getManagedPtrType(sourceType); 
}

//_________________________________________________________________________________________________
Type * IRManager::getTypeFromTag(Type::Tag tag)const
{
    switch (tag) {
        case Type::Void:    
        case Type::Tau:     
        case Type::Int8:    
        case Type::Int16:   
        case Type::Int32:   
        case Type::IntPtr:  
        case Type::Int64:   
        case Type::UInt8:   
        case Type::UInt16:  
        case Type::UInt32:  
        case Type::UInt64:  
        case Type::Single:  
        case Type::Double:  
        case Type::Boolean:  
        case Type::Float:   return typeManager.getPrimitiveType(tag);
        default:            return new(memoryManager) Type(tag);
    }
}

//_____________________________________________________________________________________________
OpndSize IRManager::getTypeSize(Type::Tag tag)
{
    OpndSize size;
    switch (tag) {
        case Type::Int8:
        case Type::UInt8:
        case Type::Boolean:
            size = OpndSize_8;
            break;
        case Type::Int16:   
        case Type::UInt16:
        case Type::Char:
            size = OpndSize_16;
            break;
#ifndef _EM64T_
        case Type::IntPtr:   
        case Type::UIntPtr:   
#endif
        case Type::Int32:   
        case Type::UInt32:
            size = OpndSize_32;
            break;
#ifdef _EM64T_
        case Type::IntPtr:   
        case Type::UIntPtr:   
#endif
        case Type::Int64:   
        case Type::UInt64:
            size = OpndSize_64;
            break;
        case Type::Single:
            size = OpndSize_32;
            break;
        case Type::Double:
            size = OpndSize_64;
            break;
        case Type::Float:
            size = OpndSize_80;
            break;
        default:
#ifdef _EM64T_
            size = (tag>=Type::CompressedSystemObject && tag<=Type::CompressedVTablePtr)?OpndSize_32:OpndSize_64;
#else
            size = OpndSize_32;
#endif
            break;
    }
    return size;

}

//_____________________________________________________________________________________________
void IRManager::indexInsts() {
    const Nodes& postOrder = fg->getNodesPostOrder();
    U_32 idx=0;
    for (Nodes::const_reverse_iterator it = postOrder.rbegin(), end = postOrder.rend(); it!=end; ++it) {
        Node* node = *it;
        if (node->isBlockNode()){
            for (Inst* inst = (Inst*)node->getFirstInst(); inst!=NULL; inst = inst->getNextInst()) {
                inst->index=idx++;
            }
        }
    }
}

//_____________________________________________________________________________________________
U_32 IRManager::calculateOpndStatistics(bool reindex)
{
    POpnd * arr=&opnds.front();
    for (U_32 i=0, n=(U_32)opnds.size(); i<n; i++){
        Opnd * opnd=arr[i];
        if (opnd==NULL) {
            continue;
        }
        opnd->defScope=Opnd::DefScope_Temporary;
        opnd->definingInst=NULL;
        opnd->refCount=0;
        if (reindex) {
            opnd->id=EmptyUint32;
        }
    }

    U_32 index=0;
    U_32 instIdx=0;
    const Nodes& nodes = fg->getNodesPostOrder();
    for (Nodes::const_reverse_iterator  it = nodes.rbegin(), end = nodes.rend(); it!=end; ++it) {
        Node* node = *it;
        if (!node->isBlockNode()) {
            continue;
        }
        I_32 execCount=1;//(I_32)node->getExecCount()*100;
        for (Inst * inst=(Inst*)node->getFirstInst(); inst!=NULL; inst=inst->getNextInst()){
            inst->index=instIdx++;
            for (U_32 i=0, n=inst->getOpndCount(Inst::OpndRole_InstLevel|Inst::OpndRole_UseDef); i<n; i++){
                Opnd * opnd=inst->getOpnd(i);
                opnd->addRefCount(index, execCount);
                if ((inst->getOpndRoles(i)&Inst::OpndRole_Def)!=0){
                    opnd->setDefiningInst(inst);
                }
            }
        }
    }

    for (U_32 i=0; i<IRMaxRegNames; i++){ // update predefined regOpnds to prevent losing them from the ID space
        if (regOpnds[i]!=NULL) {
            regOpnds[i]->addRefCount(index, 1);
        }
    }
    return index;
}

//_____________________________________________________________________________________________
void IRManager::packOpnds()
{
    static CountTime packOpndsTimer("ia32::packOpnds");
    AutoTimer tm(packOpndsTimer);

    _hasLivenessInfo=false;

    U_32 maxIndex=calculateOpndStatistics(true);

    U_32 opndsBefore=(U_32)opnds.size();
    opnds.resize(opnds.size()+maxIndex);
    POpnd * arr=&opnds.front();
    for (U_32 i=0; i<opndsBefore; i++){
        Opnd * opnd=arr[i];
        if (opnd->id!=EmptyUint32)
            arr[opndsBefore+opnd->id]=opnd;
    }
    opnds.erase(opnds.begin(), opnds.begin()+opndsBefore);

    _hasLivenessInfo=false;
}

//_____________________________________________________________________________________________
void IRManager::fixLivenessInfo( U_32 * map )
{
    U_32 opndCount = getOpndCount();
    const Nodes& nodes = fg->getNodes();
    for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) {
        CGNode* node = (CGNode*)*it;
        BitSet * ls = node->getLiveAtEntry();
        ls->resize(opndCount);
    }   
}

//_____________________________________________________________________________________________
void IRManager::calculateLivenessInfo()
{
    static CountTime livenessTimer("ia32::liveness");
    AutoTimer tm(livenessTimer);

    _hasLivenessInfo=false;
    LoopTree* lt = fg->getLoopTree();
    lt->rebuild(false);
    const U_32 opndCount = getOpndCount();    

    const Nodes& nodes = fg->getNodesPostOrder();
    //clean all prev. liveness info
    for (Nodes::const_iterator it = nodes.begin(),end = nodes.end();it!=end; ++it) {
        CGNode* node = (CGNode*)*it;
        node->getLiveAtEntry()->resizeClear(opndCount);
    }
    U_32 loopDepth = lt->getMaxLoopDepth();
    U_32 nIterations = loopDepth + 1;
#ifdef _DEBUG
    nIterations++; //one more extra iteration to prove that nothing changed
#endif 
    BitSet tmpLs(memoryManager, opndCount);
    bool changed = true;
    Node* exitNode = fg->getExitNode();
    for (U_32 iteration=0; iteration < nIterations; iteration++) {
        changed = false;
        for (Nodes::const_iterator it = nodes.begin(),end = nodes.end();it!=end; ++it) {
            CGNode* node = (CGNode*)*it;
            if (node == exitNode) {
                if (!methodDesc.isStatic() 
                    && (methodDesc.isSynchronized() || methodDesc.isParentClassIsLikelyExceptionType())) 
                {
                    BitSet * exitLs  = node->getLiveAtEntry();
                    EntryPointPseudoInst * entryPointInst = getEntryPointInst();
#ifdef _EM64T_
                    Opnd * thisOpnd  = entryPointInst->thisOpnd;
                    //on EM64T 'this' opnd is spilled to stack only after finalizeCallSites call (copy expansion pass)
                    //TODO: do it after code selector and tune early propagation and regalloc to skip this opnd from optimizations.
                    if (thisOpnd == NULL) continue; 
#else
                    Opnd * thisOpnd = entryPointInst->getOpnd(0);
#endif
                    exitLs->setBit(thisOpnd->getId(), true);
                } 
                continue;
            }
            bool processNode = true;
            if (iteration > 0) {
                U_32 depth = lt->getLoopDepth(node);
                processNode = iteration <= depth;
#ifdef _DEBUG
                processNode = processNode || iteration == nIterations-1; //last iteration will check all blocks
#endif
            }
            if (processNode) {
                getLiveAtExit(node, tmpLs);
                if (node->isBlockNode()){
                    for (Inst * inst=(Inst*)node->getLastInst(); inst!=NULL; inst=inst->getPrevInst()){
                        updateLiveness(inst, tmpLs);
                    }
                }
                BitSet * ls = node->getLiveAtEntry();
                if (iteration == 0 || !ls->isEqual(tmpLs)) {
                    changed = true;
                    ls->copyFrom(tmpLs);
                }
            }
        }
        if (!changed) {
            break;
        }
    }
#ifdef _DEBUG
    assert(!changed);
#endif
    _hasLivenessInfo=true;
}

//_____________________________________________________________________________________________
bool IRManager::ensureLivenessInfoIsValid() {
    return true;
}

//_____________________________________________________________________________________________
void IRManager::getLiveAtExit(const Node * node, BitSet & ls) const
{
    assert(ls.getSetSize()<=getOpndCount());
    const Edges& edges=node->getOutEdges();
    U_32 i=0;
    for (Edges::const_iterator ite = edges.begin(), ende = edges.end(); ite!=ende; ++ite, ++i) {
        Edge* edge = *ite;
        CGNode * succ=(CGNode*)edge->getTargetNode();
        const BitSet * succLs=succ->getLiveAtEntry();
        if (i==0) {
            ls.copyFrom(*succLs);
        } else {
            ls.unionWith(*succLs);
        }
    }
}

//_____________________________________________________________________________________________
void IRManager::updateLiveness(const Inst * inst, BitSet & ls) const 
{
    const Opnd * const * opnds = inst->getOpnds();
    U_32 opndCount = inst->getOpndCount();

    for (U_32 i = 0; i < opndCount; i++){
        const Opnd * opnd = opnds[i];
        U_32 id = opnd->getId();
        if (inst->isLiveRangeEnd(i))
            ls.setBit(id, false);
        else if (inst->isLiveRangeStart(i))
            ls.setBit(id, true);
    }
    for (U_32 i = 0; i < opndCount; i++){
        const Opnd * opnd = opnds[i];
        if (opnd->getMemOpndKind() != MemOpndKind_Null){
            const Opnd * const * subOpnds = opnd->getMemOpndSubOpnds();
            for (U_32 j = 0; j < MemOpndSubOpndKind_Count; j++){
                const Opnd * subOpnd = subOpnds[j];
                if (subOpnd != NULL && subOpnd->isSubjectForLivenessAnalysis())
                    ls.setBit(subOpnd->getId(), true);
            }
        }
    }

}

//_____________________________________________________________________________________________
U_32 IRManager::getRegUsageFromLiveSet(BitSet * ls, OpndKind regKind)const
{
    assert(ls->getSetSize()<=getOpndCount());
    U_32 mask=0;
    BitSet::IterB ib(*ls);
    for (int i = ib.getNext(); i != -1; i = ib.getNext()){
        Opnd * opnd=getOpnd(i);
        if (opnd->isPlacedIn(regKind))
            mask |= getRegMask(opnd->getRegName());
    }
    return mask;
}


//_____________________________________________________________________________________________
void IRManager::getRegUsageAtExit(const Node * node, OpndKind regKind, U_32 & mask)const
{
    assert(node->isBlockNode());
    const Edges& edges=node->getOutEdges();
    mask=0;
    for (Edges::const_iterator ite = edges.begin(), ende = edges.end(); ite!=ende; ++ite) {
        Edge* edge = *ite;
        mask |= getRegUsageAtEntry(edge->getTargetNode(), regKind);
    }
}

//_____________________________________________________________________________________________
void IRManager::updateRegUsage(const Inst * inst, OpndKind regKind, U_32 & mask)const
{
    Inst::Opnds opnds(inst, Inst::OpndRole_All);
    for (Inst::Opnds::iterator it = opnds.begin(); it != opnds.end(); it = opnds.next(it)){
        Opnd * opnd=inst->getOpnd(it);
        if (opnd->isPlacedIn(regKind)){
            U_32 m=getRegMask(opnd->getRegName());
            if (inst->isLiveRangeEnd(it))
                mask &= ~m;
            else if (inst->isLiveRangeStart(it))
                mask |= m;
        }
    }
}

//_____________________________________________________________________________________________
void IRManager::resetOpndConstraints()
{
    for (U_32 i=0, n=getOpndCount(); i<n; i++){
        Opnd * opnd=getOpnd(i);
        opnd->setCalculatedConstraint(opnd->getConstraint(Opnd::ConstraintKind_Initial));
    }
}

void IRManager::finalizeCallSites()
{
#ifdef _EM64T_
    MethodDesc& md = getMethodDesc();
    if (!md.isStatic() 
            && (md.isSynchronized() || md.isParentClassIsLikelyExceptionType())) {
        Type* thisType = entryPointInst->getOpnd(0)->getType();
        entryPointInst->thisOpnd = newMemOpnd(thisType, MemOpndKind_StackAutoLayout, getRegOpnd(STACK_REG), 0); 
        entryPointInst->getBasicBlock()->appendInst(newCopyPseudoInst(Mnemonic_MOV, entryPointInst->thisOpnd, entryPointInst->getOpnd(0)));
    }
#endif

    const Nodes& nodes = fg->getNodes();
    for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
        Node* node = *it;
        if (node->isBlockNode()) {
            for (Inst * inst = (Inst*)node->getLastInst(), * prevInst = NULL; inst != NULL; inst = prevInst) {
                prevInst = inst->getPrevInst();
                if (inst->getMnemonic() == Mnemonic_CALL) {
                    const CallInst * callInst = (const CallInst*)inst;
                    const CallingConvention * cc =
                        callInst->getCallingConventionClient().getCallingConvention();
                    const StlVector<CallingConventionClient::StackOpndInfo>& stackOpndInfos = 
                        callInst->getCallingConventionClient().getStackOpndInfos(Inst::OpndRole_Use);
                    
                    Inst * instToPrepend = inst;
                    Opnd * const * opnds = callInst->getOpnds();

                    unsigned shadowSize = 0;
                    
                    // Align stack.
                    if (callInst->getArgStackDepthAlignment() > 0) {
                        node->prependInst(newInst(Mnemonic_SUB, getRegOpnd(STACK_REG),
                            newImmOpnd(typeManager.getInt32Type(), callInst->getArgStackDepthAlignment())), inst);
                    }

                    // Put inputs on the stack.
                    for (U_32 i = 0, n = (U_32)stackOpndInfos.size(); i < n; i++) {
                        Opnd* opnd = opnds[stackOpndInfos[i].opndIndex];
                        Inst * pushInst = newCopyPseudoInst(Mnemonic_PUSH, opnd);
                        pushInst->insertBefore(instToPrepend);
                        instToPrepend = pushInst;
                    }
                    
#ifdef _WIN64
                    // Assert that shadow doesn't break stack alignment computed earlier.
                    assert((shadowSize & (STACK_ALIGNMENT - 1)) == 0);
                    Opnd::RuntimeInfo * rt = callInst->getRuntimeInfo();
                    //TODO (Low priority): Strictly speaking we should allocate shadow area for CDECL
                    // calling convention. Currently it is used in one case only (see VM_RT_MULTIANEWARRAY_RESOLVED).
                    // But this helper is not aware about shadow area.
                    if (rt && cc == &CallingConvention_STDCALL) {
                        // Stack size for parameters: "number of entries is equal to 4 or the maximum number of parameters"
                        // See http://msdn2.microsoft.com/en-gb/library/ms794596.aspx for details.
                        // Shadow - is an area on stack reserved to map parameters passed with registers.
                        shadowSize = 4 * sizeof(POINTER_SIZE_INT);
                        node->prependInst(newInst(Mnemonic_SUB, getRegOpnd(STACK_REG), newImmOpnd(typeManager.getInt32Type(), shadowSize)), inst);
                    }
#endif
                    unsigned stackPopSize = cc->calleeRestoresStack() ? 0 : callInst->getArgStackDepth();
                    stackPopSize += shadowSize;
                    // Restore stack pointer.
                    if(stackPopSize != 0) {
                        Inst* newIns = newInst(Mnemonic_ADD, getRegOpnd(STACK_REG), newImmOpnd(typeManager.getInt32Type(), stackPopSize));
                        newIns->insertAfter(inst);
                    }
                }
            }
        }
    }
}

//_____________________________________________________________________________________________
U_32 IRManager::calculateStackDepth()
{
    MemoryManager mm("calculateStackDepth");
    StlVector<I_32> stackDepths(mm, fg->getNodeCount(), -1);
    I_32 maxMethodStackDepth = -1;    
    
    const Nodes& nodes = fg->getNodesPostOrder();
    //iterating in topological (reverse postorder) order
    for (Nodes::const_reverse_iterator itn = nodes.rbegin(), endn = nodes.rend(); itn!=endn; ++itn) {
        Node* node = *itn;
        if (node->isBlockNode() || (node->isDispatchNode() && node!=fg->getUnwindNode())) {
            I_32 stackDepth=-1;
            const Edges& edges=node->getInEdges();
            for (Edges::const_iterator ite = edges.begin(), ende = edges.end(); ite!=ende; ++ite) {
                Edge* edge = *ite;
                Node * pred=edge->getSourceNode();
                I_32 predStackDepth=stackDepths[pred->getDfNum()];
                if (predStackDepth>=0){
                    assert(stackDepth==-1 || stackDepth==predStackDepth);
                    stackDepth=predStackDepth;
                }
            }
            
            if (stackDepth<0) {
                stackDepth=0;
            }
            if (node->isBlockNode()){
                for (Inst * inst=(Inst*)node->getFirstInst(); inst!=NULL; inst=inst->getNextInst()){
                    inst->setStackDepth(stackDepth);

                    Inst::Opnds opnds(inst, Inst::OpndRole_Explicit | Inst::OpndRole_Auxilary | Inst::OpndRole_UseDef);
                    Inst::Opnds::iterator it = opnds.begin();
                    if (it != opnds.end() && inst->getOpnd(it)->isPlacedIn(STACK_REG)) {
                        if (inst->getMnemonic()==Mnemonic_ADD)
                            stackDepth -= (I_32)inst->getOpnd(opnds.next(it))->getImmValue();
                        else if (inst->getMnemonic()==Mnemonic_SUB)
                            stackDepth += (I_32)inst->getOpnd(opnds.next(it))->getImmValue();
                        else
                            assert(0);
                    }else{
                        if(inst->getMnemonic()==Mnemonic_PUSH) {
                            stackDepth+=getByteSize(inst->getOpnd(it)->getSize());
                        } else if (inst->getMnemonic() == Mnemonic_POP) {
                            stackDepth-=getByteSize(inst->getOpnd(it)->getSize());
                        } else if (inst->getMnemonic() == Mnemonic_PUSHFD) {
                            stackDepth+=sizeof(POINTER_SIZE_INT);
                        } else if (inst->getMnemonic() == Mnemonic_POPFD) {
                            stackDepth-=sizeof(POINTER_SIZE_INT);
                        } else if (inst->getMnemonic() == Mnemonic_CALL && ((CallInst *)inst)->getCallingConventionClient().getCallingConvention()->calleeRestoresStack()) {
                            stackDepth -= ((CallInst *)inst)->getArgStackDepth();
                        }
                    }
                    maxMethodStackDepth = std::max(maxMethodStackDepth, stackDepth);
                }
                assert(stackDepth>=0);
            }
            stackDepths[node->getDfNum()]=stackDepth;
        }
    }
    assert(maxMethodStackDepth>=0);
    return (U_32)maxMethodStackDepth;
}

//_____________________________________________________________________________________________
bool IRManager::isOnlyPrologSuccessor(Node * bb) {
    Node * predBB = bb;
    for(; ; ) {
        if(predBB == fg->getEntryNode()) {
            return true;
        }
        if (predBB != bb &&  predBB->getOutDegree() > 1) {
            return false;
        } 
        if (predBB->getInDegree() > 1) {
            return false;
        }
        predBB = predBB->getInEdges().front()->getSourceNode();
    }
}
//_____________________________________________________________________________________________
void IRManager::expandSystemExceptions(U_32 reservedForFlags)
{
    calculateOpndStatistics();
    StlMap<Opnd *, POINTER_SIZE_INT> checkOpnds(getMemoryManager());
    StlVector<Inst *> excInsts(memoryManager);
    const Nodes& nodes = fg->getNodes();
    for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) {
        Node* node = *it;
        if (node->isBlockNode()){
            Inst * inst=(Inst*)node->getLastInst();
            if (inst && inst->hasKind(Inst::Kind_SystemExceptionCheckPseudoInst)) {
                excInsts.push_back(inst);
                Node* dispatchNode  = node->getExceptionEdgeTarget();
                if (dispatchNode==NULL || dispatchNode==fg->getUnwindNode()) {
                    checkOpnds[inst->getOpnd(0)] = 
                        ((SystemExceptionCheckPseudoInst*)inst)->checksThisOfInlinedMethod() ?
                        (POINTER_SIZE_INT)-1:
                        (POINTER_SIZE_INT)inst;
                }
                
            }

            if(checkOpnds.size() == 0)
                continue;

            for (inst=(Inst*)node->getFirstInst(); inst!=NULL; inst = inst->getNextInst()){
                if (inst->getMnemonic() == Mnemonic_CALL && !inst->hasKind(Inst::Kind_SystemExceptionCheckPseudoInst) && ((CallInst *)inst)->isDirect()) {
                    Opnd::RuntimeInfo * rt = inst->getOpnd(((ControlTransferInst*)inst)->getTargetOpndIndex())->getRuntimeInfo();
                    if(rt->getKind() == Opnd::RuntimeInfo::Kind_MethodDirectAddr &&  !((MethodDesc *)rt->getValue(0))->isStatic()) {
                        Inst::Opnds opnds(inst, Inst::OpndRole_Auxilary | Inst::OpndRole_Use);
                        for (Inst::Opnds::iterator it = opnds.begin(); it != opnds.end(); it = opnds.next(it)){
                            Opnd * opnd = inst->getOpnd(it);
                            if(checkOpnds.find(opnd) != checkOpnds.end()) 
                                checkOpnds[opnd] = (POINTER_SIZE_INT)-1;
                        }
                    }
                } 
            }
        }
    }
    for(StlVector<Inst *>::iterator it = excInsts.begin(); it != excInsts.end(); it++) {
        Inst * lastInst = *it;
        Node* bb = lastInst->getNode();
        switch (((SystemExceptionCheckPseudoInst*)lastInst)->getExceptionId()){
            case CompilationInterface::Exception_NullPointer:
                {
                    Node* oldTarget = bb->getUnconditionalEdge()->getTargetNode(); //must exist
                    Opnd * opnd = lastInst->getOpnd(0);
                    Edge* dispatchEdge =  bb->getExceptionEdge();
                    assert(dispatchEdge!=NULL);
                    Node* dispatchNode= dispatchEdge->getTargetNode();
                    if ((dispatchNode!=fg->getUnwindNode()) ||(checkOpnds[opnd] == (POINTER_SIZE_INT)-1
#ifdef _EM64T_
                            ||!Type::isCompressedReference(opnd->getType()->tag)
#endif
                            )){
                        Node* throwBasicBlock = fg->createBlockNode();
                        ObjectType* excType = compilationInterface.findClassUsingBootstrapClassloader(NULL_POINTER_EXCEPTION);
                        assert(lastInst->getBCOffset()!=ILLEGAL_BC_MAPPING_VALUE);
                        throwException(excType, lastInst->getBCOffset(), throwBasicBlock);
                        //Inst* throwInst = newRuntimeHelperCallInst(VM_RT_NULL_PTR_EXCEPTION, 0, NULL, NULL);
                        //throwInst->setBCOffset(lastInst->getBCOffset());
                        //throwBasicBlock->appendInst(throwInst);
                        int64 zero = 0;
                        if( refsCompressed && opnd->getType()->isReference() ) {
                            assert(!Type::isCompressedReference(opnd->getType()->tag));
                            zero = (int64)(POINTER_SIZE_INT)VMInterface::getHeapBase();
                        }
                        Opnd* zeroOpnd = NULL;
                        if((POINTER_SIZE_INT)zero == (U_32)zero) { // heap base fits into 32 bits
                            zeroOpnd = newImmOpnd(opnd->getType(), zero);
                        } else { // zero can not be an immediate at comparison
                            Opnd* zeroImm = newImmOpnd(typeManager.getIntPtrType(), zero);
                            zeroOpnd = newOpnd(opnd->getType());
                            Inst* copy = newCopyPseudoInst(Mnemonic_MOV, zeroOpnd, zeroImm);
                            bb->appendInst(copy);
                            copy->setBCOffset(lastInst->getBCOffset());
                        }
                        Inst* cmpInst = newInst(Mnemonic_CMP, opnd, zeroOpnd);
                        bb->appendInst(cmpInst);
                        cmpInst->setBCOffset(lastInst->getBCOffset());

                        bb->appendInst(newBranchInst(Mnemonic_JZ, throwBasicBlock, oldTarget));
                        fg->addEdge(bb, throwBasicBlock, 0);

                        assert(dispatchNode!=NULL);
                        fg->addEdge(throwBasicBlock, dispatchNode, 1);
                        if((checkOpnds[opnd] == (POINTER_SIZE_INT)-1) && (opnd->getDefScope() == Opnd::DefScope_Temporary) && isOnlyPrologSuccessor(bb)) {
                            checkOpnds[opnd] = (POINTER_SIZE_INT)lastInst;
                        }                   
                    } else { //hardware exception handling
                        if (bb->getFirstInst() == lastInst) {
                            fg->removeEdge(dispatchEdge);
                        }
                    }
                    break;
                }
            default:
                assert(0);
        }
        lastInst->unlink();
    }
}
void IRManager::throwException(ObjectType* excType, uint16 bcOffset, Node* basicBlock){

    assert(excType);

#ifdef _EM64T_
    bool lazy = false;
#else
    bool lazy = true;
#endif
    Inst* throwInst = NULL;
    assert(bcOffset!=ILLEGAL_BC_MAPPING_VALUE);

    if (lazy){
        Opnd * helperOpnds[] = {
            // first parameter exception class
            newImmOpnd(typeManager.getUnmanagedPtrType(typeManager.getIntPtrType()),
                Opnd::RuntimeInfo::Kind_TypeRuntimeId, excType),
            // second is constructor method handle, 0 - means default constructor
            newImmOpnd(typeManager.getUnmanagedPtrType(typeManager.getIntPtrType()), 0) 
        };
        throwInst=newRuntimeHelperCallInst(
            VM_RT_THROW_LAZY, lengthof(helperOpnds), helperOpnds, NULL);
    } else {
        Opnd * helperOpnds1[] = {
            newImmOpnd(typeManager.getInt32Type(), Opnd::RuntimeInfo::Kind_Size, excType),
            newImmOpnd(typeManager.getUnmanagedPtrType(typeManager.getIntPtrType()),
                Opnd::RuntimeInfo::Kind_AllocationHandle, excType)
        };
        Opnd * retOpnd=newOpnd(excType);
        CallInst * callInst=newRuntimeHelperCallInst(
            VM_RT_NEW_RESOLVED_USING_VTABLE_AND_SIZE,
            lengthof(helperOpnds1), helperOpnds1, retOpnd);
        
        callInst->setBCOffset(bcOffset);
        basicBlock->appendInst(callInst);

        MethodDesc* md = compilationInterface.resolveMethod( excType, 
                DEFAUlT_COSTRUCTOR_NAME, DEFAUlT_COSTRUCTOR_DESCRIPTOR);
        
        Opnd * target = newImmOpnd(typeManager.getIntPtrType(), Opnd::RuntimeInfo::Kind_MethodDirectAddr, md);
        Opnd * helperOpnds2[] = { (Opnd*)retOpnd };
        callInst=newCallInst(target, getDefaultManagedCallingConvention(), 
            lengthof(helperOpnds2), helperOpnds2, NULL);
        callInst->setBCOffset(bcOffset);
        basicBlock->appendInst(callInst);

        Opnd * helperOpnds3[] = { (Opnd*)retOpnd };
        throwInst=newRuntimeHelperCallInst(
            VM_RT_THROW, 
            lengthof(helperOpnds3), helperOpnds3, NULL);
    }
    throwInst->setBCOffset(bcOffset);
    basicBlock->appendInst(throwInst);
}

//_____________________________________________________________________________________________
void IRManager::translateToNativeForm()
{
    const Nodes& nodes = fg->getNodes();
    for (Nodes::const_iterator it = nodes.begin(),end = nodes.end();it!=end; ++it) {
        Node* node = *it;
        if (node->isBlockNode()){
            for (Inst * inst=(Inst*)node->getFirstInst(); inst!=NULL; inst=inst->getNextInst()){
                if (inst->getForm()==Inst::Form_Extended) {
                    inst->makeNative(this);
                }
            }
        }
    }
}

//_____________________________________________________________________________________________
void IRManager::eliminateSameOpndMoves()
{
    const Nodes& nodes = fg->getNodes();
    for (Nodes::const_iterator it = nodes.begin(),end = nodes.end();it!=end; ++it) {
        Node* node = *it;
        if (node->isBlockNode()){
            for (Inst * inst=(Inst*)node->getFirstInst(), *nextInst=NULL; inst!=NULL; inst=nextInst){
                nextInst=inst->getNextInst();
                if (inst->getMnemonic()==Mnemonic_MOV && inst->getOpnd(0)==inst->getOpnd(1)) {
                    inst->unlink();
                }
            }
        }
    }
}

//_____________________________________________________________________________________________
void IRManager::resolveRuntimeInfo()
{
    for (U_32 i=0, n=getOpndCount(); i<n; i++){
        Opnd * opnd=getOpnd(i);
        resolveRuntimeInfo(opnd);
    }
}


void IRManager::resolveRuntimeInfo(Opnd* opnd) const {
    if (!opnd->isPlacedIn(OpndKind_Imm))
        return;
    Opnd::RuntimeInfo * info=opnd->getRuntimeInfo();
    if (info==NULL)
        return;
    int64 value=0;
    switch(info->getKind()){
        case Opnd::RuntimeInfo::Kind_HelperAddress: 
            /** The value of the operand is compilationInterface->getRuntimeHelperAddress */
            value=(POINTER_SIZE_INT)compilationInterface.getRuntimeHelperAddress(
                (VM_RT_SUPPORT)(POINTER_SIZE_INT)info->getValue(0)
                );
            assert(value!=0);
            break;
        case Opnd::RuntimeInfo::Kind_InternalHelperAddress:
            /** The value of the operand is irManager.getInternalHelperInfo((const char*)[0]).pfn */
            value=(POINTER_SIZE_INT)getInternalHelperInfo((const char*)info->getValue(0))->pfn;
            assert(value!=0);
            break;
        case Opnd::RuntimeInfo::Kind_TypeRuntimeId: 
            /*  The value of the operand is [0]->ObjectType::getRuntimeIdentifier() */
            value=(POINTER_SIZE_INT)((NamedType*)info->getValue(0))->getRuntimeIdentifier();
            break;
        case Opnd::RuntimeInfo::Kind_MethodRuntimeId: 
            value=(POINTER_SIZE_INT)((MethodDesc*)info->getValue(0))->getMethodHandle();
            break;
        case Opnd::RuntimeInfo::Kind_AllocationHandle: 
            /* The value of the operand is [0]->ObjectType::getAllocationHandle() */
            value=(POINTER_SIZE_INT)((ObjectType*)info->getValue(0))->getAllocationHandle();
            break;
        case Opnd::RuntimeInfo::Kind_StringDescription: 
            /* [0] - Type * - the containing class, [1] - string token */
            assert(0);
            break;
        case Opnd::RuntimeInfo::Kind_Size: 
            /* The value of the operand is [0]->ObjectType::getObjectSize() */
            value=(POINTER_SIZE_INT)((ObjectType*)info->getValue(0))->getObjectSize();
            break;
        case Opnd::RuntimeInfo::Kind_StringAddress:
            /** The value of the operand is the address where the interned version of the string is stored*/
            {
            MethodDesc*  mDesc = (MethodDesc*)info->getValue(0);
            U_32 token = (U_32)(POINTER_SIZE_INT)info->getValue(1);
            value = (POINTER_SIZE_INT) compilationInterface.getStringInternAddr(mDesc,token);
            }break;
        case Opnd::RuntimeInfo::Kind_StaticFieldAddress:
            /** The value of the operand is [0]->FieldDesc::getAddress() */
            value=(POINTER_SIZE_INT)((FieldDesc*)info->getValue(0))->getAddress();
            break;
        case Opnd::RuntimeInfo::Kind_FieldOffset:
            /** The value of the operand is [0]->FieldDesc::getOffset() */
            value=(POINTER_SIZE_INT)((FieldDesc*)info->getValue(0))->getOffset();
            break;
        case Opnd::RuntimeInfo::Kind_VTableAddrOffset:
            /** The value of the operand is compilationInterface.getVTableOffset(), zero args */
            value = (int64)VMInterface::getVTableOffset();
            break;
        case Opnd::RuntimeInfo::Kind_VTableConstantAddr:
            /** The value of the operand is [0]->ObjectType::getVTable() */
            value=(POINTER_SIZE_INT)((ObjectType*)info->getValue(0))->getVTable();
            break;
        case Opnd::RuntimeInfo::Kind_MethodVtableSlotOffset:
            /** The value of the operand is [0]->MethodDesc::getOffset() */
            value=(POINTER_SIZE_INT)((MethodDesc*)info->getValue(0))->getOffset();
            break;
        case Opnd::RuntimeInfo::Kind_MethodIndirectAddr:
            /** The value of the operand is [0]->MethodDesc::getIndirectAddress() */
            value=(POINTER_SIZE_INT)((MethodDesc*)info->getValue(0))->getIndirectAddress();
            break;
        case Opnd::RuntimeInfo::Kind_MethodDirectAddr:
            /** The value of the operand is *[0]->MethodDesc::getIndirectAddress() */
            value=*(POINTER_SIZE_INT*)((MethodDesc*)info->getValue(0))->getIndirectAddress();
            break;
        case Opnd::RuntimeInfo::Kind_ConstantAreaItem:
            /** The value of the operand is address of constant pool item  ((ConstantPoolItem*)[0])->getAddress() */
            value=(POINTER_SIZE_INT)((ConstantAreaItem*)info->getValue(0))->getAddress();
            break;
        case Opnd::RuntimeInfo::Kind_EM_ProfileAccessInterface:
            /** The value of the operand is a pointer to the EM_ProfileAccessInterface */
            value=(POINTER_SIZE_INT)(getProfilingInterface()->getEMProfileAccessInterface());
            break;
        case Opnd::RuntimeInfo::Kind_Method_Value_Profile_Handle:
            /** The value of the operand is Method_Profile_Handle for the value profile of the compiled method */
            value=(POINTER_SIZE_INT)(getProfilingInterface()->getMethodProfileHandle(ProfileType_Value, getMethodDesc()));
            break;
        default:
            assert(0);
    }
    opnd->assignImmValue(value+info->getAdditionalOffset());
}

//_____________________________________________________________________________________________
bool IRManager::verify()
{
    if (!verifyOpnds())
        return false;

    updateLivenessInfo();
    if (!verifyLiveness())
        return false;
    if (!verifyHeapAddressTypes())
        return false;
    

#ifdef _DEBUG
    //check unwind node;    
    Node* unwind = fg->getUnwindNode();
    Node* exit = fg->getExitNode();
    assert(exit!=NULL);
    assert(unwind == NULL || (unwind->getOutDegree() == 1 && unwind->isConnectedTo(true, exit)));
    const Edges& exitInEdges = exit->getInEdges();
    for (Edges::const_iterator ite = exitInEdges.begin(), ende = exitInEdges.end(); ite!=ende; ++ite) {
        Edge* edge = *ite;
        Node* source = edge->getSourceNode();
        assert(source == unwind || source->isBlockNode());
    }
    const Nodes& nodes = fg->getNodesPostOrder();//check only reachable nodes.
    for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) {
        CGNode* node = (CGNode*)*it;
        node->verify();
    }
#endif
    return true;
}

//_____________________________________________________________________________________________
//
//  This routine checks that every memory heap operand is referenced by single instruction only.
//
//  There are two kinds of operands - instruction-level, which are saved in Ia32::Inst structure,
//  and sub-operands (of instruction-level operands), which are saved in Ia32::Opnd structure.
//  Of course, not all instruction-level operands have sub-operands.
//
//  With this design, it would be impossible to replace sub-operand in one instruction without
//  affecting all other instructions that reference the same instruction-level operand of which
//  the sub-operand is part of.
//
//  For some codegen modules (SpillGen, ConstraintResolver) it is critically important to be able
//  to replace operand (Inst::replaceOpnd) in one instruction, without side-effect on all other
//  instruction. More specifically, only heap operands are manipulated in such way.
//
//  NOTE
//      For some obscure reason, AliasPseudoInst violates this principle, but experiments show 
//      that AliasPseudoInst can be ignored. Otherwise, massive errors from this instruction
//      make the check meanigless.
//
bool IRManager::verifyOpnds() const
{
    bool ok = true;

    typedef StlVector<Inst*> InstList;      // to register all instruction referenced an operand
    typedef StlVector<InstList*> OpndList;  // one entry for each operand, instruction register or 0

    const U_32 opnd_count = getOpndCount();
    OpndList opnd_list(getMemoryManager(), opnd_count); // fixed size

//  Watch only MemOpndKind_Heap operands - all others are simply ignored.
    for (U_32 i = 0; i != opnd_count; ++i) {
        InstList* ilp = 0; 
        if (getOpnd(i)->getMemOpndKind() == MemOpndKind_Heap)
            ilp = new (getMemoryManager()) InstList(getMemoryManager());
        opnd_list[i] = ilp;
    }

    const Nodes& nodes = fg->getNodes();
    for (Nodes::const_iterator nd = nodes.begin(), nd_end = nodes.end(); nd != nd_end; ++nd) {
        Node* node = *nd;
        if (node->isBlockNode()) {
            for (Inst* inst = (Inst*)node->getFirstInst(); inst != NULL; inst = inst->getNextInst()) 
                if (!inst->hasKind(Inst::Kind_AliasPseudoInst)) {
                //  Inspect instruction-level operand only (but all of them), ignore sub-operands.
                    Inst::Opnds opnds(inst, Inst::OpndRole_InstLevel | Inst::OpndRole_UseDef);
                    for (Inst::Opnds::iterator op = opnds.begin(), op_end = opnds.end(); op != op_end; op = opnds.next(op)) {
                        Opnd* opnd = opnds.getOpnd(op);
                    //  If this is a watched operand, then register the instruction that referenced it.
                        InstList* ilp = opnd_list.at(opnd->getId());
                        if (ilp != 0) 
                            ilp->push_back(inst);
                    }
                }
        }
    }

    for (U_32 i = 0; i != opnd_count; ++i) {
        InstList* ilp = opnd_list.at(i);
        if (ilp != 0 && ilp->size() > 1) {
        //  Error found
            ok = false;

            VERIFY_OUT("MemOpnd " << getOpnd(i) << " was referenced in the instructions:");
            for (InstList::iterator it = ilp->begin(), end = ilp->end(); it != end; ++it) {
                Inst* inst = *it;
                VERIFY_OUT(" I" << inst->getId());
            }
            VERIFY_OUT(std::endl);
        }
    }

    return ok;
}

//_____________________________________________________________________________________________
bool IRManager::verifyLiveness()
{
    Node* prolog=fg->getEntryNode();
    bool failed=false;
    BitSet * ls=getLiveAtEntry(prolog);
    assert(ls!=NULL);
    Constraint calleeSaveRegs=getCallingConvention()->getCalleeSavedRegs(OpndKind_GPReg);

    BitSet::IterB lives(*ls);
    for (int i = lives.getNext(); i != -1; i = lives.getNext()){
        Opnd * opnd=getOpnd(i);
        assert(opnd!=NULL);
        if (
            opnd->isSubjectForLivenessAnalysis() && 
            (opnd->isPlacedIn(RegName_EFLAGS)||!isPreallocatedRegOpnd(opnd))
        ){
            VERIFY_OUT("Operand live at entry: " << opnd << ::std::endl);
            VERIFY_OUT("This means there is a use of the operand when it is not yet defined" << ::std::endl);
            failed=true;
        };
    }
    if (failed)
        VERIFY_OUT(::std::endl << "Liveness verification failure" << ::std::endl);
    return !failed;
}

//_____________________________________________________________________________________________
bool IRManager::verifyHeapAddressTypes()
{
    bool failed=false;
    for (U_32 i=0, n=getOpndCount(); i<n; i++){
        Opnd * opnd = getOpnd(i);
        if (opnd->isPlacedIn(OpndKind_Mem) && opnd->getMemOpndKind()==MemOpndKind_Heap){
            Opnd * properTypeSubOpnd=NULL;
            for (U_32 j=0; j<MemOpndSubOpndKind_Count; j++){
                Opnd * subOpnd=opnd->getMemOpndSubOpnd((MemOpndSubOpndKind)j);
                if (subOpnd!=NULL){
                    Type * type=subOpnd->getType();
                    if (type->isManagedPtr() || type->isObject() || type->isMethodPtr() || type->isVTablePtr() || type->isUnmanagedPtr()
#ifdef _EM64T_
                        || subOpnd->getRegName() == RegName_RSP/*SOE handler*/
#else
                        || subOpnd->getRegName() == RegName_ESP/*SOE handler*/
#endif
                        ){
                        if (properTypeSubOpnd!=NULL){
                            VERIFY_OUT("Heap operand " << opnd << " contains more than 1 sub-operands of type Object or ManagedPointer "<<::std::endl);
                            VERIFY_OUT("Opnd 1: " << properTypeSubOpnd << ::std::endl);
                            VERIFY_OUT("Opnd 2: " << subOpnd << ::std::endl);
                            failed=true;
                            break;
                        }
                        properTypeSubOpnd=subOpnd;
                    }
                }
            }
            if (failed)
                break;
            if (properTypeSubOpnd==NULL){
                VERIFY_OUT("Heap operand " << opnd << " contains no sub-operands of type Object or ManagedPointer "<<::std::endl);
                failed=true;
                break;
            }
        }
    }
    if (failed)
        VERIFY_OUT(::std::endl << "Heap address type verification failure" << ::std::endl);
    return !failed;
}

ControlFlowGraph* IRManager::createSubCFG(bool withReturn, bool withUnwind) {
    ControlFlowGraph* cfg = new (memoryManager) ControlFlowGraph(memoryManager, this);
    cfg->setEntryNode(cfg->createBlockNode());
    cfg->setExitNode(cfg->createExitNode());
    if (withReturn) {
        cfg->setReturnNode(cfg->createBlockNode());
        cfg->addEdge(cfg->getReturnNode(), cfg->getExitNode(), 1);
    }
    if (withUnwind) {
        cfg->setUnwindNode(cfg->createDispatchNode());
        cfg->addEdge(cfg->getUnwindNode(), cfg->getExitNode(), 1);
    }
    return cfg;
}


// factory method for ControlFlowGraph
Node* IRManager::createNode(MemoryManager& mm, Node::Kind kind) {
    if (kind == Node::Kind_Block) {
        return new (mm) BasicBlock(mm, *this);
    } 
    return new (mm) CGNode(mm, *this, kind);
}

// factory method for ControlFlowGraph
Edge* IRManager::createEdge(MemoryManager& mm, Node::Kind srcKind, Node::Kind dstKind) {
    if (srcKind == Node::Kind_Dispatch && dstKind == Node::Kind_Block) {
        return new (mm) CatchEdge();
    }
    return ControlFlowGraphFactory::createEdge(mm, srcKind, dstKind);
}
bool IRManager::isGCSafePoint(const Inst* inst) {
    if (inst->getMnemonic() == Mnemonic_CALL) {
        const CallInst* callInst =  (const CallInst*)inst;
        Opnd::RuntimeInfo * rt = callInst->getRuntimeInfo();
        bool isInternalHelper = rt && rt->getKind() == Opnd::RuntimeInfo::Kind_InternalHelperAddress;
        bool isNonGCVMHelper = false;
        if (!isInternalHelper) {
            CompilationInterface* ci = CompilationContext::getCurrentContext()->getVMCompilationInterface();
            isNonGCVMHelper = rt && rt->getKind() == Opnd::RuntimeInfo::Kind_HelperAddress 
                && !ci->mayBeInterruptible((VM_RT_SUPPORT)(POINTER_SIZE_INT)rt->getValue(0));
        }
        bool isGCPoint = !isInternalHelper && !isNonGCVMHelper;
        return isGCPoint;
    }
    return false;
}


//=============================================================================================
// class Ia32::SessionAction implementation
//=============================================================================================

void SessionAction::run() 
{
    irManager = &getIRManager();

    stageId=Log::getStageId();

    if (isLogEnabled(LogStream::IRDUMP)) 
        Log::printStageBegin(log(LogStream::IRDUMP).out(), stageId, "IA32", getName(), getTagName());

    U_32 needInfo=getNeedInfo();
    if (needInfo & NeedInfo_LivenessInfo)
        irManager->updateLivenessInfo();
    if (needInfo & NeedInfo_LoopInfo)
        irManager->updateLoopInfo();

    runImpl();

    U_32 sideEffects=getSideEffects();
    if (sideEffects & SideEffect_InvalidatesLivenessInfo)
        irManager->invalidateLivenessInfo();
    if (sideEffects & SideEffect_InvalidatesLoopInfo)
        irManager->invalidateLoopInfo();

    debugOutput("after");

    if (!verify())
        crash("\nVerification failure after %s\n", getName());

    if (isLogEnabled(LogStream::IRDUMP)) 
        Log::printStageEnd(log(LogStream::IRDUMP).out(), stageId, "IA32", getName(), getTagName());
}


U_32 SessionAction::getSideEffects()const
{
    return ~(U_32)0;
}

U_32 SessionAction::getNeedInfo()const
{
    return ~(U_32)0;
}

bool SessionAction::verify(bool force)
{   
    if (force || getVerificationLevel()>=2)
        return getIRManager().verify();
    return true;
}   

void SessionAction::dumpIR(const char * subKind1, const char * subKind2)
{
    Ia32::dumpIR(irManager, stageId, "IA32 LIR CFG after ", getName(), getTagName(), 
        subKind1, subKind2);
}

void SessionAction::printDot(const char * subKind1, const char * subKind2)
{
    Ia32::printDot(irManager, stageId, "IA32 LIR CFG after ", getName(), getTagName(), 
        subKind1, subKind2);
}

void SessionAction::debugOutput(const char * subKind)
{
    if (!isIRDumpEnabled())
        return;

    if (isLogEnabled(LogStream::IRDUMP)) {
        irManager->updateLoopInfo();
        irManager->updateLivenessInfo();
        if (isLogEnabled("irdump_verbose")) {
            dumpIR(subKind, "opnds");
            dumpIR(subKind, "liveness");
        }
        dumpIR(subKind);
    }

    if (isLogEnabled(LogStream::DOTDUMP)) {
        irManager->updateLoopInfo();
        irManager->updateLivenessInfo();
        printDot(subKind);
        printDot(subKind, "liveness");
    }
}

void SessionAction::computeDominators(void)
{
    ControlFlowGraph* cfg = irManager->getFlowGraph();
    DominatorTree* dominatorTree = cfg->getDominatorTree();
    if(dominatorTree != NULL && dominatorTree->isValid()) {
        // Already valid.
        return;
    }
    static CountTime computeDominatorsTimer("ia32::helper::computeDominators");
    AutoTimer tm(computeDominatorsTimer);
    DominatorBuilder db;
    dominatorTree = db.computeDominators(irManager->getMemoryManager(), cfg,false,true);
    cfg->setDominatorTree(dominatorTree);
}


} //namespace Ia32
} //namespace Jitrino