From c95fff5be72f367f092ccbee2b42a81f483734e5 Mon Sep 17 00:00:00 2001 From: Kazu Hirata Date: Sat, 7 Nov 2020 19:35:02 -0800 Subject: [PATCH] [JumpThreading] Fix function names (NFC) --- .../include/llvm/Transforms/Scalar/JumpThreading.h | 54 ++--- llvm/lib/Transforms/Scalar/JumpThreading.cpp | 218 ++++++++++----------- 2 files changed, 136 insertions(+), 136 deletions(-) diff --git a/llvm/include/llvm/Transforms/Scalar/JumpThreading.h b/llvm/include/llvm/Transforms/Scalar/JumpThreading.h index b5b9074..5c12e51 100644 --- a/llvm/include/llvm/Transforms/Scalar/JumpThreading.h +++ b/llvm/include/llvm/Transforms/Scalar/JumpThreading.h @@ -109,65 +109,65 @@ public: BPI.reset(); } - void FindLoopHeaders(Function &F); - bool ProcessBlock(BasicBlock *BB); - bool MaybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB); - void UpdateSSA(BasicBlock *BB, BasicBlock *NewBB, + void findLoopHeaders(Function &F); + bool processBlock(BasicBlock *BB); + bool maybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB); + void updateSSA(BasicBlock *BB, BasicBlock *NewBB, DenseMap &ValueMapping); - DenseMap CloneInstructions(BasicBlock::iterator BI, + DenseMap cloneInstructions(BasicBlock::iterator BI, BasicBlock::iterator BE, BasicBlock *NewBB, BasicBlock *PredBB); - bool TryThreadEdge(BasicBlock *BB, + bool tryThreadEdge(BasicBlock *BB, const SmallVectorImpl &PredBBs, BasicBlock *SuccBB); - void ThreadEdge(BasicBlock *BB, const SmallVectorImpl &PredBBs, + void threadEdge(BasicBlock *BB, const SmallVectorImpl &PredBBs, BasicBlock *SuccBB); - bool DuplicateCondBranchOnPHIIntoPred( + bool duplicateCondBranchOnPHIIntoPred( BasicBlock *BB, const SmallVectorImpl &PredBBs); - bool ComputeValueKnownInPredecessorsImpl( + bool computeValueKnownInPredecessorsImpl( Value *V, BasicBlock *BB, jumpthreading::PredValueInfo &Result, jumpthreading::ConstantPreference Preference, DenseSet &RecursionSet, Instruction *CxtI = nullptr); bool - ComputeValueKnownInPredecessors(Value *V, BasicBlock *BB, + computeValueKnownInPredecessors(Value *V, BasicBlock *BB, jumpthreading::PredValueInfo &Result, jumpthreading::ConstantPreference Preference, Instruction *CxtI = nullptr) { DenseSet RecursionSet; - return ComputeValueKnownInPredecessorsImpl(V, BB, Result, Preference, + return computeValueKnownInPredecessorsImpl(V, BB, Result, Preference, RecursionSet, CxtI); } - Constant *EvaluateOnPredecessorEdge(BasicBlock *BB, BasicBlock *PredPredBB, + Constant *evaluateOnPredecessorEdge(BasicBlock *BB, BasicBlock *PredPredBB, Value *cond); - bool MaybeThreadThroughTwoBasicBlocks(BasicBlock *BB, Value *Cond); - void ThreadThroughTwoBasicBlocks(BasicBlock *PredPredBB, BasicBlock *PredBB, + bool maybethreadThroughTwoBasicBlocks(BasicBlock *BB, Value *Cond); + void threadThroughTwoBasicBlocks(BasicBlock *PredPredBB, BasicBlock *PredBB, BasicBlock *BB, BasicBlock *SuccBB); - bool ProcessThreadableEdges(Value *Cond, BasicBlock *BB, + bool processThreadableEdges(Value *Cond, BasicBlock *BB, jumpthreading::ConstantPreference Preference, Instruction *CxtI = nullptr); - bool ProcessBranchOnPHI(PHINode *PN); - bool ProcessBranchOnXOR(BinaryOperator *BO); - bool ProcessImpliedCondition(BasicBlock *BB); + bool processBranchOnPHI(PHINode *PN); + bool processBranchOnXOR(BinaryOperator *BO); + bool processImpliedCondition(BasicBlock *BB); - bool SimplifyPartiallyRedundantLoad(LoadInst *LI); - void UnfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, SelectInst *SI, + bool simplifyPartiallyRedundantLoad(LoadInst *LI); + void unfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, SelectInst *SI, PHINode *SIUse, unsigned Idx); - bool TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB); - bool TryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB); - bool TryToUnfoldSelectInCurrBB(BasicBlock *BB); + bool tryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB); + bool tryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB); + bool tryToUnfoldSelectInCurrBB(BasicBlock *BB); - bool ProcessGuards(BasicBlock *BB); - bool ThreadGuard(BasicBlock *BB, IntrinsicInst *Guard, BranchInst *BI); + bool processGuards(BasicBlock *BB); + bool threadGuard(BasicBlock *BB, IntrinsicInst *Guard, BranchInst *BI); private: - BasicBlock *SplitBlockPreds(BasicBlock *BB, ArrayRef Preds, + BasicBlock *splitBlockPreds(BasicBlock *BB, ArrayRef Preds, const char *Suffix); - void UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB, + void updateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB, BasicBlock *NewBB, BasicBlock *SuccBB); /// Check if the block has profile metadata for its outgoing edges. bool doesBlockHaveProfileData(BasicBlock *BB); diff --git a/llvm/lib/Transforms/Scalar/JumpThreading.cpp b/llvm/lib/Transforms/Scalar/JumpThreading.cpp index 12deaaa..936c888 100644 --- a/llvm/lib/Transforms/Scalar/JumpThreading.cpp +++ b/llvm/lib/Transforms/Scalar/JumpThreading.cpp @@ -404,7 +404,7 @@ bool JumpThreadingPass::runImpl(Function &F, TargetLibraryInfo *TLI_, Unreachable.insert(&BB); if (!ThreadAcrossLoopHeaders) - FindLoopHeaders(F); + findLoopHeaders(F); bool EverChanged = false; bool Changed; @@ -413,7 +413,7 @@ bool JumpThreadingPass::runImpl(Function &F, TargetLibraryInfo *TLI_, for (auto &BB : F) { if (Unreachable.count(&BB)) continue; - while (ProcessBlock(&BB)) // Thread all of the branches we can over BB. + while (processBlock(&BB)) // Thread all of the branches we can over BB. Changed = true; // Jump threading may have introduced redundant debug values into BB @@ -428,7 +428,7 @@ bool JumpThreadingPass::runImpl(Function &F, TargetLibraryInfo *TLI_, continue; if (pred_empty(&BB)) { - // When ProcessBlock makes BB unreachable it doesn't bother to fix up + // When processBlock makes BB unreachable it doesn't bother to fix up // the instructions in it. We must remove BB to prevent invalid IR. LLVM_DEBUG(dbgs() << " JT: Deleting dead block '" << BB.getName() << "' with terminator: " << *BB.getTerminator() @@ -440,7 +440,7 @@ bool JumpThreadingPass::runImpl(Function &F, TargetLibraryInfo *TLI_, continue; } - // ProcessBlock doesn't thread BBs with unconditional TIs. However, if BB + // processBlock doesn't thread BBs with unconditional TIs. However, if BB // is "almost empty", we attempt to merge BB with its sole successor. auto *BI = dyn_cast(BB.getTerminator()); if (BI && BI->isUnconditional()) { @@ -474,7 +474,7 @@ bool JumpThreadingPass::runImpl(Function &F, TargetLibraryInfo *TLI_, // at the end of block. RAUW unconditionally replaces all uses // including the guards/assumes themselves and the uses before the // guard/assume. -static void ReplaceFoldableUses(Instruction *Cond, Value *ToVal) { +static void replaceFoldableUses(Instruction *Cond, Value *ToVal) { assert(Cond->getType() == ToVal->getType()); auto *BB = Cond->getParent(); // We can unconditionally replace all uses in non-local blocks (i.e. uses @@ -573,7 +573,7 @@ static unsigned getJumpThreadDuplicationCost(BasicBlock *BB, return Size > Bonus ? Size - Bonus : 0; } -/// FindLoopHeaders - We do not want jump threading to turn proper loop +/// findLoopHeaders - We do not want jump threading to turn proper loop /// structures into irreducible loops. Doing this breaks up the loop nesting /// hierarchy and pessimizes later transformations. To prevent this from /// happening, we first have to find the loop headers. Here we approximate this @@ -587,7 +587,7 @@ static unsigned getJumpThreadDuplicationCost(BasicBlock *BB, /// within the loop (forming a nested loop). This simple analysis is not rich /// enough to track all of these properties and keep it up-to-date as the CFG /// mutates, so we don't allow any of these transformations. -void JumpThreadingPass::FindLoopHeaders(Function &F) { +void JumpThreadingPass::findLoopHeaders(Function &F) { SmallVector, 32> Edges; FindFunctionBackedges(F, Edges); @@ -614,13 +614,13 @@ static Constant *getKnownConstant(Value *Val, ConstantPreference Preference) { return dyn_cast(Val); } -/// ComputeValueKnownInPredecessors - Given a basic block BB and a value V, see +/// computeValueKnownInPredecessors - Given a basic block BB and a value V, see /// if we can infer that the value is a known ConstantInt/BlockAddress or undef /// in any of our predecessors. If so, return the known list of value and pred /// BB in the result vector. /// /// This returns true if there were any known values. -bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl( +bool JumpThreadingPass::computeValueKnownInPredecessorsImpl( Value *V, BasicBlock *BB, PredValueInfo &Result, ConstantPreference Preference, DenseSet &RecursionSet, Instruction *CxtI) { @@ -688,7 +688,7 @@ bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl( // Handle Cast instructions. if (CastInst *CI = dyn_cast(I)) { Value *Source = CI->getOperand(0); - ComputeValueKnownInPredecessorsImpl(Source, BB, Result, Preference, + computeValueKnownInPredecessorsImpl(Source, BB, Result, Preference, RecursionSet, CxtI); if (Result.empty()) return false; @@ -702,7 +702,7 @@ bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl( if (FreezeInst *FI = dyn_cast(I)) { Value *Source = FI->getOperand(0); - ComputeValueKnownInPredecessorsImpl(Source, BB, Result, Preference, + computeValueKnownInPredecessorsImpl(Source, BB, Result, Preference, RecursionSet, CxtI); erase_if(Result, [](auto &Pair) { @@ -721,9 +721,9 @@ bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl( I->getOpcode() == Instruction::And) { PredValueInfoTy LHSVals, RHSVals; - ComputeValueKnownInPredecessorsImpl(I->getOperand(0), BB, LHSVals, + computeValueKnownInPredecessorsImpl(I->getOperand(0), BB, LHSVals, WantInteger, RecursionSet, CxtI); - ComputeValueKnownInPredecessorsImpl(I->getOperand(1), BB, RHSVals, + computeValueKnownInPredecessorsImpl(I->getOperand(1), BB, RHSVals, WantInteger, RecursionSet, CxtI); if (LHSVals.empty() && RHSVals.empty()) @@ -759,7 +759,7 @@ bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl( if (I->getOpcode() == Instruction::Xor && isa(I->getOperand(1)) && cast(I->getOperand(1))->isOne()) { - ComputeValueKnownInPredecessorsImpl(I->getOperand(0), BB, Result, + computeValueKnownInPredecessorsImpl(I->getOperand(0), BB, Result, WantInteger, RecursionSet, CxtI); if (Result.empty()) return false; @@ -777,7 +777,7 @@ bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl( && "A binary operator creating a block address?"); if (ConstantInt *CI = dyn_cast(BO->getOperand(1))) { PredValueInfoTy LHSVals; - ComputeValueKnownInPredecessorsImpl(BO->getOperand(0), BB, LHSVals, + computeValueKnownInPredecessorsImpl(BO->getOperand(0), BB, LHSVals, WantInteger, RecursionSet, CxtI); // Try to use constant folding to simplify the binary operator. @@ -911,7 +911,7 @@ bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl( // Try to find a constant value for the LHS of a comparison, // and evaluate it statically if we can. PredValueInfoTy LHSVals; - ComputeValueKnownInPredecessorsImpl(I->getOperand(0), BB, LHSVals, + computeValueKnownInPredecessorsImpl(I->getOperand(0), BB, LHSVals, WantInteger, RecursionSet, CxtI); for (const auto &LHSVal : LHSVals) { @@ -932,7 +932,7 @@ bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl( Constant *FalseVal = getKnownConstant(SI->getFalseValue(), Preference); PredValueInfoTy Conds; if ((TrueVal || FalseVal) && - ComputeValueKnownInPredecessorsImpl(SI->getCondition(), BB, Conds, + computeValueKnownInPredecessorsImpl(SI->getCondition(), BB, Conds, WantInteger, RecursionSet, CxtI)) { for (auto &C : Conds) { Constant *Cond = C.first; @@ -975,7 +975,7 @@ bool JumpThreadingPass::ComputeValueKnownInPredecessorsImpl( /// /// Since we can pick an arbitrary destination, we pick the successor with the /// fewest predecessors. This should reduce the in-degree of the others. -static unsigned GetBestDestForJumpOnUndef(BasicBlock *BB) { +static unsigned getBestDestForJumpOnUndef(BasicBlock *BB) { Instruction *BBTerm = BB->getTerminator(); unsigned MinSucc = 0; BasicBlock *TestBB = BBTerm->getSuccessor(MinSucc); @@ -1003,9 +1003,9 @@ static bool hasAddressTakenAndUsed(BasicBlock *BB) { return !BA->use_empty(); } -/// ProcessBlock - If there are any predecessors whose control can be threaded +/// processBlock - If there are any predecessors whose control can be threaded /// through to a successor, transform them now. -bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) { +bool JumpThreadingPass::processBlock(BasicBlock *BB) { // If the block is trivially dead, just return and let the caller nuke it. // This simplifies other transformations. if (DTU->isBBPendingDeletion(BB) || @@ -1016,14 +1016,14 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) { // successor, merge the blocks. This encourages recursive jump threading // because now the condition in this block can be threaded through // predecessors of our predecessor block. - if (MaybeMergeBasicBlockIntoOnlyPred(BB)) + if (maybeMergeBasicBlockIntoOnlyPred(BB)) return true; - if (TryToUnfoldSelectInCurrBB(BB)) + if (tryToUnfoldSelectInCurrBB(BB)) return true; // Look if we can propagate guards to predecessors. - if (HasGuards && ProcessGuards(BB)) + if (HasGuards && processGuards(BB)) return true; // What kind of constant we're looking for. @@ -1066,11 +1066,11 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) { } // If the terminator is branching on an undef or freeze undef, we can pick any - // of the successors to branch to. Let GetBestDestForJumpOnUndef decide. + // of the successors to branch to. Let getBestDestForJumpOnUndef decide. auto *FI = dyn_cast(Condition); if (isa(Condition) || (FI && isa(FI->getOperand(0)) && FI->hasOneUse())) { - unsigned BestSucc = GetBestDestForJumpOnUndef(BB); + unsigned BestSucc = getBestDestForJumpOnUndef(BB); std::vector Updates; // Fold the branch/switch. @@ -1110,7 +1110,7 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) { // All the rest of our checks depend on the condition being an instruction. if (!CondInst) { // FIXME: Unify this with code below. - if (ProcessThreadableEdges(Condition, BB, Preference, Terminator)) + if (processThreadableEdges(Condition, BB, Preference, Terminator)) return true; return ConstantFolded; } @@ -1153,7 +1153,7 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) { auto *CI = Ret == LazyValueInfo::True ? ConstantInt::getTrue(CondCmp->getType()) : ConstantInt::getFalse(CondCmp->getType()); - ReplaceFoldableUses(CondCmp, CI); + replaceFoldableUses(CondCmp, CI); } DTU->applyUpdatesPermissive( {{DominatorTree::Delete, BB, ToRemoveSucc}}); @@ -1162,13 +1162,13 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) { // We did not manage to simplify this branch, try to see whether // CondCmp depends on a known phi-select pattern. - if (TryToUnfoldSelect(CondCmp, BB)) + if (tryToUnfoldSelect(CondCmp, BB)) return true; } } if (SwitchInst *SI = dyn_cast(BB->getTerminator())) - if (TryToUnfoldSelect(SI, BB)) + if (tryToUnfoldSelect(SI, BB)) return true; // Check for some cases that are worth simplifying. Right now we want to look @@ -1188,7 +1188,7 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) { // TODO: There are other places where load PRE would be profitable, such as // more complex comparisons. if (LoadInst *LoadI = dyn_cast(SimplifyValue)) - if (SimplifyPartiallyRedundantLoad(LoadI)) + if (simplifyPartiallyRedundantLoad(LoadI)) return true; // Before threading, try to propagate profile data backwards: @@ -1199,7 +1199,7 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) { // Handle a variety of cases where we are branching on something derived from // a PHI node in the current block. If we can prove that any predecessors // compute a predictable value based on a PHI node, thread those predecessors. - if (ProcessThreadableEdges(CondInst, BB, Preference, Terminator)) + if (processThreadableEdges(CondInst, BB, Preference, Terminator)) return true; // If this is an otherwise-unfoldable branch on a phi node or freeze(phi) in @@ -1209,22 +1209,22 @@ bool JumpThreadingPass::ProcessBlock(BasicBlock *BB) { : CondInst); if (PN && PN->getParent() == BB && isa(BB->getTerminator())) - return ProcessBranchOnPHI(PN); + return processBranchOnPHI(PN); // If this is an otherwise-unfoldable branch on a XOR, see if we can simplify. if (CondInst->getOpcode() == Instruction::Xor && CondInst->getParent() == BB && isa(BB->getTerminator())) - return ProcessBranchOnXOR(cast(CondInst)); + return processBranchOnXOR(cast(CondInst)); // Search for a stronger dominating condition that can be used to simplify a // conditional branch leaving BB. - if (ProcessImpliedCondition(BB)) + if (processImpliedCondition(BB)) return true; return false; } -bool JumpThreadingPass::ProcessImpliedCondition(BasicBlock *BB) { +bool JumpThreadingPass::processImpliedCondition(BasicBlock *BB) { auto *BI = dyn_cast(BB->getTerminator()); if (!BI || !BI->isConditional()) return false; @@ -1271,11 +1271,11 @@ static bool isOpDefinedInBlock(Value *Op, BasicBlock *BB) { return false; } -/// SimplifyPartiallyRedundantLoad - If LoadI is an obviously partially +/// simplifyPartiallyRedundantLoad - If LoadI is an obviously partially /// redundant load instruction, eliminate it by replacing it with a PHI node. /// This is an important optimization that encourages jump threading, and needs /// to be run interlaced with other jump threading tasks. -bool JumpThreadingPass::SimplifyPartiallyRedundantLoad(LoadInst *LoadI) { +bool JumpThreadingPass::simplifyPartiallyRedundantLoad(LoadInst *LoadI) { // Don't hack volatile and ordered loads. if (!LoadI->isUnordered()) return false; @@ -1445,7 +1445,7 @@ bool JumpThreadingPass::SimplifyPartiallyRedundantLoad(LoadInst *LoadI) { } // Split them out to their own block. - UnavailablePred = SplitBlockPreds(LoadBB, PredsToSplit, "thread-pre-split"); + UnavailablePred = splitBlockPreds(LoadBB, PredsToSplit, "thread-pre-split"); } // If the value isn't available in all predecessors, then there will be @@ -1509,11 +1509,11 @@ bool JumpThreadingPass::SimplifyPartiallyRedundantLoad(LoadInst *LoadI) { return true; } -/// FindMostPopularDest - The specified list contains multiple possible +/// findMostPopularDest - The specified list contains multiple possible /// threadable destinations. Pick the one that occurs the most frequently in /// the list. static BasicBlock * -FindMostPopularDest(BasicBlock *BB, +findMostPopularDest(BasicBlock *BB, const SmallVectorImpl> &PredToDestList) { assert(!PredToDestList.empty()); @@ -1548,7 +1548,7 @@ FindMostPopularDest(BasicBlock *BB, // Try to evaluate the value of V when the control flows from PredPredBB to // BB->getSinglePredecessor() and then on to BB. -Constant *JumpThreadingPass::EvaluateOnPredecessorEdge(BasicBlock *BB, +Constant *JumpThreadingPass::evaluateOnPredecessorEdge(BasicBlock *BB, BasicBlock *PredPredBB, Value *V) { BasicBlock *PredBB = BB->getSinglePredecessor(); @@ -1575,9 +1575,9 @@ Constant *JumpThreadingPass::EvaluateOnPredecessorEdge(BasicBlock *BB, if (CmpInst *CondCmp = dyn_cast(V)) { if (CondCmp->getParent() == BB) { Constant *Op0 = - EvaluateOnPredecessorEdge(BB, PredPredBB, CondCmp->getOperand(0)); + evaluateOnPredecessorEdge(BB, PredPredBB, CondCmp->getOperand(0)); Constant *Op1 = - EvaluateOnPredecessorEdge(BB, PredPredBB, CondCmp->getOperand(1)); + evaluateOnPredecessorEdge(BB, PredPredBB, CondCmp->getOperand(1)); if (Op0 && Op1) { return ConstantExpr::getCompare(CondCmp->getPredicate(), Op0, Op1); } @@ -1588,7 +1588,7 @@ Constant *JumpThreadingPass::EvaluateOnPredecessorEdge(BasicBlock *BB, return nullptr; } -bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock *BB, +bool JumpThreadingPass::processThreadableEdges(Value *Cond, BasicBlock *BB, ConstantPreference Preference, Instruction *CxtI) { // If threading this would thread across a loop header, don't even try to @@ -1597,15 +1597,15 @@ bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock *BB, return false; PredValueInfoTy PredValues; - if (!ComputeValueKnownInPredecessors(Cond, BB, PredValues, Preference, + if (!computeValueKnownInPredecessors(Cond, BB, PredValues, Preference, CxtI)) { // We don't have known values in predecessors. See if we can thread through // BB and its sole predecessor. - return MaybeThreadThroughTwoBasicBlocks(BB, Cond); + return maybethreadThroughTwoBasicBlocks(BB, Cond); } assert(!PredValues.empty() && - "ComputeValueKnownInPredecessors returned true with no values"); + "computeValueKnownInPredecessors returned true with no values"); LLVM_DEBUG(dbgs() << "IN BB: " << *BB; for (const auto &PredValue : PredValues) { @@ -1712,7 +1712,7 @@ bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock *BB, // guard/assume. else if (OnlyVal && OnlyVal != MultipleVal && CondInst->getParent() == BB) - ReplaceFoldableUses(CondInst, OnlyVal); + replaceFoldableUses(CondInst, OnlyVal); } return true; } @@ -1725,7 +1725,7 @@ bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock *BB, BasicBlock *MostPopularDest = OnlyDest; if (MostPopularDest == MultipleDestSentinel) { - // Remove any loop headers from the Dest list, ThreadEdge conservatively + // Remove any loop headers from the Dest list, threadEdge conservatively // won't process them, but we might have other destination that are eligible // and we still want to process. erase_if(PredToDestList, @@ -1736,7 +1736,7 @@ bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock *BB, if (PredToDestList.empty()) return false; - MostPopularDest = FindMostPopularDest(BB, PredToDestList); + MostPopularDest = findMostPopularDest(BB, PredToDestList); } // Now that we know what the most popular destination is, factor all @@ -1758,16 +1758,16 @@ bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock *BB, // the destination that these predecessors should get to. if (!MostPopularDest) MostPopularDest = BB->getTerminator()-> - getSuccessor(GetBestDestForJumpOnUndef(BB)); + getSuccessor(getBestDestForJumpOnUndef(BB)); // Ok, try to thread it! - return TryThreadEdge(BB, PredsToFactor, MostPopularDest); + return tryThreadEdge(BB, PredsToFactor, MostPopularDest); } -/// ProcessBranchOnPHI - We have an otherwise unthreadable conditional branch on +/// processBranchOnPHI - We have an otherwise unthreadable conditional branch on /// a PHI node (or freeze PHI) in the current block. See if there are any /// simplifications we can do based on inputs to the phi node. -bool JumpThreadingPass::ProcessBranchOnPHI(PHINode *PN) { +bool JumpThreadingPass::processBranchOnPHI(PHINode *PN) { BasicBlock *BB = PN->getParent(); // TODO: We could make use of this to do it once for blocks with common PHI @@ -1788,7 +1788,7 @@ bool JumpThreadingPass::ProcessBranchOnPHI(PHINode *PN) { if (PredBr->isUnconditional()) { PredBBs[0] = PredBB; // Try to duplicate BB into PredBB. - if (DuplicateCondBranchOnPHIIntoPred(BB, PredBBs)) + if (duplicateCondBranchOnPHIIntoPred(BB, PredBBs)) return true; } } @@ -1796,10 +1796,10 @@ bool JumpThreadingPass::ProcessBranchOnPHI(PHINode *PN) { return false; } -/// ProcessBranchOnXOR - We have an otherwise unthreadable conditional branch on +/// processBranchOnXOR - We have an otherwise unthreadable conditional branch on /// a xor instruction in the current block. See if there are any /// simplifications we can do based on inputs to the xor. -bool JumpThreadingPass::ProcessBranchOnXOR(BinaryOperator *BO) { +bool JumpThreadingPass::processBranchOnXOR(BinaryOperator *BO) { BasicBlock *BB = BO->getParent(); // If either the LHS or RHS of the xor is a constant, don't do this @@ -1837,17 +1837,17 @@ bool JumpThreadingPass::ProcessBranchOnXOR(BinaryOperator *BO) { PredValueInfoTy XorOpValues; bool isLHS = true; - if (!ComputeValueKnownInPredecessors(BO->getOperand(0), BB, XorOpValues, + if (!computeValueKnownInPredecessors(BO->getOperand(0), BB, XorOpValues, WantInteger, BO)) { assert(XorOpValues.empty()); - if (!ComputeValueKnownInPredecessors(BO->getOperand(1), BB, XorOpValues, + if (!computeValueKnownInPredecessors(BO->getOperand(1), BB, XorOpValues, WantInteger, BO)) return false; isLHS = false; } assert(!XorOpValues.empty() && - "ComputeValueKnownInPredecessors returned true with no values"); + "computeValueKnownInPredecessors returned true with no values"); // Scan the information to see which is most popular: true or false. The // predecessors can be of the set true, false, or undef. @@ -1908,13 +1908,13 @@ bool JumpThreadingPass::ProcessBranchOnXOR(BinaryOperator *BO) { return false; // Try to duplicate BB into PredBB. - return DuplicateCondBranchOnPHIIntoPred(BB, BlocksToFoldInto); + return duplicateCondBranchOnPHIIntoPred(BB, BlocksToFoldInto); } -/// AddPHINodeEntriesForMappedBlock - We're adding 'NewPred' as a new +/// addPHINodeEntriesForMappedBlock - We're adding 'NewPred' as a new /// predecessor to the PHIBB block. If it has PHI nodes, add entries for /// NewPred using the entries from OldPred (suitably mapped). -static void AddPHINodeEntriesForMappedBlock(BasicBlock *PHIBB, +static void addPHINodeEntriesForMappedBlock(BasicBlock *PHIBB, BasicBlock *OldPred, BasicBlock *NewPred, DenseMap &ValueMap) { @@ -1935,7 +1935,7 @@ static void AddPHINodeEntriesForMappedBlock(BasicBlock *PHIBB, } /// Merge basic block BB into its sole predecessor if possible. -bool JumpThreadingPass::MaybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB) { +bool JumpThreadingPass::maybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB) { BasicBlock *SinglePred = BB->getSinglePredecessor(); if (!SinglePred) return false; @@ -1986,7 +1986,7 @@ bool JumpThreadingPass::MaybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB) { /// Update the SSA form. NewBB contains instructions that are copied from BB. /// ValueMapping maps old values in BB to new ones in NewBB. -void JumpThreadingPass::UpdateSSA( +void JumpThreadingPass::updateSSA( BasicBlock *BB, BasicBlock *NewBB, DenseMap &ValueMapping) { // If there were values defined in BB that are used outside the block, then we @@ -2032,7 +2032,7 @@ void JumpThreadingPass::UpdateSSA( /// arguments that come from PredBB. Return the map from the variables in the /// source basic block to the variables in the newly created basic block. DenseMap -JumpThreadingPass::CloneInstructions(BasicBlock::iterator BI, +JumpThreadingPass::cloneInstructions(BasicBlock::iterator BI, BasicBlock::iterator BE, BasicBlock *NewBB, BasicBlock *PredBB) { // We are going to have to map operands from the source basic block to the new @@ -2071,7 +2071,7 @@ JumpThreadingPass::CloneInstructions(BasicBlock::iterator BI, } /// Attempt to thread through two successive basic blocks. -bool JumpThreadingPass::MaybeThreadThroughTwoBasicBlocks(BasicBlock *BB, +bool JumpThreadingPass::maybethreadThroughTwoBasicBlocks(BasicBlock *BB, Value *Cond) { // Consider: // @@ -2140,7 +2140,7 @@ bool JumpThreadingPass::MaybeThreadThroughTwoBasicBlocks(BasicBlock *BB, BasicBlock *OnePred = nullptr; for (BasicBlock *P : predecessors(PredBB)) { if (ConstantInt *CI = dyn_cast_or_null( - EvaluateOnPredecessorEdge(BB, P, Cond))) { + evaluateOnPredecessorEdge(BB, P, Cond))) { if (CI->isZero()) { ZeroCount++; ZeroPred = P; @@ -2171,7 +2171,7 @@ bool JumpThreadingPass::MaybeThreadThroughTwoBasicBlocks(BasicBlock *BB, } // If threading this would thread across a loop header, don't thread the edge. - // See the comments above FindLoopHeaders for justifications and caveats. + // See the comments above findLoopHeaders for justifications and caveats. if (LoopHeaders.count(BB) || LoopHeaders.count(SuccBB)) { LLVM_DEBUG({ bool BBIsHeader = LoopHeaders.count(BB); @@ -2204,11 +2204,11 @@ bool JumpThreadingPass::MaybeThreadThroughTwoBasicBlocks(BasicBlock *BB, } // Now we are ready to duplicate PredBB. - ThreadThroughTwoBasicBlocks(PredPredBB, PredBB, BB, SuccBB); + threadThroughTwoBasicBlocks(PredPredBB, PredBB, BB, SuccBB); return true; } -void JumpThreadingPass::ThreadThroughTwoBasicBlocks(BasicBlock *PredPredBB, +void JumpThreadingPass::threadThroughTwoBasicBlocks(BasicBlock *PredPredBB, BasicBlock *PredBB, BasicBlock *BB, BasicBlock *SuccBB) { @@ -2234,7 +2234,7 @@ void JumpThreadingPass::ThreadThroughTwoBasicBlocks(BasicBlock *PredPredBB, // copy of the block 'NewBB'. If there are PHI nodes in PredBB, evaluate them // to account for entry from PredPredBB. DenseMap ValueMapping = - CloneInstructions(PredBB->begin(), PredBB->end(), NewBB, PredPredBB); + cloneInstructions(PredBB->begin(), PredBB->end(), NewBB, PredPredBB); // Copy the edge probabilities from PredBB to NewBB. if (HasProfileData) { @@ -2254,9 +2254,9 @@ void JumpThreadingPass::ThreadThroughTwoBasicBlocks(BasicBlock *PredPredBB, PredPredTerm->setSuccessor(i, NewBB); } - AddPHINodeEntriesForMappedBlock(PredBBBranch->getSuccessor(0), PredBB, NewBB, + addPHINodeEntriesForMappedBlock(PredBBBranch->getSuccessor(0), PredBB, NewBB, ValueMapping); - AddPHINodeEntriesForMappedBlock(PredBBBranch->getSuccessor(1), PredBB, NewBB, + addPHINodeEntriesForMappedBlock(PredBBBranch->getSuccessor(1), PredBB, NewBB, ValueMapping); DTU->applyUpdatesPermissive( @@ -2265,7 +2265,7 @@ void JumpThreadingPass::ThreadThroughTwoBasicBlocks(BasicBlock *PredPredBB, {DominatorTree::Insert, PredPredBB, NewBB}, {DominatorTree::Delete, PredPredBB, PredBB}}); - UpdateSSA(PredBB, NewBB, ValueMapping); + updateSSA(PredBB, NewBB, ValueMapping); // Clean up things like PHI nodes with single operands, dead instructions, // etc. @@ -2274,11 +2274,11 @@ void JumpThreadingPass::ThreadThroughTwoBasicBlocks(BasicBlock *PredPredBB, SmallVector PredsToFactor; PredsToFactor.push_back(NewBB); - ThreadEdge(BB, PredsToFactor, SuccBB); + threadEdge(BB, PredsToFactor, SuccBB); } -/// TryThreadEdge - Thread an edge if it's safe and profitable to do so. -bool JumpThreadingPass::TryThreadEdge( +/// tryThreadEdge - Thread an edge if it's safe and profitable to do so. +bool JumpThreadingPass::tryThreadEdge( BasicBlock *BB, const SmallVectorImpl &PredBBs, BasicBlock *SuccBB) { // If threading to the same block as we come from, we would infinite loop. @@ -2289,7 +2289,7 @@ bool JumpThreadingPass::TryThreadEdge( } // If threading this would thread across a loop header, don't thread the edge. - // See the comments above FindLoopHeaders for justifications and caveats. + // See the comments above findLoopHeaders for justifications and caveats. if (LoopHeaders.count(BB) || LoopHeaders.count(SuccBB)) { LLVM_DEBUG({ bool BBIsHeader = LoopHeaders.count(BB); @@ -2310,14 +2310,14 @@ bool JumpThreadingPass::TryThreadEdge( return false; } - ThreadEdge(BB, PredBBs, SuccBB); + threadEdge(BB, PredBBs, SuccBB); return true; } -/// ThreadEdge - We have decided that it is safe and profitable to factor the +/// threadEdge - We have decided that it is safe and profitable to factor the /// blocks in PredBBs to one predecessor, then thread an edge from it to SuccBB /// across BB. Transform the IR to reflect this change. -void JumpThreadingPass::ThreadEdge(BasicBlock *BB, +void JumpThreadingPass::threadEdge(BasicBlock *BB, const SmallVectorImpl &PredBBs, BasicBlock *SuccBB) { assert(SuccBB != BB && "Don't create an infinite loop"); @@ -2332,7 +2332,7 @@ void JumpThreadingPass::ThreadEdge(BasicBlock *BB, else { LLVM_DEBUG(dbgs() << " Factoring out " << PredBBs.size() << " common predecessors.\n"); - PredBB = SplitBlockPreds(BB, PredBBs, ".thr_comm"); + PredBB = splitBlockPreds(BB, PredBBs, ".thr_comm"); } // And finally, do it! @@ -2356,7 +2356,7 @@ void JumpThreadingPass::ThreadEdge(BasicBlock *BB, // Copy all the instructions from BB to NewBB except the terminator. DenseMap ValueMapping = - CloneInstructions(BB->begin(), std::prev(BB->end()), NewBB, PredBB); + cloneInstructions(BB->begin(), std::prev(BB->end()), NewBB, PredBB); // We didn't copy the terminator from BB over to NewBB, because there is now // an unconditional jump to SuccBB. Insert the unconditional jump. @@ -2365,7 +2365,7 @@ void JumpThreadingPass::ThreadEdge(BasicBlock *BB, // Check to see if SuccBB has PHI nodes. If so, we need to add entries to the // PHI nodes for NewBB now. - AddPHINodeEntriesForMappedBlock(SuccBB, BB, NewBB, ValueMapping); + addPHINodeEntriesForMappedBlock(SuccBB, BB, NewBB, ValueMapping); // Update the terminator of PredBB to jump to NewBB instead of BB. This // eliminates predecessors from BB, which requires us to simplify any PHI @@ -2382,7 +2382,7 @@ void JumpThreadingPass::ThreadEdge(BasicBlock *BB, {DominatorTree::Insert, PredBB, NewBB}, {DominatorTree::Delete, PredBB, BB}}); - UpdateSSA(BB, NewBB, ValueMapping); + updateSSA(BB, NewBB, ValueMapping); // At this point, the IR is fully up to date and consistent. Do a quick scan // over the new instructions and zap any that are constants or dead. This @@ -2390,7 +2390,7 @@ void JumpThreadingPass::ThreadEdge(BasicBlock *BB, SimplifyInstructionsInBlock(NewBB, TLI); // Update the edge weight from BB to SuccBB, which should be less than before. - UpdateBlockFreqAndEdgeWeight(PredBB, BB, NewBB, SuccBB); + updateBlockFreqAndEdgeWeight(PredBB, BB, NewBB, SuccBB); // Threaded an edge! ++NumThreads; @@ -2399,7 +2399,7 @@ void JumpThreadingPass::ThreadEdge(BasicBlock *BB, /// Create a new basic block that will be the predecessor of BB and successor of /// all blocks in Preds. When profile data is available, update the frequency of /// this new block. -BasicBlock *JumpThreadingPass::SplitBlockPreds(BasicBlock *BB, +BasicBlock *JumpThreadingPass::splitBlockPreds(BasicBlock *BB, ArrayRef Preds, const char *Suffix) { SmallVector NewBBs; @@ -2460,7 +2460,7 @@ bool JumpThreadingPass::doesBlockHaveProfileData(BasicBlock *BB) { /// Update the block frequency of BB and branch weight and the metadata on the /// edge BB->SuccBB. This is done by scaling the weight of BB->SuccBB by 1 - /// Freq(PredBB->BB) / Freq(BB->SuccBB). -void JumpThreadingPass::UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB, +void JumpThreadingPass::updateBlockFreqAndEdgeWeight(BasicBlock *PredBB, BasicBlock *BB, BasicBlock *NewBB, BasicBlock *SuccBB) { @@ -2552,18 +2552,18 @@ void JumpThreadingPass::UpdateBlockFreqAndEdgeWeight(BasicBlock *PredBB, } } -/// DuplicateCondBranchOnPHIIntoPred - PredBB contains an unconditional branch +/// duplicateCondBranchOnPHIIntoPred - PredBB contains an unconditional branch /// to BB which contains an i1 PHI node and a conditional branch on that PHI. /// If we can duplicate the contents of BB up into PredBB do so now, this /// improves the odds that the branch will be on an analyzable instruction like /// a compare. -bool JumpThreadingPass::DuplicateCondBranchOnPHIIntoPred( +bool JumpThreadingPass::duplicateCondBranchOnPHIIntoPred( BasicBlock *BB, const SmallVectorImpl &PredBBs) { assert(!PredBBs.empty() && "Can't handle an empty set"); // If BB is a loop header, then duplicating this block outside the loop would // cause us to transform this into an irreducible loop, don't do this. - // See the comments above FindLoopHeaders for justifications and caveats. + // See the comments above findLoopHeaders for justifications and caveats. if (LoopHeaders.count(BB)) { LLVM_DEBUG(dbgs() << " Not duplicating loop header '" << BB->getName() << "' into predecessor block '" << PredBBs[0]->getName() @@ -2587,7 +2587,7 @@ bool JumpThreadingPass::DuplicateCondBranchOnPHIIntoPred( else { LLVM_DEBUG(dbgs() << " Factoring out " << PredBBs.size() << " common predecessors.\n"); - PredBB = SplitBlockPreds(BB, PredBBs, ".thr_comm"); + PredBB = splitBlockPreds(BB, PredBBs, ".thr_comm"); } Updates.push_back({DominatorTree::Delete, PredBB, BB}); @@ -2659,12 +2659,12 @@ bool JumpThreadingPass::DuplicateCondBranchOnPHIIntoPred( // Check to see if the targets of the branch had PHI nodes. If so, we need to // add entries to the PHI nodes for branch from PredBB now. BranchInst *BBBranch = cast(BB->getTerminator()); - AddPHINodeEntriesForMappedBlock(BBBranch->getSuccessor(0), BB, PredBB, + addPHINodeEntriesForMappedBlock(BBBranch->getSuccessor(0), BB, PredBB, ValueMapping); - AddPHINodeEntriesForMappedBlock(BBBranch->getSuccessor(1), BB, PredBB, + addPHINodeEntriesForMappedBlock(BBBranch->getSuccessor(1), BB, PredBB, ValueMapping); - UpdateSSA(BB, PredBB, ValueMapping); + updateSSA(BB, PredBB, ValueMapping); // PredBB no longer jumps to BB, remove entries in the PHI node for the edge // that we nuked. @@ -2683,7 +2683,7 @@ bool JumpThreadingPass::DuplicateCondBranchOnPHIIntoPred( // a PHI node in BB. SI has no other use. // A new basic block, NewBB, is created and SI is converted to compare and // conditional branch. SI is erased from parent. -void JumpThreadingPass::UnfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, +void JumpThreadingPass::unfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, SelectInst *SI, PHINode *SIUse, unsigned Idx) { // Expand the select. @@ -2718,7 +2718,7 @@ void JumpThreadingPass::UnfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, Phi->addIncoming(Phi->getIncomingValueForBlock(Pred), NewBB); } -bool JumpThreadingPass::TryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB) { +bool JumpThreadingPass::tryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB) { PHINode *CondPHI = dyn_cast(SI->getCondition()); if (!CondPHI || CondPHI->getParent() != BB) @@ -2730,7 +2730,7 @@ bool JumpThreadingPass::TryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB) { // The second and third condition can be potentially relaxed. Currently // the conditions help to simplify the code and allow us to reuse existing - // code, developed for TryToUnfoldSelect(CmpInst *, BasicBlock *) + // code, developed for tryToUnfoldSelect(CmpInst *, BasicBlock *) if (!PredSI || PredSI->getParent() != Pred || !PredSI->hasOneUse()) continue; @@ -2738,13 +2738,13 @@ bool JumpThreadingPass::TryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB) { if (!PredTerm || !PredTerm->isUnconditional()) continue; - UnfoldSelectInstr(Pred, BB, PredSI, CondPHI, I); + unfoldSelectInstr(Pred, BB, PredSI, CondPHI, I); return true; } return false; } -/// TryToUnfoldSelect - Look for blocks of the form +/// tryToUnfoldSelect - Look for blocks of the form /// bb1: /// %a = select /// br bb2 @@ -2756,7 +2756,7 @@ bool JumpThreadingPass::TryToUnfoldSelect(SwitchInst *SI, BasicBlock *BB) { /// /// And expand the select into a branch structure if one of its arms allows %c /// to be folded. This later enables threading from bb1 over bb2. -bool JumpThreadingPass::TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB) { +bool JumpThreadingPass::tryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB) { BranchInst *CondBr = dyn_cast(BB->getTerminator()); PHINode *CondLHS = dyn_cast(CondCmp->getOperand(0)); Constant *CondRHS = cast(CondCmp->getOperand(1)); @@ -2790,14 +2790,14 @@ bool JumpThreadingPass::TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB) { if ((LHSFolds != LazyValueInfo::Unknown || RHSFolds != LazyValueInfo::Unknown) && LHSFolds != RHSFolds) { - UnfoldSelectInstr(Pred, BB, SI, CondLHS, I); + unfoldSelectInstr(Pred, BB, SI, CondLHS, I); return true; } } return false; } -/// TryToUnfoldSelectInCurrBB - Look for PHI/Select or PHI/CMP/Select in the +/// tryToUnfoldSelectInCurrBB - Look for PHI/Select or PHI/CMP/Select in the /// same BB in the form /// bb: /// %p = phi [false, %bb1], [true, %bb2], [false, %bb3], [true, %bb4], ... @@ -2817,14 +2817,14 @@ bool JumpThreadingPass::TryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB) { /// select if the associated PHI has at least one constant. If the unfolded /// select is not jump-threaded, it will be folded again in the later /// optimizations. -bool JumpThreadingPass::TryToUnfoldSelectInCurrBB(BasicBlock *BB) { +bool JumpThreadingPass::tryToUnfoldSelectInCurrBB(BasicBlock *BB) { // This transform would reduce the quality of msan diagnostics. // Disable this transform under MemorySanitizer. if (BB->getParent()->hasFnAttribute(Attribute::SanitizeMemory)) return false; // If threading this would thread across a loop header, don't thread the edge. - // See the comments above FindLoopHeaders for justifications and caveats. + // See the comments above findLoopHeaders for justifications and caveats. if (LoopHeaders.count(BB)) return false; @@ -2916,7 +2916,7 @@ bool JumpThreadingPass::TryToUnfoldSelectInCurrBB(BasicBlock *BB) { /// And cond either implies condGuard or !condGuard. In this case all the /// instructions before the guard can be duplicated in both branches, and the /// guard is then threaded to one of them. -bool JumpThreadingPass::ProcessGuards(BasicBlock *BB) { +bool JumpThreadingPass::processGuards(BasicBlock *BB) { using namespace PatternMatch; // We only want to deal with two predecessors. @@ -2941,7 +2941,7 @@ bool JumpThreadingPass::ProcessGuards(BasicBlock *BB) { if (auto *BI = dyn_cast(Parent->getTerminator())) for (auto &I : *BB) - if (isGuard(&I) && ThreadGuard(BB, cast(&I), BI)) + if (isGuard(&I) && threadGuard(BB, cast(&I), BI)) return true; return false; @@ -2950,7 +2950,7 @@ bool JumpThreadingPass::ProcessGuards(BasicBlock *BB) { /// Try to propagate the guard from BB which is the lower block of a diamond /// to one of its branches, in case if diamond's condition implies guard's /// condition. -bool JumpThreadingPass::ThreadGuard(BasicBlock *BB, IntrinsicInst *Guard, +bool JumpThreadingPass::threadGuard(BasicBlock *BB, IntrinsicInst *Guard, BranchInst *BI) { assert(BI->getNumSuccessors() == 2 && "Wrong number of successors?"); assert(BI->isConditional() && "Unconditional branch has 2 successors?"); -- 2.7.4