/**
* A runtime guard block may have monitor stores and privarg stores along with the guard
* it self. This method will rearrange these stores and split the block, managing any
* uncommoning necessary for eventual block order.
*
* The provided block will become the privarg block, containing any privarg stores and additonal
* temps for uncommoning. It must be evaluated first. The returned block will contain monitor
* stores and the guard. If no split is required, the provided block will be returned.
*
* @param comp Compilation object
* @param block Block to manipulate
* @param cfg Current CFG
* @return The block containing the guard.
*/
static TR::Block* splitRuntimeGuardBlock(TR::Compilation *comp, TR::Block* block, TR::CFG *cfg)
{
TR::NodeChecklist checklist(comp);
TR::TreeTop *start = block->getFirstRealTreeTop();
TR::TreeTop *guard = block->getLastRealTreeTop();
TR::TreeTop *firstPrivArg = NULL;
TR::TreeTop *firstMonitor = NULL;
// Manage the unexpected case that monitors and priv args are reversed
bool privThenMonitor = false;
TR_ASSERT(isMergeableGuard(guard->getNode()), "last node must be guard %p", guard->getNode());
// Search for privarg and monitor stores
// Only commoned nodes under the guard are required to be anchored, due to the guard being
// evaluted before the monitor stores later on
bool anchoredTemps = false;
for (TR::TreeTop *tt = start; tt && tt->getNode()->getOpCodeValue() != TR::BBEnd; tt = tt->getNextTreeTop())
{
TR::Node * node = tt->getNode();
if (node->getOpCode().hasSymbolReference() && node->getSymbol()->holdsMonitoredObject())
firstMonitor = firstMonitor == NULL ? tt : firstMonitor;
else if (node->chkIsPrivatizedInlinerArg())
{
if (firstPrivArg == NULL)
{
firstPrivArg = tt;
privThenMonitor = (firstMonitor == NULL);
}
}
else if (isMergeableGuard(node))
anchoredTemps |= anchorCommonNodes(comp, node, start, checklist);
else
TR_ASSERT(0, "Node other than monitor or privarg store %p before runtime guard", node);
}
// If there are monitors then privargs, they must be swapped around, such that all privargs are
// evaluated first
if (firstPrivArg && firstMonitor && !privThenMonitor)
{
TR::TreeTop *monitorEnd = firstPrivArg->getPrevTreeTop();
firstMonitor->getPrevTreeTop()->join(firstPrivArg);
guard->getPrevTreeTop()->join(firstMonitor);
monitorEnd->join(guard);
}
// If there were temps created or privargs in the block, perform a split
TR::TreeTop *split = NULL;
if (firstPrivArg)
split = firstMonitor ? firstMonitor : guard;
else if (anchoredTemps)
split = start;
if (split)
return block->split(split, cfg, true /* fixupCommoning */, false /* copyExceptionSuccessors */);
return block;
}
// Add an async check into a block - MUST be at block entry
//
void TR_AsyncCheckInsertion::insertAsyncCheck(TR::Block *block, TR::Compilation *comp, const char *counterPrefix)
{
TR::TreeTop *lastTree = block->getLastRealTreeTop();
TR::TreeTop *asyncTree =
TR::TreeTop::create(comp,
TR::Node::createWithSymRef(lastTree->getNode(), TR::asynccheck, 0,
comp->getSymRefTab()->findOrCreateAsyncCheckSymbolRef(comp->getMethodSymbol())));
if (lastTree->getNode()->getOpCode().isReturn())
{
TR::TreeTop *prevTree = lastTree->getPrevTreeTop();
prevTree->join(asyncTree);
asyncTree->join(lastTree);
}
else
{
TR::TreeTop *nextTree = block->getEntry()->getNextTreeTop();
block->getEntry()->join(asyncTree);
asyncTree->join(nextTree);
}
const char * const name = TR::DebugCounter::debugCounterName(comp,
"asynccheck.insert/%s/(%s)/%s/block_%d",
counterPrefix,
comp->signature(),
comp->getHotnessName(),
block->getNumber());
TR::DebugCounter::prependDebugCounter(comp, name, asyncTree->getNextTreeTop());
}
void TR::ILValidator::checkSoundness(TR::TreeTop *start, TR::TreeTop *stop)
{
soundnessRule(start, start != NULL, "Start tree must exist");
soundnessRule(stop, !stop || stop->getNode() != NULL, "Stop tree must have a node");
TR::NodeChecklist treetopNodes(comp()), ancestorNodes(comp()), visitedNodes(comp());
// Can't use iterators here, because those presuppose the IL is sound. Walk trees the old-fashioned way.
//
for (TR::TreeTop *currentTree = start; currentTree != stop; currentTree = currentTree->getNextTreeTop())
{
soundnessRule(currentTree, currentTree->getNode() != NULL, "Tree must have a node");
soundnessRule(currentTree, !treetopNodes.contains(currentTree->getNode()), "Treetop node n%dn encountered twice", currentTree->getNode()->getGlobalIndex());
treetopNodes.add(currentTree->getNode());
TR::TreeTop *next = currentTree->getNextTreeTop();
if (next)
{
soundnessRule(currentTree, next->getNode() != NULL, "Tree after n%dn must have a node", currentTree->getNode()->getGlobalIndex());
soundnessRule(currentTree, next->getPrevTreeTop() == currentTree, "Doubly-linked treetop list must be consistent: n%dn->n%dn<-n%dn", currentTree->getNode()->getGlobalIndex(), next->getNode()->getGlobalIndex(), next->getPrevTreeTop()->getNode()->getGlobalIndex());
}
else
{
soundnessRule(currentTree, stop == NULL, "Reached the end of the trees after n%dn without encountering the stop tree n%dn", currentTree->getNode()->getGlobalIndex(), stop? stop->getNode()->getGlobalIndex() : 0);
checkNodeSoundness(currentTree, currentTree->getNode(), ancestorNodes, visitedNodes);
}
}
}
void
TR_ExpressionsSimplification::transformNode(TR::Node *srcNode, TR::Block *dstBlock)
{
TR::TreeTop *lastTree = dstBlock->getLastRealTreeTop();
TR::TreeTop *prevTree = lastTree->getPrevTreeTop();
TR::TreeTop *srcNodeTT = TR::TreeTop::create(comp(), srcNode);
if (trace())
comp()->getDebug()->print(comp()->getOutFile(),srcNode,0,true);
if (lastTree->getNode()->getOpCode().isBranch() ||
(lastTree->getNode()->getOpCode().isJumpWithMultipleTargets() && lastTree->getNode()->getOpCode().hasBranchChildren()))
{
srcNodeTT->join(lastTree);
prevTree->join(srcNodeTT);
}
/*
else if (dstBlock->getEntry()->getNode()->getOpCodeValue() == TR::BBStart)
{
srcNodeTT->join(dstBlock->getExit());
dstBlock->getEntry()->join(srcNodeTT);
}
*/
else
{
srcNodeTT->join(dstBlock->getExit());
lastTree->join(srcNodeTT);
}
return;
}
void TR_Latestness::analyzeTreeTopsInBlockStructure(TR_BlockStructure *blockStructure)
{
TR::Block *block = blockStructure->getBlock();
TR::TreeTop *currentTree = block->getExit();
TR::TreeTop *entryTree = block->getEntry();
/////copyFromInto(_regularInfo, _outSetInfo[blockStructure->getNumber()]);
bool notSeenTreeWithChecks = true;
_containsExceptionTreeTop = false;
while (!(currentTree == entryTree))
{
if (notSeenTreeWithChecks)
{
bool currentTreeHasChecks = treeHasChecks(currentTree);
if (currentTreeHasChecks)
{
notSeenTreeWithChecks = false;
_containsExceptionTreeTop = true;
/////compose(_regularInfo, _exceptionInfo);
/////compose(_outSetInfo[blockStructure->getNumber()], _exceptionInfo);
}
}
else
break;
if (!(currentTree == entryTree))
currentTree = currentTree->getPrevTreeTop();
}
}
void TR::SoundnessRule::validate(TR::ResolvedMethodSymbol *methodSymbol)
{
TR::TreeTop *start = methodSymbol->getFirstTreeTop();
TR::TreeTop *stop = methodSymbol->getLastTreeTop();
checkSoundnessCondition(start, start != NULL, "Start tree must exist");
checkSoundnessCondition(stop, !stop || stop->getNode() != NULL,
"Stop tree must have a node");
TR::NodeChecklist treetopNodes(comp()), ancestorNodes(comp()), visitedNodes(comp());
/* NOTE: Can't use iterators here, because iterators presuppose that the IL is sound. */
for (TR::TreeTop *currentTree = start; currentTree != stop;
currentTree = currentTree->getNextTreeTop())
{
checkSoundnessCondition(currentTree, currentTree->getNode() != NULL,
"Tree must have a node");
checkSoundnessCondition(currentTree, !treetopNodes.contains(currentTree->getNode()),
"Treetop node n%dn encountered twice",
currentTree->getNode()->getGlobalIndex());
treetopNodes.add(currentTree->getNode());
TR::TreeTop *next = currentTree->getNextTreeTop();
if (next)
{
checkSoundnessCondition(currentTree, next->getNode() != NULL,
"Tree after n%dn must have a node",
currentTree->getNode()->getGlobalIndex());
checkSoundnessCondition(currentTree, next->getPrevTreeTop() == currentTree,
"Doubly-linked treetop list must be consistent: n%dn->n%dn<-n%dn",
currentTree->getNode()->getGlobalIndex(),
next->getNode()->getGlobalIndex(),
next->getPrevTreeTop()->getNode()->getGlobalIndex());
}
else
{
checkSoundnessCondition(currentTree, stop == NULL,
"Reached the end of the trees after n%dn without encountering the stop tree n%dn",
currentTree->getNode()->getGlobalIndex(),
stop? stop->getNode()->getGlobalIndex() : 0);
checkNodeSoundness(currentTree, currentTree->getNode(),
ancestorNodes, visitedNodes);
}
}
}
inline TR::TreeTop *
OMR::TreeTop::getPrevRealTreeTop()
{
TR::TreeTop *treeTop;
for (treeTop = self()->getPrevTreeTop();
treeTop && treeTop->getNode()->getOpCode().isExceptionRangeFence();
treeTop = treeTop->getPrevTreeTop())
{}
return treeTop;
}
inline TR::Block *
OMR::TreeTop::getEnclosingBlock( bool forward)
{
TR::TreeTop * tt = self();
if (forward)
while (tt->getNode()->getOpCodeValue() != TR::BBEnd)
{
tt = tt->getNextTreeTop();
//TR_ASSERT(tt && tt->getNode(), "either tt or node on a tt null here, we will segfault");
}
else
while (tt->getNode()->getOpCodeValue() != TR::BBStart)
{
tt = tt->getPrevTreeTop();
//TR_ASSERT(tt && tt->getNode(), "either tt or node on a tt null here, we will segfault");
}
return tt->getNode()->getBlock();
}
bool TR_LocalLiveRangeReduction::moveTreeBefore(TR_TreeRefInfo *treeToMove,TR_TreeRefInfo *anchor,int32_t passNumber)
{
TR::TreeTop *treeToMoveTT = treeToMove->getTreeTop();
TR::TreeTop *anchorTT = anchor->getTreeTop();
if (treeToMoveTT->getNextRealTreeTop() == anchorTT)
{
addDepPair(treeToMove, anchor);
return false;
}
if (!performTransformation(comp(), "%sPass %d: moving tree [%p] before Tree %p\n", OPT_DETAILS, passNumber, treeToMoveTT->getNode(),anchorTT->getNode()))
return false;
// printf("Moving [%p] before Tree %p\n", treeToMoveTT->getNode(),anchorTT->getNode());
//changing location in block
TR::TreeTop *origPrevTree = treeToMoveTT->getPrevTreeTop();
TR::TreeTop *origNextTree = treeToMoveTT->getNextTreeTop();
origPrevTree->setNextTreeTop(origNextTree);
origNextTree->setPrevTreeTop(origPrevTree);
TR::TreeTop *prevTree = anchorTT->getPrevTreeTop();
anchorTT->setPrevTreeTop(treeToMoveTT);
treeToMoveTT->setNextTreeTop(anchorTT);
treeToMoveTT->setPrevTreeTop(prevTree);
prevTree->setNextTreeTop(treeToMoveTT);
//UPDATE REFINFO
//find locations of treeTops in TreeTopsRefInfo array
//startIndex points to the currentTree that has moved
//endIndex points to the treeTop after which we moved the tree (nextTree)
int32_t startIndex = getIndexInArray(treeToMove);
int32_t endIndex = getIndexInArray(anchor)-1;
int32_t i=0;
for ( i = startIndex+1; i<= endIndex ; i++)
{
TR_TreeRefInfo *currentTreeRefInfo = _treesRefInfoArray[i];
List<TR::Node> *firstList = currentTreeRefInfo->getFirstRefNodesList();
List<TR::Node> *midList = currentTreeRefInfo->getMidRefNodesList();
List<TR::Node> *lastList = currentTreeRefInfo->getLastRefNodesList();
List<TR::Node> *M_firstList = treeToMove->getFirstRefNodesList();
List<TR::Node> *M_midList = treeToMove->getMidRefNodesList();
List<TR::Node> *M_lastList = treeToMove->getLastRefNodesList();
if (trace())
{
traceMsg(comp(),"Before move:\n");
printRefInfo(treeToMove);
printRefInfo(currentTreeRefInfo);
}
updateRefInfo(treeToMove->getTreeTop()->getNode(), currentTreeRefInfo, treeToMove , false);
treeToMove->resetSyms();
currentTreeRefInfo->resetSyms();
populatePotentialDeps(currentTreeRefInfo,currentTreeRefInfo->getTreeTop()->getNode());
populatePotentialDeps(treeToMove,treeToMove->getTreeTop()->getNode());
if (trace())
{
traceMsg(comp(),"After move:\n");
printRefInfo(treeToMove);
printRefInfo(currentTreeRefInfo);
traceMsg(comp(),"------------------------\n");
}
}
TR_TreeRefInfo *temp = _treesRefInfoArray[startIndex];
for (i = startIndex; i< endIndex ; i++)
{
_treesRefInfoArray[i] = _treesRefInfoArray[i+1];
}
_treesRefInfoArray[endIndex]=temp;
#if defined(DEBUG) || defined(PROD_WITH_ASSUMES)
if (!(comp()->getOption(TR_EnableParanoidOptCheck) || debug("paranoidOptCheck")))
return true;
//verifier
{
TR::StackMemoryRegion stackMemoryRegion(*trMemory());
vcount_t visitCount = comp()->getVisitCount();
int32_t maxRefCount = 0;
TR::TreeTop *tt;
TR_TreeRefInfo **treesRefInfoArrayTemp = (TR_TreeRefInfo**)trMemory()->allocateStackMemory(_numTreeTops*sizeof(TR_TreeRefInfo*));
memset(treesRefInfoArrayTemp, 0, _numTreeTops*sizeof(TR_TreeRefInfo*));
TR_TreeRefInfo *treeRefInfoTemp;
//collect info
for ( int32_t i = 0; i<_numTreeTops-1; i++)
{
tt =_treesRefInfoArray[i]->getTreeTop();
treeRefInfoTemp = new (trStackMemory()) TR_TreeRefInfo(tt, trMemory());
collectRefInfo(treeRefInfoTemp, tt->getNode(),visitCount,&maxRefCount);
treesRefInfoArrayTemp[i] = treeRefInfoTemp;
}
comp()->setVisitCount(visitCount+maxRefCount);
for ( int32_t i = 0; i<_numTreeTops-1; i++)
{
if (!verifyRefInfo(treesRefInfoArrayTemp[i]->getFirstRefNodesList(),_treesRefInfoArray[i]->getFirstRefNodesList()))
{
printOnVerifyError(_treesRefInfoArray[i],treesRefInfoArrayTemp[i]);
TR_ASSERT(0,"fail to verify firstRefNodesList for %p\n",_treesRefInfoArray[i]->getTreeTop()->getNode());
}
if (!verifyRefInfo(treesRefInfoArrayTemp[i]->getMidRefNodesList(),_treesRefInfoArray[i]->getMidRefNodesList()))
{
printOnVerifyError(_treesRefInfoArray[i],treesRefInfoArrayTemp[i]);
TR_ASSERT(0,"fail to verify midRefNodesList for %p\n",_treesRefInfoArray[i]->getTreeTop()->getNode());
}
if (!verifyRefInfo(treesRefInfoArrayTemp[i]->getLastRefNodesList(),_treesRefInfoArray[i]->getLastRefNodesList()))
{
printOnVerifyError(_treesRefInfoArray[i],treesRefInfoArrayTemp[i]);
TR_ASSERT(0,"fail to verify lastRefNodesList for %p\n",_treesRefInfoArray[i]->getTreeTop()->getNode());
}
}
} // scope of the stack memory region
#endif
return true;
}
TR::TreeTop *
OMR::Simplifier::simplifyExtendedBlock(TR::TreeTop * treeTop)
{
TR::Block * block = 0;
_containingStructure = NULL;
_blockRemoved = false;
for (; treeTop; treeTop = treeTop->getNextTreeTop())
{
TR::Node * node = treeTop->getNode();
TR_ASSERT(node->getOpCodeValue() == TR::BBStart, "Simplification, expected BBStart treetop");
TR::Block * b = node->getBlock();
if (block && !b->isExtensionOfPreviousBlock())
break;
if (b->isOSRCodeBlock() || b->isOSRCatchBlock())
{
b->setHasBeenVisited();
treeTop = b->getExit();
continue;
}
#ifdef DEBUG
if (block != b)
b->setHasBeenVisited();
#endif
if (!block && _reassociate &&
comp()->getFlowGraph()->getStructure() != NULL // [99391] getStructureOf() only valid if structure isn't invalidated
)
{ // b is first block in the extended block
TR_BlockStructure *blockStructure = b->getStructureOf();
if(blockStructure)
{
TR_Structure *parent = blockStructure->getParent();
while (parent)
{
TR_RegionStructure *region = parent->asRegion();
if (region->isNaturalLoop() /* || region->containsInternalCycles() */)
{
_containingStructure = region;
break;
}
parent = parent->getParent();
}
}
}
block = b;
if (trace())
traceMsg(comp(), "simplifying block_%d\n", block->getNumber());
_performLowerTreeSimplifier=NULL;
_performLowerTreeNode=NULL;
simplify(block);
if(_performLowerTreeSimplifier)
{
_performLowerTreeNode = postWalkLowerTreeSimplifier(_performLowerTreeSimplifier, _performLowerTreeNode, block, (TR::Simplifier *) this);
_performLowerTreeSimplifier->setNode(_performLowerTreeNode);
}
// If the block itself was removed from the CFG during simplification, find
// the next 'legitimate' block to be simplified
//
//if (comp()->getFlowGraph()->getRemovedNodes().find(block))
if(block->nodeIsRemoved())
{
TR::TreeTop * tt = findNextLegalTreeTop(comp(), block);
// in certain cases the removed block might be the last one we haven't
// visited and therefore we won't be able to find a treetop to continue
// in such cases we exit the loop
//
treeTop = tt ? tt->getPrevTreeTop() : 0;
if (!treeTop)
break;
}
else
{
treeTop = block->getExit();
}
}
// now remove any unreachable blocks
//
if (_blockRemoved)
{
// if the next block to be processed has been removed,
// find the next valid block to process
//
if (treeTop)
{
TR::Block *b = treeTop->getNode()->getBlock();
//if (comp()->getFlowGraph()->getRemovedNodes().find(b))
if(b->nodeIsRemoved())
treeTop = findNextLegalTreeTop(comp(), b);
}
}
return treeTop;
}
int32_t TR::DeadTreesElimination::process(TR::TreeTop *startTree, TR::TreeTop *endTree)
{
TR::StackMemoryRegion stackRegion(*comp()->trMemory());
LongestPathMap longestPaths(std::less<TR::Node*>(), stackRegion);
typedef TR::typed_allocator<CRAnchor, TR::Region&> CRAnchorAlloc;
typedef TR::forward_list<CRAnchor, CRAnchorAlloc> CRAnchorList;
CRAnchorList anchors(stackRegion);
vcount_t visitCount = comp()->incOrResetVisitCount();
TR::TreeTop *treeTop;
for (treeTop = startTree; (treeTop != endTree); treeTop = treeTop->getNextTreeTop())
treeTop->getNode()->initializeFutureUseCounts(visitCount);
TR::Block *block = NULL;
bool delayedRegStoresBeforeThisPass = _delayedRegStores;
// Update visitCount as they are used in this optimization and need to be
visitCount = comp()->incOrResetVisitCount();
for (TR::TreeTopIterator iter(startTree, comp()); iter != endTree; ++iter)
{
TR::Node *node = iter.currentTree()->getNode();
if (node->getOpCodeValue() == TR::BBStart)
{
block = node->getBlock();
if (!block->isExtensionOfPreviousBlock())
longestPaths.clear();
}
int vcountLimit = MAX_VCOUNT - 3;
if (comp()->getVisitCount() > vcountLimit)
{
dumpOptDetails(comp(),
"%sVisit count %d exceeds limit %d; stopping\n",
optDetailString(), comp()->getVisitCount(), vcountLimit);
return 0;
}
// correct at all intermediate stages
//
if ((node->getOpCodeValue() != TR::treetop) &&
(!node->getOpCode().isAnchor() || (node->getFirstChild()->getReferenceCount() != 1)) &&
(!node->getOpCode().isStoreReg() || (node->getFirstChild()->getReferenceCount() != 1)) &&
(delayedRegStoresBeforeThisPass ||
(iter.currentTree() == block->getLastRealTreeTop()) ||
!node->getOpCode().isStoreReg() ||
(node->getVisitCount() == visitCount)))
{
if (node->getOpCode().isAnchor() && node->getFirstChild()->getOpCode().isLoadIndirect())
anchors.push_front(CRAnchor(iter.currentTree(), block));
TR::TransformUtil::recursivelySetNodeVisitCount(node, visitCount);
continue;
}
if (node->getOpCode().isStoreReg())
_delayedRegStores = true;
TR::Node *child = node->getFirstChild();
if (child->getOpCodeValue() == TR::PassThrough)
{
TR::Node *newChild = child->getFirstChild();
node->setAndIncChild(0, newChild);
newChild->incFutureUseCount();
if (child->getReferenceCount() <= 1)
optimizer()->prepareForNodeRemoval(child);
child->recursivelyDecReferenceCount();
recursivelyDecFutureUseCount(child);
child = newChild;
}
bool treeTopCanBeEliminated = false;
// If the treetop child has been seen before then it must be anchored
// somewhere above already; so we don't need the treetop to be anchoring
// this node (as the computation is already done at the first reference to
// the node).
//
if (visitCount == child->getVisitCount())
{
treeTopCanBeEliminated = true;
}
else
{
TR::ILOpCode &childOpCode = child->getOpCode();
TR::ILOpCodes opCodeValue = childOpCode.getOpCodeValue();
bool seenConditionalBranch = false;
bool callWithNoSideEffects = child->getOpCode().isCall() &&
child->getSymbolReference()->getSymbol()->isResolvedMethod() &&
child->getSymbolReference()->getSymbol()->castToResolvedMethodSymbol()->isSideEffectFree();
if (callWithNoSideEffects)
{
treeTopCanBeEliminated = true;
}
else if (!((childOpCode.isCall() && !callWithNoSideEffects) ||
childOpCode.isStore() ||
((opCodeValue == TR::New ||
opCodeValue == TR::anewarray ||
opCodeValue == TR::newarray) &&
child->getReferenceCount() > 1) ||
opCodeValue == TR::multianewarray ||
opCodeValue == TR::MergeNew ||
opCodeValue == TR::checkcast ||
opCodeValue == TR::Prefetch ||
opCodeValue == TR::iu2l ||
((childOpCode.isDiv() ||
childOpCode.isRem()) &&
child->getNumChildren() == 3)))
{
// Perform the rather complex check to see whether its safe
// to disconnect the child node from the treetop
//
bool safeToReplaceNode = false;
if (child->getReferenceCount() == 1)
{
safeToReplaceNode = true;
#ifdef J9_PROJECT_SPECIFIC
if (child->getOpCode().isPackedExponentiation())
{
// pdexp has a possible message side effect in truncating or no significant digits left cases
safeToReplaceNode = false;
}
#endif
if (opCodeValue == TR::loadaddr)
treeTopCanBeEliminated = true;
}
else if (!_cannotBeEliminated)
{
safeToReplaceNode = isSafeToReplaceNode(
child,
iter.currentTree(),
&seenConditionalBranch,
visitCount,
comp(),
&_targetTrees,
_cannotBeEliminated,
longestPaths);
}
if (safeToReplaceNode)
{
if (childOpCode.hasSymbolReference())
{
TR::SymbolReference *symRef = child->getSymbolReference();
if (symRef->getSymbol()->isAuto() || symRef->getSymbol()->isParm())
treeTopCanBeEliminated = true;
else
{
if (childOpCode.isLoad() ||
(opCodeValue == TR::loadaddr) ||
(opCodeValue == TR::instanceof) ||
(((opCodeValue == TR::New) ||
(opCodeValue == TR::anewarray ||
opCodeValue == TR::newarray)) &&
///child->getFirstChild()->isNonNegative()))
child->markedAllocationCanBeRemoved()))
// opCodeValue == TR::multianewarray ||
// opCodeValue == TR::MergeNew)
treeTopCanBeEliminated = true;
}
}
else
treeTopCanBeEliminated = true;
}
}
// Fix for the case when a float to non-float conversion node swings
// down past a branch on IA32; this would cause a FP value to be commoned
// across a branch where there was none originally; this causes pblms
// as a value is left on the stack.
//
if (treeTopCanBeEliminated &&
seenConditionalBranch)
{
if (!cg()->getSupportsJavaFloatSemantics())
{
if (child->getOpCode().isConversion() ||
child->getOpCode().isBooleanCompare())
{
if (child->getFirstChild()->getOpCode().isFloatingPoint() &&
!child->getOpCode().isFloatingPoint())
treeTopCanBeEliminated = false;
}
}
}
if (treeTopCanBeEliminated)
{
TR::NodeChecklist visited(comp());
bool containsFloatingPoint = false;
for (int32_t i = 0; i < child->getNumChildren(); ++i)
{
// Anchor nodes with reference count > 1
//
bool highGlobalIndex = false;
if (fixUpTree(child->getChild(i), iter.currentTree(), visited, highGlobalIndex, self(), visitCount))
containsFloatingPoint = true;
if (highGlobalIndex)
{
dumpOptDetails(comp(),
"%sGlobal index limit exceeded; stopping\n",
optDetailString());
return 0;
}
}
if (seenConditionalBranch &&
containsFloatingPoint)
{
if (!cg()->getSupportsJavaFloatSemantics())
treeTopCanBeEliminated = false;
}
}
}
// Update visitCount as they are used in this optimization and need to be
// correct at all intermediate stages
//
if (!treeTopCanBeEliminated)
TR::TransformUtil::recursivelySetNodeVisitCount(node, visitCount);
if (treeTopCanBeEliminated)
{
TR::TreeTop *prevTree = iter.currentTree()->getPrevTreeTop();
TR::TreeTop *nextTree = iter.currentTree()->getNextTreeTop();
if (!node->getOpCode().isStoreReg() || (node->getFirstChild()->getReferenceCount() == 1))
{
// Actually going to remove the treetop now
//
if (performTransformation(comp(), "%sRemove tree : [" POINTER_PRINTF_FORMAT "] ([" POINTER_PRINTF_FORMAT "] = %s)\n", optDetailString(), node, node->getFirstChild(), node->getFirstChild()->getOpCode().getName()))
{
prevTree->join(nextTree);
optimizer()->prepareForNodeRemoval(node);
///child->recursivelyDecReferenceCount();
node->recursivelyDecReferenceCount();
recursivelyDecFutureUseCount(child);
iter.jumpTo(prevTree);
if (child->getReferenceCount() == 1)
requestOpt(OMR::treeSimplification, true, block);
if (nextTree->getNode()->getOpCodeValue() == TR::Goto
&& prevTree->getNode()->getOpCodeValue() == TR::BBStart
&& !prevTree->getNode()->getBlock()->isExtensionOfPreviousBlock())
{
requestOpt(
OMR::redundantGotoElimination,
prevTree->getNode()->getBlock());
}
}
}
else
{
if (performTransformation(comp(), "%sMove tree : [" POINTER_PRINTF_FORMAT "]([" POINTER_PRINTF_FORMAT "] = %s) to end of block\n", optDetailString(), node, node->getFirstChild(), node->getFirstChild()->getOpCode().getName()))
{
prevTree->join(nextTree);
node->setVisitCount(visitCount);
TR::TreeTop *lastTree = findLastTreetop(block, prevTree);
TR::TreeTop *prevLastTree = lastTree->getPrevTreeTop();
TR::TreeTop *cursorTreeTop = nextTree;
while (cursorTreeTop != lastTree)
{
if (cursorTreeTop->getNode()->getOpCode().isStoreReg() &&
(cursorTreeTop->getNode()->getGlobalRegisterNumber() == iter.currentTree()->getNode()->getGlobalRegisterNumber()))
{
lastTree = cursorTreeTop;
prevLastTree = lastTree->getPrevTreeTop();
break;
}
cursorTreeTop = cursorTreeTop->getNextTreeTop();
}
if (lastTree->getNode()->getOpCodeValue() == TR::BBStart)
{
prevLastTree = lastTree;
lastTree = block->getExit();
}
TR::Node *lastNode = lastTree->getNode();
TR::Node *prevLastNode = prevLastTree->getNode();
if (lastNode->getOpCode().isIf() && !lastNode->getOpCode().isCompBranchOnly() &&
prevLastNode->getOpCode().isStoreReg() &&
((prevLastNode->getFirstChild() == lastNode->getFirstChild()) ||
(prevLastNode->getFirstChild() == lastNode->getSecondChild())))
{
lastTree = prevLastTree;
prevLastTree = lastTree->getPrevTreeTop();
}
prevLastTree->join(iter.currentTree());
iter.currentTree()->join(lastTree);
iter.jumpTo(prevTree);
requestOpt(OMR::treeSimplification, true, block);
}
}
}
}
for (auto it = anchors.begin(); it != anchors.end(); ++it)
{
TR::Node *anchor = it->tree->getNode();
TR::Node *load = anchor->getChild(0);
if (load->getReferenceCount() > 1)
continue;
// We can eliminate the indirect load immediately, but for the moment the
// subtree providing the base object has to be anchored.
TR::Node *heapBase = anchor->getChild(1);
TR::Node::recreate(anchor, TR::treetop);
anchor->setAndIncChild(0, load->getChild(0));
anchor->setChild(1, NULL);
anchor->setNumChildren(1);
if (!heapBase->getOpCode().isLoadConst())
{
it->tree->insertAfter(
TR::TreeTop::create(
comp(),
TR::Node::create(heapBase, TR::treetop, 1, heapBase)));
}
load->recursivelyDecReferenceCount();
heapBase->recursivelyDecReferenceCount();
// A later pass of dead trees can likely move (or even remove) the base
// object expression.
requestOpt(OMR::deadTreesElimination, true, it->block);
}
return 1; // actual cost
}
void TR::DeadTreesElimination::prePerformOnBlocks()
{
_cannotBeEliminated = false;
_delayedRegStores = false;
_targetTrees.deleteAll();
// Walk through all the blocks to remove trivial dead trees of the form
// treetop
// => node
// The problem with these trees is in the scenario where the earlier use
// of 'node' is also dead. However, our analysis won't find that because
// the reference count is > 1.
vcount_t visitCount = comp()->incOrResetVisitCount();
for (TR::TreeTop *tt = comp()->getStartTree();
tt != 0;
tt = tt->getNextTreeTop())
{
bool removed = false;
TR::Node *node = tt->getNode();
if (node->getOpCodeValue() == TR::treetop &&
node->getFirstChild()->getVisitCount() == visitCount &&
performTransformation(comp(), "%sRemove trivial dead tree: %p\n", optDetailString(), node))
{
TR::TransformUtil::removeTree(comp(), tt);
removed = true;
}
else
{
if (node->getOpCode().isCheck() &&
node->getFirstChild()->getOpCode().isCall() &&
node->getFirstChild()->getReferenceCount() == 1 &&
node->getFirstChild()->getSymbolReference()->getSymbol()->isResolvedMethod() &&
node->getFirstChild()->getSymbolReference()->getSymbol()->castToResolvedMethodSymbol()->isSideEffectFree() &&
performTransformation(comp(), "%sRemove dead check of side-effect free call: %p\n", optDetailString(), node))
{
TR::TransformUtil::removeTree(comp(), tt);
removed = true;
}
}
if (removed
&& tt->getNextTreeTop()->getNode()->getOpCodeValue() == TR::Goto
&& tt->getPrevTreeTop()->getNode()->getOpCodeValue() == TR::BBStart
&& !tt->getPrevTreeTop()->getNode()->getBlock()->isExtensionOfPreviousBlock())
{
requestOpt(OMR::redundantGotoElimination, tt->getEnclosingBlock());
}
if (node->getVisitCount() >= visitCount)
continue;
TR::TransformUtil::recursivelySetNodeVisitCount(tt->getNode(), visitCount);
}
// If the last use of an iRegLoad has been removed, then remove the node from
// the BBStart and remove the corresponding dependency node from each of the block's
// predecessors.
//
while (1)
{
bool glRegDepRemoved = false;
for (TR::Block * b = comp()->getStartBlock(); b; b = b->getNextBlock())
{
TR::TreeTop * startTT = b->getEntry();
TR::Node * startNode = startTT->getNode();
if (startNode->getNumChildren() > 0 && !debug("disableEliminationOfGlRegDeps"))
{
TR::Node * glRegDeps = startNode->getFirstChild();
TR_ASSERT(glRegDeps->getOpCodeValue() == TR::GlRegDeps, "expected TR::GlRegDeps");
for (int32_t i = glRegDeps->getNumChildren() - 1; i >= 0; --i)
{
TR::Node * dep = glRegDeps->getChild(i);
if (dep->getReferenceCount() == 1 &&
(!dep->getOpCode().isFloatingPoint() ||
cg()->getSupportsJavaFloatSemantics()) &&
performTransformation(comp(), "%sRemove GlRegDep : %p\n", optDetailString(), glRegDeps->getChild(i)))
{
glRegDeps->removeChild(i);
glRegDepRemoved = true;
TR_GlobalRegisterNumber registerNum = dep->getGlobalRegisterNumber();
for (auto e = b->getPredecessors().begin(); e != b->getPredecessors().end(); ++e)
{
TR::Block * pred = toBlock((*e)->getFrom());
if (pred == comp()->getFlowGraph()->getStart())
continue;
TR::Node * parent = pred->getLastRealTreeTop()->getNode();
if ( parent->getOpCode().isJumpWithMultipleTargets() && parent->getOpCode().hasBranchChildren())
{
for (int32_t j = parent->getCaseIndexUpperBound() - 1; j > 0; --j)
{
TR::Node * caseNode = parent->getChild(j);
TR_ASSERT(caseNode->getOpCode().isCase() || caseNode->getOpCodeValue() == TR::branch,
"having problems navigating a switch");
if (caseNode->getBranchDestination() == startTT &&
caseNode->getNumChildren() > 0 &&
0) // can't do this now that all glRegDeps are hung off the default branch
removeGlRegDep(caseNode, registerNum, pred, this);
}
}
else if (!parent->getOpCode().isReturn() &&
parent->getOpCodeValue() != TR::igoto &&
!( parent->getOpCode().isJumpWithMultipleTargets() && parent->getOpCode().hasBranchChildren()) &&
!(parent->getOpCodeValue()==TR::treetop &&
parent->getFirstChild()->getOpCode().isCall() &&
parent->getFirstChild()->getOpCode().isIndirect()))
{
if (pred->getNextBlock() == b)
parent = pred->getExit()->getNode();
removeGlRegDep(parent, registerNum, pred, this);
}
}
}
}
if (glRegDeps->getNumChildren() == 0)
startNode->removeChild(0);
}
}
if (!glRegDepRemoved)
break;
}
}
