bool OSR::isNoArrayInLoop(LoopNode* lnode, SsaOpnd* iv) {
Nodes nodes = lnode->getNodesInLoop();
StlVector < Node* >::iterator iter = nodes.begin(), end = nodes.end();
for (; iter != end; iter++) {
Node* node = *iter;
Inst* last_inst = (Inst*) node->getLastInst();
for (Inst* iter1 = (Inst*) node->getFirstInst();
iter1 != last_inst; iter1 = iter1->getNextInst()) {
Inst inst = *iter1;
if (inst.getOpcode() == Op_AddScaledIndex) {
Opnd* opnd = inst.getSrc(1);
findLeadingOpnd(&inst, (SsaOpnd*) opnd);
SsaOpnd* lop = getLeadingOperand((SsaOpnd*) opnd);
if (lop != 0) {
SsaOpnd* ivlop = getLeadingOperand(iv);
if (lop == ivlop) {
return false;
}
}
}
}
}
return true;
}
/**
* Checks if Op_TauStInd (stind) instruction has a side effect.
* @param inst - checked instruction
* @return <code>true</code> if an instruction has side effect;
* <code>false<code> if an instruction has no side effect.
*/
bool
LazyExceptionOpt::fieldUsageHasSideEffect(Inst* inst) {
Opnd* insOp = inst->getSrc(0);
Inst* instDef = insOp->getInst();
if (instDef->getOpcode() == Op_DefArg) {
#ifdef _DEBUG
if (Log::isEnabled()) {
Log::out() << " fieldUsageHasSideEffect: ";
inst->print(Log::out());
Log::out() << std::endl;
Log::out() << " fieldUsageHasSideEffect: ";
instDef->print(Log::out());
Log::out() << std::endl;
Log::out() << " fieldUsageHasSideEffect: ";
Log::out() << (int)(instDef->getDefArgModifier()) << " " <<
(instDef->getDefArgModifier()==DefArgNoModifier) << " " <<
(instDef->getDefArgModifier()==NonNullThisArg) << " " <<
(instDef->getDefArgModifier()==DefArgBothModifiers) << std::endl;
}
#endif
if (instDef->getDefArgModifier()==NonNullThisArg && isExceptionInit)
return false;
}
return true;
}
void OSR::replaceLinearFuncTest(StlVector < Node* >&postOrderNodes) {
StlVector < Node* >::reverse_iterator riter = postOrderNodes.rbegin(),
rend = postOrderNodes.rend();
for (; riter != rend; ++riter) {
Node* node = *riter;
Inst* labelInst = (Inst*) node->getLabelInst();
for (Inst* iter = (Inst*) labelInst->next();
(iter != 0 && iter != labelInst);
iter = (Inst*) iter->next()) {
if ((iter->getOpcode() == Op_Cmp)
|| (iter->getOpcode() == Op_Branch))
performLFTR(iter);
}
}
}
void OSR::replace(SsaOpnd* opnd, SsaOpnd* iv, SsaOpnd* rc) {
Inst* inst = opnd->getInst();
SsaOpnd* dstInst = reduce(inst->getDst()->getType(), inst->getOpcode(),
inst->getOperation(), iv, rc);
Inst* copyInst = irManager.getInstFactory().makeCopy(opnd, dstInst);
copyInst->insertBefore(inst);
inst->unlink();
writeLeadingOperand(opnd, getLeadingOperand(iv));
}
SsaTmpOpnd* OSR::makeTmp(SsaOpnd* inOpnd, Inst* place) {
if (inOpnd->isSsaVarOpnd()) {
SsaVarOpnd* inSsaVarOpnd = inOpnd->asSsaVarOpnd();
Inst* inst = inSsaVarOpnd->getInst();
if (inst->getOpcode() == Op_StVar) {
SsaTmpOpnd* res = inst->getSrc(0)->asSsaTmpOpnd();
return res;
} else {
OpndManager& opndManager = irManager.getOpndManager();
InstFactory& instFactory = irManager.getInstFactory();
SsaTmpOpnd* res = opndManager.createSsaTmpOpnd(inOpnd->getType());
Inst* ldVarInst = instFactory.makeLdVar(res, inSsaVarOpnd);
Inst* where = chooseLocationForConvert(inst, place);
insertInst(ldVarInst, where);
writeLeadingOperand(res, getLeadingOperand(inOpnd));
return res;
}
} else {
return inOpnd->asSsaTmpOpnd();
}
}
/* The code below is based on loop_unroll processOpnd function. However it
* gathers some additional OSR-specific information which is obsolele for
* loop_unroll.
*
* TODO: create flexible mechanism for gathering info on the operands which
* would help to avoid code duplication from the one hand, and be customizable
* from another hand
*/
OSROpndInfo OSRInductionDetector::processOpnd(LoopTree* tree,
LoopNode* loopHead,
InstStack& defStack,
const Opnd* opnd,
iv_detection_flag flag) {
if (Log::isEnabled()) {
Log::out() << "Processing opnd: ";
opnd->print(Log::out());
Log::out() << "\n";
}
OSROpndInfo result;
Inst* defInst = opnd->getInst();
if (std::find(defStack.begin(), defStack.end(), defInst) !=
defStack.end()) {
result.setType(OSROpndInfo::COUNTER);
result.setIncrement(0);
result.setOpnd((Opnd*) opnd);
return result;
}
Opcode opcode = defInst->getOpcode();
if (opcode == Op_LdConstant) {
result.setType(OSROpndInfo::LD_CONST);
result.setConst(defInst->asConstInst()->getValue().i4);
result.setOpnd((Opnd*) opnd);
result.setHeader((Opnd*) opnd);
result.setHeaderFound();
return result;
}
if (!inExactLoop(tree, (Opnd*) opnd, loopHead)) {
result.setOpnd((Opnd*) opnd);
result.setHeader((Opnd*) opnd);
result.setHeaderFound();
return result;
}
defStack.push_back(defInst);
if (opcode == Op_Phi) {
OSROpndInfo info1 =
processOpnd(tree, loopHead, defStack, defInst->getSrc(0));
if (defInst->getNumSrcOperands() > 1) {
OSROpndInfo info2 =
processOpnd(tree, loopHead, defStack, defInst->getSrc(1));
if ( ((info1.isCounter() && !info1.isPhiSplit())
&& (info2.isDOL() || info2.isLDConst()))
|| ((info2.isCounter() && !info2.isPhiSplit())
&& (info1.isDOL() || info1.isLDConst())) ) {
result.setType(OSROpndInfo::COUNTER);
result.setIncrement(info1.isCounter()? info1.
getIncrement() : info2.getIncrement());
result.markPhiSplit();
result.setHeader((Opnd*) opnd);
result.setHeaderFound();
} else if ((flag == CHOOSE_MAX_IN_BRANCH) && info1.isCounter()
&& info2.isCounter()
&& signof(info1.getIncrement()) ==
signof(info2.getIncrement())) {
result.setType(OSROpndInfo::COUNTER);
result.setIncrement(std::abs(info1.getIncrement()) >
std::abs(info2.getIncrement())? info1.
getIncrement() : info2.getIncrement());
result.markPhiSplit();
result.setHeader((Opnd*) opnd);
result.setHeaderFound();
} else {
result.setType(OSROpndInfo::UNDEF);
}
}
} else if (opcode == Op_Add || opcode == Op_Sub) {
Opnd* opnd1 = defInst->getSrc(0);
Opnd* opnd2 = defInst->getSrc(1);
OSROpndInfo info1 = processOpnd(tree, loopHead, defStack, opnd1);
OSROpndInfo info2 = processOpnd(tree, loopHead, defStack, opnd2);
if ((info1.isLDConst() || info1.isDOL())
&& (info2.isLDConst() || info2.isDOL())) {
if (info1.isLDConst() && info2.isLDConst()
&& info1.getConst() == info2.getConst()) {
result.setType(OSROpndInfo::LD_CONST);
result.setConst(info1.getConst());
writeHeaderToResult(result, tree, info1, info2);
}
} else if ((info1.isCounter() && info2.isLDConst())
|| (info2.isCounter() && info1.isLDConst())) {
U_32 increment = info1.isCounter() ?
info1.getIncrement() : info2.getIncrement();
U_32 diff = info1.isLDConst()? info1.getConst() : info2.getConst();
bool monotonousFlag = increment == 0 || diff == 0
|| (opcode == Op_Add && signof(diff) == signof(increment))
|| (opcode == Op_Sub && signof(diff) != signof(increment));
if (monotonousFlag) {
result.setType(OSROpndInfo::COUNTER);
if ((info1.isCounter() && info1.isPhiSplit()) ||
(info2.isCounter() && info2.isPhiSplit())) {
result.markPhiSplit();
writeHeaderToResult(result, tree, info1, info2);
}
if (opcode == Op_Add) {
result.setIncrement(increment + diff);
writeHeaderToResult(result, tree, info1, info2);
} else {
result.setIncrement(increment - diff);
writeHeaderToResult(result, tree, info1, info2);
}
} else {
result.setType(OSROpndInfo::UNDEF);
}
} else {
result.setType(OSROpndInfo::UNDEF);
}
} else if (opcode == Op_StVar || opcode == Op_LdVar) {
Opnd* newOpnd = defInst->getSrc(0);
result = processOpnd(tree, loopHead, defStack, newOpnd);
} else if (opcode == Op_TauArrayLen) {
Opnd* arrayOpnd = defInst->getSrc(0);
result = processOpnd(tree, loopHead, defStack, arrayOpnd);
} else {
result.setType(OSROpndInfo::UNDEF);
}
defStack.pop_back();
result.setOpnd((Opnd*) opnd);
return result;
}
static OpndLoopInfo processOpnd(LoopNode* loopHead, LoopTree* lt, InstStack& defStack, Opnd* opnd) {
OpndLoopInfo result;
Inst* defInst = opnd->getInst();
if (Log::isEnabled()) {
log_ident(defStack.size()); defInst->print(Log::out()); Log::out()<<"]"<<std::endl;
}
if (std::find(defStack.begin(), defStack.end(), defInst)!=defStack.end()) {
result.setType(OpndLoopInfo::COUNTER);
result.setIncrement(0);
if (Log::isEnabled()) {
log_ident(defStack.size());
Log::out()<<"Found duplicate in def stack -> stopping recursion. ";result.print(Log::out()); Log::out()<<std::endl;
}
return result;
}
Node* defNode = defInst->getNode();
Opcode opcode = defInst->getOpcode();
if (opcode == Op_LdConstant) {
result.setType(OpndLoopInfo::LD_CONST);
result.setConst(defInst->asConstInst()->getValue().i4);
if (Log::isEnabled()) {
log_ident(defStack.size());
Log::out()<<"assigning to const -> stopping recursion. ";result.print(Log::out());Log::out()<<std::endl;
}
return result;
}
if (!loopHead->inLoop(defNode)) {
if (Log::isEnabled()) {
log_ident(defStack.size());
Log::out()<<"Inst out of the loop -> stopping recursion. ";result.print(Log::out()); Log::out()<<std::endl;
}
return result;
}
defStack.push_back(defInst);
if (opcode == Op_Phi) {
OpndLoopInfo info1 = processOpnd(loopHead, lt, defStack, defInst->getSrc(0));
OpndLoopInfo info2 = processOpnd(loopHead, lt, defStack, defInst->getSrc(1));
if (Log::isEnabled()) {
log_ident(defStack.size());
Log::out()<<"PHI(";info1.print(Log::out());Log::out()<<",";info2.print(Log::out());Log::out()<<")"<<std::endl;
}
if ( ((info1.isCounter() && !info1.isPhiSplit()) && (info2.isDOL() || info2.isLDConst()))
|| ((info2.isCounter() && !info2.isPhiSplit()) && (info1.isDOL() || info1.isLDConst())) )
{
result.setType(OpndLoopInfo::COUNTER);
result.setIncrement(info1.isCounter() ? info1.getIncrement() : info2.getIncrement());
result.markPhiSplit();
} else {
result.setType(OpndLoopInfo::UNDEF);
}
} else if (opcode == Op_Add || opcode == Op_Sub) { //todo: LADD
Opnd *op1 = defInst->getSrc(0);
Opnd *op2 = defInst->getSrc(1);
OpndLoopInfo info1 = processOpnd(loopHead, lt, defStack, op1);
OpndLoopInfo info2 = processOpnd(loopHead, lt, defStack, op2);
if ((info1.isLDConst() || info1.isDOL()) && (info2.isLDConst() || info2.isDOL())) {
if (info1.isLDConst() && info2.isLDConst() && info1.getConst() == info2.getConst()) {
result.setType(OpndLoopInfo::LD_CONST);
result.setConst(info1.getConst());
} else {
//result is DOL (default type)
}
} else if ((info1.isCounter() && info2.isLDConst()) || (info2.isCounter() && info1.isLDConst())) {
int increment = info1.isCounter()? info1.getIncrement(): info2.getIncrement();
int diff = info1.isLDConst()? info1.getConst(): info2.getConst();
//we use SSA form to analyze how opnd changes in loop and we do not analyze actual control flow,
// so we can unroll loops with monotonically changing 'counters' only.
//Example: when 'counter' changes not monotonically and we can't unroll:
//idx=0; loop {idx+=100; if(idx>=100) break; idx-=99;} ->'increment'=1 but not monotonicaly.
bool monotonousFlag = increment == 0 || diff == 0
|| (opcode == Op_Add && signof(diff) == signof(increment))
|| (opcode == Op_Sub && signof(diff) != signof(increment));
if (monotonousFlag) {
result.setType(OpndLoopInfo::COUNTER);
if ((info1.isCounter() && info1.isPhiSplit()) || (info2.isCounter() && info2.isPhiSplit())) {
result.markPhiSplit();
}
//TO IMPROVE: for loops like: for (; length-1>=0;length--){...}
//we have 2 SUBs by -1 => "-2", but real counter is changed by "-1".
//Loop unroll will use "-2". It's ok, because this value is used in a guard inst
//and ABS(increment_in_unroll) >= ABS(real_increment). This work only for monotonous loops.
//To make increment_in_unroll == real_increment we must track modifications (SUB,ADD) that affects vars only.
if (opcode == Op_Add) {
result.setIncrement(increment + diff);
} else {
result.setIncrement(increment - diff);
}
} else {
result.setType(OpndLoopInfo::UNDEF);
}
} else {
result.setType(OpndLoopInfo::UNDEF);
}
} else if (opcode == Op_StVar || opcode == Op_LdVar) {
Opnd* newOpnd = defInst->getSrc(0);
result = processOpnd(loopHead, lt, defStack, newOpnd);
} else if (opcode == Op_TauArrayLen) {
Opnd* arrayOpnd = defInst->getSrc(0);
result = processOpnd(loopHead, lt, defStack, arrayOpnd);
} else { //unsupported op
result.setType(OpndLoopInfo::UNDEF);
if (Log::isEnabled()) {
log_ident(defStack.size()); Log::out()<<"unknown op -> stopping recursion. ";
}
}
defStack.pop_back();
if (Log::isEnabled()) {
log_ident(defStack.size());
result.print(Log::out());Log::out()<<std::endl;
}
return result;
}
Node * JavaFlowGraphBuilder::edgesForBlock(Node* block) {
//
// find if this block has any region that could catch the exception
//
Node *dispatch = NULL;
ExceptionInfo *exceptionInfo = (CatchBlock*)((LabelInst*)block->getFirstInst())->getState();
if (exceptionInfo != NULL) {
dispatch = exceptionInfo->getLabelInst()->getNode();
}else{
dispatch = fg->getUnwindNode();
}
assert(dispatch->isDispatchNode());
//
// split the block so that
// each potentially-exceptional instruction ends a block
//
Inst* first = (Inst*)block->getFirstInst();
Inst* last = (Inst*)block->getLastInst();
Inst* lastExceptionalInstSeen = NULL;
for (Inst* inst = first->getNextInst(); inst != NULL; inst = inst->getNextInst()) {
if (lastExceptionalInstSeen != NULL) {
// start a new basic block
LabelInst* label = irBuilder.getInstFactory()->makeLabel();
Node *newblock = createBlockNodeAfter(block, label);
uint16 bcOffset = ILLEGAL_BC_MAPPING_VALUE;
for (Inst *ins = lastExceptionalInstSeen->getNextInst(), *nextIns = NULL; ins!=NULL; ins = nextIns) {
nextIns = ins->getNextInst();
ins->unlink();
newblock->appendInst(ins);
if (bcOffset == ILLEGAL_BC_MAPPING_VALUE) {
bcOffset = ins->getBCOffset();
}
}
label->setBCOffset(bcOffset);
// now fix up the CFG, duplicating edges
if (!lastExceptionalInstSeen->isThrow())
fg->addEdge(block,newblock);
//
// add an edge to handler entry node
//
assert(!block->findTargetEdge(dispatch));
fg->addEdge(block,dispatch);
block = newblock;
lastExceptionalInstSeen = NULL;
}
if (inst->getOperation().canThrow()) {
lastExceptionalInstSeen = inst;
}
}
//
// examine the last instruction and create appropriate CFG edges
//
switch(last->getOpcode()) {
case Op_Jump:
{
fg->addEdge(block,((BranchInst*)last)->getTargetLabel()->getNode());
last->unlink();
}
break;
case Op_Branch:
case Op_JSR:
addEdge(block, ((BranchInst*)last)->getTargetLabel()->getNode());
edgeForFallthrough(block);
break;
case Op_Throw:
case Op_ThrowSystemException:
case Op_ThrowLinkingException:
// throw/rethrow creates an edge to a handler that catches the exception
assert(dispatch != NULL);
assert(lastExceptionalInstSeen == last);
break;
case Op_Return:
addEdge(block, fg->getReturnNode());
break;
case Op_Ret:
break; // do not do anything
case Op_Switch:
{
SwitchInst *sw = (SwitchInst*)last;
U_32 num = sw->getNumTargets();
for (U_32 i = 0; i < num; i++) {
Node* target = sw->getTarget(i)->getNode();
// two switch values may go to the same block
if (!block->findTargetEdge(target)) {
fg->addEdge(block,target);
}
}
Node* target = sw->getDefaultTarget()->getNode();
if (!block->findTargetEdge(target)) {
fg->addEdge(block,target);
}
}
break;
default:;
if (block != fg->getReturnNode()) { // a fallthrough edge is needed
// if the basic block does not have any outgoing edge, add one fall through edge
if (block->getOutEdges().empty())
edgeForFallthrough(block);
}
}
//
// add an edge to handler entry node
//
if (lastExceptionalInstSeen != NULL)
addEdge(block,dispatch);
return block;
}
