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

/**
 * @author Intel, Natalya V. Golovleva
 *
 */

#include "lazyexceptionopt.h"
#include "FlowGraph.h"
#include "irmanager.h"
#include "Opnd.h"
#include "Inst.h"
#include "Stl.h"
#include "Log.h"
#include "Dominator.h"
#include "optimizer.h"

namespace Jitrino {

DEFINE_SESSION_ACTION(LazyExceptionOptPass, lazyexc, "Lazy Exception Throwing Optimization")

void LazyExceptionOptPass::_run(IRManager& irm) {
    LazyExceptionOpt le(irm);
    le.doLazyExceptionOpt();
}

int LazyExceptionOpt::level=0;

LazyExceptionOpt::LazyExceptionOpt(IRManager &ir_manager) :
    irManager(ir_manager), 
    leMemManager("LazyExceptionOpt::doLazyExceptionOpt"),
    compInterface(ir_manager.getCompilationInterface())
{
}

/**
 * Executes lazy exception optimization pass.
 */
void 
LazyExceptionOpt::doLazyExceptionOpt() {
    MethodDesc &md = irManager.getMethodDesc();
    BitSet excOpnds(leMemManager,irManager.getOpndManager().getNumSsaOpnds());
    StlDeque<Inst*> candidateSet(leMemManager);
    optCandidates = new (leMemManager) OptCandidates(leMemManager);
    Method_Side_Effects m_sideEff = md.getSideEffect(); 

    const Nodes& nodes = irManager.getFlowGraph().getNodes();
    Nodes::const_iterator niter;

#ifdef _DEBUG
    mtdDesc=&md;
#endif

#ifdef _DEBUG
    if (Log::isEnabled()) {
        Log::out() << std::endl;
        for (int i=0; i<level; i++) Log::out() << " "; 
        Log::out() << "doLE "; md.printFullName(Log::out()); 
        Log::out() << " SideEff " << (int)m_sideEff << std::endl; 
    }
#endif

    level++;
    U_32 opndId = 0;
    isArgCheckNull = false;
    isExceptionInit = md.isInstanceInitializer() && 
            md.getParentType()->isLikelyExceptionType();
//  core api exception init
    if (m_sideEff == MSE_Unknown && isExceptionInit 
            && strncmp(md.getParentType()->getName(),"java/lang/",10) == 0) {
        m_sideEff = MSE_False;
        md.setSideEffect(m_sideEff);
#ifdef _DEBUG
        if (Log::isEnabled()) {
            Log::out() << "      core api exc "; md.printFullName(Log::out()); 
            Log::out() << " SideEff " << (int)m_sideEff << std::endl;
        }
#endif
    }

    for(niter = nodes.begin(); niter != nodes.end(); ++niter) {
        Node* node = *niter;
        Inst *headInst = (Inst*)node->getFirstInst();
        for (Inst* inst=headInst->getNextInst();inst!=NULL;inst=inst->getNextInst()) {
#ifdef _DEBUG
            if (inst->getOpcode()==Op_DefArg && isExceptionInit) {
                if (Log::isEnabled()) {
                    Log::out() << "    defarg: "; 
                    inst->print(Log::out()); Log::out()  << std::endl;
                    Log::out() << "            "; 
                    Log::out() << (int)(inst->getDefArgModifier()) << " " <<
                    (inst->getDefArgModifier()==DefArgNoModifier) << " " <<
                    (inst->getDefArgModifier()==NonNullThisArg) << " " <<
                    (inst->getDefArgModifier()==SpecializedToExactType) << " " <<
                    (inst->getDefArgModifier()==DefArgBothModifiers) << std::endl;
                }
            }
#endif
            if (inst->getOpcode()==Op_Throw) {
                if (inst->getSrc(0)->getInst()->getOpcode()==Op_NewObj) {
                    excOpnds.setBit(opndId=inst->getSrc(0)->getId(),true);
                    if (!addOptCandidates(opndId,inst))
                        excOpnds.setBit(opndId,false); // different exc. edges
#ifdef _DEBUG
                    if (excOpnds.getBit(opndId)==1) {
                        if (Log::isEnabled()) {
                            Log::out() << "      add opnd: "; 
                            inst->print(Log::out()); Log::out() << std::endl; 
                            Log::out() << "      add  obj: "; 
                            inst->getSrc(0)->getInst()->print(Log::out()); Log::out() << std::endl; 
                        }
                    }
#endif
                }
            }
            if (m_sideEff == MSE_Unknown)
                if (instHasSideEffect(inst)) {
                    m_sideEff = MSE_True;
#ifdef _DEBUG
                    if (Log::isEnabled()) {
                        Log::out() << "~~~~~~inst sideEff "; 
                        inst->print(Log::out()); Log::out() << std::endl; 
                    }
#endif
                }
        }
    }
    if (md.getSideEffect() == MSE_Unknown) {
        if (m_sideEff == MSE_Unknown) {
            if (isExceptionInit && isArgCheckNull) {
#ifdef _DEBUG
                if (Log::isEnabled()) {
                    Log::out() << "~~~~~~init sideEff reset: " << m_sideEff << " 3 "; 
                    md.printFullName(Log::out()); Log::out() << std::endl; 
                }
#endif
                m_sideEff = MSE_True_Null_Param;
            } else
                m_sideEff = MSE_False;
        }
        md.setSideEffect(m_sideEff);
    } 

    for(niter = nodes.begin(); niter != nodes.end(); ++niter) {
        Node* node = *niter;
        Inst *headInst = (Inst*)node->getFirstInst();
        Opnd* opnd;
        for (Inst* inst=headInst->getNextInst();inst!=NULL;inst=inst->getNextInst()) {
            U_32 nsrc = inst->getNumSrcOperands();
            for (U_32 i=0; i<nsrc; i++) {
                if (!(opnd=inst->getSrc(i))->isSsaOpnd())  // check ssa operands
                    continue;
                if (excOpnds.getBit(opndId=opnd->getId())==0) 
                    continue;
                if (inst->getOpcode()==Op_DirectCall) {
                    MethodDesc* md = inst->asMethodInst()->getMethodDesc();
                    if (md->isInstanceInitializer() &&
                        md->getParentType()->isLikelyExceptionType()) {
                        if (!addOptCandidates(opndId,inst)) {
                            excOpnds.setBit(opndId,false);
#ifdef _DEBUG
                            if (Log::isEnabled()) {
                                Log::out() << "    - rem opnd " << opnd->getId() << " "; 
                                inst->print(Log::out()); Log::out() << std::endl; 
                            }
#endif
                        } 
                    } else {
                        excOpnds.setBit(opndId,false);
#ifdef _DEBUG
                        if (Log::isEnabled()) {
                            Log::out() << "   -- rem opnd " << opnd->getId() << " "; 
                            inst->print(Log::out()); Log::out() << std::endl; 
                        }
#endif
                    }
                } else {
                    if (inst->getOpcode()!=Op_Throw) {
                        excOpnds.setBit(opndId,false);
#ifdef _DEBUG
                        if (Log::isEnabled()) {
                            Log::out() << "      rem opnd " << opnd->getId() << " "; 
                            inst->print(Log::out()); Log::out() << std::endl; 
                        }
#endif
                    }
                }
            }
        }
    }
    if (!excOpnds.isEmpty()) {
#ifdef _DEBUG
        if (Log::isEnabled()) {
            Log::out() << "------LE: "; 
            md.printFullName(Log::out()); Log::out() << std::endl;
        }
#endif
        fixOptCandidates(&excOpnds);
    }

level--;
#ifdef _DEBUG
    if (Log::isEnabled()) {
        for (int i=0; i<level; i++) Log::out() << " "; 
        Log::out() << "done "; md.printFullName(Log::out()); 
        Log::out() << " SideEff " << (int)m_sideEff << std::endl; 
    }
#endif
};

/**
 * Adds information to optCandidates list for specified exception object.
 * @param id - an exception object operand Id
 * @param inst - call, or throw instructions operating with this exception object
 * @return <code>true</code> if an information is added; 
 *         <code>false<code> if an exception object cannot be optimized.
 */
bool 
LazyExceptionOpt::addOptCandidates(U_32 id, Inst* inst) {
    OptCandidate* oc = NULL;
    ThrowInsts* thrinst = NULL;
    OptCandidates::iterator it;
    if (optCandidates == NULL)
        optCandidates = new (leMemManager) OptCandidates(leMemManager);
    for (it = optCandidates->begin( ); it != optCandidates->end( ); it++ ) {
        if ((*it)->opndId==id) {
            oc = *it;
            break;
        }
    }
#ifdef _DEBUG
    if (Log::isEnabled()) {
        Log::out() << "    addOptCandidates: "; 
        inst->print(Log::out()); Log::out()  << std::endl;
    }
#endif
    if (oc == NULL) {
        if (inst->getOpcode()==Op_Throw) {
            bool hasFinalize =
                ((NamedType*)inst->getSrc(0)->getType())->isFinalizable();
            if (hasFinalize) {
#ifdef _DEBUG
                Log::out() << "    isFinalizable: "
                 << hasFinalize << std::endl;
#endif
                return false;
            }
        }
        oc = new (leMemManager) OptCandidate;
        oc->opndId = id;
        oc->objInst = inst->getSrc(0)->getInst();
        oc->initInst=NULL;
        thrinst = new (leMemManager) ThrowInsts(leMemManager);
        thrinst->push_back(inst);
        oc->throwInsts = thrinst;
        optCandidates->push_back(oc);
        if (!isEqualExceptionNodes(oc->objInst,inst)) {
            return false;
        }
    } else {
        if (inst->getOpcode()==Op_Throw) {
            oc->throwInsts->push_back(inst);
            return true;
        } else {
            assert(inst->getOpcode()==Op_DirectCall);
            assert(oc->initInst==NULL);
            oc->initInst = inst;
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "    addOptCandidates: call checkMC "; 
                inst->print(Log::out()); Log::out()  << std::endl;
            }
#endif
            U_32 nii_id=((Inst*)(inst->getNode()->getUnconditionalEdgeTarget()->getFirstInst()))->getId();
            ThrowInsts::iterator it1;
            for (it1 = oc->throwInsts->begin(); it1 !=oc->throwInsts->end(); it1++) {
                if ((*it1)->getId() != nii_id) {
#ifdef _DEBUG
                    if (Log::isEnabled()) {
                        Log::out() << "??  addOptCandidates: throw "; 
                        (*it1)->print(Log::out()); Log::out()  << std::endl;
                    }
#endif
                    if (checkInSideEff((*it1),inst))
                        return false;
                }
            }
            if (methodCallHasSideEffect(inst)) {
                return false;
            }
        }
    }
    return true;
};

/**
 * Checks if there is a side effect between throw_inst and init_inst instructions.
 * @param throw_inst - the exception object throw instruction
 * @param init_inst - the exception object constructor call instruction
 * @return <code>true</code> if there is side effect;
 *         <code>false<code> if there is no side effect.
 */
bool 
LazyExceptionOpt::checkInSideEff(Inst* throw_inst, Inst* init_inst) {
    Node* node = throw_inst->getNode();
    Inst* instfirst = (Inst*)node->getFirstInst();;
    Inst* instlast = throw_inst;
    Inst* inst;
    bool dofind = true;
    bool inSE = false;
    if (throw_inst!=instfirst)
        instlast=throw_inst->getPrevInst();
    else {
        node = node->getInEdges().front()->getSourceNode();
        instlast = (Inst*)node->getLastInst();    
    } 
    while (dofind && node!=NULL) {
        instfirst = (Inst*)node->getFirstInst();
        for (inst = instlast; inst!=instfirst; inst=inst->getPrevInst()) {
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "      checkInSE: see "; 
                inst->print(Log::out()); Log::out() << std::endl; 
            }
#endif
            if (inst==init_inst) {
                dofind=false;
                break;
            }
            if (!inSE) {
                if (instHasSideEffect(inst)) {
                    inSE=true;
#ifdef _DEBUG
                    if (Log::isEnabled()) {
                        Log::out() << "      checkInSE: sideEff "; 
                        inst->print(Log::out()); Log::out() << std::endl; 
                    }
#endif
                    break;
                }
            }
        }
        if (dofind){
            node = node->getInEdges().front()->getSourceNode();
            instlast = (Inst*)node->getLastInst();
        }
    }
    if (dofind)
        return true; // call init wasn't found
    return inSE;
}

/**
 * Checks that exception edges are equal for newobj instruction node and
 * throw instruction node.
 * @param oi - newobj instruction
 * @param ti - throw instruction
 * @return <code>true</code> if exception edges are equal;
 *         <code>false<code> otherwise.
 */
bool
LazyExceptionOpt::isEqualExceptionNodes(Inst* oi, Inst* ti) {
    Edge* oedge = oi->getNode()->getExceptionEdge();
    Edge* tedge = ti->getNode()->getExceptionEdge();
    if (oedge->getTargetNode()!=tedge->getTargetNode()) {
#ifdef _DEBUG
        if (Log::isEnabled()) {
            Log::out() << "    addOptCandidates: diff.exc.edges for obj&throw "; 
            Log::out() << oedge->getTargetNode()->getId() << "  ";
            Log::out() << tedge->getTargetNode()->getId() << std::endl;
        }
#endif
        return false;
    }
    return true;
}

/**
 * Prints information about optimization candidates.
 * @param os - output stream
 */
void 
LazyExceptionOpt::printOptCandidates(::std::ostream& os) {
    OptCandidates::iterator it;
    Inst* oinst;
    Inst* iinst;
    Inst* tinst;

    if (optCandidates == NULL) {
        return;
    }
    for (it = optCandidates->begin( ); it != optCandidates->end( ); it++ ) {
        os << "~~  opndId " << (*it)->opndId << std::endl;
        oinst = (*it)->objInst; 
        os << "  obj       ";
        if (oinst != NULL)
            oinst->print(os);
        else
            os << "newobj NULL";
        os << std::endl;
        iinst = (*it)->initInst; 
        os << "  init      ";
        if (iinst != NULL)
            iinst->print(os);
        else
            os << "call init NULL";
        os << std::endl;
        if ((*it)->throwInsts == NULL) {
            os << "  thr        throw NULL";
            os << std::endl;
            continue;
        }
        ThrowInsts::iterator it1;
        for (it1 = (*it)->throwInsts->begin(); it1 !=(*it)->throwInsts->end(); it1++) {
            tinst = *it1;
            assert(tinst != NULL);
            os << "  thr       ";
            tinst->print(os);
            os << std::endl;
        }
    }
    os << "end~~" << std::endl;
}

/**
 * Checks that exception edges are equal for newobj instruction node and
 * throw instruction node.
 * @param bs - bit set of operands that may be optimized
 */
void 
LazyExceptionOpt::fixOptCandidates(BitSet* bs) {
    OptCandidates::iterator it;
    Inst* oinst;
    MethodCallInst* iinst;
    Inst* tinst;
    Inst* tlinst;
    U_32 opcount;
    Opnd **opnds = NULL;

    if (optCandidates == NULL) {
        return;
    }
    for (it = optCandidates->begin( ); it != optCandidates->end( ); it++ ) {
        if (bs->getBit((*it)->opndId)) {
            oinst = (*it)->objInst; 
            assert(oinst != NULL);
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "  to remove ";
                oinst->print(Log::out());
                Log::out() << std::endl;
            }
#endif
            if ((*it)->initInst == NULL) {
#ifdef _DEBUG
                if (Log::isEnabled()) {
                    Log::out() << "  init inst is null ";
                    Log::out() << std::endl;
                }
#endif
                continue;
            }
            iinst = (*it)->initInst->asMethodCallInst(); 
            // inline info from constructor should be propagated to lazy
            // exception if any
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "  to remove ";
                iinst->print(Log::out());
                Log::out() << std::endl;
            }
#endif
            assert((*it)->throwInsts != NULL);
            assert(iinst->getNumSrcOperands() >= 3);
            if (!removeInsts(oinst,iinst))
                continue;   // to null bitset?
            TypeManager& tm = irManager.getTypeManager();
            Opnd* mpt = irManager.getOpndManager().createSsaTmpOpnd(
                        tm.getMethodPtrType(iinst->getMethodDesc()));
            opcount = iinst->getNumSrcOperands()-2;  //numSrc-3+1 
            if (opcount >0) {
                opnds = new (leMemManager) Opnd*[opcount];   //local mem should be used
                opnds[0] = mpt;
                for (U_32 i = 0; i < opcount-1; i++)
                    opnds[i+1] = iinst->getSrc(i+3);
            }
            Inst* mptinst = irManager.getInstFactory().makeLdFunAddr(mpt,iinst->getMethodDesc());
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "  1st      ";
                mptinst->print(Log::out());
                Log::out() << std::endl;
            }
#endif
            ThrowInsts::iterator it1;
            for (it1 = (*it)->throwInsts->begin(); it1 !=(*it)->throwInsts->end(); it1++) {
                tinst = *it1;
                assert(tinst != NULL);
                tlinst=irManager.getInstFactory().makeVMHelperCall(  
                        OpndManager::getNullOpnd(), VM_RT_THROW_LAZY, opcount, opnds);
#ifdef _DEBUG
                if (Log::isEnabled()) {
                    Log::out() << "  2nd      ";
                    tlinst->print(Log::out());
                    Log::out() << std::endl;
                }
                if (Log::isEnabled()) {
                    Log::out() << "  to change ";
                    tinst->print(Log::out());
                    Log::out() << std::endl;
                }
#endif
                mptinst->insertBefore(tinst); 
                tlinst->insertBefore(tinst);
                tinst->unlink();

                uint16 bcOffset = iinst->getBCOffset();
                mptinst->setBCOffset(bcOffset);
                tlinst->setBCOffset(bcOffset);
            }
        }
    }
}

/**
 * Removes specified instructions if they have the same exception node.
 * @param oinst - exception creating instruction
 * @param iinst - constructor call instruction
 * @return <code>true</code> if instruction were removed;
 *         <code>false<code> otherwise.
 */
bool
LazyExceptionOpt::removeInsts(Inst* oinst,Inst* iinst) {
    ControlFlowGraph& fg = irManager.getFlowGraph();
    Edge* oedge = oinst->getNode()->getExceptionEdge();
    Edge* iedge = iinst->getNode()->getExceptionEdge();
    Node* otn = oedge->getTargetNode();
    Node* itn = iedge->getTargetNode();

    if (otn!=itn) {
#ifdef _DEBUG
        if (Log::isEnabled()) {
            Log::out() << "    removeInsts: diff.exc.edges for obj&init "; 
            Log::out() << otn->getId() << "  "  << itn->getId() << std::endl;
            Log::out() << "   "; oinst->print(Log::out()); 
            Log::out() << std::endl;
            Log::out() << "   "; iinst->print(Log::out()); 
            Log::out() << std::endl;
        }
#endif
        return false;
    }
    oinst->unlink();
    iinst->unlink();
    if (otn->getInEdges().size() > 1) {
        fg.removeEdge(oedge);
    } else
        removeNode(otn);
    if (itn->getInEdges().size() > 1) {
        fg.removeEdge(iedge);
    } else
        removeNode(itn);
    return true;
}

/**
 * Removes node from compiled method flow graph.
 * @param node - removed node
 */
void 
LazyExceptionOpt::removeNode(Node* node) {
    const Edges &out_edges = node->getOutEdges();
    Edges::const_iterator eit;
    Node* n; 
    for (eit = out_edges.begin(); eit != out_edges.end(); ++eit) {
        n = (*eit)->getTargetNode();
        if (n->getInEdges().size() == 1)
            removeNode(n);
    }
    irManager.getFlowGraph().removeNode(node);
}

void 
LazyExceptionOpt::printInst1(::std::ostream& os, Inst* inst, std::string txt) {
    U_32 nsrc = inst->getNumSrcOperands();
    os << txt;
    inst->print(os);
    os << std::endl;
    for (U_32 i=0; i<nsrc; i++) {
        printInst1(os, inst->getSrc(i)->getInst(),txt+"  ");
    }

}

/**
 * Checks a callee method side effect.
 * @param inst - method call instruction
 * @return <code>true</code> if method has side effect;
 *         <code>false<code> if method has no side effect.
 */
bool 
LazyExceptionOpt::methodCallHasSideEffect(Inst* inst) {
    U_32 opcode = inst->getOpcode();
    MethodDesc* cmd = NULL;
    Method_Side_Effects mse = MSE_Unknown;

    if (opcode==Op_DirectCall || opcode==Op_TauVirtualCall) {
        cmd = inst->asMethodCallInst()->getMethodDesc();
    } else {
        if (opcode==Op_IndirectCall || opcode==Op_IndirectMemoryCall) {
            Type* type = inst->asCallInst()->getFunPtr()->getType();
            if (type->isUnresolvedType()) {
                return true;
            }
            cmd = type->asMethodPtrType()->getMethodDesc();
        } else {
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "    checkMC: no check "; 
                inst->print(Log::out()); Log::out()  << std::endl;
            }
#endif
            return true;
        }
    }
#ifdef _DEBUG
    if (Log::isEnabled()) {
        Log::out() << "    checkMC: "; 
        cmd->printFullName(Log::out()); Log::out() << std::endl;
    }
#endif
    
    mse = cmd->getSideEffect();
#ifdef _DEBUG
    if (mse != MSE_Unknown) {
        if (Log::isEnabled()) {
            Log::out() << "    checkMC: prev.set sideEff " << mse << "  "; 
            inst->print(Log::out()); Log::out() << std::endl;
        }
    }
#endif
    if (mse == MSE_True) {
        return true;
    }
    if (mse == MSE_False) {
        return false;
    }
//  core api exception init
    if (cmd->isInstanceInitializer() && cmd->getParentType()->isLikelyExceptionType()
            && strncmp(cmd->getParentType()->getName(),"java/lang/",10) == 0) {
        cmd->setSideEffect(MSE_False);
#ifdef _DEBUG
        if (Log::isEnabled()) {
            Log::out() << "    checkMC: core api exc "; 
            inst->print(Log::out()); Log::out() << std::endl;
        }
#endif
        return false;
    }

    if ( opcode!=Op_DirectCall && !cmd->isFinal() ) {
#ifdef _DEBUG
        if (Log::isEnabled()) {
            Log::out() << "    checkMC: not DirCall not final "; 
            inst->print(Log::out()); Log::out() << std::endl;
        }
#endif
        return true;
    }

    if (!isExceptionInit && 
        !(cmd->isInstanceInitializer()&&cmd->getParentType()->isLikelyExceptionType())) {
#ifdef _DEBUG
        if (Log::isEnabled()) {
            Log::out() << "    checkMC: no init "; 
            Log::out() << isExceptionInit << " ";
            Log::out() << cmd->isInstanceInitializer() << " ";
            Log::out() << cmd->getParentType()->isLikelyExceptionType() << " ";
            inst->print(Log::out()); Log::out() << std::endl;
        }
#endif
        return true;
    }

/*
    if (cmd->getParentType()->needsInitialization()) {
#ifdef _DEBUG
        if (Log::isEnabled()) {
            Log::out() << "    checkMC: need cinit "; 
            inst->print(Log::out()); Log::out() << std::endl;
        }
#endif
        return true;  // cannot compile <init> before <clinit> (to fix vm)
    }
*/

    if (mse == MSE_Unknown) {  // try to compile method
        //TODO: avoid compilation here. Use translator to perform analysis needed
        bool allowRecursion = !compInterface.getTypeManager().isLazyResolutionMode();
        if (!allowRecursion) {
            return MSE_True;
        }
        if (!compInterface.compileMethod(cmd)) {
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "    checkMC: method was not compiled " << std::endl;
            }
#endif
            return true;
        } else {
             mse = cmd->getSideEffect();
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "    checkMC: method was compiled, sideEff " 
                    << mse << std::endl;
            }
#endif
            if (mse == MSE_True)
                return true;
            if (mse == MSE_False) {
                return false;
            }
       }
    }

    if (mse == MSE_True_Null_Param) {
        U_32 nsrc=inst->getNumSrcOperands();
        bool mayBeNull;
        if (nsrc>3) {
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "    checkMC: exc.init "; 
                inst->print(Log::out()); Log::out() << std::endl;
            }
#endif
            mayBeNull=false;
            for (U_32 i=3; i<nsrc; i++) {
                if (inst->getSrc(i)->getType()->isReference()) {
                    if (mayBeNullArg(inst,i))
                        mayBeNull=true;
                }
            }
            if (!mayBeNull)
                return false;
#ifdef _DEBUG
            for (U_32 i=0; i<nsrc; i++) {
                if (Log::isEnabled()) {
                    Log::out() << "        "<<i<<" isRef: "<<
                    inst->getSrc(i)->getType()->isReference()<<" "; 
                    inst->getSrc(i)->getInst()->print(Log::out()); 
                    Log::out() << std::endl;
                }
            }
#endif
            return true;
        } 
#ifdef _DEBUG
        else {
            if (Log::isEnabled()) {
                Log::out() << " ?????? MSE_NULL_PARAM & nsrc "<<
                nsrc << std::endl;
            }
        }
#endif
    }
    return true;
}

/**
 * Checks if a callee method agrument may be null.
 * @param call_inst - method call instruction
 * @param arg_n - callee method argument number
 * @return <code>true</code> if a callee method argument may be null
 *         <code>false<code> if a callee method argument is not null
 */
bool 
LazyExceptionOpt::mayBeNullArg(Inst* call_inst, U_32 arg_n) {
    Opnd* arg_opnd = call_inst->getSrc(arg_n);
    Inst* inst=arg_opnd->getInst();

    while ((inst=inst->getNextInst())!=NULL) {
        if (inst->getOpcode()==Op_TauCheckNull && inst->getSrc(0)==arg_opnd) {
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "   check node: " << inst->getNode()->getId() << " ";
                inst->print(Log::out()); Log::out() << std::endl; 
            }
#endif 
            return false; // may not be null
        }
    }
#ifdef _DEBUG
    if (Log::isEnabled()) {
        Log::out() << "   chknull wasn,t found in node: "
            << arg_opnd->getInst()->getId()<< std::endl; 
    }
#endif 
    return true;  // may be null
}

/**
 * Checks if Op_TauStInd (stind) instruction has a side effect.
 * @param inst - checked instruction
 * @return <code>true</code> if an instruction has side effect;
 *         <code>false<code> if an instruction has no side effect.
 */
bool
LazyExceptionOpt::fieldUsageHasSideEffect(Inst* inst) {
    Opnd* insOp = inst->getSrc(0);
    Inst* instDef = insOp->getInst();
    if (instDef->getOpcode() == Op_DefArg) {
#ifdef _DEBUG
        if (Log::isEnabled()) {
            Log::out() << "    fieldUsageHasSideEffect: "; 
            inst->print(Log::out()); Log::out()  << std::endl;
            Log::out() << "    fieldUsageHasSideEffect: "; 
            instDef->print(Log::out()); Log::out()  << std::endl;
            Log::out() << "    fieldUsageHasSideEffect: "; 
            Log::out() << (int)(instDef->getDefArgModifier()) << " " <<
            (instDef->getDefArgModifier()==DefArgNoModifier) << " " <<
            (instDef->getDefArgModifier()==NonNullThisArg) << " " <<
            (instDef->getDefArgModifier()==DefArgBothModifiers) << std::endl;
        }
#endif
        if (instDef->getDefArgModifier()==NonNullThisArg && isExceptionInit)
            return false;
    }
    return true;
}

/**
 * Checks if there is a side effect between throw_inst and init_inst instructions.
 * @param inst - checked instruction
 * @return <code>true</code> if an instruction has side effect;
 *         <code>false<code> if an instruction has no side effect.
 */
bool 
LazyExceptionOpt::instHasSideEffect(Inst* inst) {
    switch (inst->getOpcode()) {
        case Op_Add:
        case Op_Mul:
        case Op_Sub:
        case Op_TauDiv:
        case Op_TauRem:
        case Op_Neg:
        case Op_MulHi:
        case Op_Min:
        case Op_Max:
        case Op_Abs:
        case Op_And:
        case Op_Or:
        case Op_Xor:
        case Op_Not:
        case Op_Select:
            return false;
        case Op_Conv:
        case Op_ConvZE:
        case Op_ConvUnmanaged:
            return true;
        case Op_Shladd:
        case Op_Shl:
        case Op_Shr:
        case Op_Cmp:
        case Op_Cmp3:
        case Op_Branch:
        case Op_Jump:
        case Op_Switch:
            return false;
        case Op_DirectCall:
        case Op_TauVirtualCall:
        case Op_IndirectCall:
        case Op_IndirectMemoryCall:
#ifdef _DEBUG
            if (Log::isEnabled()) {
                Log::out() << "    instHasSideEffect: call checkMC "; 
                inst->print(Log::out()); Log::out()  << std::endl;
            }
#endif
            return methodCallHasSideEffect(inst);  
        case Op_JitHelperCall:
        case Op_VMHelperCall:
            return true;
        case Op_Return:
        case Op_Catch:
            return false;
        case Op_PseudoThrow:
            return false;
        case Op_Throw:
        case Op_ThrowSystemException:
        case Op_ThrowLinkingException:
            return true;
        case Op_JSR:              // deleted
        case Op_Ret:
        case Op_SaveRet:
            return true;
        case Op_Copy:
            return true;
        case Op_DefArg:
        case Op_LdConstant:
        case Op_LdRef:
        case Op_LdVar:    
        case Op_LdVarAddr:
        case Op_TauLdInd:
            return false;
        case Op_TauLdField:
            return true; 
        case Op_LdStatic:
            return true;
        case Op_TauLdElem:
             return false;
        case Op_LdFieldAddr: 
             return false;
        case Op_LdStaticAddr:
            return true;
        case Op_LdElemAddr:
            return false; //
        case Op_TauLdVTableAddr:
        case Op_TauLdIntfcVTableAddr:
        case Op_TauLdVirtFunAddr:
        case Op_TauLdVirtFunAddrSlot:
        case Op_LdFunAddr:
        case Op_LdFunAddrSlot:
        case Op_GetVTableAddr:
        case Op_GetClassObj:
            return false;
        case Op_TauArrayLen:
        case Op_LdArrayBaseAddr:
        case Op_AddScaledIndex:
            return true;
        case Op_StVar:
            return false;
        case Op_TauStInd:
            {
                Inst* inst_src1 = inst->getSrc(1)->getInst();
#ifdef _DEBUG
                if (Log::isEnabled()) {
                    Log::out() << "    stind: "; 
                    inst->print(Log::out()); Log::out()  << std::endl;
                    Log::out() << "           "; 
                    inst_src1->print(Log::out()); Log::out()  << std::endl;
                }
#endif
                if (inst_src1->getOpcode()==Op_LdFieldAddr ) 
                    return fieldUsageHasSideEffect(inst_src1);
            }
            return true;
        case Op_TauStRef:
            {
                Inst* inst_src1 = inst->getSrc(1)->getInst();
#ifdef _DEBUG
                if (Log::isEnabled()) {
                    Log::out() << "    stref: "; 
                    inst->print(Log::out()); Log::out()  << std::endl;
                    Log::out() << "           "; 
                    inst_src1->print(Log::out()); Log::out()  << std::endl;
                }
#endif
                if (inst_src1->getOpcode()==Op_LdFieldAddr ) 
                    return fieldUsageHasSideEffect(inst_src1);
            }
            return true;
        case Op_TauStField:
            return true; // 
        case Op_TauStElem:
        case Op_TauStStatic:
        case Op_TauCheckBounds:
        case Op_TauCheckLowerBound:
        case Op_TauCheckUpperBound:
            return true;
        case Op_TauCheckNull:
            {
                Inst* inst_src = inst->getSrc(0)->getInst();
#ifdef _DEBUG
                if (Log::isEnabled()) {
                    Log::out() << "    chknull: "; 
                    inst->print(Log::out()); Log::out()  << std::endl;
                    Log::out() << "               "; 
                    inst_src->print(Log::out()); Log::out()  << std::endl;
                }
#endif
                if (inst_src->getOpcode()==Op_DefArg && isExceptionInit) {
                    isArgCheckNull = true;
                    return false;
                }
            }
            return true; // 
        case Op_TauCheckZero:
        case Op_TauCheckDivOpnds:
        case Op_TauCheckElemType:
        case Op_TauCheckFinite:
            return true;
        case Op_NewObj:
// core api
            {
                NamedType* nt = inst->getDst()->getType()->asNamedType();
                if (strncmp(nt->getName(),"java/lang/",10)==0 && nt->isLikelyExceptionType()) {
#ifdef _DEBUG
                    if (Log::isEnabled()) {
                        Log::out() << "====newobj "; 
                        inst->print(Log::out()); Log::out()  << std::endl;
                        Log::out() << "core api exc " << nt->getName() << " "
                            << strncmp(nt->getName(),"java/lang/",10)
                            << " excType: " << nt->isLikelyExceptionType() << std::endl; 
                    }
#endif
                    return false;
                }
            }
            return true;
        case Op_NewArray:
        case Op_NewMultiArray:
        case Op_TauMonitorEnter:
        case Op_TauMonitorExit:
        case Op_TypeMonitorEnter:
        case Op_TypeMonitorExit:
        case Op_LdLockAddr:
        case Op_IncRecCount:
        case Op_TauBalancedMonitorEnter:
        case Op_BalancedMonitorExit:
        case Op_TauOptimisticBalancedMonitorEnter:
        case Op_OptimisticBalancedMonitorExit:
        case Op_MonitorEnterFence:
        case Op_MonitorExitFence:
            return true;
        case Op_TauStaticCast:
        case Op_TauCast:
        case Op_TauAsType:
        case Op_TauInstanceOf:
        case Op_InitType:
            return true;
        case Op_Label:
        case Op_MethodEntry:
        case Op_MethodEnd:
            return false;                
        case Op_Phi:
        case Op_TauPi:
            return false;
        case Op_IncCounter:
        case Op_Prefetch:
            return false;
        case Op_UncompressRef:
        case Op_CompressRef:
        case Op_LdFieldOffset:
        case Op_LdFieldOffsetPlusHeapbase:
        case Op_LdArrayBaseOffset:
        case Op_LdArrayBaseOffsetPlusHeapbase:
        case Op_LdArrayLenOffset:
        case Op_LdArrayLenOffsetPlusHeapbase:
        case Op_AddOffset:
        case Op_AddOffsetPlusHeapbase:
            return true;
        case Op_TauPoint:
        case Op_TauEdge:
        case Op_TauAnd:
        case Op_TauUnsafe:
        case Op_TauSafe:
            return false;
        case Op_TauCheckCast:
            return true;
        case Op_TauHasType:
        case Op_TauHasExactType:
        case Op_TauIsNonNull:
            return false;
        default:
            return true;
    }
}

} //namespace Jitrino