void TR_LocalAnalysis::initializeLocalAnalysis(bool isSparse, bool lock)
{
_info = (TR_LocalAnalysisInfo::LAInfo*) trMemory()->allocateStackMemory(_lainfo._numBlocks*sizeof(TR_LocalAnalysisInfo::LAInfo));
memset(_info, 0, _lainfo._numBlocks*sizeof(TR_LocalAnalysisInfo::LAInfo));
TR::BitVector blocksSeen(comp()->allocator());
initializeBlocks(toBlock(comp()->getFlowGraph()->getStart()), blocksSeen);
int32_t i;
for (i = 0; i < _lainfo._numBlocks; i++)
{
_info[i]._analysisInfo = allocateContainer(getNumNodes());
_info[i]._downwardExposedAnalysisInfo = allocateContainer(getNumNodes());
_info[i]._downwardExposedStoreAnalysisInfo = allocateContainer(getNumNodes());
}
}
void TR_ReachingDefinitions::initializeGenAndKillSetInfoForNode(TR::Node *node, TR_UseDefInfo::BitVector &defsKilled, bool seenException, int32_t blockNum, TR::Node *parent)
{
// Update gen and kill info for nodes in this subtree
//
int32_t i;
if (node->getVisitCount() == comp()->getVisitCount())
return;
node->setVisitCount(comp()->getVisitCount());
// Process the children first
//
for (i = node->getNumChildren()-1; i >= 0; --i)
{
initializeGenAndKillSetInfoForNode(node->getChild(i), defsKilled, seenException, blockNum, node);
}
bool irrelevantStore = false;
scount_t nodeIndex = node->getLocalIndex();
if (nodeIndex <= 0)
{
if (node->getOpCode().isStore() &&
node->getSymbol()->isAutoOrParm() &&
node->storedValueIsIrrelevant())
{
irrelevantStore = true;
}
else
return;
}
bool foundDefsToKill = false;
int32_t numDefNodes = 0;
defsKilled.Clear();
TR::ILOpCode &opCode = node->getOpCode();
TR::SymbolReference *symRef;
TR::Symbol *sym;
uint16_t symIndex;
uint32_t num_aliases;
if (_useDefInfo->_useDefForRegs &&
(opCode.isLoadReg() ||
opCode.isStoreReg()))
{
sym = NULL;
symRef = NULL;
symIndex = _useDefInfo->getNumSymbols() + node->getGlobalRegisterNumber();
num_aliases = 1;
}
else
{
symRef = node->getSymbolReference();
sym = symRef->getSymbol();
symIndex = symRef->getSymbol()->getLocalIndex();
num_aliases = _useDefInfo->getNumAliases(symRef, _aux);
}
if (symIndex == NULL_USEDEF_SYMBOL_INDEX || node->getOpCode().isCall() || node->getOpCode().isFence() ||
(parent && parent->getOpCode().isResolveCheck() && num_aliases > 1))
{
// A call or unresolved reference is a definition of all
// symbols it is aliased with
//
numDefNodes = num_aliases;
//for all symbols that are a mustdef of a call, kill defs of those symbols
if (node->getOpCode().isCall())
foundDefsToKill = false;
}
else if (irrelevantStore || _useDefInfo->isExpandedDefIndex(nodeIndex))
{
// DefOnly node defines all symbols it is aliased with
// UseDef node(load) defines only the symbol itself
//
if (!irrelevantStore)
{
numDefNodes = num_aliases;
numDefNodes = _useDefInfo->isExpandedUseDefIndex(nodeIndex) ? 1 : numDefNodes;
if (!_useDefInfo->getDefsForSymbolIsZero(symIndex, _aux) &&
(!sym ||
(!sym->isShadow() &&
!sym->isMethod())))
{
foundDefsToKill = true;
// defsKilled ORed with defsForSymbol(symIndex);
_useDefInfo->getDefsForSymbol(defsKilled, symIndex, _aux);
}
if (node->getOpCode().isStoreIndirect())
{
int32_t memSymIndex = _useDefInfo->getMemorySymbolIndex(node);
if (memSymIndex != -1 &&
!_useDefInfo->getDefsForSymbolIsZero(memSymIndex, _aux))
{
foundDefsToKill = true;
// defsKilled ORed with defsForSymbol(symIndex);
_useDefInfo->getDefsForSymbol(defsKilled, memSymIndex, _aux);
}
}
}
else if (!_useDefInfo->getDefsForSymbolIsZero(symIndex, _aux))
{
numDefNodes = 1;
foundDefsToKill = true;
// defsKilled ORed with defsForSymbol(symIndex);
_useDefInfo->getDefsForSymbol(defsKilled, symIndex, _aux);
}
}
else
{
numDefNodes = 0;
}
if (foundDefsToKill)
{
if (_regularKillSetInfo[blockNum] == NULL)
allocateContainer(&_regularKillSetInfo[blockNum]);
*_regularKillSetInfo[blockNum] |= defsKilled;
if (!seenException)
{
if (_exceptionKillSetInfo[blockNum] == NULL)
allocateContainer(&_exceptionKillSetInfo[blockNum]);
*_exceptionKillSetInfo[blockNum] |= defsKilled;
}
}
if (_regularGenSetInfo[blockNum] == NULL)
allocateContainer(&_regularGenSetInfo[blockNum]);
else if (foundDefsToKill)
*_regularGenSetInfo[blockNum] -= defsKilled;
if (_exceptionGenSetInfo[blockNum] == NULL)
allocateContainer(&_exceptionGenSetInfo[blockNum]);
else if (foundDefsToKill && !seenException)
*_exceptionGenSetInfo[blockNum] -= defsKilled;
if (!irrelevantStore)
{
for (i = 0; i < numDefNodes; ++i)
{
_regularGenSetInfo[blockNum]->set(nodeIndex+i);
_exceptionGenSetInfo[blockNum]->set(nodeIndex+i);
}
}
else // fake up the method entry def as the def index to "gen" to avoid a use without a def completely
{
_regularGenSetInfo[blockNum]->set(sym->getLocalIndex());
_exceptionGenSetInfo[blockNum]->set(sym->getLocalIndex());
}
}
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;
}
