Index: vm/jitrino/src/translator/ExceptionInfo.h =================================================================== --- vm/jitrino/src/translator/ExceptionInfo.h (revision 542415) +++ vm/jitrino/src/translator/ExceptionInfo.h (working copy) @@ -15,18 +15,14 @@ * limitations under the License. */ -/** - * @author Intel, George A. Timoshenko - * @version $Revision: 1.10.24.4 $ - * - */ - #ifndef _EXCEPTIONINFO_H_ #define _EXCEPTIONINFO_H_ namespace Jitrino { class LabelInst; +class CatchBlock; +class Type; class ExceptionInfo { public: @@ -61,31 +57,14 @@ LabelInst* label; }; -class Handler : public ExceptionInfo { +class CatchHandler : public ExceptionInfo { public: - Handler(uint32 id, - uint32 beginOffset, - uint32 endOffset, - ExceptionInfo* _tryBlock) - : ExceptionInfo(id,beginOffset,endOffset), tryBlock(_tryBlock) {} - virtual ~Handler() {} - - uint32 getTryRegionId() {return tryBlock->getId();} - ExceptionInfo* getTryBlock() {return tryBlock;} -private: - ExceptionInfo* tryBlock; -}; - -class CatchBlock; -class Type; - -class CatchHandler : public Handler { -public: CatchHandler(uint32 id, uint32 beginOffset, uint32 endOffset, - CatchBlock* tryBlock, - Type* excType); + Type* excType) + : ExceptionInfo(id, beginOffset, endOffset), + exceptionType(excType), nextHandler(NULL), order(0) {} virtual ~CatchHandler() {} Type* getExceptionType() {return exceptionType;} Index: vm/jitrino/src/translator/java/JavaLabelPrepass.cpp =================================================================== --- vm/jitrino/src/translator/java/JavaLabelPrepass.cpp (revision 542427) +++ vm/jitrino/src/translator/java/JavaLabelPrepass.cpp (working copy) @@ -14,11 +14,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - -/** - * @author Intel, George A. Timoshenko - * @version $Revision: 1.40.12.2.4.4 $ - */ #include #include @@ -32,8 +27,8 @@ namespace Jitrino { -VariableIncarnation::VariableIncarnation(uint32 offset, uint32 block, Type* t) -: definingOffset(offset), definingBlock(block), declaredType(t), opnd(NULL) +VariableIncarnation::VariableIncarnation(uint32 offset, Type* t) +: definingOffset(offset), declaredType(t), opnd(NULL) { _prev = _next = NULL; } @@ -41,14 +36,8 @@ void VariableIncarnation::setMultipleDefs() { definingOffset = -1; - definingBlock = -1; } -void VariableIncarnation::ldBlock(int32 blockNumber) -{ - if (definingBlock!=blockNumber) definingBlock = -1; -} - Type* VariableIncarnation::getDeclaredType() { return declaredType; @@ -147,7 +136,7 @@ out << " (" << tmp << ",DO=" << tmp->definingOffset << ") <-i->"; tmp = (VariableIncarnation*)tmp->_next; } while (tmp); - out << ::std::endl; + //out << ::std::endl; } @@ -159,7 +148,7 @@ out << " (" << cur_var_inc << ",DO=" << cur_var_inc->definingOffset << ",LO=" << linkOffset << ") <->"; tmp = (SlotVar*)tmp->_next; } while (tmp); - out << ::std::endl; + //out << ::std::endl; } @@ -246,34 +235,49 @@ if (definingOffset==-1) createVarOpnd(irBuilder); } -void StateInfo::addExceptionInfo(ExceptionInfo *info) +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) { - if ( !info->isCatchBlock() ) { + 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{ - 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); - } + } else { + info->setNextExceptionInfoAtOffset(prev->getNextExceptionInfoAtOffset()); + prev->setNextExceptionInfoAtOffset(info); } } void StateInfo::cleanFinallyInfo(uint32 offset) { - for (int32 k=0; k < stackDepth; k++) { + for (unsigned k=0; k < stackDepth; k++) { if (stack[k].jsrLabelOffset == offset) { stack[k].jsrLabelOffset = 0; stack[k].type = 0; @@ -299,7 +303,7 @@ enclosingMethod->getHandlerInfo(i,&beginOffset,&endOffset, &handlerOffset,&handlerClassIndex); if (!catchBlock(beginOffset,endOffset-beginOffset, - handlerOffset,0,handlerClassIndex)) + handlerOffset,handlerClassIndex)) { // handlerClass failed to be resolved. LinkingException throwing helper // will be generated instead of method's body @@ -311,22 +315,36 @@ void addHandlerForCatchBlock(CatchBlock* block, uint32 handlerOffset, - uint32 handlerLength, Type* exceptionType) { jitrino_assert( exceptionType); assert(!exceptionType->isUnresolvedType());//must be resolved by verifier - Log::out() << "Catch Exception Type = " << exceptionType->getName() << ::std::endl; + if (Log::isEnabled()) Log::out() << "Catch Exception Type = " << exceptionType->getName() << ::std::endl; + // FIXME can we do with just sole handler per offset, just merging exceptionTypes? CatchHandler* handler = new (memManager) CatchHandler(nextRegionId++, handlerOffset, - handlerOffset+handlerLength, - block, + handlerOffset, exceptionType); block->addHandler(handler); - StateInfo *catchInfo = prepass.stateTable->createStateInfo(handlerOffset); - catchInfo->setCatchLabel(); - catchInfo->addExceptionInfo(handler); + StateInfo *hi = prepass.stateTable->createStateInfo(handlerOffset, true); + 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); + StateInfo::setExactType(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, uint32 offset) @@ -346,16 +364,9 @@ for (CatchHandler* handler = block->getHandlers(); handler != NULL; - handler = handler->getNextHandler() ) { - CatchHandler* newHandler = - new (memManager) CatchHandler(nextRegionId++, - handler->getBeginOffset(), - handler->getEndOffset(), - newBlock, - handler->getExceptionType()); - newBlock->addHandler(newHandler); - assert(prepass.stateTable->getStateInfo(handler->getBeginOffset())); - prepass.stateTable->getStateInfo(handler->getBeginOffset())->addExceptionInfo(newHandler); + handler = handler->getNextHandler() ) + { + addHandlerForCatchBlock(newBlock, handler->getBeginOffset(), handler->getExceptionType()); } return newBlock; } @@ -363,17 +374,16 @@ bool catchBlock(uint32 tryOffset, uint32 tryLength, uint32 handlerOffset, - uint32 handlerLength, uint32 exceptionTypeToken) { - Log::out() << "CatchBlock @ " << (int)tryOffset << "," << (int)tryOffset+(int)tryLength - << " handler @ " << (int)handlerOffset << "," << (int)handlerOffset+(int)handlerLength + if (Log::isEnabled()) Log::out() << "CatchBlock @ " << (int)tryOffset << "," + << (int)tryOffset+(int)tryLength + << " handler @ " << (int)handlerOffset << "," << " exception type " << (int)exceptionTypeToken << "," << " numCatch " << numCatch << ::std::endl; uint32 endOffset = tryOffset + tryLength; prepass.setLabel(handlerOffset); - prepass.setLabel(handlerOffset+handlerLength); prepass.setLabel(tryOffset); prepass.setLabel(endOffset); @@ -392,16 +402,17 @@ //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 - Log::out()<<"WARNING: resolving type from inside of compilation session!!"<getParentHandle(),exceptionTypeToken); } } 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, handlerLength, exceptionType); + addHandlerForCatchBlock(catchBlock, handlerOffset, exceptionType); } else { prepass.stateTable->createStateInfo(tryOffset); // @@ -419,7 +430,7 @@ if ( block->offsetSplits(tryOffset) || block->offsetSplits(endOffset) ) { if ( !unnested_try_regions_found ) { unnested_try_regions_found = true; - Log::out() << "unnested try-regions encountered" << std::endl; + if (Log::isEnabled()) Log::out() << "unnested try-regions encountered" << std::endl; } } assert(tryOffset < endOffset); @@ -442,7 +453,7 @@ new (memManager) CatchBlock(nextRegionId++, tryOffset, endOffset, numCatch++); prepass.stateTable->getStateInfo(tryOffset)->addExceptionInfo(catchBlock); prepass.exceptionTable.push_back(catchBlock); - addHandlerForCatchBlock(catchBlock, handlerOffset, handlerLength, exceptionType); + addHandlerForCatchBlock(catchBlock, handlerOffset, exceptionType); } return 1; // all exceptionTypes are OK } @@ -482,11 +493,11 @@ doubleType= typeManager.getDoubleType(); numLabels = 0; - numVars = methodDesc.getNumVars(); labels = new (memManager) BitSet(memManager,numByteCodes); subroutines = new (memManager) BitSet(memManager,numByteCodes); - int numStack = md.getMaxStack()+1; - stateInfo.stack = new (memManager) struct StateInfo::SlotInfo[numVars+numStack]; + numVars = methodDesc.getNumVars(); + int numStack = methodDesc.getMaxStack()+1; + stateInfo.stack = new (memManager) StateInfo::SlotInfo[numVars+numStack]; stateInfo.stackDepth = numVars; for (uint32 k=0; k < numVars+numStack; k++) { struct StateInfo::SlotInfo *slot = &stateInfo.stack[k]; @@ -498,7 +509,7 @@ blockNumber = 0; labelOffsets = NULL; // exceptions - stateTable = new (memManager) StateTable(memManager,typeManager,*this,20,numVars); + stateTable = new (memManager) StateTable(memManager,typeManager,*this,numStack,numVars); // 1st count number of catch and finally blocks // parse and create exception info @@ -515,8 +526,6 @@ } hasJsrLabels = false; isFallThruLabel = true; - numVars = methodDesc.getNumVars(); - methodDesc.getMaxStack(); uint32 numArgs = methodDesc.getNumParams(); for (uint32 i=0, j=0; itype = typeManager.toInternalType(type); } - slot->vars = new (memManager) SlotVar(getOrCreateVarInc(0, j, slot->type, NULL)); + slot->vars = new (memManager) SlotVar(getOrCreateVarInc(0, j, slot->type)); JavaVarType javaType = getJavaType(type); if (javaType == L || javaType == D) j++; } @@ -552,11 +561,11 @@ } void JavaLabelPrepass::offset(uint32 offset) { - Log::out() << std::endl << "PREPASS OFFSET " << (int32)offset << ", blockNo=" << blockNumber << std::endl; + if (Log::isEnabled()) Log::out() << std::endl << "PREPASS OFFSET " << (int32)offset << ", blockNo=" << blockNumber << std::endl; bytecodevisited->setBit(offset,true); if (offset==0) stateTable->restoreStateInfo(&stateInfo, offset); - if (labels->getBit(offset) == true/* && !visited->getBit(offset)*/) { + if (labels->getBit(offset) == true) { if (linearPassDone) stateTable->restoreStateInfo(&stateInfo, offset); setStackVars(); @@ -565,33 +574,14 @@ propagateStateInfo(offset,isFallThruLabel); isFallThruLabel = true; } - Log::out() << "BASICBLOCK " << (int32)offset << " " << blockNumber << std::endl; + if (Log::isEnabled()) Log::out() << "BASICBLOCK " << (int32)offset << " #" << blockNumber << std::endl; ++blockNumber; visited->setBit(offset,true); stateTable->restoreStateInfo(&stateInfo,offset); - if (stateInfo.isCatchLabel()) { - Type *handlerExceptionType = NULL; - for (ExceptionInfo* exceptionInfo = stateInfo.exceptionInfo; - exceptionInfo != NULL; - exceptionInfo = exceptionInfo->getNextExceptionInfoAtOffset()) { - if (exceptionInfo->isCatchHandler()) { - // catch handler block - CatchHandler* handler = (CatchHandler*)exceptionInfo; - handlerExceptionType = handler->getExceptionType(); - break; - } - } - if(Log::isEnabled()) { - Log::out() << "CATCH " << (int32) offset << " "; - handlerExceptionType->print(Log::out()); - Log::out() << ::std::endl; - } - pushType(handlerExceptionType); + if (stateInfo.isSubroutineEntry()) { + stateInfo.push(typeManager.getSystemObjectType()); + stateInfo.top().jsrLabelOffset = offset; } - else if (stateInfo.isSubroutineEntry()) { - pushType(typeManager.getSystemObjectType()); - stateInfo.stack[stateInfo.stackDepth-1].jsrLabelOffset = offset; - } } } @@ -600,7 +590,7 @@ void JavaLabelPrepass::setLabel(uint32 offset) { if (labels->getBit(offset)) // this label is already seen return; - Log::out() << "SET LABEL " << (int) offset << " " << (int) numLabels << ::std::endl; + if (Log::isEnabled()) Log::out() << "SET LABEL " << (int) offset << " #" << (int) numLabels << ::std::endl; labels->setBit(offset,true); numLabels++; } @@ -652,14 +642,14 @@ return (*iter).second; } -VariableIncarnation* JavaLabelPrepass::getOrCreateVarInc(uint32 offset, uint32 index, Type* type, VariableIncarnation* prev) +VariableIncarnation* JavaLabelPrepass::getOrCreateVarInc(uint32 offset, uint32 index, Type* type) { int numStack = methodDesc.getMaxStack()+1; uint32 key = offset*(numVars+numStack)+index; StlHashMap::iterator iter = localVars.find(key); VariableIncarnation* var; if (iter==localVars.end()) { - var = new(memManager) VariableIncarnation(offset, blockNumber, type); + var = new(memManager) VariableIncarnation(offset, type); localVars[key] = var; } else { var = (*iter).second; @@ -680,49 +670,39 @@ // stack operations // -struct StateInfo::SlotInfo JavaLabelPrepass::topType() { +StateInfo::SlotInfo& JavaLabelPrepass::topType() { return stateInfo.stack[stateInfo.stackDepth-1]; } -struct StateInfo::SlotInfo JavaLabelPrepass::popType() { - struct StateInfo::SlotInfo top = stateInfo.stack[--stateInfo.stackDepth]; - assert (stateInfo.stackDepth >= (int)numVars); +StateInfo::SlotInfo& JavaLabelPrepass::popType() { + StateInfo::SlotInfo& top = stateInfo.stack[--stateInfo.stackDepth]; + assert (stateInfo.stackDepth >= numVars); return top; } void JavaLabelPrepass::popAndCheck(Type *type) { - struct StateInfo::SlotInfo top = popType(); + StateInfo::SlotInfo& top = popType(); if( !(top.type == type) ) assert(0); } void JavaLabelPrepass::popAndCheck(JavaVarType type) { - struct StateInfo::SlotInfo top = popType(); + StateInfo::SlotInfo& top = popType(); if(!(top.type && getJavaType(top.type) == type)) assert(0); } void JavaLabelPrepass::pushType(Type *type) { - struct StateInfo::SlotInfo* slot = &stateInfo.stack[stateInfo.stackDepth++]; - slot->type = type; - slot->slotFlags = 0; - slot->vars = NULL; - slot->jsrLabelOffset = 0; + stateInfo.push(type); } void JavaLabelPrepass::pushType(Type *type, uint32 varNumber) { - struct StateInfo::SlotInfo* slot = &stateInfo.stack[stateInfo.stackDepth++]; - slot->type = type; - slot->slotFlags = 0; - slot->varNumber = varNumber; - slot->vars = NULL; - slot->jsrLabelOffset = 0; - StateInfo::setVarNumber(slot); + stateInfo.push(type).setVarNumber(varNumber); } -void JavaLabelPrepass::pushType(struct StateInfo::SlotInfo slot) { +void JavaLabelPrepass::pushType(StateInfo::SlotInfo& slot) { stateInfo.stack[stateInfo.stackDepth++] = slot; stateInfo.stack[stateInfo.stackDepth-1].jsrLabelOffset = 0; } @@ -733,29 +713,19 @@ Log::out() << "SET STACK VARS:" << ::std::endl; } - for (int i=numVars; i < stateInfo.stackDepth; i++) { + for (unsigned i=numVars; i < stateInfo.stackDepth; i++) { struct StateInfo::SlotInfo* slot = &stateInfo.stack[i]; if(Log::isEnabled()) { Log::out() << "SLOT " << i << ":" << ::std::endl; - Log::out() << " type = "; - if (slot->type) - slot->type->print(Log::out()); - else - Log::out() << "NULL"; + StateInfo::print(*slot, Log::out()); Log::out() << ::std::endl; - Log::out() << " vars = "; - if (slot->vars) - slot->vars->getVarIncarnation()->print(Log::out()); - else - Log::out() << "NULL"; - Log::out() << ::std::endl; } Type* type = slot->type; assert(type); SlotVar* sv = slot->vars; - VariableIncarnation* var = getOrCreateVarInc(currentOffset, i, type, NULL); + VariableIncarnation* var = getOrCreateVarInc(currentOffset, i, type); // Do not merge stack vars of incompatible types if (sv && (sv->getVarIncarnation()->getDeclaredType() == var->getDeclaredType())) { @@ -767,18 +737,8 @@ if(Log::isEnabled()) { Log::out() << "AFTER" << ::std::endl; - Log::out() << " type = "; - if (slot->type) - slot->type->print(Log::out()); - else - Log::out() << "NULL"; + StateInfo::print(*slot, Log::out()); Log::out() << ::std::endl; - Log::out() << " vars = "; - if (slot->vars) - slot->vars->getVarIncarnation()->print(Log::out()); - else - Log::out() << "NULL"; - Log::out() << ::std::endl; } } if(Log::isEnabled()) { @@ -1549,7 +1509,7 @@ void JavaLabelPrepass::pop() { popType(); } void JavaLabelPrepass::pop2() { - struct StateInfo::SlotInfo type = popType(); + StateInfo::SlotInfo& type = popType(); if (isCategory2(type)) return; popType(); @@ -1560,23 +1520,23 @@ } void JavaLabelPrepass::dup_x1() { - struct StateInfo::SlotInfo opnd1 = popType(); - struct StateInfo::SlotInfo opnd2 = popType(); + StateInfo::SlotInfo& opnd1 = popType(); + StateInfo::SlotInfo& opnd2 = popType(); pushType(opnd1); pushType(opnd2); pushType(opnd1); } void JavaLabelPrepass::dup_x2() { - struct StateInfo::SlotInfo opnd1 = popType(); - struct StateInfo::SlotInfo opnd2 = popType(); + StateInfo::SlotInfo& opnd1 = popType(); + StateInfo::SlotInfo& opnd2 = popType(); if (isCategory2(opnd2)) { pushType(opnd1); pushType(opnd2); pushType(opnd1); return; } - struct StateInfo::SlotInfo opnd3 = popType(); + StateInfo::SlotInfo& opnd3 = popType(); pushType(opnd1); pushType(opnd3); pushType(opnd2); @@ -1584,13 +1544,13 @@ } void JavaLabelPrepass::dup2() { - struct StateInfo::SlotInfo opnd1 = popType(); + StateInfo::SlotInfo& opnd1 = popType(); if (isCategory2(opnd1)) { pushType(opnd1); pushType(opnd1); return; } - struct StateInfo::SlotInfo opnd2 = popType(); + StateInfo::SlotInfo& opnd2 = popType(); pushType(opnd2); pushType(opnd1); pushType(opnd2); @@ -1598,8 +1558,8 @@ } void JavaLabelPrepass::dup2_x1() { - struct StateInfo::SlotInfo opnd1 = popType(); - struct StateInfo::SlotInfo opnd2 = popType(); + StateInfo::SlotInfo& opnd1 = popType(); + StateInfo::SlotInfo& opnd2 = popType(); if (isCategory2(opnd1)) { // opnd1 is a category 2 instruction pushType(opnd1); @@ -1607,7 +1567,7 @@ pushType(opnd1); } else { // opnd1 is a category 1 instruction - struct StateInfo::SlotInfo opnd3 = popType(); + StateInfo::SlotInfo& opnd3 = popType(); pushType(opnd2); pushType(opnd1); pushType(opnd3); @@ -1618,8 +1578,8 @@ void JavaLabelPrepass::dup2_x2() { - struct StateInfo::SlotInfo opnd1 = popType(); - struct StateInfo::SlotInfo opnd2 = popType(); + StateInfo::SlotInfo& opnd1 = popType(); + StateInfo::SlotInfo& opnd2 = popType(); if (isCategory2(opnd1)) { // opnd1 is category 2 if (isCategory2(opnd2)) { @@ -1628,7 +1588,7 @@ pushType(opnd1); } else { // opnd2 is category 1 - struct StateInfo::SlotInfo opnd3 = popType(); + StateInfo::SlotInfo& opnd3 = popType(); assert(isCategory2(opnd3) == false); pushType(opnd1); pushType(opnd3); @@ -1638,7 +1598,7 @@ } else { assert(isCategory2(opnd2) == false); // both opnd1 & opnd2 are category 1 - struct StateInfo::SlotInfo opnd3 = popType(); + StateInfo::SlotInfo& opnd3 = popType(); if (isCategory2(opnd3)) { pushType(opnd2); pushType(opnd1); @@ -1647,7 +1607,7 @@ pushType(opnd1); } else { // opnd1, opnd2, opnd3 all are category 1 - struct StateInfo::SlotInfo opnd4 = popType(); + StateInfo::SlotInfo& opnd4 = popType(); assert(isCategory2(opnd4) == false); pushType(opnd2); pushType(opnd1); @@ -1660,8 +1620,8 @@ } void JavaLabelPrepass::swap() { - struct StateInfo::SlotInfo opnd1 = popType(); - struct StateInfo::SlotInfo opnd2 = popType(); + StateInfo::SlotInfo& opnd1 = popType(); + StateInfo::SlotInfo& opnd2 = popType(); pushType(opnd1); pushType(opnd2); } @@ -1679,16 +1639,16 @@ popAndCheck(type); stateInfo.stack[index].type = type; stateInfo.stack[index].slotFlags= 0; - stateInfo.stack[index].vars = new (memManager) SlotVar(getOrCreateVarInc(offset, index, type, NULL/*prevVar*/)); + stateInfo.stack[index].vars = new (memManager) SlotVar(getOrCreateVarInc(offset, index, type)); propagateLocalVarToHandlers(index); } void JavaLabelPrepass::genTypeStore(uint32 index, uint32 offset) { - struct StateInfo::SlotInfo slot = popType(); + 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, NULL/*prevVar*/); + 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()) { @@ -1708,7 +1668,6 @@ stateInfo.stack[stateInfo.stackDepth-1].jsrLabelOffset = stateInfo.stack[index].jsrLabelOffset; SlotVar* vars = stateInfo.stack[index].vars; if (vars) { - vars->getVarIncarnation()->ldBlock(blockNumber); vars->mergeVarIncarnations(&typeManager); } } @@ -1717,7 +1676,6 @@ Type *type = stateInfo.stack[index].type; SlotVar* vars = stateInfo.stack[index].vars; if (vars) { - vars->getVarIncarnation()->ldBlock(blockNumber); vars->mergeVarIncarnations(&typeManager); type = vars->getVarIncarnation()->getDeclaredType(); } @@ -1750,15 +1708,9 @@ } void JavaLabelPrepass::genTypeArrayStore() { -#ifndef NDEBUG - Type *type = -#endif - popType().type; + UNUSED Type *type = popType().type; popAndCheck(int32Type); -#ifndef NDEBUG - type = -#endif - popType().type; + type = popType().type; assert(type->isArrayType() || type->isNullObject() || type->isUnresolvedObject()); } @@ -1804,7 +1756,7 @@ to.vars = from.vars ? new (memManager) SlotVar(from.vars, memManager) : NULL; } -void StateTable::setStateInfo(StateInfo *inState, uint32 offset, bool isFallThru) { +void StateTable::setStateInfo(StateInfo *inState, uint32 offset, bool isFallThru, bool varsOnly) { if(Log::isEnabled()) { Log::out() << "SETSTATE offset=" <<(int)offset << " depth=" << inState->stackDepth << ::std::endl; printState(inState); @@ -1820,6 +1772,7 @@ state->clearFallThroughLabel(); assert(getStateInfo(offset) != NULL); + setStackInfo(inState, offset, true, !varsOnly); if (!state->isVisited() ) { state->setVisited(); @@ -1828,7 +1781,7 @@ CatchBlock* except = *it; if ( except->hasOffset(offset) ) { - Log::out() << "try-region begin=" << (int)except->getBeginOffset() + if (Log::isEnabled()) Log::out() << "try-region begin=" << (int)except->getBeginOffset() << " end=" << (int)except->getEndOffset() << ::std::endl; ExceptionInfo *prev = state->exceptionInfo; bool found = false; @@ -1858,51 +1811,43 @@ } } } - int stackDepth = inState->stackDepth; +} + +void StateTable::setStackInfo(StateInfo *inState, uint32 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; - Log::out() << "MAXDEPTH " << maxDepth << ::std::endl; - struct StateInfo::SlotInfo *stack = state->stack; + 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 (int i=0; i < stackDepth; i++) { + for (unsigned i = from; i < to; i++) { copySlotInfo(stack[i], inState->stack[i]); } - state->stackDepth = stackDepth; + state->stackDepth = to; } else { // needs to merge the states - assert(state->stackDepth == stackDepth); + assert(!includeStack || state->stackDepth == stackDepth); if(Log::isEnabled()) { Log::out() << " before\n"; printState(state); } - for (int i=0; i < stackDepth; i++) { + 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->type: "; - if (inSlot->type) { - inSlot->type->print(Log::out()); - } else { - Log::out() << "null"; - } - Log::out() << ::std::endl; - Log::out() << "slot->type: "; - if (slot->type) { - slot->type->print(Log::out()); - } else { - Log::out() << "null"; - } - Log::out() << ::std::endl; - if (inSlot->vars) { - Log::out() << "inSlot->vars: "; inSlot->vars->print(Log::out()); - } - if (slot->vars) { - Log::out() << "slot->vars: "; slot->vars->print(Log::out()); - } + Log::out() << "inSlot: ";StateInfo::print(*inSlot, Log::out());Log::out() << ::std::endl; + Log::out() << "slot: ";StateInfo::print(*slot, Log::out());Log::out() << ::std::endl; } - mergeSlots(inSlot, slot, offset, i < numVars); + mergeSlots(inSlot, slot, offset, i < (unsigned)numVars); } } if(Log::isEnabled()) { @@ -1913,6 +1858,14 @@ } void StateTable::mergeSlots(StateInfo::SlotInfo* inSlot, StateInfo::SlotInfo* slot, uint32 offset, bool isVar) { + + if (!getStateInfo(offset)->isVisited()) { + assert(NULL == slot->type); + assert(NULL == slot->vars); + copySlotInfo(*slot, *inSlot); + return; + } + slot->jsrLabelOffset = inSlot->jsrLabelOffset; slot->slotFlags = slot->slotFlags & inSlot->slotFlags; @@ -1973,28 +1926,26 @@ Log::out() << "SETSTATE FROM FINALLY offset=" <<(int)offset << " depth=" << inState->stackDepth << ::std::endl; printState(inState); } - StateInfo *state = hashtable[offset]; - assert(getStateInfo(offset) != NULL); - int stackDepth = inState->stackDepth; + StateInfo *state = getStateInfo(offset); + assert(state); + unsigned stackDepth = inState->stackDepth; if (stackDepth > 0) { if (maxDepth < stackDepth) maxDepth = stackDepth; - Log::out() << "MAXDEPTH " << maxDepth << ::std::endl; + if (Log::isEnabled()) Log::out() << "MAXDEPTH " << maxDepth << ::std::endl; struct StateInfo::SlotInfo *stack = state->stack; - if (stack == NULL) { - // stack must be propagated from JSR to jsrNext earlier - assert(0); - } + // stack must be propagated from JSR to jsrNext earlier + assert(stack); assert(state->stackDepth == stackDepth); if(Log::isEnabled()) { Log::out() << " before\n"; printState(state); } - for (int i=0; i < stackDepth; i++) { + 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; - Log::out() << "STACK " << i << ": "<< type << ::std::endl; + if (Log::isEnabled()) Log::out() << "STACK " << i << ": "<< type << ::std::endl; if (!type && intype) { // don't merge, just rewrite! slot->type = intype; // Consider copying not pointers but SlotVat structures. @@ -2047,7 +1998,8 @@ uint32 handler_offset = handler->getBeginOffset(); struct StateInfo::SlotInfo *slot = &stateTable->getStateInfo(handler_offset)->stack[varIndex]; - Log::out() << "HANDLER SLOT " << varIndex << " merged to offset " << handler_offset << ::std::endl; + if (Log::isEnabled()) Log::out() << "HANDLER SLOT " << varIndex + << " merged to offset " << handler_offset << ::std::endl; stateTable->mergeSlots(inSlot, slot, handler_offset, true); } } Index: vm/jitrino/src/translator/java/JavaByteCodeParser.h =================================================================== --- vm/jitrino/src/translator/java/JavaByteCodeParser.h (revision 542415) +++ vm/jitrino/src/translator/java/JavaByteCodeParser.h (working copy) @@ -47,10 +47,9 @@ class JavaByteCodeParserCallback : public ByteCodeParserCallback { public: - JavaByteCodeParserCallback() { + JavaByteCodeParserCallback() : isLinearPass(true) { currentOffset = 0; nextOffset = 0; - isLinearPass = true; linearPassDone = false; visited = NULL; bytecodevisited = NULL; @@ -58,10 +57,11 @@ labelStack = NULL; noNeedToParse = false; } - JavaByteCodeParserCallback(MemoryManager& memManager,uint32 byteCodeLength) { + JavaByteCodeParserCallback(MemoryManager& memManager,uint32 byteCodeLength) + : isLinearPass(false) + { currentOffset = 0; nextOffset = 0; - isLinearPass = false; linearPassDone = false; visited = new (memManager) BitSet(memManager,byteCodeLength); bytecodevisited = new (memManager) BitSet(memManager,byteCodeLength); @@ -74,7 +74,7 @@ protected: // the current byte codes offset uint32 currentOffset; - bool isLinearPass; + const bool isLinearPass; bool linearPassDone; BitSet* visited; BitSet* bytecodevisited; Index: vm/jitrino/src/translator/java/JavaFlowGraphBuilder.cpp =================================================================== --- vm/jitrino/src/translator/java/JavaFlowGraphBuilder.cpp (revision 543442) +++ vm/jitrino/src/translator/java/JavaFlowGraphBuilder.cpp (working copy) @@ -65,15 +65,10 @@ // NodeList::const_iterator niter = std::find(fallThruNodes.begin(), fallThruNodes.end(), block); assert(niter != fallThruNodes.end()); - TranslatorFlags* translatorFlags = irBuilder.getTranslatorFlags(); for(++niter; niter != fallThruNodes.end(); ++niter) { Node* node = *niter; - if (translatorFlags->newCatchHandling) { - if (node->isBlockNode() && !((LabelInst*)node->getFirstInst())->isCatchLabel()) { - break; - } - } else if (node->isBlockNode()) { - break; + if (node->isBlockNode() && !((LabelInst*)node->getFirstInst())->isCatchLabel()) { + break; } } assert(niter != fallThruNodes.end()); Index: vm/jitrino/src/translator/java/JavaLabelPrepass.h =================================================================== --- vm/jitrino/src/translator/java/JavaLabelPrepass.h (revision 542415) +++ vm/jitrino/src/translator/java/JavaLabelPrepass.h (working copy) @@ -15,12 +15,6 @@ * limitations under the License. */ -/** - * @author Intel, George A. Timoshenko - * @version $Revision: 1.24.12.1.4.4 $ - * - */ - #ifndef _JAVALABELPREPASS_H_ #define _JAVALABELPREPASS_H_ @@ -40,9 +34,8 @@ class VariableIncarnation : private Dlink { public: - VariableIncarnation(uint32 offset, uint32 block, Type*); + VariableIncarnation(uint32 offset, Type*); void setMultipleDefs(); - void ldBlock(int32 blockNumber); Type* getDeclaredType(); void setDeclaredType(Type*); @@ -69,7 +62,6 @@ private: friend class SlotVar; int32 definingOffset; // offset where the def was found, -1 if multiple defs - int32 definingBlock; // block where the def was found, -1 if spans basic block Type* declaredType; Opnd* opnd; }; @@ -116,12 +108,10 @@ bool isFallThroughLabel() { return (flags & 4) != 0; } bool isVisited() { return (flags & 8) != 0; } - // - // addExceptionInfo() adds both catch-blocks and handlers. // Catch-blocks should be listed in the same order as the // corresponding exception table entries were listed in byte-code. (according to VM spec) - // - void addExceptionInfo(ExceptionInfo *info); + void addExceptionInfo(CatchBlock* info); + void addCatchHandler(CatchHandler* info); struct SlotInfo { Type *type; @@ -130,8 +120,15 @@ SlotVar *vars; uint32 jsrLabelOffset; SlotInfo() : type(NULL), varNumber(0), slotFlags(0), vars(NULL), jsrLabelOffset(0){} + void setVarNumber(uint32 n) { varNumber = n;slotFlags |= VarNumberIsSet; } }; + // Push type to modelled operand stack + SlotInfo& push(Type *type); + + // Obtain top slot of modelled operand stack + SlotInfo& top(); + // remove all slots containing returnAddress for RET instruction with jsrNexOffset == offset void cleanFinallyInfo(uint32 offset); @@ -144,47 +141,38 @@ StackOpndAlive = 0x10, // the following to get rid of phi nodes in the translator StackOpndSaved = 0x20 // the following to get rid of phi nodes in the translator }; - static bool isNonNull(uint32 flags) { return (flags & IsNonNull) != 0; } - static bool isExactType(uint32 flags) { return (flags & IsExactType) != 0; } - static uint32 setNonNull(uint32 flags,bool val) { - return (val ? (flags | IsNonNull) : (flags & ~IsNonNull)); - } - static uint32 setExactType(uint32 flags,bool val){ - return (val ? (flags | IsExactType) : (flags & ~IsExactType)); - } - static bool isStackOpndAlive(uint32 flags) {return (flags & StackOpndAlive) != 0;} - static bool isStackOpndSaved(uint32 flags) {return (flags & StackOpndSaved) != 0;} - static uint32 setStackOpndAlive(uint32 flags,bool val) { - return (val ? (flags | StackOpndAlive) : (flags & ~StackOpndAlive)); - } - static uint32 setStackOpndSaved(uint32 flags,bool val) { - return (val ? (flags | StackOpndSaved) : (flags & ~StackOpndSaved)); - } - static bool isVarNumberSet(struct SlotInfo s) { return (s.slotFlags & VarNumberIsSet) != 0; } static bool isNonNull(struct SlotInfo s) { return (s.slotFlags & IsNonNull) != 0; } static bool isExactType(struct SlotInfo s) { return (s.slotFlags & IsExactType) != 0; } static bool changeState(struct SlotInfo s) { return (s.slotFlags & ChangeState) != 0; } - static void setVarNumber(struct SlotInfo *s) { s->slotFlags |= VarNumberIsSet; } static void setNonNull(struct SlotInfo *s) { s->slotFlags |= IsNonNull; } static void setExactType(struct SlotInfo *s) { s->slotFlags |= IsExactType; } + static void clearExactType(struct SlotInfo *s) { s->slotFlags &= ~IsExactType; } static void setChangeState(struct SlotInfo *s) { s->slotFlags |= ChangeState; } - static void print(struct SlotInfo s, ::std::ostream& os) { + static void print(SlotInfo& s, ::std::ostream& os) { + Log::out() << "\ttype: "; if (s.type == NULL) - os << "null"; + os << "NULL"; else s.type->print(os); - if (isVarNumberSet(s)) os << (int)s.varNumber<< ","; + if (isVarNumberSet(s)) os << " ->[" <<(int)s.varNumber<< "],"; if (isNonNull(s)) os << ",nn"; if (isExactType(s)) os << ",ex"; if (changeState(s)) os << ",cs"; + //Log::out() << ::std::endl; + Log::out() << "\tvar: "; + if (s.vars) { + s.vars->print(Log::out()); + } else { + Log::out() << "NULL"; + } } // add flags as needed friend class JavaLabelPrepass; friend class JavaByteCodeTranslator; - int flags; - int stackDepth; + unsigned flags; + unsigned stackDepth; struct SlotInfo* stack; ExceptionInfo *exceptionInfo; }; @@ -244,20 +232,20 @@ // Variable information VariableIncarnation* getVarInc(uint32 offset, uint32 index); - VariableIncarnation* getOrCreateVarInc(uint32 offset, uint32 index, Type* type, VariableIncarnation* prev); + VariableIncarnation* getOrCreateVarInc(uint32 offset, uint32 index, Type* type); void createMultipleDefVarOpnds(IRBuilder*); // // operand stack manipulation (to keep track of state only !) // - struct StateInfo::SlotInfo topType(); - struct StateInfo::SlotInfo popType(); + StateInfo::SlotInfo& topType(); + StateInfo::SlotInfo& popType(); void popAndCheck(Type *type); void popAndCheck(JavaVarType type); - void pushType(struct StateInfo::SlotInfo slot); + void pushType(StateInfo::SlotInfo& slot); void pushType(Type *type, uint32 varNumber); void pushType(Type *type); - bool isCategory2(struct StateInfo::SlotInfo slot) { return slot.type == int64Type || slot.type == doubleType; } + bool isCategory2(StateInfo::SlotInfo& slot) { return slot.type == int64Type || slot.type == doubleType; } // bool allExceptionTypesResolved() {return problemTypeToken == MAX_UINT32;} @@ -549,9 +537,9 @@ virtual ~StateTable() { } - StateTable(MemoryManager& mm,TypeManager& tm, JavaLabelPrepass& jlp, uint32 size, uint32 numvars) : + StateTable(MemoryManager& mm,TypeManager& tm, JavaLabelPrepass& jlp, uint32 numstack, uint32 numvars) : memManager(mm), typeManager(tm), prepass(jlp), - hashtable(mm), maxDepth(numvars), numVars(numvars) + hashtable(mm), maxDepth(numvars + numstack), numVars(numvars) { assert(sizeof(POINTER_SIZE_INT)>=sizeof(uint32)); assert(sizeof(uint32*)>=sizeof(uint32)); @@ -559,23 +547,28 @@ StateInfo *getStateInfo(uint32 offset) { return hashtable[offset]; } - StateInfo *createStateInfo(uint32 offset) { - StateInfo *state = hashtable[offset]; //lookup((uint32*)(POINTER_SIZE_INT)offset); + StateInfo *createStateInfo(uint32 offset, bool createStack = false) { + StateInfo *state = hashtable[offset]; if (state == NULL) { state = new (memManager) StateInfo(); hashtable[offset] = state; } + if (createStack && state->stack == NULL) { + state->stack = new (memManager) StateInfo::SlotInfo[maxDepth]; + state->stackDepth = numVars; + } if(Log::isEnabled()) { Log::out() << "CREATESTATE " <<(int)offset << " depth " << state->stackDepth << ::std::endl; - printState(state); + //printState(state); } return state; } void copySlotInfo(StateInfo::SlotInfo& to, StateInfo::SlotInfo& from); - void mergeSlots(StateInfo::SlotInfo* inSlot, StateInfo::SlotInfo* slot, uint32 offset, bool isVar); - void setStateInfo(StateInfo *inState, uint32 offset, bool isFallThru); - void setStateInfoFromFinally(StateInfo *inState, uint32 offset); + void mergeSlots(StateInfo::SlotInfo* inSlot, StateInfo::SlotInfo* slot, uint32 offset, bool isVar); + void setStackInfo(StateInfo *inState, uint32 offset, bool includeVars, bool includeStack); + void setStateInfo(StateInfo *inState, uint32 offset, bool isFallThru, bool varsOnly = false); + void setStateInfoFromFinally(StateInfo *inState, uint32 offset); void restoreStateInfo(StateInfo *stateInfo, uint32 offset) { if(Log::isEnabled()) { @@ -586,7 +579,7 @@ assert(state != NULL && (state->stack || state->stackDepth==0)); stateInfo->flags = state->flags; stateInfo->stackDepth = state->stackDepth; - for (int i=0; i < stateInfo->stackDepth; i++) + for (unsigned i=0; i < stateInfo->stackDepth; i++) stateInfo->stack[i] = state->stack[i]; stateInfo->exceptionInfo = state->exceptionInfo; for (ExceptionInfo *except = stateInfo->exceptionInfo; except != NULL; @@ -597,12 +590,9 @@ for (CatchHandler *handler = block->getHandlers(); handler != NULL; handler = handler->getNextHandler()) { int cstart = handler->getBeginOffset(); - Log::out() << "SETCATCHINFO "<<(int)cstart<<" "<<(int)prepass.getNumVars()<< ::std::endl; + if (Log::isEnabled()) Log::out() << "SETCATCHINFO "<<(int)cstart<<" "<<(int)numVars<< ::std::endl; prepass.pushCatchLabel(cstart); - int stackDepth = stateInfo->stackDepth; - stateInfo->stackDepth = prepass.getNumVars(); - setStateInfo(stateInfo,cstart,false); - stateInfo->stackDepth = stackDepth; + setStateInfo(stateInfo,cstart,false,true); } } } @@ -612,17 +602,10 @@ void printState(StateInfo *state) { if (state == NULL) return; struct StateInfo::SlotInfo *stack = state->stack; - for (int i=0; i < state->stackDepth; i++) { + for (unsigned i=0; i < state->stackDepth; i++) { Log::out() << "STACK " << i << ":"; StateInfo::print(stack[i],Log::out()); Log::out() << ::std::endl; - Log::out() << " var: "; - if (stack[i].vars) { - stack[i].vars->print(Log::out()); - } else { - Log::out() << "null"; - } - Log::out() << ::std::endl; } } protected: @@ -638,8 +621,8 @@ TypeManager& typeManager; JavaLabelPrepass& prepass; StlHashMap hashtable; - int maxDepth; - int numVars; + unsigned maxDepth; + unsigned numVars; }; #endif // _JAVALABELPREPASS_H_ Index: vm/jitrino/src/translator/java/JavaByteCodeTranslator.cpp =================================================================== --- vm/jitrino/src/translator/java/JavaByteCodeTranslator.cpp (revision 542415) +++ vm/jitrino/src/translator/java/JavaByteCodeTranslator.cpp (working copy) @@ -430,7 +430,7 @@ } // start a new basic block - Log::out() << "TRANSLATOR BASICBLOCK " << (int32)offset << " " << ::std::endl; + if (Log::isEnabled()) Log::out() << "TRANSLATOR BASICBLOCK " << (int32)offset << " " << ::std::endl; // finish the previous basic block, if any work was required if (!lastInstructionWasABranch) { @@ -443,13 +443,12 @@ stateInfo->flags = state->flags; stateInfo->stackDepth = state->stackDepth; stateInfo->exceptionInfo = state->exceptionInfo; - for(int i=0; istackDepth; ++i) + for(unsigned i=0; istackDepth; ++i) stateInfo->stack[i] = state->stack[i]; assert(stateInfo != NULL); Type* handlerExceptionType = NULL; uint32 lblId = getNextLabelId(); LabelInst* labelInst = getLabel(lblId); - ::std::vector oldLabels; ::std::vector catchLabels; @@ -459,10 +458,10 @@ exceptionInfo = exceptionInfo->getNextExceptionInfoAtOffset()) { if (exceptionInfo->isCatchBlock()) { CatchBlock* catchBlock = (CatchBlock*)exceptionInfo; - Log::out() << "TRY REGION " << (int)exceptionInfo->getBeginOffset() - << " " << (int)exceptionInfo->getEndOffset() << ::std::endl; CatchHandler *first = ((CatchBlock*)exceptionInfo)->getHandlers(); if (Log::isEnabled()) { + Log::out() << "TRY REGION " << (int)exceptionInfo->getBeginOffset() + << " " << (int)exceptionInfo->getEndOffset() << ::std::endl; for (; first != NULL; first = first->getNextHandler()) { Log::out() << " handler " << (int)first->getBeginOffset() << ::std::endl; } @@ -482,32 +481,16 @@ // catch handler block isCatchHandler = true; CatchHandler* handler = (CatchHandler*)exceptionInfo; - Log::out() << "CATCH REGION " << (int)exceptionInfo->getBeginOffset() + if (Log::isEnabled()) Log::out() << "CATCH REGION " << (int)exceptionInfo->getBeginOffset() << " " << (int)exceptionInfo->getEndOffset() << ::std::endl; - if (translationFlags.newCatchHandling) { - handlerExceptionType = (handlerExceptionType == NULL) ? - handler->getExceptionType() : - typeManager.getCommonObjectType((ObjectType*) handlerExceptionType, (ObjectType*) handler->getExceptionType()); - } else { - handlerExceptionType = handler->getExceptionType(); - } + handlerExceptionType = (handlerExceptionType == NULL) ? + handler->getExceptionType() : + typeManager.getCommonObjectType((ObjectType*) handlerExceptionType, (ObjectType*) handler->getExceptionType()); LabelInst *oldLabel = labelInst; - oldLabels.push_back(oldLabel); - - if (translationFlags.newCatchHandling) { - labelInst = (LabelInst*) - irBuilder.getInstFactory()->makeCatchLabel( - handler->getExceptionOrder(), - handler->getExceptionType()); - catchLabels.push_back(labelInst); - } else { - labelInst = (LabelInst*) - irBuilder.getInstFactory()->makeCatchLabel( - labelInst->getLabelId(), - handler->getExceptionOrder(), - handlerExceptionType); - setLabel(lblId,labelInst); - } + labelInst = irBuilder.getInstFactory()->makeCatchLabel( + handler->getExceptionOrder(), + handler->getExceptionType()); + catchLabels.push_back(labelInst); labelInst->setState(oldLabel->getState()); exceptionInfo->setLabelInst(labelInst); if(Log::isEnabled()) { @@ -517,7 +500,7 @@ } else {jitrino_assert(0);} // only catch blocks should occur in Java } // generate the label instruction - if(translationFlags.newCatchHandling && !catchLabels.empty()) { + if(!catchLabels.empty()) { for(::std::vector::iterator iter = catchLabels.begin(); iter != catchLabels.end(); ++iter) { LabelInst* catchLabel = *iter; irBuilder.genLabel(catchLabel); @@ -538,20 +521,25 @@ } cfgBuilder.genBlock(labelInst); } - // - // Load var operands where current basic block begins - // - for (uint32 k=numVars; k < (uint32)stateInfo->stackDepth; k++) { - if(Log::isEnabled()) { - Log::out() << "STACK ";stateInfo->stack[k].type->print(Log::out()); Log::out() << ::std::endl; - } - genLdVar(k,prepass.getJavaType(stateInfo->stack[k].type)); - } if (isCatchHandler) { // for catch handler blocks, generate the catch instruction - pushOpnd(irBuilder.genCatch(handlerExceptionType)); - } else if (stateInfo->isSubroutineEntry()) { + assert(stateInfo->isCatchLabel()); + assert(1 == stateInfo->stackDepth - numVars); + assert(stateInfo->stack[numVars].type == handlerExceptionType); + pushOpnd(irBuilder.genCatch(stateInfo->stack[numVars].type)); + } else { + // + // Load var operands where current basic block begins + // + for (uint32 k=numVars; k < (uint32)stateInfo->stackDepth; k++) { + if(Log::isEnabled()) { + Log::out() << "STACK ";StateInfo::print(stateInfo->stack[k], Log::out());Log::out() << ::std::endl; + } + genLdVar(k,prepass.getJavaType(stateInfo->stack[k].type)); + } + } + if (stateInfo->isSubroutineEntry()) { pushOpnd(irBuilder.genSaveRet()); } } Index: vm/jitrino/src/translator/java/JavaByteCodeParser.cpp =================================================================== --- vm/jitrino/src/translator/java/JavaByteCodeParser.cpp (revision 542415) +++ vm/jitrino/src/translator/java/JavaByteCodeParser.cpp (working copy) @@ -691,7 +691,6 @@ nextOffset = currentOffset + len; return true; } - linearPassDone = true; // get next label by popping label stack while (!labelStack->isEmpty()) { nextOffset = (uint32) (labelStack->pop() - byteCodes); Index: vm/jitrino/src/translator/TranslatorIntfc.h =================================================================== --- vm/jitrino/src/translator/TranslatorIntfc.h (revision 542415) +++ vm/jitrino/src/translator/TranslatorIntfc.h (working copy) @@ -56,7 +56,6 @@ bool onlyBalancedSync : 1; // treat all method synchronization as balanced bool ignoreSync : 1; // do not generate monitor enter/exit instructions bool syncAsEnterFence : 1; // implement monitor enter as enter fence and - bool newCatchHandling : 1; // use fix for catch handler ordering problem bool genMinMaxAbs : 1; // gen min/max/abs opcodes instead of using select bool genFMinMaxAbs : 1; // gen min/max/abs opcodes for floats bool optArrayInit : 1; // skip array initializers from optimizations Index: vm/jitrino/src/translator/ExceptionInfo.cpp =================================================================== --- vm/jitrino/src/translator/ExceptionInfo.cpp (revision 542415) +++ vm/jitrino/src/translator/ExceptionInfo.cpp (working copy) @@ -1,39 +0,0 @@ -/* - * 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, George A. Timoshenko - * @version $Revision: 1.12.24.4 $ - * - */ - -#include -#include "open/types.h" -#include "ExceptionInfo.h" - -namespace Jitrino { - -CatchHandler::CatchHandler(uint32 id, - uint32 beginOffset, - uint32 endOffset, - CatchBlock* tryBlock, - Type* excType) -: Handler(id,beginOffset,endOffset,tryBlock), - exceptionType(excType), nextHandler(NULL) {} - - -} //namespace Jitrino Index: vm/jitrino/src/translator/TranslatorIntfc.cpp =================================================================== --- vm/jitrino/src/translator/TranslatorIntfc.cpp (revision 543442) +++ vm/jitrino/src/translator/TranslatorIntfc.cpp (working copy) @@ -123,8 +123,6 @@ flags.ignoreSync = getBoolArg("ignoreSync",false); flags.syncAsEnterFence = getBoolArg("syncAsEnterFence",false); - flags.newCatchHandling = getBoolArg("newCatchHandling",true); - flags.genMinMaxAbs = getBoolArg("genMinMaxAbs", false); flags.genFMinMaxAbs = getBoolArg("genFMinMaxAbs", false);