static BasicBlock *findPredecessorBlock(const CompilationUnit *cUnit, const BasicBlock *bb) { int numPred = dvmCountSetBits(bb->predecessors); BitVectorIterator bvIterator; dvmBitVectorIteratorInit(bb->predecessors, &bvIterator); if (numPred == 1) { int predIdx = dvmBitVectorIteratorNext(&bvIterator); return (BasicBlock *) dvmGrowableListGetElement(&cUnit->blockList, predIdx); /* First loop block */ } else if ((numPred == 2) && dvmIsBitSet(bb->predecessors, cUnit->entryBlock->id)) { while (true) { int predIdx = dvmBitVectorIteratorNext(&bvIterator); if (predIdx == cUnit->entryBlock->id) continue; return (BasicBlock *) dvmGrowableListGetElement(&cUnit->blockList, predIdx); } /* Doesn't support other shape of control flow yet */ } else { return NULL; } }
/* * Worker function to insert phi-operands with latest SSA names from * predecessor blocks */ static bool insertPhiNodeOperands(CompilationUnit *cUnit, BasicBlock *bb) { BitVector *ssaRegV = cUnit->tempSSARegisterV; BitVectorIterator bvIterator; GrowableList *blockList = &cUnit->blockList; MIR *mir; /* Phi nodes are at the beginning of each block */ for (mir = bb->firstMIRInsn; mir; mir = mir->next) { if (mir->dalvikInsn.opcode != (Opcode) kMirOpPhi) return true; int ssaReg = mir->ssaRep->defs[0]; int encodedDalvikValue = (int) dvmGrowableListGetElement(cUnit->ssaToDalvikMap, ssaReg); int dalvikReg = DECODE_REG(encodedDalvikValue); dvmClearAllBits(ssaRegV); /* Iterate through the predecessors */ dvmBitVectorIteratorInit(bb->predecessors, &bvIterator); while (true) { int predIdx = dvmBitVectorIteratorNext(&bvIterator); if (predIdx == -1) break; BasicBlock *predBB = (BasicBlock *) dvmGrowableListGetElement( blockList, predIdx); int encodedSSAValue = predBB->dataFlowInfo->dalvikToSSAMap[dalvikReg]; int ssaReg = DECODE_REG(encodedSSAValue); dvmSetBit(ssaRegV, ssaReg); } /* Count the number of SSA registers for a Dalvik register */ int numUses = dvmCountSetBits(ssaRegV); mir->ssaRep->numUses = numUses; mir->ssaRep->uses = (int *) dvmCompilerNew(sizeof(int) * numUses, false); mir->ssaRep->fpUse = (bool *) dvmCompilerNew(sizeof(bool) * numUses, true); BitVectorIterator phiIterator; dvmBitVectorIteratorInit(ssaRegV, &phiIterator); int *usePtr = mir->ssaRep->uses; /* Set the uses array for the phi node */ while (true) { int ssaRegIdx = dvmBitVectorIteratorNext(&phiIterator); if (ssaRegIdx == -1) break; *usePtr++ = ssaRegIdx; } } return true; }
/* Worker function to compute each block's dominators */ static bool computeBlockDominators(CompilationUnit *cUnit, BasicBlock *bb) { GrowableList *blockList = &cUnit->blockList; int numTotalBlocks = blockList->numUsed; BitVector *tempBlockV = cUnit->tempBlockV; BitVectorIterator bvIterator; /* * The dominator of the entry block has been preset to itself and we need * to skip the calculation here. */ if (bb == cUnit->entryBlock) return false; dvmSetInitialBits(tempBlockV, numTotalBlocks); /* Iterate through the predecessors */ dvmBitVectorIteratorInit(bb->predecessors, &bvIterator); while (true) { int predIdx = dvmBitVectorIteratorNext(&bvIterator); if (predIdx == -1) break; BasicBlock *predBB = (BasicBlock *) dvmGrowableListGetElement( blockList, predIdx); /* tempBlockV = tempBlockV ^ dominators */ dvmIntersectBitVectors(tempBlockV, tempBlockV, predBB->dominators); } dvmSetBit(tempBlockV, bb->id); if (dvmCompareBitVectors(tempBlockV, bb->dominators)) { dvmCopyBitVector(bb->dominators, tempBlockV); return true; } return false; }
/* Worker function to compute the dominance frontier */ static bool computeDominanceFrontier(CompilationUnit *cUnit, BasicBlock *bb) { GrowableList *blockList = &cUnit->blockList; /* Calculate DF_local */ if (bb->taken) { checkForDominanceFrontier(bb, bb->taken); } if (bb->fallThrough) { checkForDominanceFrontier(bb, bb->fallThrough); } if (bb->successorBlockList.blockListType != kNotUsed) { GrowableListIterator iterator; dvmGrowableListIteratorInit(&bb->successorBlockList.blocks, &iterator); while (true) { SuccessorBlockInfo *successorBlockInfo = (SuccessorBlockInfo *) dvmGrowableListIteratorNext(&iterator); if (successorBlockInfo == NULL) break; BasicBlock *succBB = successorBlockInfo->block; checkForDominanceFrontier(bb, succBB); } } /* Calculate DF_up */ BitVectorIterator bvIterator; dvmBitVectorIteratorInit(bb->iDominated, &bvIterator); while (true) { int dominatedIdx = dvmBitVectorIteratorNext(&bvIterator); if (dominatedIdx == -1) break; BasicBlock *dominatedBB = (BasicBlock *) dvmGrowableListGetElement(blockList, dominatedIdx); BitVectorIterator dfIterator; dvmBitVectorIteratorInit(dominatedBB->domFrontier, &dfIterator); while (true) { int dfUpIdx = dvmBitVectorIteratorNext(&dfIterator); if (dfUpIdx == -1) break; BasicBlock *dfUpBlock = (BasicBlock *) dvmGrowableListGetElement(blockList, dfUpIdx); checkForDominanceFrontier(bb, dfUpBlock); } } return true; }
/* Worker function to compute the idom */ static bool computeImmediateDominator(CompilationUnit *cUnit, BasicBlock *bb) { GrowableList *blockList = &cUnit->blockList; BitVector *tempBlockV = cUnit->tempBlockV; BitVectorIterator bvIterator; BasicBlock *iDom; if (bb == cUnit->entryBlock) return false; dvmCopyBitVector(tempBlockV, bb->dominators); dvmClearBit(tempBlockV, bb->id); dvmBitVectorIteratorInit(tempBlockV, &bvIterator); /* Should not see any dead block */ assert(dvmCountSetBits(tempBlockV) != 0); if (dvmCountSetBits(tempBlockV) == 1) { iDom = (BasicBlock *) dvmGrowableListGetElement( blockList, dvmBitVectorIteratorNext(&bvIterator)); bb->iDom = iDom; } else { int iDomIdx = dvmBitVectorIteratorNext(&bvIterator); assert(iDomIdx != -1); while (true) { int nextDom = dvmBitVectorIteratorNext(&bvIterator); if (nextDom == -1) break; BasicBlock *nextDomBB = (BasicBlock *) dvmGrowableListGetElement(blockList, nextDom); /* iDom dominates nextDom - set new iDom */ if (dvmIsBitSet(nextDomBB->dominators, iDomIdx)) { iDomIdx = nextDom; } } iDom = (BasicBlock *) dvmGrowableListGetElement(blockList, iDomIdx); /* Set the immediate dominator block for bb */ bb->iDom = iDom; } /* Add bb to the iDominated set of the immediate dominator block */ dvmCompilerSetBit(iDom->iDominated, bb->id); return true; }
/* Compute the post-order traversal of the CFG */ static void computeDomPostOrderTraversal(CompilationUnit *cUnit, BasicBlock *bb) { BitVectorIterator bvIterator; dvmBitVectorIteratorInit(bb->iDominated, &bvIterator); GrowableList *blockList = &cUnit->blockList; /* Iterate through the dominated blocks first */ while (true) { int bbIdx = dvmBitVectorIteratorNext(&bvIterator); if (bbIdx == -1) break; BasicBlock *dominatedBB = (BasicBlock *) dvmGrowableListGetElement(blockList, bbIdx); computeDomPostOrderTraversal(cUnit, dominatedBB); } /* Enter the current block id */ dvmInsertGrowableList(&cUnit->domPostOrderTraversal, bb->id); /* hacky loop detection */ if (bb->taken && dvmIsBitSet(bb->dominators, bb->taken->id)) { cUnit->hasLoop = true; } }
/* 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); } } }