/// FindReusablePredBB - Check all of the predecessors of the block DestPHI /// lives in to see if there is a block that we can reuse as a critical edge /// from TIBB. static BasicBlock *FindReusablePredBB(PHINode *DestPHI, BasicBlock *TIBB) { BasicBlock *Dest = DestPHI->getParent(); /// TIPHIValues - This array is lazily computed to determine the values of /// PHIs in Dest that TI would provide. SmallVector<Value*, 32> TIPHIValues; /// TIBBEntryNo - This is a cache to speed up pred queries for TIBB. unsigned TIBBEntryNo = 0; // Check to see if Dest has any blocks that can be used as a split edge for // this terminator. for (unsigned pi = 0, e = DestPHI->getNumIncomingValues(); pi != e; ++pi) { BasicBlock *Pred = DestPHI->getIncomingBlock(pi); // To be usable, the pred has to end with an uncond branch to the dest. BranchInst *PredBr = dyn_cast<BranchInst>(Pred->getTerminator()); if (!PredBr || !PredBr->isUnconditional()) continue; // Must be empty other than the branch and debug info. BasicBlock::iterator I = Pred->begin(); while (isa<DbgInfoIntrinsic>(I)) I++; if (&*I != PredBr) continue; // Cannot be the entry block; its label does not get emitted. if (Pred == &Dest->getParent()->getEntryBlock()) continue; // Finally, since we know that Dest has phi nodes in it, we have to make // sure that jumping to Pred will have the same effect as going to Dest in // terms of PHI values. PHINode *PN; unsigned PHINo = 0; unsigned PredEntryNo = pi; bool FoundMatch = true; for (BasicBlock::iterator I = Dest->begin(); (PN = dyn_cast<PHINode>(I)); ++I, ++PHINo) { if (PHINo == TIPHIValues.size()) { if (PN->getIncomingBlock(TIBBEntryNo) != TIBB) TIBBEntryNo = PN->getBasicBlockIndex(TIBB); TIPHIValues.push_back(PN->getIncomingValue(TIBBEntryNo)); } // If the PHI entry doesn't work, we can't use this pred. if (PN->getIncomingBlock(PredEntryNo) != Pred) PredEntryNo = PN->getBasicBlockIndex(Pred); if (TIPHIValues[PHINo] != PN->getIncomingValue(PredEntryNo)) { FoundMatch = false; break; } } // If we found a workable predecessor, change TI to branch to Succ. if (FoundMatch) return Pred; } return 0; }
// PHINode - Make the scalar for the PHI node point to all of the things the // incoming values point to... which effectively causes them to be merged. // void GraphBuilder::visitPHINode(PHINode &PN) { if (!isa<PointerType>(PN.getType())) return; // Only pointer PHIs DSNodeHandle &PNDest = G.getNodeForValue(&PN); for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) PNDest.mergeWith(getValueDest(PN.getIncomingValue(i))); }
/// getTripCount - Return a loop-invariant LLVM value indicating the number of /// times the loop will be executed. Note that this means that the backedge /// of the loop executes N-1 times. If the trip-count cannot be determined, /// this returns null. /// /// The IndVarSimplify pass transforms loops to have a form that this /// function easily understands. /// Value *Loop::getTripCount() const { // Canonical loops will end with a 'cmp ne I, V', where I is the incremented // canonical induction variable and V is the trip count of the loop. PHINode *IV = getCanonicalInductionVariable(); if (IV == 0 || IV->getNumIncomingValues() != 2) return 0; bool P0InLoop = contains(IV->getIncomingBlock(0)); Value *Inc = IV->getIncomingValue(!P0InLoop); BasicBlock *BackedgeBlock = IV->getIncomingBlock(!P0InLoop); if (BranchInst *BI = dyn_cast<BranchInst>(BackedgeBlock->getTerminator())) if (BI->isConditional()) { if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) { if (ICI->getOperand(0) == Inc) { if (BI->getSuccessor(0) == getHeader()) { if (ICI->getPredicate() == ICmpInst::ICMP_NE) return ICI->getOperand(1); } else if (ICI->getPredicate() == ICmpInst::ICMP_EQ) { return ICI->getOperand(1); } } } } return 0; }
SizeOffsetType ObjectSizeOffsetVisitor::visitPHINode(PHINode &PHI) { if (PHI.getNumIncomingValues() == 0) return unknown(); SizeOffsetType Ret = compute(PHI.getIncomingValue(0)); if (!bothKnown(Ret)) return unknown(); // verify that all PHI incoming pointers have the same size and offset for (unsigned i = 1, e = PHI.getNumIncomingValues(); i != e; ++i) { SizeOffsetType EdgeData = compute(PHI.getIncomingValue(i)); if (!bothKnown(EdgeData) || EdgeData != Ret) return unknown(); } return Ret; }
void LoopVersioning::addPHINodes( const SmallVectorImpl<Instruction *> &DefsUsedOutside) { BasicBlock *PHIBlock = VersionedLoop->getExitBlock(); assert(PHIBlock && "No single successor to loop exit block"); for (auto *Inst : DefsUsedOutside) { auto *NonVersionedLoopInst = cast<Instruction>(VMap[Inst]); PHINode *PN; // First see if we have a single-operand PHI with the value defined by the // original loop. for (auto I = PHIBlock->begin(); (PN = dyn_cast<PHINode>(I)); ++I) { assert(PN->getNumOperands() == 1 && "Exit block should only have on predecessor"); if (PN->getIncomingValue(0) == Inst) break; } // If not create it. if (!PN) { PN = PHINode::Create(Inst->getType(), 2, Inst->getName() + ".lver", &PHIBlock->front()); for (auto *User : Inst->users()) if (!VersionedLoop->contains(cast<Instruction>(User)->getParent())) User->replaceUsesOfWith(Inst, PN); PN->addIncoming(Inst, VersionedLoop->getExitingBlock()); } // Add the new incoming value from the non-versioned loop. PN->addIncoming(NonVersionedLoopInst, NonVersionedLoop->getExitingBlock()); } }
/* PHINode is NOT a terminator. */ void RAFlowFunction::visitPHINode(PHINode &PHI){ while (info_in_casted.size() > 1) { LatticePoint *l1 = info_in_casted.back(); info_in_casted.pop_back(); LatticePoint *l2 = info_in_casted.back(); info_in_casted.pop_back(); RALatticePoint* result = dyn_cast<RALatticePoint>(l1->join(l2)); info_in_casted.push_back(result); } RALatticePoint* inRLP = new RALatticePoint(*(info_in_casted.back())); PHINode* current = &PHI; ConstantRange* current_range = new ConstantRange(32, false); int num_incoming_vals = PHI.getNumIncomingValues(); for (int i = 0; i != num_incoming_vals; i++){ Value* val = PHI.getIncomingValue(i); if (inRLP->representation.count(val) > 0) { *current_range = current_range->unionWith(*(inRLP->representation[val])); // Optimistic analysis } else if(isa<ConstantInt>(val)){ ConstantInt* c_val = cast<ConstantInt>(val); ConstantRange* c_range = new ConstantRange(c_val->getValue()); *current_range = current_range->unionWith(*c_range); } } inRLP->representation[current] = current_range; //inRLP->printToErrs(); info_out.clear(); info_out.push_back(inRLP); }
PHINode *vSSA::findSExtSigma(Value *V, BasicBlock *BB, BasicBlock *BB_from) { DEBUG(dbgs() << "findSExtSigma: " << *V << " :: " << BB->getName() << " :: " << BB_from->getName() << "\n"); if (CastInst *CI = dyn_cast<CastInst>(V)) { return findSigma(CI->getOperand(0), BB, BB_from); } for (BasicBlock::iterator it = BB->begin(); isa<PHINode>(it); ++it) { PHINode *sigma = cast<PHINode>(it); unsigned e = sigma->getNumIncomingValues(); if (e != 1) continue; if (CastInst *CI = dyn_cast<CastInst>(sigma->getIncomingValue(0))) if (CI->getOperand(0) == V && (sigma->getIncomingBlock(0) == BB_from)) { DEBUG(dbgs() << "findSigma: Result: " << *sigma << "\n"); return sigma; } } return NULL; }
// SimplifyPredecessors(switch) - We know that SI is switch based on a PHI node // defined in this block. If the phi node contains constant operands, then the // blocks corresponding to those operands can be modified to jump directly to // the destination instead of going through this block. void CondProp::SimplifyPredecessors(SwitchInst *SI) { // TODO: We currently only handle the most trival case, where the PHI node has // one use (the branch), and is the only instruction besides the branch in the // block. PHINode *PN = cast<PHINode>(SI->getCondition()); if (!PN->hasOneUse()) return; BasicBlock *BB = SI->getParent(); if (&*BB->begin() != PN || &*next(BB->begin()) != SI) return; bool RemovedPreds = false; // Ok, we have this really simple case, walk the PHI operands, looking for // constants. Walk from the end to remove operands from the end when // possible, and to avoid invalidating "i". for (unsigned i = PN->getNumIncomingValues(); i != 0; --i) if (ConstantInt *CI = dyn_cast<ConstantInt>(PN->getIncomingValue(i-1))) { // If we have a constant, forward the edge from its current to its // ultimate destination. unsigned DestCase = SI->findCaseValue(CI); RevectorBlockTo(PN->getIncomingBlock(i-1), SI->getSuccessor(DestCase)); ++NumSwThread; RemovedPreds = true; // If there were two predecessors before this simplification, or if the // PHI node contained all the same value except for the one we just // substituted, the PHI node may be deleted. Don't iterate through it the // last time. if (SI->getCondition() != PN) return; } }
/// IVUseShouldUsePostIncValue - We have discovered a "User" of an IV expression /// and now we need to decide whether the user should use the preinc or post-inc /// value. If this user should use the post-inc version of the IV, return true. /// /// Choosing wrong here can break dominance properties (if we choose to use the /// post-inc value when we cannot) or it can end up adding extra live-ranges to /// the loop, resulting in reg-reg copies (if we use the pre-inc value when we /// should use the post-inc value). static bool IVUseShouldUsePostIncValue(Instruction *User, Value *Operand, const Loop *L, DominatorTree *DT) { // If the user is in the loop, use the preinc value. if (L->contains(User)) return false; BasicBlock *LatchBlock = L->getLoopLatch(); if (!LatchBlock) return false; // Ok, the user is outside of the loop. If it is dominated by the latch // block, use the post-inc value. if (DT->dominates(LatchBlock, User->getParent())) return true; // There is one case we have to be careful of: PHI nodes. These little guys // can live in blocks that are not dominated by the latch block, but (since // their uses occur in the predecessor block, not the block the PHI lives in) // should still use the post-inc value. Check for this case now. PHINode *PN = dyn_cast<PHINode>(User); if (!PN || !Operand) return false; // not a phi, not dominated by latch block. // Look at all of the uses of Operand by the PHI node. If any use corresponds // to a block that is not dominated by the latch block, give up and use the // preincremented value. for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) if (PN->getIncomingValue(i) == Operand && !DT->dominates(LatchBlock, PN->getIncomingBlock(i))) return false; // Okay, all uses of Operand by PN are in predecessor blocks that really are // dominated by the latch block. Use the post-incremented value. return true; }
/// getTripCount - Return a loop-invariant LLVM value indicating the number of /// times the loop will be executed. Note that this means that the backedge /// of the loop executes N-1 times. If the trip-count cannot be determined, /// this returns null. /// /// The IndVarSimplify pass transforms loops to have a form that this /// function easily understands. /// Value *Loop::getTripCount() const { // Canonical loops will end with a 'cmp ne I, V', where I is the incremented // canonical induction variable and V is the trip count of the loop. PHINode *IV = getCanonicalInductionVariable(); if (IV == 0 || IV->getNumIncomingValues() != 2) return 0; bool P0InLoop = contains(IV->getIncomingBlock(0)); Value *Inc = IV->getIncomingValue(!P0InLoop); BasicBlock *BackedgeBlock = IV->getIncomingBlock(!P0InLoop); if (BranchInst *BI = dyn_cast<BranchInst>(BackedgeBlock->getTerminator())) if (BI->isConditional()) { if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) { if (ICI->getOperand(0) == Inc) { if (BI->getSuccessor(0) == getHeader()) { if (ICI->getPredicate() == ICmpInst::ICMP_NE) return ICI->getOperand(1); } else if (ICI->getPredicate() == ICmpInst::ICMP_EQ) { return ICI->getOperand(1); } } } } else { // LunarGLASS quick fix: While this is handled properly in a more // general way in future versions of LLVM, for now also recognise the // case of a simple while or for loop. The exit condition is checked in // the loop header, and if that condition fails then the body of the // loop is branched to which is an unconditional latch whose only // predecessor is the loop header assert(BI->isUnconditional() && "neither conditional nor unconditional"); if (BasicBlock* pred = BackedgeBlock->getSinglePredecessor()) { if (pred == getHeader() && getLoopLatch()) { assert(BackedgeBlock == getLoopLatch() && "mis-identified latch"); if (BI = dyn_cast<BranchInst>(pred->getTerminator())) { if (BI->isConditional()) { if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) { // Either the IV or the incremeted variable is // fine if (ICI->getOperand(0) == Inc || ICI->getOperand(0) == IV ) { if (ICI->getPredicate() == ICmpInst::ICMP_NE) { if (BI->getSuccessor(0) == BackedgeBlock) { return ICI->getOperand(1); } } else if (ICI->getPredicate() == ICmpInst::ICMP_EQ) if (BI->getSuccessor(1) == BackedgeBlock) { return ICI->getOperand(1); } } } } } } } } return 0; }
// -- handle phi node -- void UnsafeTypeCastingCheck::handlePHINode (Instruction *inst) { PHINode *pnode = dyn_cast<PHINode>(inst); if (pnode == NULL) utccAbort("handlePHINode cannot process with a non-phinode instruction"); assert(pnode->getNumIncomingValues() >= 1); UTCC_TYPE pnode_ut = queryExprType(pnode->getIncomingValue(0)); for (unsigned int i = 1 ; i < pnode->getNumIncomingValues() ; i++) { if (pnode_ut == UH_UT) break; UTCC_TYPE next_ut = queryExprType(pnode->getIncomingValue(i)); if (pnode_ut == UINT_UT) { if (next_ut == UINT_UT) ; else if (next_ut == NINT_UT) pnode_ut = NINT_UT; else if (next_ut == INT_UT) pnode_ut = INT_UT; else pnode_ut = UH_UT; } else if (pnode_ut == NINT_UT) { if (next_ut == UINT_UT || next_ut == NINT_UT) ; else if (next_ut == INT_UT) pnode_ut = INT_UT; else pnode_ut = UH_UT; } else if (pnode_ut == INT_UT) { if (next_ut == UINT_UT || next_ut == NINT_UT || next_ut == INT_UT) ; else pnode_ut = UH_UT; } else if (pnode_ut == NFP_UT) { if (next_ut == NFP_UT) ; else if (next_ut == FP_UT) pnode_ut = FP_UT; else pnode_ut = UH_UT; } else if (pnode_ut == FP_UT) { if (next_ut == NFP_UT || next_ut == FP_UT) ; else pnode_ut = UH_UT; } else utccAbort("Unknown Error on Setting next_ut in handlePHINode..."); } setExprType(pnode, pnode_ut); }
bool LoopInterchangeTransform::transform() { DEBUG(dbgs() << "transform\n"); bool Transformed = false; Instruction *InnerIndexVar; if (InnerLoop->getSubLoops().size() == 0) { BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader(); DEBUG(dbgs() << "Calling Split Inner Loop\n"); PHINode *InductionPHI = getInductionVariable(InnerLoop, SE); if (!InductionPHI) { DEBUG(dbgs() << "Failed to find the point to split loop latch \n"); return false; } if (InductionPHI->getIncomingBlock(0) == InnerLoopPreHeader) InnerIndexVar = dyn_cast<Instruction>(InductionPHI->getIncomingValue(1)); else InnerIndexVar = dyn_cast<Instruction>(InductionPHI->getIncomingValue(0)); // // Split at the place were the induction variable is // incremented/decremented. // TODO: This splitting logic may not work always. Fix this. splitInnerLoopLatch(InnerIndexVar); DEBUG(dbgs() << "splitInnerLoopLatch Done\n"); // Splits the inner loops phi nodes out into a separate basic block. splitInnerLoopHeader(); DEBUG(dbgs() << "splitInnerLoopHeader Done\n"); } Transformed |= adjustLoopLinks(); if (!Transformed) { DEBUG(dbgs() << "adjustLoopLinks Failed\n"); return false; } restructureLoops(InnerLoop, OuterLoop); return true; }
/* * This function verifies if there is a sigma function inside BB whose incoming value is equal to V and whose incoming block is equal to BB_from */ bool vSSA::verifySigmaExistance(Value *V, BasicBlock *BB, BasicBlock *BB_from) { for (BasicBlock::iterator it = BB->begin(); isa<PHINode>(it); ++it) { PHINode *sigma = cast<PHINode>(it); unsigned e = sigma->getNumIncomingValues(); if (e != 1) continue; if ((sigma->getIncomingValue(0) == V) && (sigma->getIncomingBlock(0) == BB_from)) return true; } return false; }
static bool containsSafePHI(BasicBlock *Block, bool isOuterLoopExitBlock) { for (auto I = Block->begin(); isa<PHINode>(I); ++I) { PHINode *PHI = cast<PHINode>(I); // Reduction lcssa phi will have only 1 incoming block that from loop latch. if (PHI->getNumIncomingValues() > 1) return false; Instruction *Ins = dyn_cast<Instruction>(PHI->getIncomingValue(0)); if (!Ins) return false; // Incoming value for lcssa phi's in outer loop exit can only be inner loop // exits lcssa phi else it would not be tightly nested. if (!isa<PHINode>(Ins) && isOuterLoopExitBlock) return false; } return true; }
void SparseSolver::visitPHINode(PHINode &PN) { // The lattice function may store more information on a PHINode than could be // computed from its incoming values. For example, SSI form stores its sigma // functions as PHINodes with a single incoming value. if (LatticeFunc->IsSpecialCasedPHI(&PN)) { LatticeVal IV = LatticeFunc->ComputeInstructionState(PN, *this); if (IV != LatticeFunc->getUntrackedVal()) UpdateState(PN, IV); return; } LatticeVal PNIV = getOrInitValueState(&PN); LatticeVal Overdefined = LatticeFunc->getOverdefinedVal(); // If this value is already overdefined (common) just return. if (PNIV == Overdefined || PNIV == LatticeFunc->getUntrackedVal()) return; // Quick exit // Super-extra-high-degree PHI nodes are unlikely to ever be interesting, // and slow us down a lot. Just mark them overdefined. if (PN.getNumIncomingValues() > 64) { UpdateState(PN, Overdefined); return; } // Look at all of the executable operands of the PHI node. If any of them // are overdefined, the PHI becomes overdefined as well. Otherwise, ask the // transfer function to give us the merge of the incoming values. for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) { // If the edge is not yet known to be feasible, it doesn't impact the PHI. if (!isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent(), true)) continue; // Merge in this value. LatticeVal OpVal = getOrInitValueState(PN.getIncomingValue(i)); if (OpVal != PNIV) PNIV = LatticeFunc->MergeValues(PNIV, OpVal); if (PNIV == Overdefined) break; // Rest of input values don't matter. } // Update the PHI with the compute value, which is the merge of the inputs. UpdateState(PN, PNIV); }
/* * This function verifies if there is a sigma function inside BB whose incoming value is equal to V and whose incoming block is equal to BB_from */ bool vSSA::verifySigmaExistance(Value *V, BasicBlock *BB, BasicBlock *BB_from) { DEBUG(dbgs() << "verifiy: " << *V << " :: " << BB->getName() << " :: " << BB_from->getName() << "\n"); for (BasicBlock::iterator it = BB->begin(); isa<PHINode>(it); ++it) { PHINode *sigma = cast<PHINode>(it); DEBUG(dbgs() << "vveriying: " << *sigma << "\n"); unsigned e = sigma->getNumIncomingValues(); if (e != 1) continue; if ((sigma->getIncomingValue(0) == V) && (sigma->getIncomingBlock(0) == BB_from)) return true; } return false; }
void CastVerifier::removeNonSecurityCast( Function &F, Instruction *inst, SmallVector<Instruction *, 16> &InstToDelete) { // Now we have non-security cast here, so remove the instrumented // instructions. PHINode *nullPhiInst = dyn_cast<PHINode>(inst); if (!nullPhiInst) { CVER_DEBUG("ERROR : Cannot locate PHINode\n"); return; } // Phi(CastecValue, NullValue) ==> Phi(CastedValue, CastedValue) Value *castedValue = nullPhiInst->getIncomingValue(0); nullPhiInst->setIncomingValue(1, castedValue); CVER_DEBUG("Removing null conditions : " << *nullPhiInst << "\n"); Instruction *actualCastInst = dyn_cast<Instruction>(castedValue); if (!actualCastInst) { CVER_DEBUG("ERROR : Cannot locate Actual casting instruction\n"); return; } Instruction *ptrtointInst = getNextInstruction(actualCastInst); Instruction *callInst = getNextInstruction(ptrtointInst); if (!ptrtointInst->getMetadata("cver_check") || !callInst->getMetadata("cver_check") || !isa<CallInst>(callInst)) { CVER_DEBUG("ERROR : Cannot locate Cver's check call isntruction\n"); return; } // Replace callInst with simple assign instruction (always assign 1). Instruction *voidCallInst = new PtrToIntInst( ConstantInt::get(callInst->getType(), 1), callInst->getType()); ReplaceInstWithInst(callInst, voidCallInst); // Remove ptrtoint instruction. ptrtointInst->eraseFromParent(); return; }
PHINode *vSSA::findSigma(Value *V, BasicBlock *BB, BasicBlock *BB_from) { DEBUG(dbgs() << "findSigma: " << *V << " :: " << BB->getName() << " :: " << BB_from->getName() << "\n"); for (BasicBlock::iterator it = BB->begin(); isa<PHINode>(it); ++it) { PHINode *sigma = cast<PHINode>(it); unsigned e = sigma->getNumIncomingValues(); if (e != 1) continue; if ((sigma->getIncomingValue(0) == V) && (sigma->getIncomingBlock(0) == BB_from)) { DEBUG(dbgs() << "findSigma: Result: " << *sigma << "\n"); return sigma; } } DEBUG(dbgs() << "findSigma: Result: " << NULL << "\n"); return NULL; }
/// \brief The first part of loop-nestification is to find a PHI node that tells /// us how to partition the loops. static PHINode *findPHIToPartitionLoops(Loop *L, DominatorTree *DT, AssumptionCache *AC) { const DataLayout &DL = L->getHeader()->getModule()->getDataLayout(); for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) { PHINode *PN = cast<PHINode>(I); ++I; if (Value *V = SimplifyInstruction(PN, DL, nullptr, DT, AC)) { // This is a degenerate PHI already, don't modify it! PN->replaceAllUsesWith(V); PN->eraseFromParent(); continue; } // Scan this PHI node looking for a use of the PHI node by itself. for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) if (PN->getIncomingValue(i) == PN && L->contains(PN->getIncomingBlock(i))) // We found something tasty to remove. return PN; } return nullptr; }
/// FindPHIToPartitionLoops - The first part of loop-nestification is to find a /// PHI node that tells us how to partition the loops. static PHINode *FindPHIToPartitionLoops(Loop *L, DominatorTree *DT, AliasAnalysis *AA, LoopInfo *LI) { for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) { PHINode *PN = cast<PHINode>(I); ++I; if (Value *V = SimplifyInstruction(PN, 0, DT)) { // This is a degenerate PHI already, don't modify it! PN->replaceAllUsesWith(V); if (AA) AA->deleteValue(PN); PN->eraseFromParent(); continue; } // Scan this PHI node looking for a use of the PHI node by itself. for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) if (PN->getIncomingValue(i) == PN && L->contains(PN->getIncomingBlock(i))) // We found something tasty to remove. return PN; } return 0; }
/// When there is a phi node that is created in a BasicBlock and it is used /// as an operand of another phi function used in the same BasicBlock, /// LLVM looks this as an error. So on the second phi, the first phi is called /// P and the BasicBlock it incomes is B. This P will be replaced by the value /// it has for BasicBlock B. It also includes undef values for predecessors /// that were not included in the phi. /// void SSI::fixPhis() { for (SmallPtrSet<PHINode *, 1>::iterator begin = phisToFix.begin(), end = phisToFix.end(); begin != end; ++begin) { PHINode *PN = *begin; for (unsigned i = 0, e = PN->getNumIncomingValues(); i < e; ++i) { PHINode *PN_father = dyn_cast<PHINode>(PN->getIncomingValue(i)); if (PN_father && PN->getParent() == PN_father->getParent() && !DT_->dominates(PN->getParent(), PN->getIncomingBlock(i))) { BasicBlock *BB = PN->getIncomingBlock(i); int pos = PN_father->getBasicBlockIndex(BB); PN->setIncomingValue(i, PN_father->getIncomingValue(pos)); } } } for (DenseMapIterator<PHINode *, Instruction*> begin = phis.begin(), end = phis.end(); begin != end; ++begin) { PHINode *PN = begin->first; BasicBlock *BB = PN->getParent(); pred_iterator PI = pred_begin(BB), PE = pred_end(BB); SmallVector<BasicBlock*, 8> Preds(PI, PE); for (unsigned size = Preds.size(); PI != PE && PN->getNumIncomingValues() != size; ++PI) { bool found = false; for (unsigned i = 0, pn_end = PN->getNumIncomingValues(); i < pn_end; ++i) { if (PN->getIncomingBlock(i) == *PI) { found = true; break; } } if (!found) { PN->addIncoming(UndefValue::get(PN->getType()), *PI); } } } }
SizeOffsetEvalType ObjectSizeOffsetEvaluator::visitPHINode(PHINode &PHI) { // create 2 PHIs: one for size and another for offset PHINode *SizePHI = Builder.CreatePHI(IntTy, PHI.getNumIncomingValues()); PHINode *OffsetPHI = Builder.CreatePHI(IntTy, PHI.getNumIncomingValues()); // insert right away in the cache to handle recursive PHIs CacheMap[&PHI] = std::make_pair(SizePHI, OffsetPHI); // compute offset/size for each PHI incoming pointer for (unsigned i = 0, e = PHI.getNumIncomingValues(); i != e; ++i) { Builder.SetInsertPoint(PHI.getIncomingBlock(i)->getFirstInsertionPt()); SizeOffsetEvalType EdgeData = compute_(PHI.getIncomingValue(i)); if (!bothKnown(EdgeData)) { OffsetPHI->replaceAllUsesWith(UndefValue::get(IntTy)); OffsetPHI->eraseFromParent(); SizePHI->replaceAllUsesWith(UndefValue::get(IntTy)); SizePHI->eraseFromParent(); return unknown(); } SizePHI->addIncoming(EdgeData.first, PHI.getIncomingBlock(i)); OffsetPHI->addIncoming(EdgeData.second, PHI.getIncomingBlock(i)); } Value *Size = SizePHI, *Offset = OffsetPHI, *Tmp; if ((Tmp = SizePHI->hasConstantValue())) { Size = Tmp; SizePHI->replaceAllUsesWith(Size); SizePHI->eraseFromParent(); } if ((Tmp = OffsetPHI->hasConstantValue())) { Offset = Tmp; OffsetPHI->replaceAllUsesWith(Offset); OffsetPHI->eraseFromParent(); } return std::make_pair(Size, Offset); }
bool Scalarizer::visitPHINode(PHINode &PHI) { VectorType *VT = dyn_cast<VectorType>(PHI.getType()); if (!VT) return false; unsigned NumElems = VT->getNumElements(); IRBuilder<> Builder(PHI.getParent(), &PHI); ValueVector Res; Res.resize(NumElems); unsigned NumOps = PHI.getNumOperands(); for (unsigned I = 0; I < NumElems; ++I) Res[I] = Builder.CreatePHI(VT->getElementType(), NumOps, PHI.getName() + ".i" + Twine(I)); for (unsigned I = 0; I < NumOps; ++I) { Scatterer Op = scatter(&PHI, PHI.getIncomingValue(I)); BasicBlock *IncomingBlock = PHI.getIncomingBlock(I); for (unsigned J = 0; J < NumElems; ++J) cast<PHINode>(Res[J])->addIncoming(Op[J], IncomingBlock); } gather(&PHI, Res); return true; }
// TODO: improve store placement. Inserting at def is probably good, but need // to be careful not to introduce interfering stores (needs liveness analysis). // TODO: identify related phi nodes that can share spill slots, and share them // (also needs liveness). void WinEHPrepare::insertPHIStores(PHINode *OriginalPHI, AllocaInst *SpillSlot) { // Use a worklist of (Block, Value) pairs -- the given Value needs to be // stored to the spill slot by the end of the given Block. SmallVector<std::pair<BasicBlock *, Value *>, 4> Worklist; Worklist.push_back({OriginalPHI->getParent(), OriginalPHI}); while (!Worklist.empty()) { BasicBlock *EHBlock; Value *InVal; std::tie(EHBlock, InVal) = Worklist.pop_back_val(); PHINode *PN = dyn_cast<PHINode>(InVal); if (PN && PN->getParent() == EHBlock) { // The value is defined by another PHI we need to remove, with no room to // insert a store after the PHI, so each predecessor needs to store its // incoming value. for (unsigned i = 0, e = PN->getNumIncomingValues(); i < e; ++i) { Value *PredVal = PN->getIncomingValue(i); // Undef can safely be skipped. if (isa<UndefValue>(PredVal)) continue; insertPHIStore(PN->getIncomingBlock(i), PredVal, SpillSlot, Worklist); } } else { // We need to store InVal, which dominates EHBlock, but can't put a store // in EHBlock, so need to put stores in each predecessor. for (BasicBlock *PredBlock : predecessors(EHBlock)) { insertPHIStore(PredBlock, InVal, SpillSlot, Worklist); } } } }
void BlockGenerator::generateScalarStores(ScopStmt &Stmt, BasicBlock *BB, ValueMapT &BBMap, ValueMapT &GlobalMap) { const Region &R = Stmt.getParent()->getRegion(); assert(Stmt.isBlockStmt() && BB == Stmt.getBasicBlock() && "Region statements need to use the generateScalarStores() " "function in the RegionGenerator"); // Set to remember a store to the phiops alloca of a PHINode. It is needed as // we might have multiple write accesses to the same PHI and while one is the // self write of the PHI (to the ScalarMap alloca) the other is the write to // the operand alloca (PHIOpMap). SmallPtrSet<PHINode *, 4> SeenPHIs; // Iterate over all accesses in the given statement. for (MemoryAccess *MA : Stmt) { // Skip non-scalar and read accesses. if (!MA->isScalar() || MA->isRead()) continue; Instruction *ScalarBase = cast<Instruction>(MA->getBaseAddr()); Instruction *ScalarInst = MA->getAccessInstruction(); PHINode *ScalarBasePHI = dyn_cast<PHINode>(ScalarBase); // Get the alloca node for the base instruction and the value we want to // store. In total there are 4 options: // (1) The base is no PHI, hence it is a simple scalar def-use chain. // (2) The base is a PHI, // (a) and the write is caused by an operand in the block. // (b) and it is the PHI self write (same as case (1)). // (c) (2a) and (2b) are not distinguishable. // For case (1) and (2b) we get the alloca from the scalar map and the value // we want to store is initialized with the instruction attached to the // memory access. For case (2a) we get the alloca from the PHI operand map // and the value we want to store is initialized with the incoming value for // this block. The tricky case (2c) is when both (2a) and (2b) match. This // happens if the PHI operand is in the same block as the PHI. To handle // that we choose the alloca of (2a) first and (2b) for the next write // access to that PHI (there must be 2). Value *ScalarValue = nullptr; AllocaInst *ScalarAddr = nullptr; if (!ScalarBasePHI) { // Case (1) ScalarAddr = getOrCreateAlloca(ScalarBase, ScalarMap, ".s2a"); ScalarValue = ScalarInst; } else { int PHIIdx = ScalarBasePHI->getBasicBlockIndex(BB); if (ScalarBasePHI != ScalarInst) { // Case (2a) assert(PHIIdx >= 0 && "Bad scalar write to PHI operand"); SeenPHIs.insert(ScalarBasePHI); ScalarAddr = getOrCreateAlloca(ScalarBase, PHIOpMap, ".phiops"); ScalarValue = ScalarBasePHI->getIncomingValue(PHIIdx); } else if (PHIIdx < 0) { // Case (2b) ScalarAddr = getOrCreateAlloca(ScalarBase, ScalarMap, ".s2a"); ScalarValue = ScalarInst; } else { // Case (2c) if (SeenPHIs.insert(ScalarBasePHI).second) { // First access ==> same as (2a) ScalarAddr = getOrCreateAlloca(ScalarBase, PHIOpMap, ".phiops"); ScalarValue = ScalarBasePHI->getIncomingValue(PHIIdx); } else { // Second access ==> same as (2b) ScalarAddr = getOrCreateAlloca(ScalarBase, ScalarMap, ".s2a"); ScalarValue = ScalarInst; } } } ScalarValue = getNewScalarValue(ScalarValue, R, ScalarMap, BBMap, GlobalMap); Builder.CreateStore(ScalarValue, ScalarAddr); } }
void RegionGenerator::generateScalarStores(ScopStmt &Stmt, BasicBlock *BB, ValueMapT &BBMap, ValueMapT &GlobalMap) { const Region &R = Stmt.getParent()->getRegion(); Region *StmtR = Stmt.getRegion(); assert(StmtR && "Block statements need to use the generateScalarStores() " "function in the BlockGenerator"); BasicBlock *ExitBB = StmtR->getExit(); // For region statements three kinds of scalar stores exists: // (1) A definition used by a non-phi instruction outside the region. // (2) A phi-instruction in the region entry. // (3) A write to a phi instruction in the region exit. // The last case is the tricky one since we do not know anymore which // predecessor of the exit needs to store the operand value that doesn't // have a definition in the region. Therefore, we have to check in each // block in the region if we should store the value or not. // Iterate over all accesses in the given statement. for (MemoryAccess *MA : Stmt) { // Skip non-scalar and read accesses. if (!MA->isScalar() || MA->isRead()) continue; Instruction *ScalarBase = cast<Instruction>(MA->getBaseAddr()); Instruction *ScalarInst = MA->getAccessInstruction(); PHINode *ScalarBasePHI = dyn_cast<PHINode>(ScalarBase); Value *ScalarValue = nullptr; AllocaInst *ScalarAddr = nullptr; if (!ScalarBasePHI) { // Case (1) ScalarAddr = getOrCreateAlloca(ScalarBase, ScalarMap, ".s2a"); ScalarValue = ScalarInst; } else if (ScalarBasePHI->getParent() != ExitBB) { // Case (2) assert(ScalarBasePHI->getParent() == StmtR->getEntry() && "Bad PHI self write in non-affine region"); assert(ScalarBase == ScalarInst && "Bad PHI self write in non-affine region"); ScalarAddr = getOrCreateAlloca(ScalarBase, ScalarMap, ".s2a"); ScalarValue = ScalarInst; } else { int PHIIdx = ScalarBasePHI->getBasicBlockIndex(BB); // Skip accesses we will not handle in this basic block but in another one // in the statement region. if (PHIIdx < 0) continue; // Case (3) ScalarAddr = getOrCreateAlloca(ScalarBase, PHIOpMap, ".phiops"); ScalarValue = ScalarBasePHI->getIncomingValue(PHIIdx); } ScalarValue = getNewScalarValue(ScalarValue, R, ScalarMap, BBMap, GlobalMap); Builder.CreateStore(ScalarValue, ScalarAddr); } }
/// DupRetToEnableTailCallOpts - Look for opportunities to duplicate return /// instructions to the predecessor to enable tail call optimizations. The /// case it is currently looking for is: /// bb0: /// %tmp0 = tail call i32 @f0() /// br label %return /// bb1: /// %tmp1 = tail call i32 @f1() /// br label %return /// bb2: /// %tmp2 = tail call i32 @f2() /// br label %return /// return: /// %retval = phi i32 [ %tmp0, %bb0 ], [ %tmp1, %bb1 ], [ %tmp2, %bb2 ] /// ret i32 %retval /// /// => /// /// bb0: /// %tmp0 = tail call i32 @f0() /// ret i32 %tmp0 /// bb1: /// %tmp1 = tail call i32 @f1() /// ret i32 %tmp1 /// bb2: /// %tmp2 = tail call i32 @f2() /// ret i32 %tmp2 /// bool CodeGenPrepare::DupRetToEnableTailCallOpts(ReturnInst *RI) { if (!TLI) return false; Value *V = RI->getReturnValue(); PHINode *PN = V ? dyn_cast<PHINode>(V) : NULL; if (V && !PN) return false; BasicBlock *BB = RI->getParent(); if (PN && PN->getParent() != BB) return false; // It's not safe to eliminate the sign / zero extension of the return value. // See llvm::isInTailCallPosition(). const Function *F = BB->getParent(); Attributes CallerRetAttr = F->getAttributes().getRetAttributes(); if ((CallerRetAttr & Attribute::ZExt) || (CallerRetAttr & Attribute::SExt)) return false; // Make sure there are no instructions between the PHI and return, or that the // return is the first instruction in the block. if (PN) { BasicBlock::iterator BI = BB->begin(); do { ++BI; } while (isa<DbgInfoIntrinsic>(BI)); if (&*BI != RI) return false; } else { BasicBlock::iterator BI = BB->begin(); while (isa<DbgInfoIntrinsic>(BI)) ++BI; if (&*BI != RI) return false; } /// Only dup the ReturnInst if the CallInst is likely to be emitted as a tail /// call. SmallVector<CallInst*, 4> TailCalls; if (PN) { for (unsigned I = 0, E = PN->getNumIncomingValues(); I != E; ++I) { CallInst *CI = dyn_cast<CallInst>(PN->getIncomingValue(I)); // Make sure the phi value is indeed produced by the tail call. if (CI && CI->hasOneUse() && CI->getParent() == PN->getIncomingBlock(I) && TLI->mayBeEmittedAsTailCall(CI)) TailCalls.push_back(CI); } } else { SmallPtrSet<BasicBlock*, 4> VisitedBBs; for (pred_iterator PI = pred_begin(BB), PE = pred_end(BB); PI != PE; ++PI) { if (!VisitedBBs.insert(*PI)) continue; BasicBlock::InstListType &InstList = (*PI)->getInstList(); BasicBlock::InstListType::reverse_iterator RI = InstList.rbegin(); BasicBlock::InstListType::reverse_iterator RE = InstList.rend(); do { ++RI; } while (RI != RE && isa<DbgInfoIntrinsic>(&*RI)); if (RI == RE) continue; CallInst *CI = dyn_cast<CallInst>(&*RI); if (CI && CI->use_empty() && TLI->mayBeEmittedAsTailCall(CI)) TailCalls.push_back(CI); } } bool Changed = false; for (unsigned i = 0, e = TailCalls.size(); i != e; ++i) { CallInst *CI = TailCalls[i]; CallSite CS(CI); // Conservatively require the attributes of the call to match those of the // return. Ignore noalias because it doesn't affect the call sequence. Attributes CalleeRetAttr = CS.getAttributes().getRetAttributes(); if ((CalleeRetAttr ^ CallerRetAttr) & ~Attribute::NoAlias) continue; // Make sure the call instruction is followed by an unconditional branch to // the return block. BasicBlock *CallBB = CI->getParent(); BranchInst *BI = dyn_cast<BranchInst>(CallBB->getTerminator()); if (!BI || !BI->isUnconditional() || BI->getSuccessor(0) != BB) continue; // Duplicate the return into CallBB. (void)FoldReturnIntoUncondBranch(RI, BB, CallBB); ModifiedDT = Changed = true; ++NumRetsDup; } // If we eliminated all predecessors of the block, delete the block now. if (Changed && pred_begin(BB) == pred_end(BB)) BB->eraseFromParent(); return Changed; }
/// EliminateMostlyEmptyBlock - Eliminate a basic block that have only phi's and /// an unconditional branch in it. void CodeGenPrepare::EliminateMostlyEmptyBlock(BasicBlock *BB) { BranchInst *BI = cast<BranchInst>(BB->getTerminator()); BasicBlock *DestBB = BI->getSuccessor(0); DEBUG(dbgs() << "MERGING MOSTLY EMPTY BLOCKS - BEFORE:\n" << *BB << *DestBB); // If the destination block has a single pred, then this is a trivial edge, // just collapse it. if (BasicBlock *SinglePred = DestBB->getSinglePredecessor()) { if (SinglePred != DestBB) { // Remember if SinglePred was the entry block of the function. If so, we // will need to move BB back to the entry position. bool isEntry = SinglePred == &SinglePred->getParent()->getEntryBlock(); MergeBasicBlockIntoOnlyPred(DestBB, this); if (isEntry && BB != &BB->getParent()->getEntryBlock()) BB->moveBefore(&BB->getParent()->getEntryBlock()); DEBUG(dbgs() << "AFTER:\n" << *DestBB << "\n\n\n"); return; } } // Otherwise, we have multiple predecessors of BB. Update the PHIs in DestBB // to handle the new incoming edges it is about to have. PHINode *PN; for (BasicBlock::iterator BBI = DestBB->begin(); (PN = dyn_cast<PHINode>(BBI)); ++BBI) { // Remove the incoming value for BB, and remember it. Value *InVal = PN->removeIncomingValue(BB, false); // Two options: either the InVal is a phi node defined in BB or it is some // value that dominates BB. PHINode *InValPhi = dyn_cast<PHINode>(InVal); if (InValPhi && InValPhi->getParent() == BB) { // Add all of the input values of the input PHI as inputs of this phi. for (unsigned i = 0, e = InValPhi->getNumIncomingValues(); i != e; ++i) PN->addIncoming(InValPhi->getIncomingValue(i), InValPhi->getIncomingBlock(i)); } else { // Otherwise, add one instance of the dominating value for each edge that // we will be adding. if (PHINode *BBPN = dyn_cast<PHINode>(BB->begin())) { for (unsigned i = 0, e = BBPN->getNumIncomingValues(); i != e; ++i) PN->addIncoming(InVal, BBPN->getIncomingBlock(i)); } else { for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) PN->addIncoming(InVal, *PI); } } } // The PHIs are now updated, change everything that refers to BB to use // DestBB and remove BB. BB->replaceAllUsesWith(DestBB); if (DT && !ModifiedDT) { BasicBlock *BBIDom = DT->getNode(BB)->getIDom()->getBlock(); BasicBlock *DestBBIDom = DT->getNode(DestBB)->getIDom()->getBlock(); BasicBlock *NewIDom = DT->findNearestCommonDominator(BBIDom, DestBBIDom); DT->changeImmediateDominator(DestBB, NewIDom); DT->eraseNode(BB); } if (PFI) { PFI->replaceAllUses(BB, DestBB); PFI->removeEdge(ProfileInfo::getEdge(BB, DestBB)); } BB->eraseFromParent(); ++NumBlocksElim; DEBUG(dbgs() << "AFTER:\n" << *DestBB << "\n\n\n"); }
/// Create a clone of the blocks in a loop and connect them together. /// This function doesn't create a clone of the loop structure. /// /// There are two value maps that are defined and used. VMap is /// for the values in the current loop instance. LVMap contains /// the values from the last loop instance. We need the LVMap values /// to update the initial values for the current loop instance. /// static void CloneLoopBlocks(Loop *L, bool FirstCopy, BasicBlock *InsertTop, BasicBlock *InsertBot, std::vector<BasicBlock *> &NewBlocks, LoopBlocksDFS &LoopBlocks, ValueToValueMapTy &VMap, ValueToValueMapTy &LVMap, LoopInfo *LI) { BasicBlock *Preheader = L->getLoopPreheader(); BasicBlock *Header = L->getHeader(); BasicBlock *Latch = L->getLoopLatch(); Function *F = Header->getParent(); LoopBlocksDFS::RPOIterator BlockBegin = LoopBlocks.beginRPO(); LoopBlocksDFS::RPOIterator BlockEnd = LoopBlocks.endRPO(); // For each block in the original loop, create a new copy, // and update the value map with the newly created values. for (LoopBlocksDFS::RPOIterator BB = BlockBegin; BB != BlockEnd; ++BB) { BasicBlock *NewBB = CloneBasicBlock(*BB, VMap, ".unr", F); NewBlocks.push_back(NewBB); if (Loop *ParentLoop = L->getParentLoop()) ParentLoop->addBasicBlockToLoop(NewBB, LI->getBase()); VMap[*BB] = NewBB; if (Header == *BB) { // For the first block, add a CFG connection to this newly // created block InsertTop->getTerminator()->setSuccessor(0, NewBB); // Change the incoming values to the ones defined in the // previously cloned loop. for (BasicBlock::iterator I = Header->begin(); isa<PHINode>(I); ++I) { PHINode *NewPHI = cast<PHINode>(VMap[I]); if (FirstCopy) { // We replace the first phi node with the value from the preheader VMap[I] = NewPHI->getIncomingValueForBlock(Preheader); NewBB->getInstList().erase(NewPHI); } else { // Update VMap with values from the previous block unsigned idx = NewPHI->getBasicBlockIndex(Latch); Value *InVal = NewPHI->getIncomingValue(idx); if (Instruction *I = dyn_cast<Instruction>(InVal)) if (L->contains(I)) InVal = LVMap[InVal]; NewPHI->setIncomingValue(idx, InVal); NewPHI->setIncomingBlock(idx, InsertTop); } } } if (Latch == *BB) { VMap.erase((*BB)->getTerminator()); NewBB->getTerminator()->eraseFromParent(); BranchInst::Create(InsertBot, NewBB); } } // LastValueMap is updated with the values for the current loop // which are used the next time this function is called. for (ValueToValueMapTy::iterator VI = VMap.begin(), VE = VMap.end(); VI != VE; ++VI) { LVMap[VI->first] = VI->second; } }
/// Tests whether this function is known to not return null. /// /// Requires that the function returns a pointer. /// /// Returns true if it believes the function will not return a null, and sets /// \p Speculative based on whether the returned conclusion is a speculative /// conclusion due to SCC calls. static bool isReturnNonNull(Function *F, const SCCNodeSet &SCCNodes, bool &Speculative) { assert(F->getReturnType()->isPointerTy() && "nonnull only meaningful on pointer types"); Speculative = false; SmallSetVector<Value *, 8> FlowsToReturn; for (BasicBlock &BB : *F) if (auto *Ret = dyn_cast<ReturnInst>(BB.getTerminator())) FlowsToReturn.insert(Ret->getReturnValue()); for (unsigned i = 0; i != FlowsToReturn.size(); ++i) { Value *RetVal = FlowsToReturn[i]; // If this value is locally known to be non-null, we're good if (isKnownNonNull(RetVal)) continue; // Otherwise, we need to look upwards since we can't make any local // conclusions. Instruction *RVI = dyn_cast<Instruction>(RetVal); if (!RVI) return false; switch (RVI->getOpcode()) { // Extend the analysis by looking upwards. case Instruction::BitCast: case Instruction::GetElementPtr: case Instruction::AddrSpaceCast: FlowsToReturn.insert(RVI->getOperand(0)); continue; case Instruction::Select: { SelectInst *SI = cast<SelectInst>(RVI); FlowsToReturn.insert(SI->getTrueValue()); FlowsToReturn.insert(SI->getFalseValue()); continue; } case Instruction::PHI: { PHINode *PN = cast<PHINode>(RVI); for (int i = 0, e = PN->getNumIncomingValues(); i != e; ++i) FlowsToReturn.insert(PN->getIncomingValue(i)); continue; } case Instruction::Call: case Instruction::Invoke: { CallSite CS(RVI); Function *Callee = CS.getCalledFunction(); // A call to a node within the SCC is assumed to return null until // proven otherwise if (Callee && SCCNodes.count(Callee)) { Speculative = true; continue; } return false; } default: return false; // Unknown source, may be null }; llvm_unreachable("should have either continued or returned"); } return true; }