/* Perform SSA transformation for the whole method */
void dvmCompilerMethodSSATransformation(CompilationUnit *cUnit) {
/* Compute the DFS order */
computeDFSOrder(cUnit);
/* Compute the dominator info */
computeDominators(cUnit);
/* Allocate data structures in preparation for SSA conversion */
dvmInitializeSSAConversion(cUnit);
/* Find out the "Dalvik reg def x block" relation */
computeDefBlockMatrix(cUnit);
/* Insert phi nodes to dominance frontiers for all variables */
insertPhiNodes(cUnit);
/* Rename register names by local defs and phi nodes */
dvmCompilerDataFlowAnalysisDispatcher(cUnit, dvmCompilerDoSSAConversion,
kPreOrderDFSTraversal,
false /* isIterative */);
/*
* Shared temp bit vector used by each block to count the number of defs
* from all the predecessor blocks.
*/
cUnit->tempSSARegisterV = dvmCompilerAllocBitVector(cUnit->numSSARegs,
false);
/* Insert phi-operands with latest SSA names from predecessor blocks */
dvmCompilerDataFlowAnalysisDispatcher(cUnit, insertPhiNodeOperands,
kReachableNodes,
false /* isIterative */);
}
static void computeDefBlockMatrix(CompilationUnit *cUnit) {
int numRegisters = cUnit->numDalvikRegisters;
/* Allocate numDalvikRegisters bit vector pointers */
cUnit->defBlockMatrix = (BitVector **)
dvmCompilerNew(sizeof(BitVector *) * numRegisters, true);
int i;
/* Initialize numRegister vectors with numBlocks bits each */
for (i = 0; i < numRegisters; i++) {
cUnit->defBlockMatrix[i] = dvmCompilerAllocBitVector(cUnit->numBlocks,
false);
}
dvmCompilerDataFlowAnalysisDispatcher(cUnit, dvmCompilerFindLocalLiveIn,
kAllNodes,
false /* isIterative */);
dvmCompilerDataFlowAnalysisDispatcher(cUnit, fillDefBlockMatrix,
kAllNodes,
false /* isIterative */);
if (cUnit->jitMode == kJitMethod) {
/*
* Also set the incoming parameters as defs in the entry block.
* Only need to handle the parameters for the outer method.
*/
int inReg = cUnit->method->registersSize - cUnit->method->insSize;
for (; inReg < cUnit->method->registersSize; inReg++) {
dvmCompilerSetBit(cUnit->defBlockMatrix[inReg],
cUnit->entryBlock->id);
}
}
}
/* Build a loop. Return true if a loop structure is successfully identified. */
bool dvmCompilerBuildLoop(CompilationUnit *cUnit) {
/* Compute the DFS order */
computeDFSOrder(cUnit);
/* Compute the dominator info */
computeDominators(cUnit);
/* Loop structure not recognized/supported - return false */
if (dvmCompilerFilterLoopBlocks(cUnit) == false)
return false;
/* Re-compute the DFS order just for the loop */
computeDFSOrder(cUnit);
/* Re-compute the dominator info just for the loop */
computeDominators(cUnit);
/* Allocate data structures in preparation for SSA conversion */
dvmInitializeSSAConversion(cUnit);
/* Find out the "Dalvik reg def x block" relation */
computeDefBlockMatrix(cUnit);
/* Insert phi nodes to dominance frontiers for all variables */
insertPhiNodes(cUnit);
/* Rename register names by local defs and phi nodes */
dvmCompilerDataFlowAnalysisDispatcher(cUnit, dvmCompilerDoSSAConversion,
kPreOrderDFSTraversal,
false /* isIterative */);
/*
* Shared temp bit vector used by each block to count the number of defs
* from all the predecessor blocks.
*/
cUnit->tempSSARegisterV = dvmCompilerAllocBitVector(cUnit->numSSARegs,
false);
/* Insert phi-operands with latest SSA names from predecessor blocks */
dvmCompilerDataFlowAnalysisDispatcher(cUnit, insertPhiNodeOperands,
kReachableNodes,
false /* isIterative */);
if (gDvmJit.receivedSIGUSR2 || gDvmJit.printMe) {
dvmDumpCFG(cUnit, "/sdcard/cfg/");
}
return true;
}
/* Compute dominators, immediate dominator, and dominance fronter */
static void computeDominators(CompilationUnit *cUnit) {
int numReachableBlocks = cUnit->numReachableBlocks;
int numTotalBlocks = cUnit->blockList.numUsed;
/* Initialize domination-related data structures */
dvmCompilerDataFlowAnalysisDispatcher(cUnit, initializeDominationInfo,
kReachableNodes,
false /* isIterative */);
/* Set the dominator for the root node */
dvmClearAllBits(cUnit->entryBlock->dominators);
dvmSetBit(cUnit->entryBlock->dominators, cUnit->entryBlock->id);
if (cUnit->tempBlockV == NULL) {
cUnit->tempBlockV = dvmCompilerAllocBitVector(numTotalBlocks,
false /* expandable */);
} else {
dvmClearAllBits(cUnit->tempBlockV);
}
dvmCompilerDataFlowAnalysisDispatcher(cUnit, computeBlockDominators,
kPreOrderDFSTraversal,
true /* isIterative */);
cUnit->entryBlock->iDom = NULL;
dvmCompilerDataFlowAnalysisDispatcher(cUnit, computeImmediateDominator,
kReachableNodes,
false /* isIterative */);
/*
* Now go ahead and compute the post order traversal based on the
* iDominated sets.
*/
if (cUnit->domPostOrderTraversal.elemList == NULL) {
dvmInitGrowableList(&cUnit->domPostOrderTraversal, numReachableBlocks);
} else {
cUnit->domPostOrderTraversal.numUsed = 0;
}
computeDomPostOrderTraversal(cUnit, cUnit->entryBlock);
assert(cUnit->domPostOrderTraversal.numUsed ==
(unsigned) cUnit->numReachableBlocks);
/* Now compute the dominance frontier for each block */
dvmCompilerDataFlowAnalysisDispatcher(cUnit, computeDominanceFrontier,
kPostOrderDOMTraversal,
false /* isIterative */);
}
/* Sort the blocks by the Depth-First-Search pre-order */
static void computeDFSOrder(CompilationUnit *cUnit) {
/* Initialize or reset the DFS order list */
if (cUnit->dfsOrder.elemList == NULL) {
dvmInitGrowableList(&cUnit->dfsOrder, cUnit->numBlocks);
} else {
/* Just reset the used length on the counter */
cUnit->dfsOrder.numUsed = 0;
}
dvmCompilerDataFlowAnalysisDispatcher(cUnit, dvmCompilerClearVisitedFlag,
kAllNodes,
false /* isIterative */);
recordDFSPreOrder(cUnit, cUnit->entryBlock);
cUnit->numReachableBlocks = cUnit->dfsOrder.numUsed;
}
void dvmCompilerMethodMIR2LIR(CompilationUnit *cUnit)
{
// FIXME - enable method compilation for selected routines here
if (strcmp(cUnit->method->name, "add")) return;
/* Used to hold the labels of each block */
cUnit->blockLabelList =
(void *) dvmCompilerNew(sizeof(ArmLIR) * cUnit->numBlocks, true);
dvmCompilerDataFlowAnalysisDispatcher(cUnit, methodBlockCodeGen,
kPreOrderDFSTraversal,
false /* isIterative */);
dvmCompilerApplyGlobalOptimizations(cUnit);
// FIXME - temporarily enable verbose printing for all methods
cUnit->printMe = true;
#if defined(WITH_SELF_VERIFICATION)
selfVerificationBranchInsertPass(cUnit);
#endif
}
/* Main entry point to do SSA conversion for non-loop traces */
void dvmCompilerNonLoopAnalysis(CompilationUnit *cUnit)
{
dvmCompilerDataFlowAnalysisDispatcher(cUnit, dvmCompilerDoSSAConversion);
}
/* Insert phi nodes to for each variable to the dominance frontiers */
static void insertPhiNodes(CompilationUnit *cUnit) {
int dalvikReg;
const GrowableList *blockList = &cUnit->blockList;
BitVector *phiBlocks =
dvmCompilerAllocBitVector(cUnit->numBlocks, false);
BitVector *tmpBlocks =
dvmCompilerAllocBitVector(cUnit->numBlocks, false);
BitVector *inputBlocks =
dvmCompilerAllocBitVector(cUnit->numBlocks, false);
cUnit->tempDalvikRegisterV =
dvmCompilerAllocBitVector(cUnit->numDalvikRegisters, false);
dvmCompilerDataFlowAnalysisDispatcher(cUnit, computeBlockLiveIns,
kPostOrderDFSTraversal,
true /* isIterative */);
/* Iterate through each Dalvik register */
for (dalvikReg = 0; dalvikReg < cUnit->numDalvikRegisters; dalvikReg++) {
bool change;
BitVectorIterator iterator;
dvmCopyBitVector(inputBlocks, cUnit->defBlockMatrix[dalvikReg]);
dvmClearAllBits(phiBlocks);
/* Calculate the phi blocks for each Dalvik register */
do {
change = false;
dvmClearAllBits(tmpBlocks);
dvmBitVectorIteratorInit(inputBlocks, &iterator);
while (true) {
int idx = dvmBitVectorIteratorNext(&iterator);
if (idx == -1) break;
BasicBlock *defBB =
(BasicBlock *) dvmGrowableListGetElement(blockList, idx);
/* Merge the dominance frontier to tmpBlocks */
dvmUnifyBitVectors(tmpBlocks, tmpBlocks, defBB->domFrontier);
}
if (dvmCompareBitVectors(phiBlocks, tmpBlocks)) {
change = true;
dvmCopyBitVector(phiBlocks, tmpBlocks);
/*
* Iterate through the original blocks plus the new ones in
* the dominance frontier.
*/
dvmCopyBitVector(inputBlocks, phiBlocks);
dvmUnifyBitVectors(inputBlocks, inputBlocks,
cUnit->defBlockMatrix[dalvikReg]);
}
} while (change);
/*
* Insert a phi node for dalvikReg in the phiBlocks if the Dalvik
* register is in the live-in set.
*/
dvmBitVectorIteratorInit(phiBlocks, &iterator);
while (true) {
int idx = dvmBitVectorIteratorNext(&iterator);
if (idx == -1) break;
BasicBlock *phiBB =
(BasicBlock *) dvmGrowableListGetElement(blockList, idx);
/* Variable will be clobbered before being used - no need for phi */
if (!dvmIsBitSet(phiBB->dataFlowInfo->liveInV, dalvikReg)) continue;
MIR *phi = (MIR *) dvmCompilerNew(sizeof(MIR), true);
phi->dalvikInsn.opcode = (Opcode) kMirOpPhi;
phi->dalvikInsn.vA = dalvikReg;
phi->offset = phiBB->startOffset;
dvmCompilerPrependMIR(phiBB, phi);
}
}
}
