/*
 *  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.
 */
 
#include <stdio.h>
#include <iostream>

#include "Log.h"
#include "IRBuilder.h"
#include "JavaLabelPrepass.h"
#include "TranslatorIntfc.h"
#include "ExceptionInfo.h"
#include "simplifier.h"     // for isExactType and isNonNullObject

namespace Jitrino {

VariableIncarnation::VariableIncarnation(U_32 offset, Type* t)
: definingOffset(offset), declaredType(t), opnd(NULL)
{
    _prev = _next = NULL;
}

void VariableIncarnation::setMultipleDefs()
{
    definingOffset = -1;
}

Type* VariableIncarnation::getDeclaredType()
{
    return declaredType;
}

void VariableIncarnation::setDeclaredType(Type* t)
{
    declaredType = t;
}

void VariableIncarnation::setCommonType(Type* t) {
    declaredType = t;
    VariableIncarnation* tmp;
    tmp = (VariableIncarnation*)_prev;
    while (tmp) {
        tmp->declaredType = t;
        tmp = (VariableIncarnation*)tmp->_prev;
    }
    tmp = (VariableIncarnation*)_next;
    while (tmp) {
        tmp->declaredType = t;
        tmp = (VariableIncarnation*)tmp->_next;
    }
}

void VariableIncarnation::linkIncarnations(VariableIncarnation* vi1, VariableIncarnation* vi2)
{
    if (vi1==vi2) return;
    while (vi1->_next) vi1 = (VariableIncarnation*)vi1->_next;
    VariableIncarnation* tmp = vi2;
    while (tmp->_next) tmp = (VariableIncarnation*)tmp->_next;
    if (vi1==tmp) return;
    while (vi2->_prev) vi2 = (VariableIncarnation*)vi2->_prev;
    vi1->_next = vi2;
    vi2->_prev = vi1;
}

void VariableIncarnation::mergeIncarnations(TypeManager* tm)
{
    mergeIncarnations(0,tm);
}

void VariableIncarnation::mergeIncarnations(Type* t, TypeManager* tm)
{
    VariableIncarnation* vi = this;
    while (vi->_prev) vi = (VariableIncarnation*)vi->_prev;
    // return if there is only one incarnation in chain.
    if (!(t || vi->_next)) return;

    if(Log::isEnabled()) {
        Log::out() << "Merging incarnations:" << ::std::endl;
        if (t) {
            Log::out() << "    assigning common type:";
            t->print(Log::out());
            Log::out() << ::std::endl;
        }
        VariableIncarnation* tmp = vi;
        do {
            tmp->getDeclaredType()->print(Log::out());
            Log::out() << " (" << tmp << ",DO=" << tmp->definingOffset << ") <=>";
            tmp = (VariableIncarnation*)tmp->_next;
        } while (tmp);
        Log::out() << " end-of-list";
    }

    Type* varType = (t ? tm->getCommonType(vi->getDeclaredType(),t) : vi->getDeclaredType());
    // Since we merge only types which are live at use there should be a common type
    assert(varType);
    for (vi = (VariableIncarnation*)vi->_next; vi; vi = (VariableIncarnation*)vi->_next) {
        varType = tm->getCommonType(varType, vi->getDeclaredType());
    }
    assert(varType);
    if(Log::isEnabled()) {
        Log::out() << "    ;;set common type: ";
        varType->print(Log::out());
        Log::out() << ::std::endl;
    }
    setCommonType(varType);
    setMultipleDefs();
}

void VariableIncarnation::linkAndMergeIncarnations(VariableIncarnation* vi1, VariableIncarnation* vi2, Type* t, TypeManager* tm) {
    linkIncarnations(vi1, vi2);
    vi1->mergeIncarnations(t, tm);
}

void VariableIncarnation::linkAndMergeIncarnations(VariableIncarnation* vi1, VariableIncarnation* vi2, TypeManager* tm) {
    linkIncarnations(vi1, vi2);
    vi1->mergeIncarnations(tm);
}

void VariableIncarnation::print(::std::ostream& out) {
    VariableIncarnation* tmp = this;
    do {
        tmp->getDeclaredType()->print(out);
        out << " (" << tmp << ",DO=" << tmp->definingOffset << ") <-i->";
        tmp = (VariableIncarnation*)tmp->_next;
    } while (tmp);
    //out << ::std::endl;
}


void SlotVar::print(::std::ostream& out) {
    SlotVar* tmp = this;
    do {
        VariableIncarnation* cur_var_inc = tmp->getVarIncarnation();
        cur_var_inc->getDeclaredType()->print(out);
        out << " (" << cur_var_inc << ",DO=" << cur_var_inc->definingOffset << ",LO=" << linkOffset << ") <->";
        tmp = (SlotVar*)tmp->_next;
    } while (tmp);
    //out << ::std::endl;
}


bool SlotVar::addVarIncarnations(SlotVar* var, MemoryManager& mm, U_32 linkOffset) {
    assert(var->_prev == NULL);
    SlotVar* this_sv = this;
    while(this_sv->_next) this_sv = (SlotVar*)this_sv->_next;

    bool added = false;
    bool found = false;
    for (SlotVar* in_var = var; in_var; in_var = (SlotVar*)in_var->_next) {
        found = false;
        VariableIncarnation* var_inc = in_var->getVarIncarnation();
        for (SlotVar* sv = this; sv; sv = (SlotVar*)sv->_next) {
            if (var_inc == sv->getVarIncarnation()) {
                found = true;
                break;
            }
        }
        if (found) continue;
        this_sv->_next = new (mm) SlotVar(var_inc);
        this_sv = (SlotVar*)this_sv->_next;
        added = true;
    }
    if (added) this->linkOffset = linkOffset;
    return added;
}

void SlotVar::mergeVarIncarnations(TypeManager* tm) {
    for (SlotVar* tmp = (SlotVar*)_next; tmp; tmp = (SlotVar*)tmp->_next) {
        VariableIncarnation* var_inc = tmp->getVarIncarnation();
        VariableIncarnation::linkIncarnations(var, var_inc);
        //var_inc ->setMultipleDefs();
    }
    var->mergeIncarnations(tm);
//    _next = NULL;
}


Opnd* VariableIncarnation::getOpnd()
{
    return opnd;
}

Opnd* VariableIncarnation::getOrCreateOpnd(IRBuilder* irBuilder)
{
    if (!opnd)
        createVarOpnd(irBuilder);
    return opnd;
}

void VariableIncarnation::createVarOpnd(IRBuilder* irBuilder)
{
    if (opnd) return;
    opnd = irBuilder->genVarDef(declaredType, false);
    if(Log::isEnabled()) {
        Log::out() << "Create operand for VarIncarnation:" << ::std::endl;
        Log::out() << "    opnd:"; opnd->print(Log::out()); Log::out() << ::std::endl;
        Log::out() << "    VarInc:"; print(Log::out()); Log::out() << ::std::endl;
    }

    VariableIncarnation* tmp;
    tmp = (VariableIncarnation*)_prev;
    while (tmp) {
        tmp->opnd = opnd;
        tmp = (VariableIncarnation*)tmp->_prev;
    }
    tmp = (VariableIncarnation*)_next;
    while (tmp) {
        tmp->opnd = opnd;
        tmp = (VariableIncarnation*)tmp->_next;
    }
}

void VariableIncarnation::setTmpOpnd(Opnd* tmpOpnd)
{
    assert(!opnd);
    opnd = tmpOpnd;
}

void VariableIncarnation::createMultipleDefVarOpnd(IRBuilder* irBuilder)
{
    if (definingOffset==-1) createVarOpnd(irBuilder);
}

StateInfo::SlotInfo& StateInfo::top() {
    assert(stack && stackDepth != 0);
    return stack[stackDepth - 1];
}

StateInfo::SlotInfo& StateInfo::push(Type *type) {
    StateInfo::SlotInfo& slot = stack[stackDepth++];
    slot.type = type;
    slot.slotFlags = 0;
    slot.vars = NULL;
    slot.jsrLabelOffset = 0;
    return slot;
}

void  StateInfo::addCatchHandler(CatchHandler *info)
{
    setCatchLabel();
    info->setNextExceptionInfoAtOffset(exceptionInfo);
    exceptionInfo = info;
}

void  StateInfo::addExceptionInfo(CatchBlock *info) {
    ExceptionInfo *exc;
    ExceptionInfo *prev = NULL;
    for (exc = exceptionInfo; exc != NULL; exc = exc->getNextExceptionInfoAtOffset()) {
        if (exc->isCatchBlock() &&
            ((CatchBlock *)exc)->getExcTableIndex() > ((CatchBlock *)info)->getExcTableIndex()) {
            break;
        }
        prev = exc;
    }
    if (prev == NULL) {
        info->setNextExceptionInfoAtOffset(exceptionInfo);
        exceptionInfo = info;
    } else {
        info->setNextExceptionInfoAtOffset(prev->getNextExceptionInfoAtOffset());
        prev->setNextExceptionInfoAtOffset(info);
    }
}

void StateInfo::cleanFinallyInfo(U_32 offset)
{
    for (unsigned k=0; k < stackDepth; k++) {
        if (stack[k].jsrLabelOffset == offset) {
            stack[k].jsrLabelOffset = 0;
            stack[k].type = 0;
            stack[k].slotFlags = 0;
            stack[k].vars = NULL;
            stack[k].varNumber = 0;
        }
    }
}

class JavaExceptionParser {
public:
    JavaExceptionParser(MemoryManager& mm,JavaLabelPrepass& p,
                    CompilationInterface& ci,MethodDesc* method) 
        : numCatch(0), memManager(mm), prepass(p), 
          compilationInterface(ci), enclosingMethod(method),
          prevCatch(NULL), nextRegionId(0) {}

    U_32 parseHandlers() {
        U_32 numHandlers = enclosingMethod->getNumHandlers();
        for (U_32 i=0; i<numHandlers; i++) {
            unsigned short beginOffset,endOffset,handlerOffset,handlerClassIndex;
            enclosingMethod->getHandlerInfo(i,&beginOffset,&endOffset,
                &handlerOffset,&handlerClassIndex);
            if (!catchBlock(beginOffset,endOffset-beginOffset,
                handlerOffset,handlerClassIndex))
            {
                // handlerClass failed to be resolved. LinkingException throwing helper
                // will be generated instead of method's body
                return handlerClassIndex;
            }
        }
        return MAX_UINT32; // all catchBlocks were processed successfully
    }

    void addHandlerForCatchBlock(CatchBlock* block, 
                                      U_32 handlerOffset,
                                      Type*  exceptionType) {
        jitrino_assert( exceptionType);
        assert(!exceptionType->isUnresolvedType());//must be resolved by verifier
        if (Log::isEnabled()) Log::out() << "Catch Exception Type = " << exceptionType->getName() << ::std::endl;

        // FIXME can we operate with just sole handler per offset, just merging exceptionTypes?
        // need to check about handler for finally.
        CatchHandler* handler = new (memManager) 
            CatchHandler(nextRegionId++,
                         handlerOffset,
                         handlerOffset,
                         exceptionType);
        block->addHandler(handler);
        StateInfo *hi = prepass.stateTable->createStateInfo(handlerOffset, prepass.getNumVars());
        hi->addCatchHandler(handler);
        StateInfo::SlotInfo* slot;
        if (hi->stackDepth != prepass.getNumVars()) {
            slot = &hi->top();
            if (slot->type != exceptionType) {
                slot->type = prepass.typeManager.getCommonType(exceptionType, slot->type);
                StateInfo::clearExactType(slot);
            }
        } else {
            slot = &hi->push(exceptionType);
            StateInfo::setNonNull(slot);
        }
        assert(prepass.getNumVars() + 1 == (unsigned)hi->stackDepth);
        slot->vars = new (memManager) SlotVar(
            prepass.getOrCreateVarInc(handlerOffset, hi->stackDepth - 1, slot->type));
        
    }

    CatchBlock* splitBlockWithOffset(CatchBlock* block, U_32 offset)
    {
        CatchBlock* newBlock = 
            new (memManager) CatchBlock(nextRegionId++, 
                                        offset,
                                        block->getEndOffset(),
                                        block->getExcTableIndex());
        assert(prepass.stateTable->getStateInfo(offset));
        prepass.stateTable->getStateInfo(offset)->addExceptionInfo(newBlock);
        block->setEndOffset(offset);

        //
        // copy all handlers
        //

        for (CatchHandler* handler = block->getHandlers(); 
                           handler != NULL; 
                           handler = handler->getNextHandler() ) 
        {
            addHandlerForCatchBlock(newBlock, handler->getBeginOffset(), handler->getExceptionType());
        }
        return newBlock;
    }

    bool catchBlock(U_32 tryOffset,
                            U_32 tryLength,
                            U_32 handlerOffset,
                            U_32 exceptionTypeToken)  {
 
        if (Log::isEnabled()) Log::out() << "CatchBlock @ " << (int)tryOffset << "," 
            << (int)tryOffset+(int)tryLength
             << " handler @ " << (int)handlerOffset << ","
             << " exception type " << (int)exceptionTypeToken << ","
             << " numCatch " << numCatch << ::std::endl;

        U_32 endOffset = tryOffset + tryLength;
        prepass.setLabel(handlerOffset);
        prepass.setLabel(tryOffset);
        prepass.setLabel(endOffset);
  
        bool unnested_try_regions_found = false;
        CatchBlock* catchBlock;

        Type* exceptionType = NULL;
        if (exceptionTypeToken != 0) {
            exceptionType = compilationInterface.getNamedType(enclosingMethod->getParentHandle(),exceptionTypeToken, ResolveNewCheck_NoCheck);
            assert(exceptionType);
            if (exceptionType->isUnresolvedObject()) {
                if(!compilationInterface.getTypeManager().isLazyResolutionMode()) {
                    // the type can not be resolved. LinkingException must be thrown
                    return 0;
                }
               //WORKAROUND! resolving exception type during a compilation session!!!
                //Details: using singleton UnresolvedObjectType we unable to 
                //distinct exception types if there are several unresolved exceptions in a single try block
                //usually verifier loads all exception types caught for in method
                //but verifier is turned off for bootstrap classes
                if (Log::isEnabled()) Log::out()<<"WARNING: resolving type from inside of compilation session!!"<<std::endl;
                exceptionType = compilationInterface.resolveNamedType(enclosingMethod->getParentHandle(),exceptionTypeToken);
                if (exceptionType->isUnresolvedType()) {
                    return 0;
                }
            }
        } else {
            //FIXME should use j.l.Throwable for correct type propagation ??
            exceptionType = prepass.typeManager.getSystemObjectType();
        }

        if (prevCatch != NULL && prevCatch->equals(tryOffset, endOffset) == true) {
            catchBlock = prevCatch;
            addHandlerForCatchBlock(catchBlock, handlerOffset, exceptionType);
        } else {
            prepass.stateTable->createStateInfo(tryOffset);
            // 
            // split all previous CatchBlocks that:
            // 1. intersect with current CatchBlock 
            // 2. are not contained by current CatchBlock
            //    (CB splitting will result in CBs with same excTableIndex, 
            //     but it is no problem since splitted CBs do not intersect)
            // Our aim is to make all try-blocks nested
            //
            for ( JavaLabelPrepass::ExceptionTable::iterator block_it = prepass.exceptionTable.begin();
                  block_it != prepass.exceptionTable.end();
                  block_it++ ) {
                CatchBlock* block = *block_it;
                if ( block->offsetSplits(tryOffset) || block->offsetSplits(endOffset) ) {
                    if ( !unnested_try_regions_found ) {
                        unnested_try_regions_found = true;
                        if (Log::isEnabled()) Log::out() << "unnested try-regions encountered" << std::endl;
                    }
                }
                assert(tryOffset < endOffset);
                if ( block->offsetSplits(tryOffset) ) {
                    block = splitBlockWithOffset(block, tryOffset);
                    prepass.exceptionTable.insert(block_it, block);
                }
                if ( block->offsetSplits(endOffset) ) {
                    prepass.stateTable->createStateInfo(endOffset);
                    block = splitBlockWithOffset(block, endOffset);
                    prepass.exceptionTable.insert(block_it, block);
                }
                assert( !(block->offsetSplits(tryOffset) || block->offsetSplits(endOffset)) );
            }

            //
            // add new CatchBlock
            //
            if (handlerOffset < endOffset && handlerOffset > tryOffset) { 
                //self-handling block: add 2 CatchBlocks(ExceptionInfos) with the following boundaries:
                //[tryOffset, handlerOffset], [handlerOffset, endOffset]
                //The reason is to avoid loops with dispatch node as header:
                // Details:
                // For a single CatchBlock(ExceptionInfo) we have only 1 dispatch node today 
                // (dispatch node is referenced by LabelInfo field in ExceptionInfo structure)
                // Having single dispatch node for self-catching regions we will have a loop with
                // dispatch node as a loop-header.
                // To avoid having dispatch nodes as a loop-header we create 2 (CatchBlocks)ExceptionInfos here: 
                // doing this we have 2 dispatch nodes for 2 ExceptionInfos and loop-header is automatically 
                // moved to the next (after the second dispatch)block node with CatchLabelInst instruction.
                // Example to reproduce: comment out this if clause and check IR for monexit loops.

                prevCatch = catchBlock = new (memManager) CatchBlock(nextRegionId++, tryOffset, handlerOffset, numCatch++);
                prepass.stateTable->getStateInfo(tryOffset)->addExceptionInfo(catchBlock);
                prepass.exceptionTable.push_back(catchBlock);
                addHandlerForCatchBlock(catchBlock, handlerOffset, exceptionType);

                prevCatch = catchBlock = new (memManager) CatchBlock(nextRegionId++, handlerOffset, endOffset, numCatch++);
                prepass.stateTable->getStateInfo(handlerOffset)->addExceptionInfo(catchBlock);
                prepass.exceptionTable.push_back(catchBlock);
                addHandlerForCatchBlock(catchBlock, handlerOffset, exceptionType);
            } else { 
                prevCatch = catchBlock = new (memManager) CatchBlock(nextRegionId++, tryOffset, endOffset, numCatch++);
                prepass.stateTable->getStateInfo(tryOffset)->addExceptionInfo(catchBlock);
                prepass.exceptionTable.push_back(catchBlock);
                addHandlerForCatchBlock(catchBlock, handlerOffset, exceptionType);
            } 
            
        }
        return 1; // all exceptionTypes are OK
    }

    U_32 numCatch;
    MemoryManager&            memManager;
    JavaLabelPrepass&      prepass;
    CompilationInterface&   compilationInterface;
    MethodDesc*             enclosingMethod;
    CatchBlock*             prevCatch;
    U_32                  nextRegionId;
};


JavaLabelPrepass::JavaLabelPrepass(MemoryManager& mm,
                                   TypeManager& tm, 
                                   MemoryManager& irManager,
                                   MethodDesc& md,
                                   CompilationInterface& ci, 
                                   Opnd **actualArgs) 
 : JavaByteCodeParserCallback(mm,md.getByteCodeSize()), 
   memManager(mm), 
   typeManager(tm), 
   methodDesc(md), 
   compilationInterface(ci),
   localVars(mm),
   jsrEntriesMap(mm),
   retToSubEntryMap(mm),
   exceptionTable(mm),
   problemTypeToken(MAX_UINT32)
{
    U_32 numByteCodes = methodDesc.getByteCodeSize();
    //nextIsLabel = false;
    int32Type = typeManager.getInt32Type();
    int64Type = typeManager.getInt64Type();
    singleType = typeManager.getSingleType();
    doubleType= typeManager.getDoubleType();

    numLabels = 0;
    labels = new (memManager) BitSet(memManager,numByteCodes);
    subroutines = new (memManager) BitSet(memManager,numByteCodes);
    numVars = methodDesc.getNumVars();
    int numStack = methodDesc.getMaxStack()+1;
    stateInfo.stack  = new (memManager) StateInfo::SlotInfo[numVars+numStack];
    stateInfo.stackDepth = numVars;
    for (U_32 k=0; k < numVars+numStack; k++) {
        struct StateInfo::SlotInfo *slot = &stateInfo.stack[k];
        slot->type = NULL;
        slot->slotFlags = 0;
        slot->vars = NULL;
        slot->jsrLabelOffset = 0;
    }
    blockNumber  = 0;
    labelOffsets = NULL;
    // exceptions
    stateTable = new (memManager)  StateTable(memManager,typeManager,*this,numStack,numVars);

    // 1st count number of catch and finally blocks
    // parse and create exception info
    JavaExceptionParser exceptionTypes(irManager,*this,compilationInterface,&methodDesc);
    // fix exception handlers
    unsigned problemToken = exceptionTypes.parseHandlers();
    if(problemToken != MAX_UINT32)
    {
        problemTypeToken = problemToken;
        noNeedToParse = true;
        numCatchHandlers = 0;
    } else {
        numCatchHandlers = exceptionTypes.numCatch;
    }
    hasJsrLabels = false;
    isFallThruLabel = true;
    U_32 numArgs = methodDesc.getNumParams();
    for (U_32 i=0, j=0; i<numArgs; i++,j++) {
        Type *type;
        struct StateInfo::SlotInfo *slot = &stateInfo.stack[j];
        if (actualArgs != NULL) { 
            // inlined version
            Opnd *actual = actualArgs[i];
            type = actual->getType();
            if(Log::isEnabled()) {
                Log::out() << "PARAM " << (int)i << " sig: ";
                methodDesc.getParamType(i)->print(Log::out());
                Log::out() << " actual: ";
                type->print(Log::out()); Log::out() << ::std::endl;
            }
            slot->type = typeManager.toInternalType(type);
            if (Simplifier::isNonNullObject(actual))   StateInfo::setNonNull(slot);
            if (Simplifier::isNonNullParameter(actual))   StateInfo::setNonNull(slot);
            if (Simplifier::isExactType(actual))       StateInfo::setExactType(slot);
        } else {
            type = methodDesc.getParamType(i);
            if (!type) {
                // linkage error will happen at the usage point of this parameter
                // here we just keep it as NullObj
                type = typeManager.getNullObjectType();
            }
            slot->type = typeManager.toInternalType(type);
        }
        slot->vars  = new (memManager) SlotVar(getOrCreateVarInc(0, j, slot->type));
        JavaVarType javaType = getJavaType(type);
        if (javaType == L || javaType == D) j++;
    }
    stateTable->setStateInfo(&stateInfo, 0, false);
}

void JavaLabelPrepass::offset(U_32 offset) {
    bytecodevisited->setBit(offset,true);
    if (offset==0)
        stateTable->restoreStateInfo(&stateInfo, offset);
    if (labels->getBit(offset) == true) {
        if (linearPassDone)
            stateTable->restoreStateInfo(&stateInfo, offset);
        setStackVars();
        if (!linearPassDone) {
            Log::out() << "LINEAR " << std::endl;
            propagateStateInfo(offset,isFallThruLabel);
            isFallThruLabel = true;
        }
        if (Log::isEnabled()) Log::out() << "BASICBLOCK " << (I_32)offset << " #" << blockNumber << std::endl;
        ++blockNumber;
        visited->setBit(offset,true);
        stateTable->restoreStateInfo(&stateInfo,offset);
        if (stateInfo.isSubroutineEntry()) {
            stateInfo.push(typeManager.getSystemObjectType());
            stateInfo.top().jsrLabelOffset = offset;
        }
    }
}


void JavaLabelPrepass::setLabel(U_32 offset) {
    if (labels->getBit(offset)) // this label is already seen
        return;
    if (Log::isEnabled()) Log::out() << "SET LABEL " << (int) offset << " #" << (int) numLabels << ::std::endl;
    labels->setBit(offset,true);
    numLabels++;
}

struct LabelOffsetVisitor : public BitSet::Visitor {
    LabelOffsetVisitor(U_32* l) : labelOffset(l) {}
    void visit(U_32 elem) {*labelOffset++ = elem;}
    U_32* labelOffset;
};


// called to indicate end of parsing
void JavaLabelPrepass::parseDone() {
    labelOffsets = new (memManager) U_32[numLabels];
    struct LabelOffsetVisitor avisitor(labelOffsets);
    labels->visitElems(avisitor);
    if (Log::isEnabled()) Log::out() << ::std::endl << "================= PREPASS IS FINISHED =================" << ::std::endl << ::std::endl;
}

U_32 JavaLabelPrepass::getLabelId(U_32 offset) {
    if (numLabels == 0)
        return (U_32) -1;
    U_32 lo = 0;
    U_32 hi = numLabels-1;
    if (offset > labelOffsets[hi] || offset < labelOffsets[lo])
        // not in this set
        return (U_32) -1;
    while (hi-lo > 4) {
        U_32 mid = lo + ((hi-lo) >> 1);
        if (offset < labelOffsets[mid]) 
            hi = mid;
        else
            lo = mid;
    }
    // hi-lo <= 4
    while (lo <= hi) {
        if (labelOffsets[lo] == offset)
            return lo;
        lo++;
    }
    return (U_32) -1;
}

VariableIncarnation* JavaLabelPrepass::getVarInc(U_32 offset, U_32 index)
{
    int numStack = methodDesc.getMaxStack()+1;
    U_32 key = offset*(numVars+numStack)+index;
    StlHashMap<U_32,VariableIncarnation*>::iterator iter = localVars.find(key);
    if (iter==localVars.end()) return NULL;
    return (*iter).second;
}

VariableIncarnation* JavaLabelPrepass::getOrCreateVarInc(U_32 offset, U_32 index, Type* type)
{
    int numStack = methodDesc.getMaxStack()+1;
    U_32 key = offset*(numVars+numStack)+index;
    StlHashMap<U_32,VariableIncarnation*>::iterator iter = localVars.find(key);
    VariableIncarnation* var;
    if (iter==localVars.end()) {
        var = new(memManager) VariableIncarnation(offset, type);
        localVars[key] = var;
    } else {
        var = (*iter).second;
    }
    return var;
}

void JavaLabelPrepass::createMultipleDefVarOpnds(IRBuilder* irBuilder)
{
    StlHashMap<U_32,VariableIncarnation*>::iterator iter;
    for(iter = localVars.begin(); iter!=localVars.end(); ++iter) {
        VariableIncarnation* var = (*iter).second;
        var->createMultipleDefVarOpnd(irBuilder);
    }
}

//
// stack operations
//

StateInfo::SlotInfo&   JavaLabelPrepass::topType() {
    return stateInfo.stack[stateInfo.stackDepth-1];
}

StateInfo::SlotInfo& JavaLabelPrepass::popType() {
    StateInfo::SlotInfo& top = stateInfo.stack[--stateInfo.stackDepth];
    assert (stateInfo.stackDepth >= numVars);
    return top;
}

void    JavaLabelPrepass::popAndCheck(Type *type) {
    StateInfo::SlotInfo& top = popType();
    if( !(top.type == type) )
        assert(0);
}

void    JavaLabelPrepass::popAndCheck(JavaVarType type) {
    StateInfo::SlotInfo& top = popType();
    if(!(top.type && getJavaType(top.type) == type))
        assert(0);
}

void    JavaLabelPrepass::pushType(Type *type) {
    stateInfo.push(type);
}


void    JavaLabelPrepass::pushType(Type *type, U_32 varNumber) {
    stateInfo.push(type).setVarNumber(varNumber);
}


void    JavaLabelPrepass::pushType(StateInfo::SlotInfo& slot) {
    stateInfo.stack[stateInfo.stackDepth++] = slot;
    stateInfo.stack[stateInfo.stackDepth-1].jsrLabelOffset = 0;
}


void JavaLabelPrepass::setStackVars() {
    if(Log::isEnabled()) {
        Log::out() << "SET STACK VARS:" << ::std::endl;
    }

    for (unsigned i=numVars; i < stateInfo.stackDepth; i++) {
        struct StateInfo::SlotInfo* slot = &stateInfo.stack[i];

        if(Log::isEnabled()) {
            Log::out() << "SLOT " << i << ":" << ::std::endl;
            StateInfo::print(*slot, Log::out());
            Log::out() << ::std::endl;
        }

        Type* type = slot->type;
        assert(type);
        SlotVar* sv = slot->vars;
        VariableIncarnation* var = getOrCreateVarInc(currentOffset, i, type);

        // Do not merge stack vars of incompatible types
        if (sv) {
            assert(sv->getVarIncarnation()->getDeclaredType());
            assert(var->getDeclaredType());
            UNUSED Type* commonType = typeManager.getCommonType(sv->getVarIncarnation()->getDeclaredType(),var->getDeclaredType());
            assert(commonType);
            VariableIncarnation::linkAndMergeIncarnations(sv->getVarIncarnation(),var,&typeManager);
            var->setMultipleDefs();
        } else {
            slot->vars = new (memManager) SlotVar(var);
        }

        if(Log::isEnabled()) {
            Log::out() << "AFTER" << ::std::endl;
            StateInfo::print(*slot, Log::out());
            Log::out() << ::std::endl;
        }
    }
    if(Log::isEnabled()) {
        Log::out() << "SET STACK VARS DONE." << ::std::endl;
    }
}


void JavaLabelPrepass::parseError() {
}


//
// branches
//

void JavaLabelPrepass::checkTargetForRestart(U_32 target) {
    // If the target of a branch has been visited, but has no state info, then we
    // will not merge information such as variable incarnations from that first visit
    // with the information from the current branch.
    // Here we try to catch this and then force a revisit to merge the old information in
    if (bytecodevisited->getBit(target) && !stateTable->getStateInfo(target)) {
        // For now let's begin again from the start and hope it propagates to the target
        pushRestart(0);
        getVisited()->clear();

    }
}

void JavaLabelPrepass::propagateStateInfo(U_32 offset, bool isFallThru) {
    setLabel(offset);
    stateTable->setStateInfo(&stateInfo,offset,isFallThru);
}


void JavaLabelPrepass::ifeq(U_32 targetOffset,U_32 nextOffset) {
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::ifne(U_32 targetOffset,U_32 nextOffset) {
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::iflt(U_32 targetOffset,U_32 nextOffset) {
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::ifge(U_32 targetOffset,U_32 nextOffset) {
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::ifgt(U_32 targetOffset,U_32 nextOffset) {
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::ifle(U_32 targetOffset,U_32 nextOffset) {
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::if_icmpeq(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(int32Type); 
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::if_icmpne(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(int32Type); 
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::if_icmplt(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(int32Type); 
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::if_icmpge(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(int32Type); 
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::if_icmpgt(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(int32Type); 
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::if_icmple(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(int32Type); 
    popAndCheck(int32Type);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::if_acmpeq(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(A);
    popAndCheck(A);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::if_acmpne(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(A);
    popAndCheck(A);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::ifnull(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(A);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::ifnonnull(U_32 targetOffset,U_32 nextOffset)    {
    popAndCheck(A);
    setStackVars();
    checkTargetForRestart(targetOffset);
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    setLabel(nextOffset);
    isFallThruLabel = targetOffset > nextOffset;
}
void JavaLabelPrepass::goto_(U_32 targetOffset,U_32 nextOffset)        {
    setStackVars();
    checkTargetForRestart(targetOffset);
    propagateStateInfo(targetOffset,false);
}

//
// returns
//
void JavaLabelPrepass::ireturn(U_32 off) {popAndCheck(int32Type); }
void JavaLabelPrepass::lreturn(U_32 off) {popAndCheck(int64Type); }
void JavaLabelPrepass::freturn(U_32 off) {popAndCheck(singleType);}
void JavaLabelPrepass::dreturn(U_32 off) {popAndCheck(doubleType);}
void JavaLabelPrepass::areturn(U_32 off) {popAndCheck(A);         }
void JavaLabelPrepass::return_(U_32 off) {                        }

//
// jsr/ret
//
void JavaLabelPrepass::jsr(U_32 targetOffset, U_32 nextOffset) {
    stateTable->createStateInfo(targetOffset)->setSubroutineEntry();
    setSubroutineEntry(targetOffset);
    hasJsrLabels = true;
    setStackVars();
    // propagate state info on both ways
    propagateStateInfo(targetOffset,false);
    propagateStateInfo(nextOffset,false);

    // store information for filling slot->jsrNextOffset
    // (in case the slot is a returnAddress)
    //
    jsrEntriesMap.insert(std::make_pair(targetOffset,nextOffset));

    getVisited()->setBit(targetOffset,false);
}
void JavaLabelPrepass::ret(uint16 varIndex, const U_8* byteCodes) { 
    StateInfo::SlotInfo *slot = &stateInfo.stack[varIndex];
    VariableIncarnation* var = slot->vars->getVarIncarnation();
    assert(var);
    var->setMultipleDefs();
    setStackVars();
    U_32 subEntryOffset = slot->jsrLabelOffset;
    stateInfo.cleanFinallyInfo(subEntryOffset);
    assert(retToSubEntryMap.find(currentOffset) == retToSubEntryMap.end() ||
        retToSubEntryMap[currentOffset] == subEntryOffset);
    retToSubEntryMap[currentOffset] = subEntryOffset;
    JsrEntriesMapCIterRange sub_entry_range = jsrEntriesMap.equal_range(subEntryOffset);
    JsrEntryToJsrNextMap::const_iterator iter;
    for (iter = sub_entry_range.first; iter != sub_entry_range.second; iter++) {
        assert((*iter).first == subEntryOffset);
        U_32 jsrNextOffset = (*iter).second;

        // according to JVM Spec:
        //      When executing the ret instruction, which implements a
        //      return from a subroutine, there must be only one possible
        //      subroutine from which the instruction can be returning. Two
        //      different subroutines cannot "merge" their execution to a
        //      single ret instruction.
        //
        // propagating new objects created in finally section 
        //      to the instruction that follows the JSR
        //
        stateTable->setStateInfoFromFinally(&stateInfo, jsrNextOffset);
        labelStack->push((U_8*)byteCodes + jsrNextOffset);
    }
}

//
// switches
//
void JavaLabelPrepass::tableswitch(JavaSwitchTargetsIter* iter) {
    popAndCheck(int32Type);
    setStackVars();
    while (iter->hasNext()) 
        propagateStateInfo(iter->getNextTarget(),false);
    propagateStateInfo(iter->getDefaultTarget(),false);
}

void JavaLabelPrepass::lookupswitch(JavaLookupSwitchTargetsIter* iter) {
    popAndCheck(int32Type);
    setStackVars();
    U_32 dummy;
    while (iter->hasNext()) 
        propagateStateInfo(iter->getNextTarget(&dummy),false);
    propagateStateInfo(iter->getDefaultTarget(),false);
}


//
// remaining instructions
//

void JavaLabelPrepass::nop()                               {}
void JavaLabelPrepass::aconst_null()                       { pushType(typeManager.getNullObjectType()); }
void JavaLabelPrepass::iconst(I_32 val)                   { pushType(int32Type); }
void JavaLabelPrepass::lconst(int64 val)                   { pushType(int64Type); }
void JavaLabelPrepass::fconst(float val)                   { pushType(singleType); }
void JavaLabelPrepass::dconst(double val)                  { pushType(doubleType); }
void JavaLabelPrepass::bipush(I_8 val)                    { pushType(int32Type); }
void JavaLabelPrepass::sipush(int16 val)                   { pushType(int32Type); }

void JavaLabelPrepass::iload(uint16 varIndex)              { genLoad(int32Type,varIndex); }
void JavaLabelPrepass::lload(uint16 varIndex)              { genLoad(int64Type,varIndex); }
void JavaLabelPrepass::fload(uint16 varIndex)              { genLoad(singleType,varIndex); }
void JavaLabelPrepass::dload(uint16 varIndex)              { genLoad(doubleType,varIndex); }
void JavaLabelPrepass::aload(uint16 varIndex)              { genTypeLoad(varIndex); }

void JavaLabelPrepass::istore(uint16 varIndex,U_32 off)  { genStore(int32Type,varIndex,off); }
void JavaLabelPrepass::lstore(uint16 varIndex,U_32 off)  { genStore(int64Type,varIndex,off); }
void JavaLabelPrepass::fstore(uint16 varIndex,U_32 off)  { genStore(singleType,varIndex,off); }
void JavaLabelPrepass::dstore(uint16 varIndex,U_32 off)  { genStore(doubleType,varIndex,off); }
void JavaLabelPrepass::astore(uint16 varIndex,U_32 off)  { genTypeStore(varIndex,off); }

void JavaLabelPrepass::iaload()                            { genArrayLoad(int32Type); }
void JavaLabelPrepass::laload()                            { genArrayLoad(int64Type); }
void JavaLabelPrepass::faload()                            { genArrayLoad(singleType); }
void JavaLabelPrepass::daload()                            { genArrayLoad(doubleType); }
void JavaLabelPrepass::aaload()                            { genTypeArrayLoad(); }
void JavaLabelPrepass::baload()                            { genArrayLoad(int32Type); }
void JavaLabelPrepass::caload()                            { genArrayLoad(int32Type); }
void JavaLabelPrepass::saload()                            { genArrayLoad(int32Type); }

void JavaLabelPrepass::iastore()                           { genArrayStore(int32Type);}
void JavaLabelPrepass::lastore()                           { genArrayStore(int64Type);}
void JavaLabelPrepass::fastore()                           { genArrayStore(singleType);}
void JavaLabelPrepass::dastore()                           { genArrayStore(doubleType);}
void JavaLabelPrepass::aastore()                           { genTypeArrayStore();}
void JavaLabelPrepass::bastore()                           { genArrayStore(int32Type);}
void JavaLabelPrepass::castore()                           { genArrayStore(int32Type);}
void JavaLabelPrepass::sastore()                           { genArrayStore(int32Type);}

void JavaLabelPrepass::iadd()                              { genBinary(int32Type); }
void JavaLabelPrepass::ladd()                              { genBinary(int64Type); }
void JavaLabelPrepass::fadd()                              { genBinary(singleType); }
void JavaLabelPrepass::dadd()                              { genBinary(doubleType); }
void JavaLabelPrepass::isub()                              { genBinary(int32Type); }
void JavaLabelPrepass::lsub()                              { genBinary(int64Type); }
void JavaLabelPrepass::fsub()                              { genBinary(singleType); }
void JavaLabelPrepass::dsub()                              { genBinary(doubleType); }
void JavaLabelPrepass::imul()                              { genBinary(int32Type); }
void JavaLabelPrepass::lmul()                              { genBinary(int64Type); }
void JavaLabelPrepass::fmul()                              { genBinary(singleType); }
void JavaLabelPrepass::dmul()                              { genBinary(doubleType); }
void JavaLabelPrepass::idiv()                              { genBinary(int32Type); }
void JavaLabelPrepass::ldiv()                              { genBinary(int64Type); }
void JavaLabelPrepass::fdiv()                              { genBinary(singleType); }
void JavaLabelPrepass::ddiv()                              { genBinary(doubleType); }
void JavaLabelPrepass::irem()                              { genBinary(int32Type); }
void JavaLabelPrepass::lrem()                              { genBinary(int64Type); }
void JavaLabelPrepass::frem()                              { genBinary(singleType); }
void JavaLabelPrepass::drem()                              { genBinary(doubleType); }
void JavaLabelPrepass::ineg()                              { genUnary (int32Type); }
void JavaLabelPrepass::lneg()                              { genUnary (int64Type); }
void JavaLabelPrepass::fneg()                              { genUnary (singleType); }
void JavaLabelPrepass::dneg()                              { genUnary (doubleType); }
void JavaLabelPrepass::ishl()                              { genShift (int32Type); }
void JavaLabelPrepass::lshl()                              { genShift (int64Type); }
void JavaLabelPrepass::ishr()                              { genShift (int32Type); }
void JavaLabelPrepass::lshr()                              { genShift (int64Type); }
void JavaLabelPrepass::iushr()                             { genShift (int32Type); }
void JavaLabelPrepass::lushr()                             { genShift (int64Type); }
void JavaLabelPrepass::iand()                              { genBinary(int32Type); }
void JavaLabelPrepass::land()                              { genBinary(int64Type); }
void JavaLabelPrepass::ior()                               { genBinary(int32Type); }
void JavaLabelPrepass::lor()                               { genBinary(int64Type); }
void JavaLabelPrepass::ixor()                              { genBinary(int32Type); }
void JavaLabelPrepass::lxor()                              { genBinary(int64Type); }
void JavaLabelPrepass::i2l()                               { genConv(int32Type,int64Type); }
void JavaLabelPrepass::i2f()                               { genConv(int32Type,singleType); }
void JavaLabelPrepass::i2d()                               { genConv(int32Type,doubleType); }
void JavaLabelPrepass::l2i()                               { genConv(int64Type,int32Type); }
void JavaLabelPrepass::l2f()                               { genConv(int64Type,singleType); }
void JavaLabelPrepass::l2d()                               { genConv(int64Type,doubleType); }
void JavaLabelPrepass::f2i()                               { genConv(singleType,int32Type); }
void JavaLabelPrepass::f2l()                               { genConv(singleType,int64Type); }
void JavaLabelPrepass::f2d()                               { genConv(singleType,doubleType); }
void JavaLabelPrepass::d2i()                               { genConv(doubleType,int32Type); }
void JavaLabelPrepass::d2l()                               { genConv(doubleType,int64Type); }
void JavaLabelPrepass::d2f()                               { genConv(doubleType,singleType); }
void JavaLabelPrepass::i2b()                               { genConv(int32Type,int32Type); }
void JavaLabelPrepass::i2c()                               { genConv(int32Type,int32Type); }
void JavaLabelPrepass::i2s()                               { genConv(int32Type,int32Type); }
void JavaLabelPrepass::lcmp()                              { genCompare(int64Type);}
void JavaLabelPrepass::fcmpl()                             { genCompare(singleType);}
void JavaLabelPrepass::fcmpg()                             { genCompare(singleType);}
void JavaLabelPrepass::dcmpl()                             { genCompare(doubleType);}
void JavaLabelPrepass::dcmpg()                             { genCompare(doubleType);}

void JavaLabelPrepass::new_(U_32 constPoolIndex)         { 
    StateInfo::SlotInfo slot;
    StateInfo::setNonNull(&slot);
    StateInfo::setExactType(&slot);
    
    Type* nType = compilationInterface.getNamedType(methodDesc.getParentHandle(), constPoolIndex, ResolveNewCheck_DoCheck);
    
    assert(nType);
    slot.type = nType;
    slot.vars = NULL;
    jitrino_assert( slot.type);
    pushType(slot);
}

void JavaLabelPrepass::newarray(U_8 etype)                { 
    popAndCheck(int32Type);
    NamedType *elemType = NULL;
    switch (etype) {
    case 4:  elemType = typeManager.getBooleanType(); break;
    case 5:  elemType = typeManager.getCharType();    break;
    case 6:  elemType = typeManager.getSingleType();  break;
    case 7:  elemType = typeManager.getDoubleType();  break;
    case 8:  elemType = typeManager.getInt8Type();    break;
    case 9:  elemType = typeManager.getInt16Type();   break;
    case 10: elemType = typeManager.getInt32Type();   break;
    case 11: elemType = typeManager.getInt64Type();   break;
    default: jitrino_assert( 0);
    }
    StateInfo::SlotInfo slot;
    StateInfo::setNonNull(&slot);
    StateInfo::setExactType(&slot);
    slot.type = typeManager.getArrayType(elemType);
    slot.vars = NULL;
    pushType(slot);
}


void JavaLabelPrepass::anewarray(U_32 constPoolIndex)    { 
    popAndCheck(int32Type); 
    StateInfo::SlotInfo slot;
    StateInfo::setNonNull(&slot);
    StateInfo::setExactType(&slot);

    Type* type = compilationInterface.getNamedType(methodDesc.getParentHandle(), constPoolIndex);
    assert(type);
    slot.type = typeManager.getArrayType(type);
    slot.vars = NULL;
    jitrino_assert( slot.type);
    pushType(slot);
}

void JavaLabelPrepass::arraylength() {
    popAndCheck(A); 
    pushType(int32Type); 
}

void JavaLabelPrepass::athrow() { 
    popAndCheck(A); 
}

void JavaLabelPrepass::checkcast(U_32 constPoolIndex)    { 
    StateInfo::SlotInfo slot = stateInfo.stack[stateInfo.stackDepth - 1];
    if ( (slot.type) &&
         (slot.type->tag == Type::NullObject ) &&
         (slot.vars == NULL) ) {
        return;
    }
    Type* type = compilationInterface.getNamedType(methodDesc.getParentHandle(), constPoolIndex);
    assert(type);
    popAndCheck(A);
    pushType(type);
}

int JavaLabelPrepass::instanceof(const U_8* bcp, U_32 constPoolIndex, U_32 off)   {
    popType();
    pushType(int32Type);
    return 3;  // length of instanceof
}
void JavaLabelPrepass::monitorenter()                      { popAndCheck(A); }
void JavaLabelPrepass::monitorexit()                       { popAndCheck(A); }

void JavaLabelPrepass::iinc(uint16 varIndex,I_32 amount)  { 
    stateInfo.stack[varIndex].vars->getVarIncarnation()->setMultipleDefs();
}

void JavaLabelPrepass::ldc(U_32 constPoolIndex)          {
    // load 32-bit quantity or string from constant pool
    Type* constantType =
                compilationInterface.getConstantType(&methodDesc,constPoolIndex);
    if (constantType->isSystemString() || constantType->isSystemClass()) {
        pushType(constantType);
    } else if (constantType->isInt4()) {
        pushType(int32Type);
    } else if (constantType->isSingle()) {
        pushType(singleType);
    } else {
        jitrino_assert( 0);
    }
}
void JavaLabelPrepass::ldc2(U_32 constPoolIndex)         {
    // load 64-bit quantity from constant pool
    Type* constantType =
                compilationInterface.getConstantType(&methodDesc,constPoolIndex);
    if (constantType->isInt8()) {
        pushType(int64Type);
    } else if (constantType->isDouble()) {
        pushType(doubleType);
    } else {
        jitrino_assert( 0);
    }
}

void JavaLabelPrepass::getstatic(U_32 constPoolIndex)    {
    FieldDesc *fdesc = compilationInterface.getStaticField(methodDesc.getParentHandle(), constPoolIndex, false);
    Type* fieldType = 0;
    if (fdesc && fdesc->isStatic()) {
        fieldType = fdesc->getFieldType();
    }
    if (!fieldType){
        fieldType = compilationInterface.getFieldType(methodDesc.getParentHandle(), constPoolIndex);
     }
    assert(fieldType);
    pushType(typeManager.toInternalType(fieldType));
}

void JavaLabelPrepass::putstatic(U_32 constPoolIndex)    {
    FieldDesc *fdesc = compilationInterface.getStaticField(methodDesc.getParentHandle(), constPoolIndex, true);
    Type* fieldType = fdesc ? fdesc->getFieldType() : NULL;
    if (fieldType){
        popAndCheck(getJavaType(fieldType));
    } else {
        // lazy resolution mode or
        // throwing respective exception helper will be inserted at the Translator
       popType();
    } 
}

void JavaLabelPrepass::getfield(U_32 constPoolIndex)     {
    popAndCheck(A);//obj
    FieldDesc *fdesc = compilationInterface.getNonStaticField(methodDesc.getParentHandle(), constPoolIndex, false);
    Type* fieldType = NULL;
    if (fdesc) {
        fieldType = fdesc->getFieldType();
    }
    if (!fieldType){
        fieldType = compilationInterface.getFieldType(methodDesc.getParentHandle(), constPoolIndex);
    }
    assert(fieldType);
    pushType(typeManager.toInternalType(fieldType));
}

void JavaLabelPrepass::putfield(U_32 constPoolIndex)     {
    FieldDesc *fdesc = compilationInterface.getNonStaticField(methodDesc.getParentHandle(), constPoolIndex, true);
    Type* fieldType = fdesc ? fdesc->getFieldType() : NULL;
    if (fieldType){
        popAndCheck(getJavaType(fieldType));
    } else {
        // throwing respective exception helper will be inserted at the Translator
        // TODO: why not check types for lazy-resolve mode?
        popType();
    }
    popAndCheck(A);
}

void JavaLabelPrepass::invokevirtual(U_32 constPoolIndex){
    MethodDesc *mdesc = compilationInterface.getVirtualMethod(methodDesc.getParentHandle(), constPoolIndex);
    if (mdesc) {// resolution was successful
        invoke(mdesc);
    } else {    // exception happens during resolving/linking
        const char* methodSig_string = methodSignatureString(constPoolIndex);
        popType(); // is not static
        pseudoInvoke(methodSig_string);
    }
}

void JavaLabelPrepass::invokespecial(U_32 constPoolIndex){
    MethodDesc* mdesc = compilationInterface.getSpecialMethod(methodDesc.getParentHandle(),constPoolIndex);
    if (mdesc) {// resolution was successful
        invoke(mdesc);
    } else {    
        // exception happens during resolving/linking or lazy resolution mode
        const char* methodSig_string = methodSignatureString(constPoolIndex);
        popType(); // is not static
        pseudoInvoke(methodSig_string);
    }
}
void JavaLabelPrepass::invokestatic(U_32 constPoolIndex) {
    MethodDesc *mdesc = compilationInterface.getStaticMethod(methodDesc.getParentHandle(), constPoolIndex);
    if (mdesc) {// resolution was successful
        invoke(mdesc);
    } else {    // exception happens during resolving/linking
        const char* methodSig_string = methodSignatureString(constPoolIndex);
        pseudoInvoke(methodSig_string);
    }
}
void JavaLabelPrepass::invokeinterface(U_32 constPoolIndex,U_32 count) {
    MethodDesc *mdesc = compilationInterface.getInterfaceMethod(methodDesc.getParentHandle(), constPoolIndex);
    if (mdesc) {// resolution was successful
        invoke(mdesc);
    } else {    // exception happens during resolving/linking
        const char* methodSig_string = methodSignatureString(constPoolIndex);
        popType(); // is not static
        pseudoInvoke(methodSig_string);
    }
}
void JavaLabelPrepass::multianewarray(U_32 constPoolIndex,U_8 dimensions) {
    for (int i =0; i < dimensions; i++) {
        popAndCheck(int32Type);
    }
    Type *type = compilationInterface.getNamedType(methodDesc.getParentHandle(), constPoolIndex);
    jitrino_assert(type);
    pushType(type);
}

void JavaLabelPrepass::pseudoInvoke(const char* methodSig) {

    assert(methodSig);
    U_32 numArgs = getNumArgsBySignature(methodSig); 

    // pop numArgs items
    for (int i=numArgs-1; i>=0; i--)
        popType();

    // recognize and push respective returnType
    Type* retType = getRetTypeBySignature(compilationInterface, methodDesc.getParentHandle(), methodSig);
    assert(retType);

    // push the return type
    if (retType->tag != Type::Void) {
        pushType(typeManager.toInternalType(retType));
    }
}

U_32 JavaLabelPrepass::getNumArgsBySignature(const char* methodSig) 
{
    assert(methodSig);
    assert(*methodSig == '(');
    U_32 numArgs = 0; 

    // start just after '(' and go until ')' counting 'numArgs' 
    for(++methodSig ;*methodSig != ')'; methodSig++) {
        switch( *methodSig ) 
        {
        case 'L':
            // skip class name
            while( *(++methodSig) != ';' ) assert(*methodSig);
        case 'B':
        case 'C':
        case 'D':
        case 'F':
        case 'I':
        case 'J':
        case 'S':
        case 'Z':
            numArgs++;
            break;
        case '[': // do nothing
            break;
        case '(': // we have started from index = 1
        case ')': // must go out earlier
        case 'V': // 'V' can not be in the argument list
        default:
            assert(0); // impossible! Verifier must check and catch this
            break;
        }
    }
    // the last observed index should point to ')' after getNumArgsBySignature call
    assert(*methodSig == ')');
    
    return numArgs;
}

Type* JavaLabelPrepass::getRetTypeBySignature(CompilationInterface& ci, Class_Handle enclClass, const char* origSig) 
{
    assert(*origSig== '(' || *origSig == ')');
    while( *(origSig++) != ')' ); 

    U_32 stub=0;
    return getTypeByDescriptorString(ci, enclClass, origSig, stub);
}

Type* JavaLabelPrepass::getTypeByDescriptorString(CompilationInterface& ci, Class_Handle enclClass, const char* descriptorString, U_32& len) {
    U_32 arrayDim = 0;
    len=1;
    Type* resType = NULL;
    // collect array dimension if any
    while( *(descriptorString) == '[' ) {
        arrayDim++;
        descriptorString++;
        len++;
    }

    TypeManager& typeManager = ci.getTypeManager();
    switch( *descriptorString ) 
    {
    case 'L': 
        {
            if (!typeManager.isLazyResolutionMode()) {
                resType = typeManager.getUnresolvedObjectType();
            } else {
                resType = ci.getTypeFromDescriptor(enclClass, descriptorString);
            }
            while( *(++descriptorString) != ';' ) {
                len++;
                assert(*descriptorString);
            }
            len++; //';' char
        }
        break;
    case 'B':
        resType = typeManager.getInt8Type();
        break;
    case 'C':
        resType = typeManager.getCharType();
        break;
    case 'D':
        resType = typeManager.getDoubleType();
        break;
    case 'F':
        resType = typeManager.getSingleType();
        break;
    case 'I':
        resType = typeManager.getInt32Type();
        break;
    case 'J':
        resType = typeManager.getInt64Type();
        break;
    case 'S':
        resType = typeManager.getInt16Type();
        break;
    case 'Z':
        resType = typeManager.getBooleanType();
        break;
    case 'V':
        resType = typeManager.getVoidType();
        break; // leave stack as is
    case '[': // all '[' are already skipped
    case '(': // we have already pass it
    case ')': // we have just leave it back
    default: // impossible! Verifier must check and catch this
        assert(0);
        resType = typeManager.getUnresolvedObjectType();
        break;
    }
    assert(resType);

    if (arrayDim > 0) {
        for (;arrayDim > 0; arrayDim--) {
            resType = typeManager.getArrayType(resType, false);
        }
    }
    return resType;
}

void JavaLabelPrepass::invoke(MethodDesc* methodDesc) {
    // pop source operands
    for (int i = methodDesc->getNumParams()-1; i>=0; i--)
        popType();
    Type* type = methodDesc->getReturnType();
    // push the return type
    if (type) {
        if ( type->tag != Type::Void ) {
            pushType(typeManager.toInternalType(type));
        }
    } else {
        // type == NULL means that the returnType was not resolved successfully
        // but it can be resolved later inside the callee (with some "magic" custom class loader for example)
        // Or respective exception will be thrown there (in the callee) at the attempt to create (new)
        // an object of unresolved type
        pushType(typeManager.getNullObjectType());
    }
}


void JavaLabelPrepass::pop()                               { popType(); }

void JavaLabelPrepass::pop2() {
    StateInfo::SlotInfo& type = popType();
    if (isCategory2(type))
        return;
    popType();
}

void JavaLabelPrepass::dup() {
    pushType(topType());
}

void JavaLabelPrepass::dup_x1() {
    StateInfo::SlotInfo opnd1 = popType();
    StateInfo::SlotInfo opnd2 = popType();
    pushType(opnd1);
    pushType(opnd2);
    pushType(opnd1);
}

void JavaLabelPrepass::dup_x2() {
    StateInfo::SlotInfo opnd1 = popType();
    StateInfo::SlotInfo opnd2 = popType();
    if (isCategory2(opnd2)) {
        pushType(opnd1);
        pushType(opnd2);
        pushType(opnd1);
        return;
    }
    StateInfo::SlotInfo opnd3 = popType();
    pushType(opnd1);
    pushType(opnd3);
    pushType(opnd2);
    pushType(opnd1);
}

void JavaLabelPrepass::dup2() {
    StateInfo::SlotInfo opnd1 = popType();
    if (isCategory2(opnd1)) {
        pushType(opnd1);
        pushType(opnd1);
        return;
    }
    StateInfo::SlotInfo opnd2 = popType();
    pushType(opnd2);
    pushType(opnd1);
    pushType(opnd2);
    pushType(opnd1);
}

void JavaLabelPrepass::dup2_x1() {
    StateInfo::SlotInfo opnd1 = popType();
    StateInfo::SlotInfo opnd2 = popType();
    if (isCategory2(opnd1)) {
        // opnd1 is a category 2 instruction
        pushType(opnd1);
        pushType(opnd2);
        pushType(opnd1);
    } else {
        // opnd1 is a category 1 instruction
        StateInfo::SlotInfo opnd3 = popType();
        pushType(opnd2);
        pushType(opnd1);
        pushType(opnd3);
        pushType(opnd2);
        pushType(opnd1);
    }
}


void JavaLabelPrepass::dup2_x2() {
    StateInfo::SlotInfo opnd1 = popType();
    StateInfo::SlotInfo opnd2 = popType();
    if (isCategory2(opnd1)) {
        // opnd1 is category 2
        if (isCategory2(opnd2)) {
            pushType(opnd1);
            pushType(opnd2);
            pushType(opnd1);
        } else {
            // opnd2 is category 1
            StateInfo::SlotInfo opnd3 = popType();
            assert(isCategory2(opnd3) == false);
            pushType(opnd1);
            pushType(opnd3);
            pushType(opnd2);
            pushType(opnd1);
        }
    } else {
        assert(isCategory2(opnd2) == false);
        // both opnd1 & opnd2 are category 1
        StateInfo::SlotInfo opnd3 = popType();
        if (isCategory2(opnd3)) {
            pushType(opnd2);
            pushType(opnd1);
            pushType(opnd3);
            pushType(opnd2);
            pushType(opnd1);
        } else {
            // opnd1, opnd2, opnd3 all are category 1
            StateInfo::SlotInfo opnd4 = popType();
            assert(isCategory2(opnd4) == false);
            pushType(opnd2);
            pushType(opnd1);
            pushType(opnd4);
            pushType(opnd3);
            pushType(opnd2);
            pushType(opnd1);
        }
    }
}

void JavaLabelPrepass::swap() {
    StateInfo::SlotInfo opnd1 = popType();
    StateInfo::SlotInfo opnd2 = popType();
    pushType(opnd1);
    pushType(opnd2);
}


///////////////////////////////////////////////////////////////////////////////
// Helper methods
///////////////////////////////////////////////////////////////////////////////

void JavaLabelPrepass::genReturn(Type *type) {
}

void JavaLabelPrepass::genStore(Type *type, U_32 index, U_32 offset) {
    stateInfo.stack[index].jsrLabelOffset = stateInfo.stack[stateInfo.stackDepth-1].jsrLabelOffset;
    popAndCheck(type);
    stateInfo.stack[index].type     = type;
    stateInfo.stack[index].slotFlags= 0;
    stateInfo.stack[index].vars = new (memManager) SlotVar(getOrCreateVarInc(offset, index, type));
    propagateLocalVarToHandlers(index);
}

void JavaLabelPrepass::genTypeStore(U_32 index, U_32 offset) {
    StateInfo::SlotInfo& slot = popType();
    Type *type = slot.type;
    stateInfo.stack[index].type     = type;
    stateInfo.stack[index].slotFlags= slot.slotFlags;
    VariableIncarnation* offset_varinc = getOrCreateVarInc(offset, index, type);
    offset_varinc->setDeclaredType(typeManager.getCommonType(type, offset_varinc->getDeclaredType()));
    stateInfo.stack[index].vars = new (memManager) SlotVar(offset_varinc);
    if(Log::isEnabled()) {
        Log::out() << "genTypeStore: offset=" << offset 
                   << " index=" << index
                   << " vars: ";
        stateInfo.stack[index].vars->print(Log::out());
        Log::out() << ::std::endl;
    }
    stateInfo.stack[index].jsrLabelOffset = slot.jsrLabelOffset;
    propagateLocalVarToHandlers(index);
}

void JavaLabelPrepass::genLoad(Type *type, U_32 index) {
    assert(stateInfo.stack[index].type == type);
    pushType(type,index);
    stateInfo.stack[stateInfo.stackDepth-1].jsrLabelOffset = stateInfo.stack[index].jsrLabelOffset;
    SlotVar* vars = stateInfo.stack[index].vars;
    if (vars) {
        vars->mergeVarIncarnations(&typeManager);
    }
}

void JavaLabelPrepass::genTypeLoad(U_32 index) {
    Type *type = stateInfo.stack[index].type;
    SlotVar* vars = stateInfo.stack[index].vars;
    if (vars) {
        vars->mergeVarIncarnations(&typeManager);
        type = vars->getVarIncarnation()->getDeclaredType();
    }
    pushType(type,index);
    stateInfo.stack[stateInfo.stackDepth-1].jsrLabelOffset = stateInfo.stack[index].jsrLabelOffset;
}

void JavaLabelPrepass::genArrayLoad (Type *type) {
    popAndCheck(int32Type);
    popAndCheck(A);
    pushType(type);
}


void JavaLabelPrepass::genTypeArrayLoad() {
    popAndCheck(int32Type);
    Type* type = popType().type;
    assert(type->isArrayType() || type->isNullObject() || type->isUnresolvedObject());
    if(type->isArrayType()) {
        type = ((ArrayType*)type)->getElementType();
    }
    pushType(type);
}

void JavaLabelPrepass::genArrayStore(Type *type) {
    popAndCheck(type);
    popAndCheck(int32Type);
    type = popType().type;
    assert(type->isArrayType() || type->isNullObject());
}

void JavaLabelPrepass::genTypeArrayStore() {
    popType();
    popAndCheck(int32Type);
    UNUSED Type *type = popType().type;
    assert(type->isArrayType() || type->isNullObject() || type->isUnresolvedObject());
}

void JavaLabelPrepass::genBinary    (Type *type) {
    popAndCheck(type);
    popAndCheck(type);
    pushType(type);
}

void JavaLabelPrepass::genUnary     (Type *type) {
    popAndCheck(type);
    pushType(type);
}

void JavaLabelPrepass::genShift     (Type *type) {
    popAndCheck(int32Type);
    popAndCheck(type);
    pushType(type);
}

void JavaLabelPrepass::genConv      (Type *from, Type *to) {
    popAndCheck(from);
    pushType(to);
}

void JavaLabelPrepass::genCompare   (Type *type) {
    popAndCheck(type);
    popAndCheck(type);
    pushType(int32Type);
}


const char*     JavaLabelPrepass::methodSignatureString(U_32 cpIndex) {
    return compilationInterface.getSignatureString(&methodDesc,cpIndex);
}

void StateTable::copySlotInfo(StateInfo::SlotInfo& to, StateInfo::SlotInfo& from) {
    to.jsrLabelOffset = from.jsrLabelOffset;
    to.slotFlags = from.slotFlags;
    to.type = from.type;
    to.varNumber = from.varNumber;
    to.vars = from.vars ? new (memManager) SlotVar(from.vars, memManager) : NULL;
}

void  StateTable::setStateInfo(StateInfo *inState, U_32 offset, bool isFallThru, bool varsOnly) {
    if(Log::isEnabled()) {
        Log::out() << "SETSTATE offset=" <<(int)offset << " depth=" << inState->stackDepth << ::std::endl;
        printState(inState);
    }

    StateInfo *state = hashtable[offset];
    if (state == NULL) {
        state = new (memManager) StateInfo();
        hashtable[offset] = state;
        if (isFallThru)
            state->setFallThroughLabel();
    } else if (!isFallThru)
        state->clearFallThroughLabel();
    assert(getStateInfo(offset) != NULL);

    setStackInfo(inState, offset, true, !varsOnly);
    if (!state->isVisited() ) {
        state->setVisited();
    
        for ( JavaLabelPrepass::ExceptionTable::const_iterator it = prepass.getExceptionTable().begin(),
              end = prepass.getExceptionTable().end(); it != end; ++it ) {

            CatchBlock* except = *it;
            if ( except->hasOffset(offset) ) {
                if (Log::isEnabled()) Log::out() << "try-region begin=" << (int)except->getBeginOffset() 
                                     << " end=" << (int)except->getEndOffset() << ::std::endl;
                ExceptionInfo *prev = state->exceptionInfo;
                bool found  = false;
                for (ExceptionInfo *exc = state->exceptionInfo; 
                     exc != NULL; 
                     exc = exc->getNextExceptionInfoAtOffset()) {                       

                    //
                    // Although exceptionInfo at this offset is built for the first time,
                    // we can find that this part of list was build for another offset.
                    // So, we should not build CatchBlock-chain any more. Note, this only works
                    // for properly nested CatchBlocks
                    //
                    if ( exc->isCatchBlock() && exc->getId() == except->getId() ) {
                        found = true;
                        break;
                    }
                    prev = exc;
                }
                if (!found) {
                    if (prev == NULL)   {
                        state->exceptionInfo = except;
                    } else {
                        prev->setNextExceptionInfoAtOffset(except);
                    }
                }
            }
        }
    }
}

void  StateTable::setStackInfo(StateInfo *inState, U_32 offset, bool includeVars, bool includeStack)
{
    if (Log::isEnabled()) Log::out() << "SETSTACK " << includeVars << ", " << includeStack << ::std::endl;
    unsigned stackDepth = inState->stackDepth;
    if (stackDepth > 0) {
        StateInfo *state = hashtable[offset];
        assert(state);
        unsigned from = includeVars ? 0 : numVars;
        unsigned to = includeStack ? stackDepth : numVars;
        if (maxDepth < stackDepth) maxDepth = stackDepth;
        if (Log::isEnabled()) Log::out() << "MAXDEPTH " << maxDepth << ::std::endl;
        StateInfo::SlotInfo *stack = state->stack;
        if (stack == NULL) {
            if (Log::isEnabled()) Log::out() << "NEWSTACK" << ::std::endl;
            stack = new (memManager) StateInfo::SlotInfo[stackDepth+1];
            state->stack = stack;
            for (unsigned i = from; i < to; i++) {
                copySlotInfo(stack[i], inState->stack[i]);
            }
            state->stackDepth = to;
        } else { // needs to merge the states
            if(Log::isEnabled()) {
                Log::out() << " before\n";
                printState(state);
            }
            for (unsigned i = from; i < to; i++) {
                struct StateInfo::SlotInfo *inSlot = &inState->stack[i];
                struct StateInfo::SlotInfo *slot   = &stack[i];
                if(Log::isEnabled()) {
                    Log::out() << "    i = " << i << ::std::endl;
                    Log::out() << "            inSlot: ";StateInfo::print(*inSlot, Log::out());Log::out() << ::std::endl;
                    Log::out() << "            slot:   ";StateInfo::print(*slot, Log::out());Log::out() << ::std::endl;
                }
                if(i < state->stackDepth) {
                    mergeSlots(inSlot, slot, offset, i < (unsigned)numVars);
                } else { // inState has more slots. Additional ones should not be merged.
                    rewriteSlots(inSlot, slot, offset, i < (unsigned)numVars);
                }
            }
            if(includeStack) {
                assert(state->stackDepth <= stackDepth);
                if(state->stackDepth < stackDepth) {
                    prepass.getVisited()->setBit(offset,false);
                    state->stackDepth = stackDepth;
                }
            }
        }
        if(Log::isEnabled()) {
            Log::out() << " after\n";
            printState(state);
        }
    }
}

void StateTable::rewriteSlots(StateInfo::SlotInfo* inSlot, StateInfo::SlotInfo* slot, U_32 offset, bool isVar) {

    Type *intype = inSlot->type;
    slot->type = intype;

    assert(inSlot->vars);
    if(!slot->vars) {
        VariableIncarnation* var_inc = inSlot->vars->getVarIncarnation();
        assert(var_inc);
        slot->vars = new (memManager) SlotVar(var_inc);
    }
    slot->vars->addVarIncarnations(inSlot->vars, memManager, offset);
    if (!isVar) {
         slot->vars->mergeVarIncarnations(&typeManager);
    }

    slot->slotFlags = inSlot->slotFlags;
    slot->jsrLabelOffset = inSlot->jsrLabelOffset;
}

void StateTable::mergeSlots(StateInfo::SlotInfo* inSlot, StateInfo::SlotInfo* slot, U_32 offset, bool isVar) {

    if (!getStateInfo(offset)->isVisited()) {
        if (!slot->type && !slot->vars) {
            copySlotInfo(*slot, *inSlot);
            return;
        } // else it is an node after (next) jsr. The state was propagated here from ret.
    }

    slot->jsrLabelOffset = inSlot->jsrLabelOffset;
    slot->slotFlags = slot->slotFlags & inSlot->slotFlags;

    SlotVar* in_vars = inSlot->vars;
    SlotVar* vars = slot->vars;
    Type *in_type = inSlot->type;
    Type *type = slot->type;

    if (!!in_vars != !!vars) {
        slot->type = NULL;
        slot->vars = NULL;
        if (type) prepass.getVisited()->setBit(offset,false);
        return;
    }

    if ((in_type == NULL) || (type == NULL)) {
        assert(in_vars == NULL);
        assert(vars == NULL);
        slot->type = NULL;
        if (type) prepass.getVisited()->setBit(offset,false);
        return;
    }
    
    Type* new_type = typeManager.getCommonType(in_type,type);
    if (new_type != NULL) {
        if (vars) {
            if(Log::isEnabled()) {
                Log::out() << "addVarIncarnations to SlotVar:" << ::std::endl;
                Log::out() << "   vars:\t";vars->print(Log::out());Log::out() << ::std::endl;
                Log::out() << "in_vars:\t";in_vars->print(Log::out());Log::out() << ::std::endl;
            }
            if (vars->addVarIncarnations(in_vars, memManager, offset)) {
                prepass.getVisited()->setBit(offset,false);
            }
            if (!isVar) {
                 vars->mergeVarIncarnations(&typeManager);
            }
            if(Log::isEnabled()) {
                Log::out() << "result_vars:\t";vars->print(Log::out());Log::out() << ::std::endl;
            }
        }
    } else {
        slot->vars = NULL;
    }
    slot->type = new_type;

    if (type != new_type) {
        prepass.getVisited()->setBit(offset,false);
    }
}


void  StateTable::setStateInfoFromFinally(StateInfo *inState, U_32 offset) {
    if(Log::isEnabled()) {
        Log::out() << "SETSTATE FROM FINALLY offset=" <<(int)offset << " depth=" << inState->stackDepth << ::std::endl;
        printState(inState);
    }
    unsigned stackDepth = inState->stackDepth;
    StateInfo *state = getStateInfo(offset);
    assert(state);
    assert(state->stackDepth <= stackDepth);

    if(state != NULL && Log::isEnabled()) {
        Log::out() << " before\n";
        printState(state);
    }
    if (stackDepth > 0) {
        if (maxDepth < stackDepth) {
            maxDepth = stackDepth;
            if (Log::isEnabled()) Log::out() << "MAXDEPTH " << maxDepth << ::std::endl;
        }
        struct StateInfo::SlotInfo *stack = state->stack;
        state->stackDepth = stackDepth;
        for (unsigned i=0; i < stackDepth; i++) {
            struct StateInfo::SlotInfo *inSlot = &inState->stack[i];
            struct StateInfo::SlotInfo *slot   = &stack[i];
            Type *intype = inSlot->type;
            Type *type  = slot->type;
//            if (Log::isEnabled()) Log::out() << "STACK " << i << ": "<< type << ::std::endl;
            if (!type && intype) {  // don't merge, just rewrite!
                rewriteSlots(inSlot, slot, offset, i < numVars);
                prepass.getVisited()->setBit(offset,false);
            } else if (!intype) {
                continue;
            } else {
                mergeSlots(inSlot, slot, offset, i < numVars);
            }
        }
        if(Log::isEnabled()) {
            Log::out() << " after\n";
            printState(state);
        }
    }
}

void JavaLabelPrepass::print_loc_vars(U_32 offset, U_32 index)
{
    int numStack = methodDesc.getMaxStack()+1;
    U_32 key = offset*(numVars+numStack)+index;
    StlHashMap<U_32,VariableIncarnation*>::iterator iter = localVars.find(key);
    if (iter==localVars.end()) {
        Log::out() << "localVars[offset=" << offset 
                    << "][index=" << index << "] is empty" << ::std::endl;
    } else {
        Log::out() << "localVars[offset=" << offset << "][index=" << index << "].var->declT = "; 
        (*iter).second->getDeclaredType()->print(Log::out()); 
        Log::out() << ::std::endl;
    }
}

void JavaLabelPrepass::propagateLocalVarToHandlers(U_32 varIndex)
{
    assert(varIndex < numVars);
    struct StateInfo::SlotInfo *inSlot = &stateInfo.stack[varIndex];

    for (ExceptionInfo *except = stateInfo.exceptionInfo; 
        except != NULL; 
        except = except->getNextExceptionInfoAtOffset()) {

            if ( except->isCatchBlock() ) {
                CatchBlock* block = (CatchBlock*)except;
                for (CatchHandler* handler = block->getHandlers(); 
                    handler != NULL; 
                    handler = handler->getNextHandler() ) {

                        U_32 handler_offset = handler->getBeginOffset();
                        struct StateInfo::SlotInfo *slot = &stateTable->getStateInfo(handler_offset)->stack[varIndex];
                        if (Log::isEnabled()) Log::out() << "HANDLER SLOT " << varIndex 
                            << " merged to offset " << handler_offset << ::std::endl;
                        stateTable->mergeSlots(inSlot, slot, handler_offset, true);
                    }
            }
        }
}


} //namespace Jitrino