TR_LocalAnalysisInfo::TR_LocalAnalysisInfo(TR::Compilation *c, bool t)
: _compilation(c), _trace(t), _trMemory(c->trMemory())
{
_numNodes = -1;
#if 0 // somehow stops PRE from happening
// We are going to increment visit count for every tree so can reach max
// for big methods quickly. Perhaps can improve containsCall() in the future.
comp()->resetVisitCounts(0);
#endif
if (comp()->getVisitCount() > HIGH_VISIT_COUNT)
{
_compilation->resetVisitCounts(1);
dumpOptDetails(comp(), "\nResetting visit counts for this method before LocalAnalysisInfo\n");
}
TR::CFG *cfg = comp()->getFlowGraph();
_numBlocks = cfg->getNextNodeNumber();
TR_ASSERT(_numBlocks > 0, "Local analysis, node numbers not assigned");
// Allocate information on the stack. It is the responsibility of the user
// of this class to determine the life of the information by using jitStackMark
// and jitStackRelease.
//
//_blocksInfo = (TR::Block **) trMemory()->allocateStackMemory(_numBlocks*sizeof(TR::Block *));
//memset(_blocksInfo, 0, _numBlocks*sizeof(TR::Block *));
TR::TreeTop *currentTree = comp()->getStartTree();
// Only do this if not done before; typically this would be done in the
// first call to this method through LocalTransparency and would NOT
// need to be re-done by LocalAnticipatability.
//
if (_numNodes < 0)
{
_optimizer = comp()->getOptimizer();
int32_t numBuckets;
int32_t numNodes = comp()->getNodeCount();
if (numNodes < 10)
numBuckets = 1;
else if (numNodes < 100)
numBuckets = 7;
else if (numNodes < 500)
numBuckets = 31;
else if (numNodes < 3000)
numBuckets = 127;
else if (numNodes < 6000)
numBuckets = 511;
else
numBuckets = 1023;
// Allocate hash table for matching expressions
//
HashTable hashTable(numBuckets, comp());
_hashTable = &hashTable;
// Null checks are handled differently as the criterion for
// commoning a null check is different than that used for
// other nodes; for a null check, the null check reference is
// important (and not the actual indirect access itself)
//
_numNullChecks = 0;
while (currentTree)
{
if (currentTree->getNode()->getOpCodeValue() == TR::NULLCHK)
//////if (currentTree->getNode()->getOpCode().isNullCheck())
_numNullChecks++;
currentTree = currentTree->getNextTreeTop();
}
if (_numNullChecks == 0)
_nullCheckNodesAsArray = NULL;
else
{
_nullCheckNodesAsArray = (TR::Node**)trMemory()->allocateStackMemory(_numNullChecks*sizeof(TR::Node*));
memset(_nullCheckNodesAsArray, 0, _numNullChecks*sizeof(TR::Node*));
}
currentTree = comp()->getStartTree();
int32_t symRefCount = comp()->getSymRefCount();
_checkSymbolReferences = new (trStackMemory()) TR_BitVector(symRefCount, trMemory(), stackAlloc);
_numNodes = 1;
_numNullChecks = 0;
// This loop counts all the nodes that are going to take part in PRE.
// This is a computation intensive loop as we check if the node that
// is syntactically equivalent to a given node has been seen before
// and if so we use the local index of the original node (that
// is syntactically equivalent to the given node). Could be improved
// in complexity with value numbering at some stage.
//
_visitCount = comp()->incVisitCount();
while (currentTree)
{
TR::Node *firstNodeInTree = currentTree->getNode();
TR::ILOpCode *opCode = &firstNodeInTree->getOpCode();
if (((firstNodeInTree->getOpCodeValue() == TR::treetop) ||
(comp()->useAnchors() && firstNodeInTree->getOpCode().isAnchor())) &&
(firstNodeInTree->getFirstChild()->getOpCode().isStore()))
{
firstNodeInTree->setLocalIndex(-1);
if (comp()->useAnchors() && firstNodeInTree->getOpCode().isAnchor())
firstNodeInTree->getSecondChild()->setLocalIndex(-1);
firstNodeInTree = firstNodeInTree->getFirstChild();
opCode = &firstNodeInTree->getOpCode();
}
// This call finds nodes with opcodes that are supported by PRE
// in this subtree; this accounts for all opcodes other than stores/checks
// which are handled later on below
//
bool firstNodeInTreeHasCallsInStoreLhs = false;
countSupportedNodes(firstNodeInTree, NULL, firstNodeInTreeHasCallsInStoreLhs);
if ((opCode->isStore() && !firstNodeInTree->getSymbolReference()->getSymbol()->isAutoOrParm()) ||
opCode->isCheck())
{
int32_t oldExpressionOnRhs = hasOldExpressionOnRhs(firstNodeInTree);
//
// Return value 0 denotes that the node contains some sub-expression
// that cannot participate in PRE; e.g. a call or a new
//
// Return value -1 denotes that the node can participate in PRE
// but did not match with any existing expression seen so far
//
// Any other return value (should be positive always) denotes that
// the node can participate in PRE and has been matched with a seen
// expression having local index == return value
//
if (oldExpressionOnRhs == -1)
{
if (trace())
{
traceMsg(comp(), "\nExpression #%d is : \n", _numNodes);
comp()->getDebug()->print(comp()->getOutFile(), firstNodeInTree, 6, true);
}
firstNodeInTree->setLocalIndex(_numNodes++);
}
else
firstNodeInTree->setLocalIndex(oldExpressionOnRhs);
if (opCode->isCheck() &&
(firstNodeInTree->getFirstChild()->getOpCode().isStore() &&
!firstNodeInTree->getFirstChild()->getSymbolReference()->getSymbol()->isAutoOrParm()))
{
int oldExpressionOnRhs = hasOldExpressionOnRhs(firstNodeInTree->getFirstChild());
if (oldExpressionOnRhs == -1)
{
if (trace())
{
traceMsg(comp(), "\nExpression #%d is : \n", _numNodes);
comp()->getDebug()->print(comp()->getOutFile(), firstNodeInTree->getFirstChild(), 6, true);
}
firstNodeInTree->getFirstChild()->setLocalIndex(_numNodes++);
}
else
firstNodeInTree->getFirstChild()->setLocalIndex(oldExpressionOnRhs);
}
}
else
firstNodeInTree->setLocalIndex(-1);
currentTree = currentTree->getNextTreeTop();
}
}
_supportedNodesAsArray = (TR::Node**)trMemory()->allocateStackMemory(_numNodes*sizeof(TR::Node*));
memset(_supportedNodesAsArray, 0, _numNodes*sizeof(TR::Node*));
_checkExpressions = new (trStackMemory()) TR_BitVector(_numNodes, trMemory(), stackAlloc);
//_checkExpressions.init(_numNodes, trMemory(), stackAlloc);
// This loop goes through the trees and collects the nodes
// that would take part in PRE. Each node has its local index set to
// the bit position that it occupies in the bit vector analyses.
//
currentTree = comp()->getStartTree();
_visitCount = comp()->incVisitCount();
while (currentTree)
{
TR::Node *firstNodeInTree = currentTree->getNode();
TR::ILOpCode *opCode = &firstNodeInTree->getOpCode();
if (((firstNodeInTree->getOpCodeValue() == TR::treetop) ||
(comp()->useAnchors() && firstNodeInTree->getOpCode().isAnchor())) &&
(firstNodeInTree->getFirstChild()->getOpCode().isStore()))
{
firstNodeInTree = firstNodeInTree->getFirstChild();
opCode = &firstNodeInTree->getOpCode();
}
collectSupportedNodes(firstNodeInTree, NULL);
if ((opCode->isStore() && !firstNodeInTree->getSymbolReference()->getSymbol()->isAutoOrParm()) ||
opCode->isCheck())
{
if (opCode->isCheck())
{
_checkSymbolReferences->set(firstNodeInTree->getSymbolReference()->getReferenceNumber());
_checkExpressions->set(firstNodeInTree->getLocalIndex());
}
if (!_supportedNodesAsArray[firstNodeInTree->getLocalIndex()])
_supportedNodesAsArray[firstNodeInTree->getLocalIndex()] = firstNodeInTree;
if (opCode->isCheck() &&
firstNodeInTree->getFirstChild()->getOpCode().isStore() &&
!firstNodeInTree->getFirstChild()->getSymbolReference()->getSymbol()->isAutoOrParm() &&
!_supportedNodesAsArray[firstNodeInTree->getFirstChild()->getLocalIndex()])
_supportedNodesAsArray[firstNodeInTree->getFirstChild()->getLocalIndex()] = firstNodeInTree->getFirstChild();
}
currentTree = currentTree->getNextTreeTop();
}
//initialize(toBlock(cfg->getStart()));
}
// Checks for syntactic equivalence and returns the side-table index
// of the syntactically equivalent node if it found one; else it returns
// -1 signifying that this is the first time any node similar syntactically
// to this node has been seen. Adds the node to the hash table if seen for the
// first time.
//
//
int TR_LocalAnalysisInfo::hasOldExpressionOnRhs(TR::Node *node, bool recalcContainsCall, bool storeLhsContainsCall)
{
//
// Get the relevant portion of the subtree
// for this node; this is different for a null check
// as its null check reference is the only
// sub-expression that matters
//
TR::Node *relevantSubtree = NULL;
if (node->getOpCodeValue() == TR::NULLCHK)
relevantSubtree = node->getNullCheckReference();
else
relevantSubtree = node;
// containsCall checks whether the relevant node has some
// sub-expression that cannot be commoned, e.g. call or a new
//
bool nodeContainsCall;
if (!recalcContainsCall && (relevantSubtree == node))
{
// can use pre-calculated value of containsCall and storeLhsContainsCall, to avoid visitCount overflow
nodeContainsCall = node->containsCall();
}
else
{
storeLhsContainsCall = false;
nodeContainsCall = containsCall(relevantSubtree, storeLhsContainsCall);
}
if (nodeContainsCall)
{
//
// If the node is not a store, a call-like sub-expression is inadmissable;
// if the node is a store, a call-like sub-expression is allowed on the RHS
// of the store as this does not inhibit privatization in any way as
// the private temp store's RHS simply points at original RHS. But if a call-like
// sub-expression is present in the LHS of the store, that is inadmissable
//
if (!node->getOpCode().isStore() ||
storeLhsContainsCall)
return 0;
}
bool seenIndirectStore = false;
#ifdef J9_PROJECT_SPECIFIC
bool seenIndirectBCDStore = false;
#endif
bool seenWriteBarrier = false;
int32_t storeNumChildren = node->getNumChildren();
// If node is a null check, compare the
// null check reference only to establish syntactic equivalence
//
if (node->getOpCodeValue() == TR::NULLCHK)
/////if (node->getOpCode().isNullCheck())
{
int32_t k;
for (k=0;k<_numNullChecks;k++)
{
if (!(_nullCheckNodesAsArray[k] == NULL))
{
if (areSyntacticallyEquivalent(_nullCheckNodesAsArray[k]->getNullCheckReference(), node->getNullCheckReference()))
return _nullCheckNodesAsArray[k]->getLocalIndex();
}
}
_nullCheckNodesAsArray[_numNullChecks++] = node;
}
else
{
//
// If this node is a global store, then equivalence check is different.
// We try to give a store to field (or static) o.f the same index as
// a load of o.f. This is so that privatization happens for fields/statics.
// So the store's opcode value is changed temporarily to be a load before
// syntactic equivalence is checked; this enables matching stores/loads to
// same global symbol.
//
if (node->getOpCode().isStore() &&
!node->getSymbolReference()->getSymbol()->isAutoOrParm())
{
if (node->getOpCode().isWrtBar())
seenWriteBarrier = true;
#ifdef J9_PROJECT_SPECIFIC
seenIndirectBCDStore = node->getType().isBCD();
#endif
if (node->getOpCode().isStoreIndirect())
{
if (seenWriteBarrier)
{
TR::Node::recreate(node, _compilation->il.opCodeForIndirectArrayLoad(node->getDataType()));
}
else
{
TR::Node::recreate(node, _compilation->il.opCodeForCorrespondingIndirectStore(node->getOpCodeValue()));
}
node->setNumChildren(1);
}
else
{
TR::Node::recreate(node, _compilation->il.opCodeForDirectLoad(node->getDataType()));
node->setNumChildren(0);
}
#ifdef J9_PROJECT_SPECIFIC
if (seenIndirectBCDStore)
node->setBCDStoreIsTemporarilyALoad(true);
#endif
seenIndirectStore = true;
}
int32_t hashValue = _hashTable->hash(node);
HashTable::Cursor cursor(_hashTable, hashValue);
TR::Node *other;
for (other = cursor.firstNode(); other; other = cursor.nextNode())
{
// Convert other node's opcode to be a load temporarily
// (only for syntactic equivalence check; see explanation above)
// to enable matching global stores/loads.
//
bool seenOtherIndirectStore = false;
#ifdef J9_PROJECT_SPECIFIC
bool seenOtherIndirectBCDStore = false;
#endif
bool seenOtherWriteBarrier = false;
int32_t otherStoreNumChildren = other->getNumChildren();
if (other->getOpCode().isStore() &&
!other->getSymbolReference()->getSymbol()->isAutoOrParm())
{
if (other->getOpCode().isWrtBar())
seenOtherWriteBarrier = true;
#ifdef J9_PROJECT_SPECIFIC
seenOtherIndirectBCDStore = other->getType().isBCD();
#endif
if (other->getOpCode().isStoreIndirect())
{
if (seenOtherWriteBarrier)
{
TR::Node::recreate(other, _compilation->il.opCodeForIndirectArrayLoad(other->getDataType()));
}
else
{
TR::Node::recreate(other, _compilation->il.opCodeForCorrespondingIndirectStore(other->getOpCodeValue()));
}
other->setNumChildren(1);
}
else
{
TR::Node::recreate(other, _compilation->il.opCodeForDirectLoad(other->getDataType()));
other->setNumChildren(0);
}
#ifdef J9_PROJECT_SPECIFIC
if (seenOtherIndirectBCDStore)
other->setBCDStoreIsTemporarilyALoad(true);
#endif
seenOtherIndirectStore = true;
}
bool areSame = areSyntacticallyEquivalent(node, other);
// Restore the other node's state to what it was originally
// (if it was a global store)
//
if (seenOtherWriteBarrier)
{
other->setNumChildren(otherStoreNumChildren);
if (otherStoreNumChildren == 3)
TR::Node::recreate(other, TR::awrtbari);
else
TR::Node::recreate(other, TR::awrtbar);
}
else if (seenOtherIndirectStore)
{
other->setNumChildren(otherStoreNumChildren);
#ifdef J9_PROJECT_SPECIFIC
if (seenOtherIndirectBCDStore)
other->setBCDStoreIsTemporarilyALoad(false);
#endif
if (other->getOpCode().isIndirect())
TR::Node::recreate(other, _compilation->il.opCodeForCorrespondingIndirectLoad(other->getOpCodeValue()));
else
TR::Node::recreate(other, _compilation->il.opCodeForDirectStore(other->getDataType()));
}
if (areSame)
{
if (seenWriteBarrier)
{
node->setNumChildren(storeNumChildren);
if (storeNumChildren == 3)
TR::Node::recreate(node, TR::awrtbari);
else
TR::Node::recreate(node, TR::awrtbar);
}
else if (seenIndirectStore)
{
node->setNumChildren(storeNumChildren);
#ifdef J9_PROJECT_SPECIFIC
if (seenIndirectBCDStore)
node->setBCDStoreIsTemporarilyALoad(false);
#endif
if (node->getOpCode().isIndirect())
TR::Node::recreate(node, _compilation->il.opCodeForCorrespondingIndirectLoad(node->getOpCodeValue()));
else
TR::Node::recreate(node, _compilation->il.opCodeForDirectStore(node->getDataType()));
}
return other->getLocalIndex();
}
}
// No match from existing nodes in the hash table;
// add this node to the hash table.
//
_hashTable->add(node, hashValue);
}
// Restore this node's state to what it was before
// (if it was a global store)
//
if (seenWriteBarrier)
{
node->setNumChildren(storeNumChildren);
if (storeNumChildren == 3)
TR::Node::recreate(node, TR::awrtbari);
else
TR::Node::recreate(node, TR::awrtbar);
}
else if (seenIndirectStore)
{
node->setNumChildren(storeNumChildren);
#ifdef J9_PROJECT_SPECIFIC
if (seenIndirectBCDStore)
node->setBCDStoreIsTemporarilyALoad(false);
#endif
if (node->getOpCode().isIndirect())
TR::Node::recreate(node, _compilation->il.opCodeForCorrespondingIndirectLoad(node->getOpCodeValue()));
else
TR::Node::recreate(node, _compilation->il.opCodeForDirectStore(node->getDataType()));
}
return -1;
}
// Collects nodes that involved in PRE that are not stores or checks.
// These nodes require temps.
//
bool TR_LocalAnalysisInfo::collectSupportedNodes(TR::Node *node, TR::Node *parent)
{
if (node->getVisitCount() == _visitCount)
return false;
node->setVisitCount(_visitCount);
bool flag = false;
bool childRelevant = false;
TR::ILOpCode &opCode = node->getOpCode();
int32_t i;
for (i = 0; i < node->getNumChildren(); i++)
{
TR::Node *child = node->getChild(i);
if (collectSupportedNodes(child, node))
flag = true;
if (_checkExpressions->get(child->getLocalIndex()))
childRelevant = true;
}
if (TR_LocalAnalysis::isSupportedNode(node, _compilation, parent))
{
_supportedNodesAsArray[node->getLocalIndex()] = node;
bool indirectionSafe = true;
if (opCode.isIndirect() && (opCode.isLoadVar() || opCode.isStore()))
{
indirectionSafe = false;
if (node->getFirstChild()->isThisPointer() &&
node->getFirstChild()->isNonNull())
{
indirectionSafe = true;
TR::Node *firstChild = node->getFirstChild();
TR::SymbolReference *symRef = firstChild->getSymbolReference();
int32_t len;
const char *sig = symRef->getTypeSignature(len);
TR::SymbolReference *otherSymRef = node->getSymbolReference();
TR_OpaqueClassBlock *cl = NULL;
if (sig && (len > 0))
cl = _compilation->fe()->getClassFromSignature(sig, len, symRef->getOwningMethod(_compilation));
TR_OpaqueClassBlock *otherClassObject = NULL;
int32_t otherLen;
const char *otherSig = otherSymRef->getOwningMethod(_compilation)->classNameOfFieldOrStatic(otherSymRef->getCPIndex(), otherLen);
if (otherSig)
{
otherSig = classNameToSignature(otherSig, otherLen, _compilation);
otherClassObject = _compilation->fe()->getClassFromSignature(otherSig, otherLen, otherSymRef->getOwningMethod(_compilation));
}
if (!cl ||
!otherClassObject ||
(cl != otherClassObject))
indirectionSafe = false;
}
}
if (childRelevant ||
(!indirectionSafe || (opCode.isArrayLength())) ||
(node->getOpCode().isArrayRef()) ||
(opCode.hasSymbolReference() && (node->getSymbolReference()->isUnresolved() || node->getSymbol()->isArrayShadowSymbol())) ||
(opCode.isDiv() || opCode.isRem()))
_checkExpressions->set(node->getLocalIndex());
}
return flag;
}
