bool LoopInterchangeLegality::tightlyNested(Loop *OuterLoop, Loop *InnerLoop) {
BasicBlock *OuterLoopHeader = OuterLoop->getHeader();
BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
BasicBlock *OuterLoopLatch = OuterLoop->getLoopLatch();
DEBUG(dbgs() << "Checking if Loops are Tightly Nested\n");
// A perfectly nested loop will not have any branch in between the outer and
// inner block i.e. outer header will branch to either inner preheader and
// outerloop latch.
BranchInst *outerLoopHeaderBI =
dyn_cast<BranchInst>(OuterLoopHeader->getTerminator());
if (!outerLoopHeaderBI)
return false;
unsigned num = outerLoopHeaderBI->getNumSuccessors();
for (unsigned i = 0; i < num; i++) {
if (outerLoopHeaderBI->getSuccessor(i) != InnerLoopPreHeader &&
outerLoopHeaderBI->getSuccessor(i) != OuterLoopLatch)
return false;
}
DEBUG(dbgs() << "Checking instructions in Loop header and Loop latch \n");
// We do not have any basic block in between now make sure the outer header
// and outer loop latch doesn't contain any unsafe instructions.
if (containsUnsafeInstructionsInHeader(OuterLoopHeader) ||
containsUnsafeInstructionsInLatch(OuterLoopLatch))
return false;
DEBUG(dbgs() << "Loops are perfectly nested \n");
// We have a perfect loop nest.
return true;
}
void BlockGenerator::createScalarInitialization(Region &R,
ValueMapT &GlobalMap) {
// The split block __just before__ the region and optimized region.
BasicBlock *SplitBB = R.getEnteringBlock();
BranchInst *SplitBBTerm = cast<BranchInst>(SplitBB->getTerminator());
assert(SplitBBTerm->getNumSuccessors() == 2 && "Bad region entering block!");
// Get the start block of the __optimized__ region.
BasicBlock *StartBB = SplitBBTerm->getSuccessor(0);
if (StartBB == R.getEntry())
StartBB = SplitBBTerm->getSuccessor(1);
// For each PHI predecessor outside the region store the incoming operand
// value prior to entering the optimized region.
Builder.SetInsertPoint(StartBB->getTerminator());
ScalarAllocaMapTy EmptyMap;
for (const auto &PHIOpMapping : PHIOpMap) {
const PHINode *PHI = cast<PHINode>(PHIOpMapping.getFirst());
// Check if this PHI has the split block as predecessor (that is the only
// possible predecessor outside the SCoP).
int idx = PHI->getBasicBlockIndex(SplitBB);
if (idx < 0)
continue;
Value *ScalarValue = PHI->getIncomingValue(idx);
ScalarValue =
getNewScalarValue(ScalarValue, R, EmptyMap, GlobalMap, GlobalMap);
// If the split block is the predecessor initialize the PHI operator alloca.
Builder.CreateStore(ScalarValue, PHIOpMapping.getSecond());
}
}
//It receives a BasicBLock and makes table of predicates and its respective gated instructions
void bSSA::makeTable (BasicBlock *BB, Function *F) {
Value *condition;
TerminatorInst *ti = BB->getTerminator();
BranchInst *bi = NULL;
SwitchInst *si=NULL;
PostDominatorTree &PD = getAnalysis<PostDominatorTree>(*F);
ProcessedBB.clear();
if ((bi = dyn_cast<BranchInst>(ti)) && bi->isConditional()) { //If the terminator instruction is a conditional branch
condition = bi->getCondition();
//Including the predicate on the predicatesVector
predicatesVector.push_back(new Pred(condition));
//Make a "Flooding" on each sucessor gated the instruction on Influence Region of the predicate
for (unsigned int i=0; i<bi->getNumSuccessors(); i++) {
findIR (BB, bi->getSuccessor(i),PD);
}
}else if ((si = dyn_cast<SwitchInst>(ti))) {
condition = si->getCondition();
//Including the predicate on the predicatesVector
predicatesVector.push_back(new Pred(condition));
//Make a "Flooding" on each sucessor gated the instruction on Influence Region of the predicate
for (unsigned int i=0; i<si->getNumSuccessors(); i++) {
findIR (BB, si->getSuccessor(i),PD);
}
}
}
Optional<unsigned> llvm::getLoopEstimatedTripCount(Loop *L) {
// Only support loops with a unique exiting block, and a latch.
if (!L->getExitingBlock())
return None;
// Get the branch weights for the the loop's backedge.
BranchInst *LatchBR =
dyn_cast<BranchInst>(L->getLoopLatch()->getTerminator());
if (!LatchBR || LatchBR->getNumSuccessors() != 2)
return None;
assert((LatchBR->getSuccessor(0) == L->getHeader() ||
LatchBR->getSuccessor(1) == L->getHeader()) &&
"At least one edge out of the latch must go to the header");
// To estimate the number of times the loop body was executed, we want to
// know the number of times the backedge was taken, vs. the number of times
// we exited the loop.
uint64_t TrueVal, FalseVal;
if (!LatchBR->extractProfMetadata(TrueVal, FalseVal))
return None;
if (!TrueVal || !FalseVal)
return 0;
// Divide the count of the backedge by the count of the edge exiting the loop,
// rounding to nearest.
if (LatchBR->getSuccessor(0) == L->getHeader())
return (TrueVal + (FalseVal / 2)) / FalseVal;
else
return (FalseVal + (TrueVal / 2)) / TrueVal;
}
/// \brief Analyze the predecessors of each block and build up predicates
void StructurizeCFG::gatherPredicates(RegionNode *N) {
RegionInfo *RI = ParentRegion->getRegionInfo();
BasicBlock *BB = N->getEntry();
BBPredicates &Pred = Predicates[BB];
BBPredicates &LPred = LoopPreds[BB];
for (BasicBlock *P : predecessors(BB)) {
// Ignore it if it's a branch from outside into our region entry
if (!ParentRegion->contains(P))
continue;
Region *R = RI->getRegionFor(P);
if (R == ParentRegion) {
// It's a top level block in our region
BranchInst *Term = cast<BranchInst>(P->getTerminator());
for (unsigned i = 0, e = Term->getNumSuccessors(); i != e; ++i) {
BasicBlock *Succ = Term->getSuccessor(i);
if (Succ != BB)
continue;
if (Visited.count(P)) {
// Normal forward edge
if (Term->isConditional()) {
// Try to treat it like an ELSE block
BasicBlock *Other = Term->getSuccessor(!i);
if (Visited.count(Other) && !Loops.count(Other) &&
!Pred.count(Other) && !Pred.count(P)) {
Pred[Other] = BoolFalse;
Pred[P] = BoolTrue;
continue;
}
}
Pred[P] = buildCondition(Term, i, false);
} else {
// Back edge
LPred[P] = buildCondition(Term, i, true);
}
}
} else {
// It's an exit from a sub region
while (R->getParent() != ParentRegion)
R = R->getParent();
// Edge from inside a subregion to its entry, ignore it
if (*R == *N)
continue;
BasicBlock *Entry = R->getEntry();
if (Visited.count(Entry))
Pred[Entry] = BoolTrue;
else
LPred[Entry] = BoolFalse;
}
}
}
static bool brTransferToLoop(Instruction *inst) {
BranchInst *bi = dyn_cast<BranchInst>(inst);
for (unsigned i = 0; i < bi->getNumSuccessors(); i++) {
BasicBlock *bb = bi->getSuccessor(i);
std::string bbName = bb->getName().str();
if (bbName.find("while") != std::string::npos
|| bbName.find("for") != std::string::npos
|| bbName.find("do") != std::string::npos)
return true;
}
return false;
}
//Start findIR method
void hammock::processNode (BasicBlock *BB, PostDominatorTree &PD ) {
TerminatorInst *ti = BB->getTerminator();
BranchInst *bi = NULL;
SwitchInst *si=NULL;
if ((bi = dyn_cast<BranchInst>(ti)) && bi->isConditional()) { //If the terminator instruction is a conditional branch
for (unsigned int i=0; i<bi->getNumSuccessors(); i++) {
findIR (BB, bi->getSuccessor(i),PD);
}
}else if ((si = dyn_cast<SwitchInst>(ti))) {
for (unsigned int i=0; i<si->getNumSuccessors(); i++) {
findIR (BB, si->getSuccessor(i),PD);
}
}
}
bool SpeculativeExecution::runOnBasicBlock(BasicBlock &B) {
BranchInst *BI = dyn_cast<BranchInst>(B.getTerminator());
if (BI == nullptr)
return false;
if (BI->getNumSuccessors() != 2)
return false;
BasicBlock &Succ0 = *BI->getSuccessor(0);
BasicBlock &Succ1 = *BI->getSuccessor(1);
if (&B == &Succ0 || &B == &Succ1 || &Succ0 == &Succ1) {
return false;
}
// Hoist from if-then (triangle).
if (Succ0.getSinglePredecessor() != nullptr &&
Succ0.getSingleSuccessor() == &Succ1) {
return considerHoistingFromTo(Succ0, B);
}
// Hoist from if-else (triangle).
if (Succ1.getSinglePredecessor() != nullptr &&
Succ1.getSingleSuccessor() == &Succ0) {
return considerHoistingFromTo(Succ1, B);
}
// Hoist from if-then-else (diamond), but only if it is equivalent to
// an if-else or if-then due to one of the branches doing nothing.
if (Succ0.getSinglePredecessor() != nullptr &&
Succ1.getSinglePredecessor() != nullptr &&
Succ1.getSingleSuccessor() != nullptr &&
Succ1.getSingleSuccessor() != &B &&
Succ1.getSingleSuccessor() == Succ0.getSingleSuccessor()) {
// If a block has only one instruction, then that is a terminator
// instruction so that the block does nothing. This does happen.
if (Succ1.size() == 1) // equivalent to if-then
return considerHoistingFromTo(Succ0, B);
if (Succ0.size() == 1) // equivalent to if-else
return considerHoistingFromTo(Succ1, B);
}
return false;
}
/// \brief Determine the end of the loops
void StructurizeCFG::analyzeLoops(RegionNode *N) {
if (N->isSubRegion()) {
// Test for exit as back edge
BasicBlock *Exit = N->getNodeAs<Region>()->getExit();
if (Visited.count(Exit))
Loops[Exit] = N->getEntry();
} else {
// Test for sucessors as back edge
BasicBlock *BB = N->getNodeAs<BasicBlock>();
BranchInst *Term = cast<BranchInst>(BB->getTerminator());
for (unsigned i = 0, e = Term->getNumSuccessors(); i != e; ++i) {
BasicBlock *Succ = Term->getSuccessor(i);
if (Visited.count(Succ))
Loops[Succ] = BB;
}
}
}
bool LoopInterchangeTransform::adjustLoopBranches() {
DEBUG(dbgs() << "adjustLoopBranches called\n");
// Adjust the loop preheader
BasicBlock *InnerLoopHeader = InnerLoop->getHeader();
BasicBlock *OuterLoopHeader = OuterLoop->getHeader();
BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();
BasicBlock *OuterLoopLatch = OuterLoop->getLoopLatch();
BasicBlock *OuterLoopPreHeader = OuterLoop->getLoopPreheader();
BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
BasicBlock *OuterLoopPredecessor = OuterLoopPreHeader->getUniquePredecessor();
BasicBlock *InnerLoopLatchPredecessor =
InnerLoopLatch->getUniquePredecessor();
BasicBlock *InnerLoopLatchSuccessor;
BasicBlock *OuterLoopLatchSuccessor;
BranchInst *OuterLoopLatchBI =
dyn_cast<BranchInst>(OuterLoopLatch->getTerminator());
BranchInst *InnerLoopLatchBI =
dyn_cast<BranchInst>(InnerLoopLatch->getTerminator());
BranchInst *OuterLoopHeaderBI =
dyn_cast<BranchInst>(OuterLoopHeader->getTerminator());
BranchInst *InnerLoopHeaderBI =
dyn_cast<BranchInst>(InnerLoopHeader->getTerminator());
if (!OuterLoopPredecessor || !InnerLoopLatchPredecessor ||
!OuterLoopLatchBI || !InnerLoopLatchBI || !OuterLoopHeaderBI ||
!InnerLoopHeaderBI)
return false;
BranchInst *InnerLoopLatchPredecessorBI =
dyn_cast<BranchInst>(InnerLoopLatchPredecessor->getTerminator());
BranchInst *OuterLoopPredecessorBI =
dyn_cast<BranchInst>(OuterLoopPredecessor->getTerminator());
if (!OuterLoopPredecessorBI || !InnerLoopLatchPredecessorBI)
return false;
BasicBlock *InnerLoopHeaderSuccessor = InnerLoopHeader->getUniqueSuccessor();
if (!InnerLoopHeaderSuccessor)
return false;
// Adjust Loop Preheader and headers
unsigned NumSucc = OuterLoopPredecessorBI->getNumSuccessors();
for (unsigned i = 0; i < NumSucc; ++i) {
if (OuterLoopPredecessorBI->getSuccessor(i) == OuterLoopPreHeader)
OuterLoopPredecessorBI->setSuccessor(i, InnerLoopPreHeader);
}
NumSucc = OuterLoopHeaderBI->getNumSuccessors();
for (unsigned i = 0; i < NumSucc; ++i) {
if (OuterLoopHeaderBI->getSuccessor(i) == OuterLoopLatch)
OuterLoopHeaderBI->setSuccessor(i, LoopExit);
else if (OuterLoopHeaderBI->getSuccessor(i) == InnerLoopPreHeader)
OuterLoopHeaderBI->setSuccessor(i, InnerLoopHeaderSuccessor);
}
// Adjust reduction PHI's now that the incoming block has changed.
updateIncomingBlock(InnerLoopHeaderSuccessor, InnerLoopHeader,
OuterLoopHeader);
BranchInst::Create(OuterLoopPreHeader, InnerLoopHeaderBI);
InnerLoopHeaderBI->eraseFromParent();
// -------------Adjust loop latches-----------
if (InnerLoopLatchBI->getSuccessor(0) == InnerLoopHeader)
InnerLoopLatchSuccessor = InnerLoopLatchBI->getSuccessor(1);
else
InnerLoopLatchSuccessor = InnerLoopLatchBI->getSuccessor(0);
NumSucc = InnerLoopLatchPredecessorBI->getNumSuccessors();
for (unsigned i = 0; i < NumSucc; ++i) {
if (InnerLoopLatchPredecessorBI->getSuccessor(i) == InnerLoopLatch)
InnerLoopLatchPredecessorBI->setSuccessor(i, InnerLoopLatchSuccessor);
}
// Adjust PHI nodes in InnerLoopLatchSuccessor. Update all uses of PHI with
// the value and remove this PHI node from inner loop.
SmallVector<PHINode *, 8> LcssaVec;
for (auto I = InnerLoopLatchSuccessor->begin(); isa<PHINode>(I); ++I) {
PHINode *LcssaPhi = cast<PHINode>(I);
LcssaVec.push_back(LcssaPhi);
}
for (auto I = LcssaVec.begin(), E = LcssaVec.end(); I != E; ++I) {
PHINode *P = *I;
Value *Incoming = P->getIncomingValueForBlock(InnerLoopLatch);
P->replaceAllUsesWith(Incoming);
P->eraseFromParent();
}
if (OuterLoopLatchBI->getSuccessor(0) == OuterLoopHeader)
OuterLoopLatchSuccessor = OuterLoopLatchBI->getSuccessor(1);
else
OuterLoopLatchSuccessor = OuterLoopLatchBI->getSuccessor(0);
if (InnerLoopLatchBI->getSuccessor(1) == InnerLoopLatchSuccessor)
InnerLoopLatchBI->setSuccessor(1, OuterLoopLatchSuccessor);
else
InnerLoopLatchBI->setSuccessor(0, OuterLoopLatchSuccessor);
updateIncomingBlock(OuterLoopLatchSuccessor, OuterLoopLatch, InnerLoopLatch);
if (OuterLoopLatchBI->getSuccessor(0) == OuterLoopLatchSuccessor) {
OuterLoopLatchBI->setSuccessor(0, InnerLoopLatch);
} else {
OuterLoopLatchBI->setSuccessor(1, InnerLoopLatch);
}
return true;
}
bool ScopDetection::isValidCFG(BasicBlock &BB,
DetectionContext &Context) const {
Region &RefRegion = Context.CurRegion;
TerminatorInst *TI = BB.getTerminator();
// Return instructions are only valid if the region is the top level region.
if (isa<ReturnInst>(TI) && !RefRegion.getExit() && TI->getNumOperands() == 0)
return true;
BranchInst *Br = dyn_cast<BranchInst>(TI);
if (!Br)
return invalid<ReportNonBranchTerminator>(Context, /*Assert=*/true, &BB);
if (Br->isUnconditional())
return true;
Value *Condition = Br->getCondition();
// UndefValue is not allowed as condition.
if (isa<UndefValue>(Condition))
return invalid<ReportUndefCond>(Context, /*Assert=*/true, &BB);
// Only Constant and ICmpInst are allowed as condition.
if (!(isa<Constant>(Condition) || isa<ICmpInst>(Condition)))
return invalid<ReportInvalidCond>(Context, /*Assert=*/true, &BB);
// Allow perfectly nested conditions.
assert(Br->getNumSuccessors() == 2 && "Unexpected number of successors");
if (ICmpInst *ICmp = dyn_cast<ICmpInst>(Condition)) {
// Unsigned comparisons are not allowed. They trigger overflow problems
// in the code generation.
//
// TODO: This is not sufficient and just hides bugs. However it does pretty
// well.
if (ICmp->isUnsigned())
return false;
// Are both operands of the ICmp affine?
if (isa<UndefValue>(ICmp->getOperand(0)) ||
isa<UndefValue>(ICmp->getOperand(1)))
return invalid<ReportUndefOperand>(Context, /*Assert=*/true, &BB);
Loop *L = LI->getLoopFor(ICmp->getParent());
const SCEV *LHS = SE->getSCEVAtScope(ICmp->getOperand(0), L);
const SCEV *RHS = SE->getSCEVAtScope(ICmp->getOperand(1), L);
if (!isAffineExpr(&Context.CurRegion, LHS, *SE) ||
!isAffineExpr(&Context.CurRegion, RHS, *SE))
return invalid<ReportNonAffBranch>(Context, /*Assert=*/true, &BB, LHS,
RHS);
}
// Allow loop exit conditions.
Loop *L = LI->getLoopFor(&BB);
if (L && L->getExitingBlock() == &BB)
return true;
// Allow perfectly nested conditions.
Region *R = RI->getRegionFor(&BB);
if (R->getEntry() != &BB)
return invalid<ReportCondition>(Context, /*Assert=*/true, &BB);
return true;
}
/////////////////////////////////////
///DuplicaAllBB() //
/////////////////////////////////////
void InsDuplica::DuplicaAllBB(Function &F) {
valueMap.clear();
toAddvalueMap.clear();
std::list<BasicBlock*> WorkList;
std::set<BasicBlock*> markedBB;
WorkList.clear();
markedBB.clear();
//error block should not be duplicated
markedBB.insert(errorBlock);
//add all BBs to WorkList.
#ifdef REG_SAFE
// Get the topological ordered tree.
ReversePostOrderTraversal<Function*> PROT(&F);
for (ReversePostOrderTraversal<Function*>::rpo_iterator
I = PROT.begin(), E = PROT.end(); I != E; ++I) {
BasicBlock *BB = *I;
WorkList.push_back(BB);
}
#else
// We don't need to care the order.
for (Function::iterator BBi = F.begin(), BBE = F.end(); BBi!=BBE; ++BBi) {
BasicBlock *BB = BBi;
WorkList.push_back(BB);
}
#endif
//while working list is empty. Do.
while (!(WorkList.empty())) {
BasicBlock *curBB = WorkList.front();
WorkList.pop_front();
#ifdef Jing_DEBUG
std::cerr << "\n---Duplicate curBB: " << curBB->getName() <<" ---\n";
#endif
//if curBB has not been replicated, let's replicate it
if (markedBB.count(curBB) == 0) {
#ifdef REG_SAFE
#ifdef Jing_DEBUG
/* This part is only valid when DuplicaBB() is not called, because
// the pred link will change after replication and checking.
//
// We need to make sure the imcoming blocks for curBB have been
// processed, except backward edges.
pred_iterator PI = pred_begin(curBB), E = pred_end(curBB);
while (PI != E) {
BasicBlock *PB = *PI;
if (markedBB.count(PB)==0) {
// PB->curBB must be a backward edge. Or PB is non-reachable.
if (!(dominset->dominates(curBB, PB))) {
if (dominset->isReachable(PB)) {
if (PI != pred_begin(curBB)) {
BasicBlock *PF = *(pred_begin(curBB));
//if the first pred dominates curBB, it is fine.
if (!(dominset->dominates(PF, curBB))) {
std::cerr << "Block(" << PB->getName() <<
") has not been processed\n";
assert(0 && "order fail");
}
}
}
}
}
++PI;
}
*/
#endif
#endif
// mark curBB
markedBB.insert(curBB);
#ifdef REG_SAFE
// Point curBB's childern's incoming blocks.
SafeRegforBB* saferegs = safeRegMap->getSafeRegsforBB(curBB);
std::set<Value*> *safeSet = saferegs->getSafeRegSet();
BranchInst *term = dyn_cast<BranchInst>(curBB->getTerminator());
if (term) {
int numS = term->getNumSuccessors();
for ( int i = 0; i < numS; i++ ) {
BasicBlock *suc = term->getSuccessor(i);
if (markedBB.count(suc) == 0) {
SafeRegforBB *safeSucc = safeRegMap->getSafeRegsforBB(suc);
// If suc has PHI, we will make sure incoming safe reg set
// is inserted at correct place.
if (PHINode *phI = dyn_cast<PHINode>(suc->begin())) {
int index = phI->getBasicBlockIndex(curBB);
safeSucc->setIncoming(index, safeSet);
} else {
safeSucc->pushIncoming(safeSet);
}
}
}
}
#endif
//replicate curBB
DuplicaBB(curBB);
}
}
assert(toAddvalueMap.empty() && "toAddvalueMap must be empty now");
}
bool LoopInterchangeTransform::adjustLoopBranches() {
DEBUG(dbgs() << "adjustLoopBranches called\n");
// Adjust the loop preheader
BasicBlock *InnerLoopHeader = InnerLoop->getHeader();
BasicBlock *OuterLoopHeader = OuterLoop->getHeader();
BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();
BasicBlock *OuterLoopLatch = OuterLoop->getLoopLatch();
BasicBlock *OuterLoopPreHeader = OuterLoop->getLoopPreheader();
BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
BasicBlock *OuterLoopPredecessor = OuterLoopPreHeader->getUniquePredecessor();
BasicBlock *InnerLoopLatchPredecessor =
InnerLoopLatch->getUniquePredecessor();
BasicBlock *InnerLoopLatchSuccessor;
BasicBlock *OuterLoopLatchSuccessor;
BranchInst *OuterLoopLatchBI =
dyn_cast<BranchInst>(OuterLoopLatch->getTerminator());
BranchInst *InnerLoopLatchBI =
dyn_cast<BranchInst>(InnerLoopLatch->getTerminator());
BranchInst *OuterLoopHeaderBI =
dyn_cast<BranchInst>(OuterLoopHeader->getTerminator());
BranchInst *InnerLoopHeaderBI =
dyn_cast<BranchInst>(InnerLoopHeader->getTerminator());
if (!OuterLoopPredecessor || !InnerLoopLatchPredecessor ||
!OuterLoopLatchBI || !InnerLoopLatchBI || !OuterLoopHeaderBI ||
!InnerLoopHeaderBI)
return false;
BranchInst *InnerLoopLatchPredecessorBI =
dyn_cast<BranchInst>(InnerLoopLatchPredecessor->getTerminator());
BranchInst *OuterLoopPredecessorBI =
dyn_cast<BranchInst>(OuterLoopPredecessor->getTerminator());
if (!OuterLoopPredecessorBI || !InnerLoopLatchPredecessorBI)
return false;
BasicBlock *InnerLoopHeaderSucessor = InnerLoopHeader->getUniqueSuccessor();
if (!InnerLoopHeaderSucessor)
return false;
// Adjust Loop Preheader and headers
unsigned NumSucc = OuterLoopPredecessorBI->getNumSuccessors();
for (unsigned i = 0; i < NumSucc; ++i) {
if (OuterLoopPredecessorBI->getSuccessor(i) == OuterLoopPreHeader)
OuterLoopPredecessorBI->setSuccessor(i, InnerLoopPreHeader);
}
NumSucc = OuterLoopHeaderBI->getNumSuccessors();
for (unsigned i = 0; i < NumSucc; ++i) {
if (OuterLoopHeaderBI->getSuccessor(i) == OuterLoopLatch)
OuterLoopHeaderBI->setSuccessor(i, LoopExit);
else if (OuterLoopHeaderBI->getSuccessor(i) == InnerLoopPreHeader)
OuterLoopHeaderBI->setSuccessor(i, InnerLoopHeaderSucessor);
}
BranchInst::Create(OuterLoopPreHeader, InnerLoopHeaderBI);
InnerLoopHeaderBI->eraseFromParent();
// -------------Adjust loop latches-----------
if (InnerLoopLatchBI->getSuccessor(0) == InnerLoopHeader)
InnerLoopLatchSuccessor = InnerLoopLatchBI->getSuccessor(1);
else
InnerLoopLatchSuccessor = InnerLoopLatchBI->getSuccessor(0);
NumSucc = InnerLoopLatchPredecessorBI->getNumSuccessors();
for (unsigned i = 0; i < NumSucc; ++i) {
if (InnerLoopLatchPredecessorBI->getSuccessor(i) == InnerLoopLatch)
InnerLoopLatchPredecessorBI->setSuccessor(i, InnerLoopLatchSuccessor);
}
if (OuterLoopLatchBI->getSuccessor(0) == OuterLoopHeader)
OuterLoopLatchSuccessor = OuterLoopLatchBI->getSuccessor(1);
else
OuterLoopLatchSuccessor = OuterLoopLatchBI->getSuccessor(0);
if (InnerLoopLatchBI->getSuccessor(1) == InnerLoopLatchSuccessor)
InnerLoopLatchBI->setSuccessor(1, OuterLoopLatchSuccessor);
else
InnerLoopLatchBI->setSuccessor(0, OuterLoopLatchSuccessor);
if (OuterLoopLatchBI->getSuccessor(0) == OuterLoopLatchSuccessor) {
OuterLoopLatchBI->setSuccessor(0, InnerLoopLatch);
} else {
OuterLoopLatchBI->setSuccessor(1, InnerLoopLatch);
}
return true;
}
bool FunctionStaticSlicer::computeBC() {
bool changed = false;
#ifdef DEBUG_BC
errs() << " ====== BEG BC Computation ======\n";
#endif
if (!forward) {
PostDominanceFrontier &PDF = MP->getAnalysis<PostDominanceFrontier>(fun);
for (inst_iterator I = inst_begin(fun), E = inst_end(fun); I != E; I++) {
Instruction *i = &*I;
const InsInfo *ii = getInsInfo(i);
if (ii->isSliced())
continue;
BasicBlock *BB = i->getParent();
#ifdef DEBUG_BC
errs() << " ";
i->print(errs());
errs() << " -> bb=" << BB->getName() << '\n';
#endif
PostDominanceFrontier::const_iterator frontier = PDF.find(BB);
if (frontier == PDF.end())
continue;
changed |= updateRCSC(frontier->second.begin(), frontier->second.end());
}
}
else {
for (inst_iterator I = inst_begin(fun), E = inst_end(fun); I != E; I++) {
Instruction *i = &*I;
if (!isa<BranchInst>(i))
continue;
BranchInst * bi = dyn_cast<BranchInst>(i);
if (bi->isUnconditional()) // skip unconditional inst
continue;
const InsInfo *ii = getInsInfo(i);
if (ii->isSliced())
continue;
unsigned succs = bi->getNumSuccessors();
for (unsigned si = 0; si < succs; si++) {
BasicBlock * BB = bi->getSuccessor(si);
BasicBlock * Pred = BB->getUniquePredecessor();
if (Pred == NULL)
continue;
for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE; BI++) {
InsInfo *bii = getInsInfo(&*BI);
bii->deslice();
for (ValSet::const_iterator VI = bii->DEF_begin(), VE = bii->DEF_end();
VI != VE; VI++) {
if (bii->addRC(*VI)) {
changed = true;
#ifdef DEBUG_RC
errs() << " added ";
printVal(*VI);
errs() << "\n";
#endif
}
}
}
}
}
}
#ifdef DEBUG_BC
errs() << " ====== END BC Computation ======\n";
#endif
return changed;
}
bool partition::runOnLoop(Loop* L, LPPassManager &LPM) {
errs() << "*************************** Loop encountered: ************************" << '\n' << L->getHeader()->getName() << '\n';
if (function->getName() != "main")
return false;
IntegerType* int32Ty = Type::getInt32Ty(*context);
IntegerType* int64Ty = Type::getInt64Ty(*context);
PointerType* voidPtrTy = Type::getInt8PtrTy(*context);
FunctionType* funcTy = FunctionType::get(int32Ty, false);
Constant* func1_c;
Function* func1;
func1_c = module->getOrInsertFunction("func1", funcTy);
func1 = cast<Function>(func1_c);
Function* pro = module->getFunction("produce");
Function* con = module->getFunction("consume");
BasicBlock* func1EntryBlock = BasicBlock::Create(*context, "entry.func1", func1);
AllocaInst* i_var = new AllocaInst(int32Ty, NULL, 4, "i", func1EntryBlock);
Value* liveIn;
BasicBlock *forCond, *forBody, *forInc;
ValueToValueMapTy VMap;
std::map<BasicBlock *, BasicBlock *> BlockMap;
for (Loop::block_iterator BB = L->block_begin(), BBe = L->block_end(); BB != BBe; ++BB) {
BasicBlock* func1Block = CloneBasicBlock(*BB, VMap, ".func1", func1);
BlockMap[*BB] = func1Block;
if ((*BB)->getName() == "for.cond")
forCond = func1Block;
if ((*BB)->getName() == "for.body")
forBody = func1Block;
if ((*BB)->getName() == "for.inc")
forInc = func1Block;
for (BasicBlock::iterator it = func1Block->begin(), ite = func1Block->end(); it != ite; ++it) {
for (User::op_iterator oit = it->op_begin(), oite = it->op_end(); oit != oite; ++oit) {
if (VMap[*oit] != NULL) {
*oit = VMap[*oit];
} else {
Constant* cons = dyn_cast<Constant>(*oit);
BranchInst* br = dyn_cast<BranchInst>(it);
if (cons == NULL && br == NULL) {
liveIn = *oit;
*oit = i_var;
}
}
}
}
if ((*BB)->getName() == "for.body") {
Instruction* term = (*BB)->getTerminator();
term->removeFromParent();
for (int i = 0; i < 7; i++) {
(*BB)->back().eraseFromParent();
}
term->insertAfter(&(*BB)->back());
(*BB)->front().eraseFromParent();
LoadInst* load = new LoadInst(liveIn, "", false, 4, term);
std::vector<Value *> produce_args;
CastInst* cast = CastInst::CreateIntegerCast(load, int64Ty, true);
cast->insertAfter(load);
produce_args.push_back(cast);
ConstantInt* val = ConstantInt::get(int32Ty, (uint32_t) 3);
produce_args.push_back(val);
CallInst::Create(pro, ArrayRef<Value*>(produce_args), "", term);
produce_args.pop_back();
val = ConstantInt::get(int32Ty, (uint32_t) 2);
produce_args.push_back(val);
CallInst::Create(pro, ArrayRef<Value*>(produce_args), "", term);
}
}
// set branch instructions to restructure the CFG in created function
BasicBlock* func1EndBlock = BasicBlock::Create(*context, "if.end.func1", func1);
BasicBlock* garbageBB = BasicBlock::Create(*context, "garbage", func1);
ConstantInt* retVal_g = ConstantInt::get(int32Ty, (uint32_t) 0);
ReturnInst* ret_g = ReturnInst::Create(*context, retVal_g, garbageBB);
for (Function::iterator fit = func1->begin(), fite = func1->end(); fit != fite; ++fit) {
if (fit->getTerminator() == NULL || fit->getName() == "garbage")
continue;
BranchInst* br = dyn_cast<BranchInst>(fit->getTerminator());
int numSuccessors = br->getNumSuccessors();
for (int i = 0; i < numSuccessors; i++) {
BasicBlock* successor = br->getSuccessor(i);
if (BlockMap[successor] != NULL) {
br->setSuccessor(i, BlockMap[successor]);
}
else {
br->setSuccessor(i, func1EndBlock);
}
}
/*
if (fit->getName() == "for.body.func1") {
for (int i = 0; i < 4; i++) {
BasicBlock::iterator it = fit->begin();
it->moveBefore(ret_g);
}
}
*/
}
garbageBB->eraseFromParent();
BranchInst* br = dyn_cast<BranchInst>(forBody->getTerminator());
br->setSuccessor(0, forCond);
forInc->eraseFromParent();
// Create return instruction for func1EndBlock and set a branch from loop header to func1EndBlock
ConstantInt* retVal = ConstantInt::get(int32Ty, (uint32_t) 0);
ReturnInst* ret1 = ReturnInst::Create(*context, retVal, func1EndBlock);
BasicBlock* loopHeader = BlockMap.at(L->getHeader());
BranchInst* brInst = BranchInst::Create(loopHeader, func1EntryBlock);
// add produce function call
std::vector<Value *> produce_args;
ConstantInt* val = ConstantInt::get(int64Ty, (uint64_t) 0);
produce_args.push_back(val);
val = ConstantInt::get(int32Ty, (uint32_t) 5);
produce_args.push_back(val);
CallInst::Create(pro, ArrayRef<Value*>(produce_args), "", func1EndBlock->getTerminator());
// add consume function call
int q_id = 2;
for (Value::use_iterator uit = i_var->use_begin(), uite = i_var->use_end(); uit != uite; ++uit) {
std::vector<Value *> consume_args;
ConstantInt* val = ConstantInt::get(int32Ty, (uint32_t) q_id);
consume_args.push_back(val);
CallInst* call = CallInst::Create(con, ArrayRef<Value*>(consume_args));
Instruction* inst = dyn_cast<Instruction>(*uit);
call->insertAfter(inst);
CastInst* cast = CastInst::CreateIntegerCast(call, int32Ty, true);
cast->insertAfter(call);
(*uit)->replaceAllUsesWith(cast);
inst->eraseFromParent();
q_id++;
}
i_var->eraseFromParent();
// add produce and consume function calls to main thread
// transmit the function pointer to created function by a produce call
BasicBlock* loopPreheader = L->getLoopPreheader();
produce_args.clear();
CastInst* cast = CastInst::CreatePointerCast(func1, int64Ty);
cast->insertBefore(loopPreheader->getTerminator());
produce_args.push_back(cast);
val = ConstantInt::get(int32Ty, (uint32_t) 0);
produce_args.push_back(val);
CallInst::Create(pro, ArrayRef<Value*>(produce_args), "", loopPreheader->getTerminator());
// transmit induction variable to created function by a produce call
Instruction* load = &L->getHeader()->front();
produce_args.clear();
cast = CastInst::CreateIntegerCast(load, int64Ty, true);
cast->insertAfter(load);
produce_args.push_back(cast);
val = ConstantInt::get(int32Ty, (uint32_t) 4);
produce_args.push_back(val);
CallInst::Create(pro, ArrayRef<Value*>(produce_args))->insertAfter(cast);
return true;
}
