void
TR_ExpressionsSimplification::removeUncertainBlocks(TR_RegionStructure* region, List<TR::Block> *candidateBlocksList)
{
// Examine the top region block first
//
TR::Block *entryBlock = _currentRegion->getEntryBlock();
ListIterator<TR::Block> blocks;
blocks.set(candidateBlocksList);
if (trace())
traceMsg(comp(), "Number of blocks %d, entry block number %d\n", candidateBlocksList->getSize(), entryBlock->getNumber());
for (TR::Block *block = blocks.getFirst(); block; block = blocks.getNext())
{
TR::CFGNode *cfgNode = block;
if (!(cfgNode->getExceptionSuccessors().empty()) || blockHasCalls(block, comp()))
{
if (trace())
traceMsg(comp(), "An exception can be thrown from block_%d. Removing all the blocks, since we cannot know the number of iterations.\n", block->getNumber());
candidateBlocksList->deleteAll();
break;
}
}
TR_PostDominators postDominators(comp());
if (postDominators.isValid())
{
postDominators.findControlDependents();
for (TR::Block *block = blocks.getFirst(); block; block = blocks.getNext())
{
if (postDominators.dominates(block, entryBlock) == 0)
{
candidateBlocksList->remove(block);
if (trace())
traceMsg(comp(), "Block_%d is not guaranteed to be executed at least once. Removing it from the list.\n", block->getNumber());
}
}
}
else
{
if (trace())
traceMsg(comp(), "There is no post dominators information. Removing all the blocks.\n");
for (TR::Block *block = blocks.getFirst(); block; block = blocks.getNext())
{
candidateBlocksList->remove(block);
if (trace())
traceMsg(comp(), "Block_%d is removed from the list\n", block->getNumber());
}
}
}
int32_t TR_CatchBlockRemover::perform()
{
TR::CFG *cfg = comp()->getFlowGraph();
if (cfg == NULL)
{
if (trace())
traceMsg(comp(), "Can't do Catch Block Removal, no CFG\n");
return 0;
}
if (trace())
traceMsg(comp(), "Starting Catch Block Removal\n");
bool thereMayBeRemovableCatchBlocks = false;
{
TR::StackMemoryRegion stackMemoryRegion(*trMemory());
TR::Block *block;
ListIterator<TR::CFGEdge> edgeIterator;
// Go through all blocks that have exception successors and see if any of them
// are not reached. Mark each of these edges with a visit count so they can
// be identified later.
//
vcount_t visitCount = comp()->incOrResetVisitCount();
TR::CFGNode *cfgNode;
for (cfgNode = cfg->getFirstNode(); cfgNode; cfgNode = cfgNode->getNext())
{
if (cfgNode->getExceptionSuccessors().empty())
continue;
block = toBlock(cfgNode);
uint32_t reachedExceptions = 0;
TR::TreeTop *treeTop;
for (treeTop = block->getEntry(); treeTop != block->getExit(); treeTop = treeTop->getNextTreeTop())
{
reachedExceptions |= treeTop->getNode()->exceptionsRaised();
if (treeTop->getNode()->getOpCodeValue() == TR::monexitfence) // for live monitor metadata
reachedExceptions |= TR::Block::CanCatchMonitorExit;
}
if (reachedExceptions & TR::Block::CanCatchUserThrows)
continue;
for (auto edge = block->getExceptionSuccessors().begin(); edge != block->getExceptionSuccessors().end();)
{
TR::CFGEdge * current = *(edge++);
TR::Block *catchBlock = toBlock(current->getTo());
if (catchBlock->isOSRCodeBlock() || catchBlock->isOSRCatchBlock()) continue;
if (!reachedExceptions &&
performTransformation(comp(), "%sRemove redundant exception edge from block_%d at [%p] to catch block_%d at [%p]\n", optDetailString(), block->getNumber(), block, catchBlock->getNumber(), catchBlock))
{
cfg->removeEdge(block, catchBlock);
thereMayBeRemovableCatchBlocks = true;
}
else
{
if (!catchBlock->canCatchExceptions(reachedExceptions))
{
current->setVisitCount(visitCount);
thereMayBeRemovableCatchBlocks = true;
}
}
}
}
bool edgesRemoved = false;
// Now look to see if there are any catch blocks for which all exception
// predecessors have the visit count set. If so, the block is unreachable and
// can be removed.
// If only some of the exception predecessors are marked, these edges are
// left in place to identify the try/catch structure properly.
//
while (thereMayBeRemovableCatchBlocks)
{
thereMayBeRemovableCatchBlocks = false;
for (cfgNode = cfg->getFirstNode(); cfgNode; cfgNode = cfgNode->getNext())
{
if (cfgNode->getExceptionPredecessors().empty())
continue;
auto edgeIt = cfgNode->getExceptionPredecessors().begin();
for (; edgeIt != cfgNode->getExceptionPredecessors().end(); ++edgeIt)
{
if ((*edgeIt)->getVisitCount() != visitCount)
break;
}
if (edgeIt == cfgNode->getExceptionPredecessors().end() && performTransformation(comp(), "%sRemove redundant catch block_%d at [%p]\n", optDetailString(), cfgNode->getNumber(), cfgNode))
{
while (!cfgNode->getExceptionPredecessors().empty())
{
cfg->removeEdge(cfgNode->getExceptionPredecessors().front());
}
edgesRemoved = true;
thereMayBeRemovableCatchBlocks = true;
}
}
}
// Any transformations invalidate use/def and value number information
//
if (edgesRemoved)
{
optimizer()->setUseDefInfo(NULL);
optimizer()->setValueNumberInfo(NULL);
requestOpt(OMR::treeSimplification, true);
}
} // scope of the stack memory region
if (trace())
traceMsg(comp(), "\nEnding Catch Block Removal\n");
return 1; // actual cost
}
TR_Latestness::TR_Latestness(TR::Compilation *comp, TR::Optimizer *optimizer, TR_Structure *rootStructure, bool trace)
: TR_BackwardIntersectionBitVectorAnalysis(comp, comp->getFlowGraph(), optimizer, trace)
{
_delayedness = new (comp->allocator()) TR_Delayedness(comp, optimizer, rootStructure, trace);
_supportedNodesAsArray = _delayedness->_supportedNodesAsArray;
if (trace)
traceMsg(comp, "Starting Latestness\n");
TR::CFG *cfg = comp->getFlowGraph();
_numberOfNodes = cfg->getNextNodeNumber();
TR_ASSERT(_numberOfNodes > 0, "Latestness, node numbers not assigned");
_numberOfBits = getNumberOfBits();
_inSetInfo = (ContainerType **)trMemory()->allocateStackMemory(_numberOfNodes*sizeof(ContainerType *));
for (int32_t i=0;i<_numberOfNodes;i++)
allocateContainer(_inSetInfo+i);
// Allocate temp bit vectors from block info, since it is local to this analysis
ContainerType *intersection, *negation;
allocateBlockInfoContainer(&intersection);
allocateBlockInfoContainer(&negation);
TR::CFGNode *nextNode;
for (nextNode = cfg->getFirstNode(); nextNode; nextNode = nextNode->getNext())
{
TR_BlockStructure *blockStructure = (toBlock(nextNode))->getStructureOf();
if ((blockStructure == NULL) || (blockStructure->getBlock()->getSuccessors().empty() && blockStructure->getBlock()->getExceptionSuccessors().empty()))
continue;
/////analyzeTreeTopsInBlockStructure(blockStructure);
/////analysisInfo->_containsExceptionTreeTop = _containsExceptionTreeTop;
initializeInfo(intersection);
for (auto succ = nextNode->getSuccessors().begin(); succ != nextNode->getSuccessors().end(); ++succ)
{
TR::CFGNode *succBlock = (*succ)->getTo();
compose(intersection, _delayedness->_inSetInfo[succBlock->getNumber()]);
}
/////if (getAnalysisInfo(blockStructure)->_containsExceptionTreeTop)
{
for (auto succ = nextNode->getExceptionSuccessors().begin(); succ != nextNode->getExceptionSuccessors().end(); ++succ)
{
TR::CFGNode *succBlock = (*succ)->getTo();
compose(intersection, _delayedness->_inSetInfo[succBlock->getNumber()]);
}
}
negation->setAll(_numberOfBits);
*negation -= *intersection;
copyFromInto(negation, _inSetInfo[blockStructure->getNumber()]);
*(_inSetInfo[blockStructure->getNumber()]) |= *(_delayedness->_earliestness->_globalAnticipatability->_localAnticipatability.getDownwardExposedAnalysisInfo(blockStructure->getBlock()->getNumber()));
*(_inSetInfo[blockStructure->getNumber()]) &= *(_delayedness->_inSetInfo[blockStructure->getNumber()]);
if (trace)
{
traceMsg(comp, "\nIn Set of Block : %d\n", blockStructure->getNumber());
_inSetInfo[blockStructure->getNumber()]->print(comp);
}
}
if (trace)
traceMsg(comp, "\nEnding Latestness\n");
// Null out info that will not be used by callers
_delayedness->_inSetInfo = NULL;
_blockAnalysisInfo = NULL;
}
