Quick Compiler function renaming
Move the Quick compiler's function naming to Art coding conventions. Will
be done is pieces: names first, then arguments and locals. Also removed
some dead code and marked statics for the top level source files
No logic changes aside from eliminating a few useless exported "oat"
routines.
Change-Id: Iadaddc560942a0fc1199ba5b1c261cd6ac5cfd9a
diff --git a/src/compiler/ssa_transformation.cc b/src/compiler/ssa_transformation.cc
index bbe08f5..664893e 100644
--- a/src/compiler/ssa_transformation.cc
+++ b/src/compiler/ssa_transformation.cc
@@ -22,7 +22,7 @@
// Make sure iterative dfs recording matches old recursive version
//#define TEST_DFS
-inline BasicBlock* needsVisit(BasicBlock* bb) {
+static inline BasicBlock* NeedsVisit(BasicBlock* bb) {
if (bb != NULL) {
if (bb->visited || bb->hidden) {
bb = NULL;
@@ -31,21 +31,21 @@
return bb;
}
-BasicBlock* nextUnvisitedSuccessor(BasicBlock* bb)
+static BasicBlock* NextUnvisitedSuccessor(BasicBlock* bb)
{
- BasicBlock* res = needsVisit(bb->fallThrough);
+ BasicBlock* res = NeedsVisit(bb->fallThrough);
if (res == NULL) {
- res = needsVisit(bb->taken);
+ res = NeedsVisit(bb->taken);
if (res == NULL) {
if (bb->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+ GrowableListIteratorInit(&bb->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *sbi = reinterpret_cast<SuccessorBlockInfo*>
- (oatGrowableListIteratorNext(&iterator));
+ (GrowableListIteratorNext(&iterator));
if (sbi == NULL) break;
- res = needsVisit(sbi->block);
+ res = NeedsVisit(sbi->block);
if (res != NULL) break;
}
}
@@ -54,35 +54,35 @@
return res;
}
-void markPreOrder(CompilationUnit* cUnit, BasicBlock* block)
+static void MarkPreOrder(CompilationUnit* cUnit, BasicBlock* block)
{
block->visited = true;
/* Enqueue the preOrder block id */
- oatInsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
+ InsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
}
-void recordDFSOrders(CompilationUnit* cUnit, BasicBlock* block)
+static void RecordDFSOrders(CompilationUnit* cUnit, BasicBlock* block)
{
std::vector<BasicBlock*> succ;
- markPreOrder(cUnit, block);
+ MarkPreOrder(cUnit, block);
succ.push_back(block);
while (!succ.empty()) {
BasicBlock* curr = succ.back();
- BasicBlock* nextSuccessor = nextUnvisitedSuccessor(curr);
+ BasicBlock* nextSuccessor = NextUnvisitedSuccessor(curr);
if (nextSuccessor != NULL) {
- markPreOrder(cUnit, nextSuccessor);
+ MarkPreOrder(cUnit, nextSuccessor);
succ.push_back(nextSuccessor);
continue;
}
curr->dfsId = cUnit->dfsPostOrder.numUsed;
- oatInsertGrowableList(cUnit, &cUnit->dfsPostOrder, curr->id);
+ InsertGrowableList(cUnit, &cUnit->dfsPostOrder, curr->id);
succ.pop_back();
}
}
#if defined(TEST_DFS)
/* Enter the node to the dfsOrder list then visit its successors */
-void recursiveRecordDFSOrders(CompilationUnit* cUnit, BasicBlock* block)
+static void RecursiveRecordDFSOrders(CompilationUnit* cUnit, BasicBlock* block)
{
if (block->visited || block->hidden) return;
@@ -98,38 +98,38 @@
}
/* Enqueue the preOrder block id */
- oatInsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
+ InsertGrowableList(cUnit, &cUnit->dfsOrder, block->id);
if (block->fallThrough) {
- recursiveRecordDFSOrders(cUnit, block->fallThrough);
+ RecursiveRecordDFSOrders(cUnit, block->fallThrough);
}
- if (block->taken) recursiveRecordDFSOrders(cUnit, block->taken);
+ if (block->taken) RecursiveRecordDFSOrders(cUnit, block->taken);
if (block->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&block->successorBlockList.blocks,
+ GrowableListIteratorInit(&block->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- (SuccessorBlockInfo *) oatGrowableListIteratorNext(&iterator);
+ (SuccessorBlockInfo *) GrowableListIteratorNext(&iterator);
if (successorBlockInfo == NULL) break;
BasicBlock* succBB = successorBlockInfo->block;
- recursiveRecordDFSOrders(cUnit, succBB);
+ RecursiveRecordDFSOrders(cUnit, succBB);
}
}
/* Record postorder in basic block and enqueue normal id in dfsPostOrder */
block->dfsId = cUnit->dfsPostOrder.numUsed;
- oatInsertGrowableList(cUnit, &cUnit->dfsPostOrder, block->id);
+ InsertGrowableList(cUnit, &cUnit->dfsPostOrder, block->id);
return;
}
#endif
/* Sort the blocks by the Depth-First-Search */
-void computeDFSOrders(CompilationUnit* cUnit)
+static void ComputeDFSOrders(CompilationUnit* cUnit)
{
/* Initialize or reset the DFS preOrder list */
if (cUnit->dfsOrder.elemList == NULL) {
- oatInitGrowableList(cUnit, &cUnit->dfsOrder, cUnit->numBlocks,
+ CompilerInitGrowableList(cUnit, &cUnit->dfsOrder, cUnit->numBlocks,
kListDfsOrder);
} else {
/* Just reset the used length on the counter */
@@ -138,7 +138,7 @@
/* Initialize or reset the DFS postOrder list */
if (cUnit->dfsPostOrder.elemList == NULL) {
- oatInitGrowableList(cUnit, &cUnit->dfsPostOrder, cUnit->numBlocks,
+ CompilerInitGrowableList(cUnit, &cUnit->dfsPostOrder, cUnit->numBlocks,
kListDfsPostOrder);
} else {
/* Just reset the used length on the counter */
@@ -147,34 +147,34 @@
#if defined(TEST_DFS)
// Reset visited flags
- oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
+ DataFlowAnalysisDispatcher(cUnit, ClearVisitedFlag,
kAllNodes, false /* isIterative */);
// Record pre and post order dfs
- recursiveRecordDFSOrders(cUnit, cUnit->entryBlock);
+ RecursiveRecordDFSOrders(cUnit, cUnit->entryBlock);
// Copy the results for later comparison and reset the lists
GrowableList recursiveDfsOrder;
GrowableList recursiveDfsPostOrder;
- oatInitGrowableList(cUnit, &recursiveDfsOrder, cUnit->dfsOrder.numUsed,
+ CompilerInitGrowableList(cUnit, &recursiveDfsOrder, cUnit->dfsOrder.numUsed,
kListDfsOrder);
for (unsigned int i = 0; i < cUnit->dfsOrder.numUsed; i++) {
- oatInsertGrowableList(cUnit, &recursiveDfsOrder,
+ InsertGrowableList(cUnit, &recursiveDfsOrder,
cUnit->dfsOrder.elemList[i]);
}
cUnit->dfsOrder.numUsed = 0;
- oatInitGrowableList(cUnit, &recursiveDfsPostOrder,
+ CompilerInitGrowableList(cUnit, &recursiveDfsPostOrder,
cUnit->dfsPostOrder.numUsed, kListDfsOrder);
for (unsigned int i = 0; i < cUnit->dfsPostOrder.numUsed; i++) {
- oatInsertGrowableList(cUnit, &recursiveDfsPostOrder,
+ InsertGrowableList(cUnit, &recursiveDfsPostOrder,
cUnit->dfsPostOrder.elemList[i]);
}
cUnit->dfsPostOrder.numUsed = 0;
#endif
// Reset visited flags from all nodes
- oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
+ DataFlowAnalysisDispatcher(cUnit, ClearVisitedFlag,
kAllNodes, false /* isIterative */);
// Record dfs orders
- recordDFSOrders(cUnit, cUnit->entryBlock);
+ RecordDFSOrders(cUnit, cUnit->entryBlock);
#if defined(TEST_DFS)
bool mismatch = false;
@@ -226,38 +226,38 @@
* Mark block bit on the per-Dalvik register vector to denote that Dalvik
* register idx is defined in BasicBlock bb.
*/
-bool fillDefBlockMatrix(CompilationUnit* cUnit, BasicBlock* bb)
+static bool FillDefBlockMatrix(CompilationUnit* cUnit, BasicBlock* bb)
{
if (bb->dataFlowInfo == NULL) return false;
ArenaBitVectorIterator iterator;
- oatBitVectorIteratorInit(bb->dataFlowInfo->defV, &iterator);
+ BitVectorIteratorInit(bb->dataFlowInfo->defV, &iterator);
while (true) {
- int idx = oatBitVectorIteratorNext(&iterator);
+ int idx = BitVectorIteratorNext(&iterator);
if (idx == -1) break;
/* Block bb defines register idx */
- oatSetBit(cUnit, cUnit->defBlockMatrix[idx], bb->id);
+ SetBit(cUnit, cUnit->defBlockMatrix[idx], bb->id);
}
return true;
}
-void computeDefBlockMatrix(CompilationUnit* cUnit)
+static void ComputeDefBlockMatrix(CompilationUnit* cUnit)
{
int numRegisters = cUnit->numDalvikRegisters;
/* Allocate numDalvikRegisters bit vector pointers */
cUnit->defBlockMatrix = static_cast<ArenaBitVector**>
- (oatNew(cUnit, sizeof(ArenaBitVector *) * numRegisters, true, kAllocDFInfo));
+ (NewMem(cUnit, sizeof(ArenaBitVector *) * numRegisters, true, kAllocDFInfo));
int i;
/* Initialize numRegister vectors with numBlocks bits each */
for (i = 0; i < numRegisters; i++) {
- cUnit->defBlockMatrix[i] = oatAllocBitVector(cUnit, cUnit->numBlocks,
+ cUnit->defBlockMatrix[i] = AllocBitVector(cUnit, cUnit->numBlocks,
false, kBitMapBMatrix);
}
- oatDataFlowAnalysisDispatcher(cUnit, oatFindLocalLiveIn,
+ DataFlowAnalysisDispatcher(cUnit, FindLocalLiveIn,
kAllNodes, false /* isIterative */);
- oatDataFlowAnalysisDispatcher(cUnit, fillDefBlockMatrix,
+ DataFlowAnalysisDispatcher(cUnit, FillDefBlockMatrix,
kAllNodes, false /* isIterative */);
/*
@@ -267,38 +267,38 @@
int numRegs = cUnit->numDalvikRegisters;
int inReg = numRegs - cUnit->numIns;
for (; inReg < numRegs; inReg++) {
- oatSetBit(cUnit, cUnit->defBlockMatrix[inReg], cUnit->entryBlock->id);
+ SetBit(cUnit, cUnit->defBlockMatrix[inReg], cUnit->entryBlock->id);
}
}
/* Compute the post-order traversal of the CFG */
-void computeDomPostOrderTraversal(CompilationUnit* cUnit, BasicBlock* bb)
+static void ComputeDomPostOrderTraversal(CompilationUnit* cUnit, BasicBlock* bb)
{
ArenaBitVectorIterator bvIterator;
- oatBitVectorIteratorInit(bb->iDominated, &bvIterator);
+ BitVectorIteratorInit(bb->iDominated, &bvIterator);
GrowableList* blockList = &cUnit->blockList;
/* Iterate through the dominated blocks first */
while (true) {
- //TUNING: hot call to oatBitVectorIteratorNext
- int bbIdx = oatBitVectorIteratorNext(&bvIterator);
+ //TUNING: hot call to BitVectorIteratorNext
+ int bbIdx = BitVectorIteratorNext(&bvIterator);
if (bbIdx == -1) break;
BasicBlock* dominatedBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, bbIdx));
- computeDomPostOrderTraversal(cUnit, dominatedBB);
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, bbIdx));
+ ComputeDomPostOrderTraversal(cUnit, dominatedBB);
}
/* Enter the current block id */
- oatInsertGrowableList(cUnit, &cUnit->domPostOrderTraversal, bb->id);
+ InsertGrowableList(cUnit, &cUnit->domPostOrderTraversal, bb->id);
/* hacky loop detection */
- if (bb->taken && oatIsBitSet(bb->dominators, bb->taken->id)) {
+ if (bb->taken && IsBitSet(bb->dominators, bb->taken->id)) {
cUnit->hasLoop = true;
}
}
-void checkForDominanceFrontier(CompilationUnit* cUnit, BasicBlock* domBB,
- const BasicBlock* succBB)
+static void CheckForDominanceFrontier(CompilationUnit* cUnit, BasicBlock* domBB,
+ const BasicBlock* succBB)
{
/*
* TODO - evaluate whether phi will ever need to be inserted into exit
@@ -307,53 +307,53 @@
if (succBB->iDom != domBB &&
succBB->blockType == kDalvikByteCode &&
succBB->hidden == false) {
- oatSetBit(cUnit, domBB->domFrontier, succBB->id);
+ SetBit(cUnit, domBB->domFrontier, succBB->id);
}
}
/* Worker function to compute the dominance frontier */
-bool computeDominanceFrontier(CompilationUnit* cUnit, BasicBlock* bb)
+static bool ComputeDominanceFrontier(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableList* blockList = &cUnit->blockList;
/* Calculate DF_local */
if (bb->taken) {
- checkForDominanceFrontier(cUnit, bb, bb->taken);
+ CheckForDominanceFrontier(cUnit, bb, bb->taken);
}
if (bb->fallThrough) {
- checkForDominanceFrontier(cUnit, bb, bb->fallThrough);
+ CheckForDominanceFrontier(cUnit, bb, bb->fallThrough);
}
if (bb->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+ GrowableListIteratorInit(&bb->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
if (successorBlockInfo == NULL) break;
BasicBlock* succBB = successorBlockInfo->block;
- checkForDominanceFrontier(cUnit, bb, succBB);
+ CheckForDominanceFrontier(cUnit, bb, succBB);
}
}
/* Calculate DF_up */
ArenaBitVectorIterator bvIterator;
- oatBitVectorIteratorInit(bb->iDominated, &bvIterator);
+ BitVectorIteratorInit(bb->iDominated, &bvIterator);
while (true) {
- //TUNING: hot call to oatBitVectorIteratorNext
- int dominatedIdx = oatBitVectorIteratorNext(&bvIterator);
+ //TUNING: hot call to BitVectorIteratorNext
+ int dominatedIdx = BitVectorIteratorNext(&bvIterator);
if (dominatedIdx == -1) break;
BasicBlock* dominatedBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, dominatedIdx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, dominatedIdx));
ArenaBitVectorIterator dfIterator;
- oatBitVectorIteratorInit(dominatedBB->domFrontier, &dfIterator);
+ BitVectorIteratorInit(dominatedBB->domFrontier, &dfIterator);
while (true) {
- //TUNING: hot call to oatBitVectorIteratorNext
- int dfUpIdx = oatBitVectorIteratorNext(&dfIterator);
+ //TUNING: hot call to BitVectorIteratorNext
+ int dfUpIdx = BitVectorIteratorNext(&dfIterator);
if (dfUpIdx == -1) break;
BasicBlock* dfUpBlock =
- reinterpret_cast<BasicBlock*>( oatGrowableListGetElement(blockList, dfUpIdx));
- checkForDominanceFrontier(cUnit, bb, dfUpBlock);
+ reinterpret_cast<BasicBlock*>( GrowableListGetElement(blockList, dfUpIdx));
+ CheckForDominanceFrontier(cUnit, bb, dfUpBlock);
}
}
@@ -361,27 +361,27 @@
}
/* Worker function for initializing domination-related data structures */
-bool initializeDominationInfo(CompilationUnit* cUnit, BasicBlock* bb)
+static bool InitializeDominationInfo(CompilationUnit* cUnit, BasicBlock* bb)
{
int numTotalBlocks = cUnit->blockList.numUsed;
if (bb->dominators == NULL ) {
- bb->dominators = oatAllocBitVector(cUnit, numTotalBlocks,
+ bb->dominators = AllocBitVector(cUnit, numTotalBlocks,
false /* expandable */,
kBitMapDominators);
- bb->iDominated = oatAllocBitVector(cUnit, numTotalBlocks,
+ bb->iDominated = AllocBitVector(cUnit, numTotalBlocks,
false /* expandable */,
kBitMapIDominated);
- bb->domFrontier = oatAllocBitVector(cUnit, numTotalBlocks,
+ bb->domFrontier = AllocBitVector(cUnit, numTotalBlocks,
false /* expandable */,
kBitMapDomFrontier);
} else {
- oatClearAllBits(bb->dominators);
- oatClearAllBits(bb->iDominated);
- oatClearAllBits(bb->domFrontier);
+ ClearAllBits(bb->dominators);
+ ClearAllBits(bb->iDominated);
+ ClearAllBits(bb->domFrontier);
}
/* Set all bits in the dominator vector */
- oatSetInitialBits(bb->dominators, numTotalBlocks);
+ SetInitialBits(bb->dominators, numTotalBlocks);
return true;
}
@@ -389,9 +389,9 @@
/*
* Worker function to compute each block's dominators. This implementation
* is only used when kDebugVerifyDataflow is active and should compute
- * the same dominator sets as computeBlockDominators.
+ * the same dominator sets as ComputeBlockDominiators.
*/
-bool slowComputeBlockDominators(CompilationUnit* cUnit, BasicBlock* bb)
+static bool SlowComputeBlockDominators(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableList* blockList = &cUnit->blockList;
int numTotalBlocks = blockList->numUsed;
@@ -404,21 +404,21 @@
*/
if (bb == cUnit->entryBlock) return false;
- oatSetInitialBits(tempBlockV, numTotalBlocks);
+ SetInitialBits(tempBlockV, numTotalBlocks);
/* Iterate through the predecessors */
- oatGrowableListIteratorInit(bb->predecessors, &iter);
+ GrowableListIteratorInit(bb->predecessors, &iter);
while (true) {
- BasicBlock* predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ BasicBlock* predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
if (!predBB) break;
/* tempBlockV = tempBlockV ^ dominators */
if (predBB->dominators != NULL) {
- oatIntersectBitVectors(tempBlockV, tempBlockV, predBB->dominators);
+ IntersectBitVectors(tempBlockV, tempBlockV, predBB->dominators);
}
}
- oatSetBit(cUnit, tempBlockV, bb->id);
- if (oatCompareBitVectors(tempBlockV, bb->dominators)) {
- oatCopyBitVector(bb->dominators, tempBlockV);
+ SetBit(cUnit, tempBlockV, bb->id);
+ if (CompareBitVectors(tempBlockV, bb->dominators)) {
+ CopyBitVector(bb->dominators, tempBlockV);
return true;
}
return false;
@@ -427,9 +427,9 @@
/*
* Worker function to compute the idom. This implementation is only
* used when kDebugVerifyDataflow is active and should compute the
- * same iDom as computeBlockIDom.
+ * same iDom as ComputeblockIDom.
*/
-bool slowComputeBlockIDom(CompilationUnit* cUnit, BasicBlock* bb)
+static bool SlowComputeBlockIDom(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableList* blockList = &cUnit->blockList;
ArenaBitVector* tempBlockV = cUnit->tempBlockV;
@@ -438,36 +438,36 @@
if (bb == cUnit->entryBlock) return false;
- oatCopyBitVector(tempBlockV, bb->dominators);
- oatClearBit(tempBlockV, bb->id);
- oatBitVectorIteratorInit(tempBlockV, &bvIterator);
+ CopyBitVector(tempBlockV, bb->dominators);
+ ClearBit(tempBlockV, bb->id);
+ BitVectorIteratorInit(tempBlockV, &bvIterator);
/* Should not see any dead block */
- DCHECK_NE(oatCountSetBits(tempBlockV), 0);
- if (oatCountSetBits(tempBlockV) == 1) {
+ DCHECK_NE(CountSetBits(tempBlockV), 0);
+ if (CountSetBits(tempBlockV) == 1) {
iDom = reinterpret_cast<BasicBlock*>
- (oatGrowableListGetElement(blockList, oatBitVectorIteratorNext(&bvIterator)));
+ (GrowableListGetElement(blockList, BitVectorIteratorNext(&bvIterator)));
bb->iDom = iDom;
} else {
- int iDomIdx = oatBitVectorIteratorNext(&bvIterator);
+ int iDomIdx = BitVectorIteratorNext(&bvIterator);
DCHECK_NE(iDomIdx, -1);
while (true) {
- int nextDom = oatBitVectorIteratorNext(&bvIterator);
+ int nextDom = BitVectorIteratorNext(&bvIterator);
if (nextDom == -1) break;
BasicBlock* nextDomBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, nextDom));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, nextDom));
/* iDom dominates nextDom - set new iDom */
- if (oatIsBitSet(nextDomBB->dominators, iDomIdx)) {
+ if (IsBitSet(nextDomBB->dominators, iDomIdx)) {
iDomIdx = nextDom;
}
}
- iDom = reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, iDomIdx));
+ iDom = reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, iDomIdx));
/* Set the immediate dominator block for bb */
bb->iDom = iDom;
}
/* Add bb to the iDominated set of the immediate dominator block */
- oatSetBit(cUnit, iDom->iDominated, bb->id);
+ SetBit(cUnit, iDom->iDominated, bb->id);
return true;
}
@@ -476,7 +476,7 @@
* Given the ordering of iDomList, this common parent represents the
* last element of the intersection of block1 and block2 dominators.
*/
-int findCommonParent(CompilationUnit *cUnit, int block1, int block2)
+static int FindCommonParent(CompilationUnit *cUnit, int block1, int block2)
{
while (block1 != block2) {
while (block1 < block2) {
@@ -492,7 +492,7 @@
}
/* Worker function to compute each block's immediate dominator */
-bool computeBlockIDom(CompilationUnit* cUnit, BasicBlock* bb)
+static bool ComputeblockIDom(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableListIterator iter;
int idom = -1;
@@ -503,11 +503,11 @@
}
/* Iterate through the predecessors */
- oatGrowableListIteratorInit(bb->predecessors, &iter);
+ GrowableListIteratorInit(bb->predecessors, &iter);
/* Find the first processed predecessor */
while (true) {
- BasicBlock* predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ BasicBlock* predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
CHECK(predBB != NULL);
if (cUnit->iDomList[predBB->dfsId] != NOTVISITED) {
idom = predBB->dfsId;
@@ -517,12 +517,12 @@
/* Scan the rest of the predecessors */
while (true) {
- BasicBlock* predBB = reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ BasicBlock* predBB = reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
if (!predBB) break;
if (cUnit->iDomList[predBB->dfsId] == NOTVISITED) {
continue;
} else {
- idom = findCommonParent(cUnit, predBB->dfsId, idom);
+ idom = FindCommonParent(cUnit, predBB->dfsId, idom);
}
}
@@ -537,48 +537,48 @@
}
/* Worker function to compute each block's domintors */
-bool computeBlockDominators(CompilationUnit* cUnit, BasicBlock* bb)
+static bool ComputeBlockDominiators(CompilationUnit* cUnit, BasicBlock* bb)
{
if (bb == cUnit->entryBlock) {
- oatClearAllBits(bb->dominators);
+ ClearAllBits(bb->dominators);
} else {
- oatCopyBitVector(bb->dominators, bb->iDom->dominators);
+ CopyBitVector(bb->dominators, bb->iDom->dominators);
}
- oatSetBit(cUnit, bb->dominators, bb->id);
+ SetBit(cUnit, bb->dominators, bb->id);
return false;
}
-bool setDominators(CompilationUnit* cUnit, BasicBlock* bb)
+static bool SetDominators(CompilationUnit* cUnit, BasicBlock* bb)
{
if (bb != cUnit->entryBlock) {
int iDomDFSIdx = cUnit->iDomList[bb->dfsId];
DCHECK_NE(iDomDFSIdx, NOTVISITED);
int iDomIdx = cUnit->dfsPostOrder.elemList[iDomDFSIdx];
BasicBlock* iDom =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(&cUnit->blockList, iDomIdx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(&cUnit->blockList, iDomIdx));
if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
DCHECK_EQ(bb->iDom->id, iDom->id);
}
bb->iDom = iDom;
/* Add bb to the iDominated set of the immediate dominator block */
- oatSetBit(cUnit, iDom->iDominated, bb->id);
+ SetBit(cUnit, iDom->iDominated, bb->id);
}
return false;
}
/* Compute dominators, immediate dominator, and dominance fronter */
-void computeDominators(CompilationUnit* cUnit)
+static void ComputeDominators(CompilationUnit* cUnit)
{
int numReachableBlocks = cUnit->numReachableBlocks;
int numTotalBlocks = cUnit->blockList.numUsed;
/* Initialize domination-related data structures */
- oatDataFlowAnalysisDispatcher(cUnit, initializeDominationInfo,
+ DataFlowAnalysisDispatcher(cUnit, InitializeDominationInfo,
kReachableNodes, false /* isIterative */);
/* Initalize & Clear iDomList */
if (cUnit->iDomList == NULL) {
- cUnit->iDomList = static_cast<int*>(oatNew(cUnit, sizeof(int) * numReachableBlocks,
+ cUnit->iDomList = static_cast<int*>(NewMem(cUnit, sizeof(int) * numReachableBlocks,
false, kAllocDFInfo));
}
for (int i = 0; i < numReachableBlocks; i++) {
@@ -590,40 +590,40 @@
cUnit->iDomList[cUnit->entryBlock->dfsId] = cUnit->entryBlock->dfsId;
/* Compute the immediate dominators */
- oatDataFlowAnalysisDispatcher(cUnit, computeBlockIDom,
+ DataFlowAnalysisDispatcher(cUnit, ComputeblockIDom,
kReversePostOrderTraversal,
true /* isIterative */);
/* Set the dominator for the root node */
- oatClearAllBits(cUnit->entryBlock->dominators);
- oatSetBit(cUnit, cUnit->entryBlock->dominators, cUnit->entryBlock->id);
+ ClearAllBits(cUnit->entryBlock->dominators);
+ SetBit(cUnit, cUnit->entryBlock->dominators, cUnit->entryBlock->id);
if (cUnit->tempBlockV == NULL) {
- cUnit->tempBlockV = oatAllocBitVector(cUnit, numTotalBlocks,
+ cUnit->tempBlockV = AllocBitVector(cUnit, numTotalBlocks,
false /* expandable */,
kBitMapTmpBlockV);
} else {
- oatClearAllBits(cUnit->tempBlockV);
+ ClearAllBits(cUnit->tempBlockV);
}
cUnit->entryBlock->iDom = NULL;
/* For testing, compute sets using alternate mechanism */
if (cUnit->enableDebug & (1 << kDebugVerifyDataflow)) {
// Use alternate mechanism to compute dominators for comparison
- oatDataFlowAnalysisDispatcher(cUnit, slowComputeBlockDominators,
+ DataFlowAnalysisDispatcher(cUnit, SlowComputeBlockDominators,
kPreOrderDFSTraversal,
true /* isIterative */);
- oatDataFlowAnalysisDispatcher(cUnit, slowComputeBlockIDom,
+ DataFlowAnalysisDispatcher(cUnit, SlowComputeBlockIDom,
kReachableNodes,
false /* isIterative */);
}
- oatDataFlowAnalysisDispatcher(cUnit, setDominators,
+ DataFlowAnalysisDispatcher(cUnit, SetDominators,
kReachableNodes,
false /* isIterative */);
- oatDataFlowAnalysisDispatcher(cUnit, computeBlockDominators,
+ DataFlowAnalysisDispatcher(cUnit, ComputeBlockDominiators,
kReversePostOrderTraversal,
false /* isIterative */);
@@ -632,17 +632,17 @@
* iDominated sets.
*/
if (cUnit->domPostOrderTraversal.elemList == NULL) {
- oatInitGrowableList(cUnit, &cUnit->domPostOrderTraversal,
+ CompilerInitGrowableList(cUnit, &cUnit->domPostOrderTraversal,
numReachableBlocks, kListDomPostOrderTraversal);
} else {
cUnit->domPostOrderTraversal.numUsed = 0;
}
- computeDomPostOrderTraversal(cUnit, cUnit->entryBlock);
+ ComputeDomPostOrderTraversal(cUnit, cUnit->entryBlock);
DCHECK_EQ(cUnit->domPostOrderTraversal.numUsed, static_cast<unsigned>(cUnit->numReachableBlocks));
/* Now compute the dominance frontier for each block */
- oatDataFlowAnalysisDispatcher(cUnit, computeDominanceFrontier,
+ DataFlowAnalysisDispatcher(cUnit, ComputeDominanceFrontier,
kPostOrderDOMTraversal,
false /* isIterative */);
}
@@ -651,9 +651,8 @@
* Perform dest U= src1 ^ ~src2
* This is probably not general enough to be placed in BitVector.[ch].
*/
-void computeSuccLiveIn(ArenaBitVector* dest,
- const ArenaBitVector* src1,
- const ArenaBitVector* src2)
+static void ComputeSuccLineIn(ArenaBitVector* dest, const ArenaBitVector* src1,
+ const ArenaBitVector* src2)
{
if (dest->storageSize != src1->storageSize ||
dest->storageSize != src2->storageSize ||
@@ -673,59 +672,59 @@
* The calculated result is used for phi-node pruning - where we only need to
* insert a phi node if the variable is live-in to the block.
*/
-bool computeBlockLiveIns(CompilationUnit* cUnit, BasicBlock* bb)
+static bool ComputeBlockLiveIns(CompilationUnit* cUnit, BasicBlock* bb)
{
ArenaBitVector* tempDalvikRegisterV = cUnit->tempDalvikRegisterV;
if (bb->dataFlowInfo == NULL) return false;
- oatCopyBitVector(tempDalvikRegisterV, bb->dataFlowInfo->liveInV);
+ CopyBitVector(tempDalvikRegisterV, bb->dataFlowInfo->liveInV);
if (bb->taken && bb->taken->dataFlowInfo)
- computeSuccLiveIn(tempDalvikRegisterV, bb->taken->dataFlowInfo->liveInV,
+ ComputeSuccLineIn(tempDalvikRegisterV, bb->taken->dataFlowInfo->liveInV,
bb->dataFlowInfo->defV);
if (bb->fallThrough && bb->fallThrough->dataFlowInfo)
- computeSuccLiveIn(tempDalvikRegisterV,
+ ComputeSuccLineIn(tempDalvikRegisterV,
bb->fallThrough->dataFlowInfo->liveInV,
bb->dataFlowInfo->defV);
if (bb->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&bb->successorBlockList.blocks,
+ GrowableListIteratorInit(&bb->successorBlockList.blocks,
&iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
if (successorBlockInfo == NULL) break;
BasicBlock* succBB = successorBlockInfo->block;
if (succBB->dataFlowInfo) {
- computeSuccLiveIn(tempDalvikRegisterV,
+ ComputeSuccLineIn(tempDalvikRegisterV,
succBB->dataFlowInfo->liveInV,
bb->dataFlowInfo->defV);
}
}
}
- if (oatCompareBitVectors(tempDalvikRegisterV, bb->dataFlowInfo->liveInV)) {
- oatCopyBitVector(bb->dataFlowInfo->liveInV, tempDalvikRegisterV);
+ if (CompareBitVectors(tempDalvikRegisterV, bb->dataFlowInfo->liveInV)) {
+ CopyBitVector(bb->dataFlowInfo->liveInV, tempDalvikRegisterV);
return true;
}
return false;
}
/* Insert phi nodes to for each variable to the dominance frontiers */
-void insertPhiNodes(CompilationUnit* cUnit)
+static void InsertPhiNodes(CompilationUnit* cUnit)
{
int dalvikReg;
const GrowableList* blockList = &cUnit->blockList;
ArenaBitVector* phiBlocks =
- oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapPhi);
+ AllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapPhi);
ArenaBitVector* tmpBlocks =
- oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapTmpBlocks);
+ AllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapTmpBlocks);
ArenaBitVector* inputBlocks =
- oatAllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapInputBlocks);
+ AllocBitVector(cUnit, cUnit->numBlocks, false, kBitMapInputBlocks);
cUnit->tempDalvikRegisterV =
- oatAllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
+ AllocBitVector(cUnit, cUnit->numDalvikRegisters, false,
kBitMapRegisterV);
- oatDataFlowAnalysisDispatcher(cUnit, computeBlockLiveIns,
+ DataFlowAnalysisDispatcher(cUnit, ComputeBlockLiveIns,
kPostOrderDFSTraversal, true /* isIterative */);
/* Iterate through each Dalvik register */
@@ -733,37 +732,37 @@
bool change;
ArenaBitVectorIterator iterator;
- oatCopyBitVector(inputBlocks, cUnit->defBlockMatrix[dalvikReg]);
- oatClearAllBits(phiBlocks);
+ CopyBitVector(inputBlocks, cUnit->defBlockMatrix[dalvikReg]);
+ ClearAllBits(phiBlocks);
/* Calculate the phi blocks for each Dalvik register */
do {
change = false;
- oatClearAllBits(tmpBlocks);
- oatBitVectorIteratorInit(inputBlocks, &iterator);
+ ClearAllBits(tmpBlocks);
+ BitVectorIteratorInit(inputBlocks, &iterator);
while (true) {
- int idx = oatBitVectorIteratorNext(&iterator);
+ int idx = BitVectorIteratorNext(&iterator);
if (idx == -1) break;
BasicBlock* defBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, idx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, idx));
/* Merge the dominance frontier to tmpBlocks */
- //TUNING: hot call to oatUnifyBitVectors
+ //TUNING: hot call to UnifyBitVetors
if (defBB->domFrontier != NULL) {
- oatUnifyBitVectors(tmpBlocks, tmpBlocks, defBB->domFrontier);
+ UnifyBitVetors(tmpBlocks, tmpBlocks, defBB->domFrontier);
}
}
- if (oatCompareBitVectors(phiBlocks, tmpBlocks)) {
+ if (CompareBitVectors(phiBlocks, tmpBlocks)) {
change = true;
- oatCopyBitVector(phiBlocks, tmpBlocks);
+ CopyBitVector(phiBlocks, tmpBlocks);
/*
* Iterate through the original blocks plus the new ones in
* the dominance frontier.
*/
- oatCopyBitVector(inputBlocks, phiBlocks);
- oatUnifyBitVectors(inputBlocks, inputBlocks,
+ CopyBitVector(inputBlocks, phiBlocks);
+ UnifyBitVetors(inputBlocks, inputBlocks,
cUnit->defBlockMatrix[dalvikReg]);
}
} while (change);
@@ -772,21 +771,21 @@
* Insert a phi node for dalvikReg in the phiBlocks if the Dalvik
* register is in the live-in set.
*/
- oatBitVectorIteratorInit(phiBlocks, &iterator);
+ BitVectorIteratorInit(phiBlocks, &iterator);
while (true) {
- int idx = oatBitVectorIteratorNext(&iterator);
+ int idx = BitVectorIteratorNext(&iterator);
if (idx == -1) break;
BasicBlock* phiBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListGetElement(blockList, idx));
+ reinterpret_cast<BasicBlock*>(GrowableListGetElement(blockList, idx));
/* Variable will be clobbered before being used - no need for phi */
- if (!oatIsBitSet(phiBB->dataFlowInfo->liveInV, dalvikReg)) continue;
- MIR *phi = static_cast<MIR*>(oatNew(cUnit, sizeof(MIR), true, kAllocDFInfo));
+ if (!IsBitSet(phiBB->dataFlowInfo->liveInV, dalvikReg)) continue;
+ MIR *phi = static_cast<MIR*>(NewMem(cUnit, sizeof(MIR), true, kAllocDFInfo));
phi->dalvikInsn.opcode = static_cast<Instruction::Code>(kMirOpPhi);
phi->dalvikInsn.vA = dalvikReg;
phi->offset = phiBB->startOffset;
phi->meta.phiNext = cUnit->phiList;
cUnit->phiList = phi;
- oatPrependMIR(phiBB, phi);
+ PrependMIR(phiBB, phi);
}
}
}
@@ -795,7 +794,7 @@
* Worker function to insert phi-operands with latest SSA names from
* predecessor blocks
*/
-bool insertPhiNodeOperands(CompilationUnit* cUnit, BasicBlock* bb)
+static bool InsertPhiNodeOperands(CompilationUnit* cUnit, BasicBlock* bb)
{
GrowableListIterator iter;
MIR *mir;
@@ -814,10 +813,10 @@
incomingArc.clear();
/* Iterate through the predecessors */
- oatGrowableListIteratorInit(bb->predecessors, &iter);
+ GrowableListIteratorInit(bb->predecessors, &iter);
while (true) {
BasicBlock* predBB =
- reinterpret_cast<BasicBlock*>(oatGrowableListIteratorNext(&iter));
+ reinterpret_cast<BasicBlock*>(GrowableListIteratorNext(&iter));
if (!predBB) break;
int ssaReg = predBB->dataFlowInfo->vRegToSSAMap[vReg];
uses.push_back(ssaReg);
@@ -828,11 +827,11 @@
int numUses = uses.size();
mir->ssaRep->numUses = numUses;
mir->ssaRep->uses =
- static_cast<int*>(oatNew(cUnit, sizeof(int) * numUses, false, kAllocDFInfo));
+ static_cast<int*>(NewMem(cUnit, sizeof(int) * numUses, false, kAllocDFInfo));
mir->ssaRep->fpUse =
- static_cast<bool*>(oatNew(cUnit, sizeof(bool) * numUses, true, kAllocDFInfo));
+ static_cast<bool*>(NewMem(cUnit, sizeof(bool) * numUses, true, kAllocDFInfo));
int* incoming =
- static_cast<int*>(oatNew(cUnit, sizeof(int) * numUses, false, kAllocDFInfo));
+ static_cast<int*>(NewMem(cUnit, sizeof(int) * numUses, false, kAllocDFInfo));
// TODO: Ugly, rework (but don't burden each MIR/LIR for Phi-only needs)
mir->dalvikInsn.vB = reinterpret_cast<uintptr_t>(incoming);
@@ -847,39 +846,39 @@
return true;
}
-void doDFSPreOrderSSARename(CompilationUnit* cUnit, BasicBlock* block)
+static void DoDFSPreOrderSSARename(CompilationUnit* cUnit, BasicBlock* block)
{
if (block->visited || block->hidden) return;
block->visited = true;
/* Process this block */
- oatDoSSAConversion(cUnit, block);
+ DoSSAConversion(cUnit, block);
int mapSize = sizeof(int) * cUnit->numDalvikRegisters;
/* Save SSA map snapshot */
- int* savedSSAMap = static_cast<int*>(oatNew(cUnit, mapSize, false, kAllocDalvikToSSAMap));
+ int* savedSSAMap = static_cast<int*>(NewMem(cUnit, mapSize, false, kAllocDalvikToSSAMap));
memcpy(savedSSAMap, cUnit->vRegToSSAMap, mapSize);
if (block->fallThrough) {
- doDFSPreOrderSSARename(cUnit, block->fallThrough);
+ DoDFSPreOrderSSARename(cUnit, block->fallThrough);
/* Restore SSA map snapshot */
memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
}
if (block->taken) {
- doDFSPreOrderSSARename(cUnit, block->taken);
+ DoDFSPreOrderSSARename(cUnit, block->taken);
/* Restore SSA map snapshot */
memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
}
if (block->successorBlockList.blockListType != kNotUsed) {
GrowableListIterator iterator;
- oatGrowableListIteratorInit(&block->successorBlockList.blocks, &iterator);
+ GrowableListIteratorInit(&block->successorBlockList.blocks, &iterator);
while (true) {
SuccessorBlockInfo *successorBlockInfo =
- reinterpret_cast<SuccessorBlockInfo*>(oatGrowableListIteratorNext(&iterator));
+ reinterpret_cast<SuccessorBlockInfo*>(GrowableListIteratorNext(&iterator));
if (successorBlockInfo == NULL) break;
BasicBlock* succBB = successorBlockInfo->block;
- doDFSPreOrderSSARename(cUnit, succBB);
+ DoDFSPreOrderSSARename(cUnit, succBB);
/* Restore SSA map snapshot */
memcpy(cUnit->vRegToSSAMap, savedSSAMap, mapSize);
}
@@ -889,45 +888,45 @@
}
/* Perform SSA transformation for the whole method */
-void oatMethodSSATransformation(CompilationUnit* cUnit)
+void SSATransformation(CompilationUnit* cUnit)
{
/* Compute the DFS order */
- computeDFSOrders(cUnit);
+ ComputeDFSOrders(cUnit);
if (!cUnit->disableDataflow) {
/* Compute the dominator info */
- computeDominators(cUnit);
+ ComputeDominators(cUnit);
}
/* Allocate data structures in preparation for SSA conversion */
- oatInitializeSSAConversion(cUnit);
+ CompilerInitializeSSAConversion(cUnit);
if (!cUnit->disableDataflow) {
/* Find out the "Dalvik reg def x block" relation */
- computeDefBlockMatrix(cUnit);
+ ComputeDefBlockMatrix(cUnit);
/* Insert phi nodes to dominance frontiers for all variables */
- insertPhiNodes(cUnit);
+ InsertPhiNodes(cUnit);
}
/* Rename register names by local defs and phi nodes */
- oatDataFlowAnalysisDispatcher(cUnit, oatClearVisitedFlag,
+ DataFlowAnalysisDispatcher(cUnit, ClearVisitedFlag,
kAllNodes, false /* isIterative */);
- doDFSPreOrderSSARename(cUnit, cUnit->entryBlock);
+ DoDFSPreOrderSSARename(cUnit, cUnit->entryBlock);
if (!cUnit->disableDataflow) {
/*
* Shared temp bit vector used by each block to count the number of defs
* from all the predecessor blocks.
*/
- cUnit->tempSSARegisterV = oatAllocBitVector(cUnit, cUnit->numSSARegs,
+ cUnit->tempSSARegisterV = AllocBitVector(cUnit, cUnit->numSSARegs,
false, kBitMapTempSSARegisterV);
cUnit->tempSSABlockIdV =
- static_cast<int*>(oatNew(cUnit, sizeof(int) * cUnit->numSSARegs, false, kAllocDFInfo));
+ static_cast<int*>(NewMem(cUnit, sizeof(int) * cUnit->numSSARegs, false, kAllocDFInfo));
/* Insert phi-operands with latest SSA names from predecessor blocks */
- oatDataFlowAnalysisDispatcher(cUnit, insertPhiNodeOperands,
+ DataFlowAnalysisDispatcher(cUnit, InsertPhiNodeOperands,
kReachableNodes, false /* isIterative */);
}
}