[llvm] 60054dc - [NFC] Lowercase the first letter of functions defined in SimplifyCFG.cpp
Shengchen Kan via llvm-commits
llvm-commits at lists.llvm.org
Fri Aug 2 08:55:11 PDT 2024
Author: Shengchen Kan
Date: 2024-08-02T23:54:40+08:00
New Revision: 60054dcd81d027db72b9ef305184e97c55465458
URL: https://github.com/llvm/llvm-project/commit/60054dcd81d027db72b9ef305184e97c55465458
DIFF: https://github.com/llvm/llvm-project/commit/60054dcd81d027db72b9ef305184e97c55465458.diff
LOG: [NFC] Lowercase the first letter of functions defined in SimplifyCFG.cpp
Added:
Modified:
llvm/include/llvm/Transforms/Utils/Local.h
llvm/lib/Transforms/Utils/LoopSimplify.cpp
llvm/lib/Transforms/Utils/SimplifyCFG.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Transforms/Utils/Local.h b/llvm/include/llvm/Transforms/Utils/Local.h
index 6937ec8dfd21c..b17ff6539a25a 100644
--- a/llvm/include/llvm/Transforms/Utils/Local.h
+++ b/llvm/include/llvm/Transforms/Utils/Local.h
@@ -195,7 +195,7 @@ bool FlattenCFG(BasicBlock *BB, AAResults *AA = nullptr);
/// If this basic block is ONLY a setcc and a branch, and if a predecessor
/// branches to us and one of our successors, fold the setcc into the
/// predecessor and use logical operations to pick the right destination.
-bool FoldBranchToCommonDest(BranchInst *BI, llvm::DomTreeUpdater *DTU = nullptr,
+bool foldBranchToCommonDest(BranchInst *BI, llvm::DomTreeUpdater *DTU = nullptr,
MemorySSAUpdater *MSSAU = nullptr,
const TargetTransformInfo *TTI = nullptr,
unsigned BonusInstThreshold = 1);
diff --git a/llvm/lib/Transforms/Utils/LoopSimplify.cpp b/llvm/lib/Transforms/Utils/LoopSimplify.cpp
index a764fef574911..2b2f82fb47cf7 100644
--- a/llvm/lib/Transforms/Utils/LoopSimplify.cpp
+++ b/llvm/lib/Transforms/Utils/LoopSimplify.cpp
@@ -659,7 +659,7 @@ static bool simplifyOneLoop(Loop *L, SmallVectorImpl<Loop *> &Worklist,
// The block has now been cleared of all instructions except for
// a comparison and a conditional branch. SimplifyCFG may be able
// to fold it now.
- if (!FoldBranchToCommonDest(BI, /*DTU=*/nullptr, MSSAU))
+ if (!foldBranchToCommonDest(BI, /*DTU=*/nullptr, MSSAU))
continue;
// Success. The block is now dead, so remove it from the loop,
diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
index f23e28888931d..a89cc9cd11d4d 100644
--- a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -246,15 +246,15 @@ class SimplifyCFGOpt {
bool Resimplify;
Value *isValueEqualityComparison(Instruction *TI);
- BasicBlock *GetValueEqualityComparisonCases(
+ BasicBlock *getValueEqualityComparisonCases(
Instruction *TI, std::vector<ValueEqualityComparisonCase> &Cases);
- bool SimplifyEqualityComparisonWithOnlyPredecessor(Instruction *TI,
+ bool simplifyEqualityComparisonWithOnlyPredecessor(Instruction *TI,
BasicBlock *Pred,
IRBuilder<> &Builder);
- bool PerformValueComparisonIntoPredecessorFolding(Instruction *TI, Value *&CV,
+ bool performValueComparisonIntoPredecessorFolding(Instruction *TI, Value *&CV,
Instruction *PTI,
IRBuilder<> &Builder);
- bool FoldValueComparisonIntoPredecessors(Instruction *TI,
+ bool foldValueComparisonIntoPredecessors(Instruction *TI,
IRBuilder<> &Builder);
bool simplifyResume(ResumeInst *RI, IRBuilder<> &Builder);
@@ -275,15 +275,15 @@ class SimplifyCFGOpt {
bool hoistSuccIdenticalTerminatorToSwitchOrIf(
Instruction *TI, Instruction *I1,
SmallVectorImpl<Instruction *> &OtherSuccTIs);
- bool SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *ThenBB);
- bool SimplifyTerminatorOnSelect(Instruction *OldTerm, Value *Cond,
+ bool speculativelyExecuteBB(BranchInst *BI, BasicBlock *ThenBB);
+ bool simplifyTerminatorOnSelect(Instruction *OldTerm, Value *Cond,
BasicBlock *TrueBB, BasicBlock *FalseBB,
uint32_t TrueWeight, uint32_t FalseWeight);
- bool SimplifyBranchOnICmpChain(BranchInst *BI, IRBuilder<> &Builder,
+ bool simplifyBranchOnICmpChain(BranchInst *BI, IRBuilder<> &Builder,
const DataLayout &DL);
- bool SimplifySwitchOnSelect(SwitchInst *SI, SelectInst *Select);
- bool SimplifyIndirectBrOnSelect(IndirectBrInst *IBI, SelectInst *SI);
- bool TurnSwitchRangeIntoICmp(SwitchInst *SI, IRBuilder<> &Builder);
+ bool simplifySwitchOnSelect(SwitchInst *SI, SelectInst *Select);
+ bool simplifyIndirectBrOnSelect(IndirectBrInst *IBI, SelectInst *SI);
+ bool turnSwitchRangeIntoICmp(SwitchInst *SI, IRBuilder<> &Builder);
public:
SimplifyCFGOpt(const TargetTransformInfo &TTI, DomTreeUpdater *DTU,
@@ -314,7 +314,7 @@ class SimplifyCFGOpt {
/// Note that if the values aren't exactly identical, but \p EquivalenceSet
/// is provided, and *both* of the values are present in the set,
/// then they are considered equal.
-static bool IncomingValuesAreCompatible(
+static bool incomingValuesAreCompatible(
BasicBlock *BB, ArrayRef<BasicBlock *> IncomingBlocks,
SmallPtrSetImpl<Value *> *EquivalenceSet = nullptr) {
assert(IncomingBlocks.size() == 2 &&
@@ -338,7 +338,7 @@ static bool IncomingValuesAreCompatible(
/// Return true if it is safe to merge these two
/// terminator instructions together.
static bool
-SafeToMergeTerminators(Instruction *SI1, Instruction *SI2,
+safeToMergeTerminators(Instruction *SI1, Instruction *SI2,
SmallSetVector<BasicBlock *, 4> *FailBlocks = nullptr) {
if (SI1 == SI2)
return false; // Can't merge with self!
@@ -354,7 +354,7 @@ SafeToMergeTerminators(Instruction *SI1, Instruction *SI2,
for (BasicBlock *Succ : successors(SI2BB)) {
if (!SI1Succs.count(Succ))
continue;
- if (IncomingValuesAreCompatible(Succ, {SI1BB, SI2BB}))
+ if (incomingValuesAreCompatible(Succ, {SI1BB, SI2BB}))
continue;
Fail = true;
if (FailBlocks)
@@ -370,7 +370,7 @@ SafeToMergeTerminators(Instruction *SI1, Instruction *SI2,
/// from the 'NewPred' block. The values that will be flowing into the PHI nodes
/// will be the same as those coming in from ExistPred, an existing predecessor
/// of Succ.
-static void AddPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred,
+static void addPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred,
BasicBlock *ExistPred,
MemorySSAUpdater *MSSAU = nullptr) {
for (PHINode &PN : Succ->phis())
@@ -478,7 +478,7 @@ static bool dominatesMergePoint(Value *V, BasicBlock *BB,
/// Extract ConstantInt from value, looking through IntToPtr
/// and PointerNullValue. Return NULL if value is not a constant int.
-static ConstantInt *GetConstantInt(Value *V, const DataLayout &DL) {
+static ConstantInt *getConstantInt(Value *V, const DataLayout &DL) {
// Normal constant int.
ConstantInt *CI = dyn_cast<ConstantInt>(V);
if (CI || !isa<Constant>(V) || !V->getType()->isPointerTy() ||
@@ -565,7 +565,7 @@ struct ConstantComparesGatherer {
ICmpInst *ICI;
ConstantInt *C;
if (!((ICI = dyn_cast<ICmpInst>(I)) &&
- (C = GetConstantInt(I->getOperand(1), DL)))) {
+ (C = getConstantInt(I->getOperand(1), DL)))) {
return false;
}
@@ -753,7 +753,7 @@ struct ConstantComparesGatherer {
} // end anonymous namespace
-static void EraseTerminatorAndDCECond(Instruction *TI,
+static void eraseTerminatorAndDCECond(Instruction *TI,
MemorySSAUpdater *MSSAU = nullptr) {
Instruction *Cond = nullptr;
if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
@@ -782,7 +782,7 @@ Value *SimplifyCFGOpt::isValueEqualityComparison(Instruction *TI) {
} else if (BranchInst *BI = dyn_cast<BranchInst>(TI))
if (BI->isConditional() && BI->getCondition()->hasOneUse())
if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) {
- if (ICI->isEquality() && GetConstantInt(ICI->getOperand(1), DL))
+ if (ICI->isEquality() && getConstantInt(ICI->getOperand(1), DL))
CV = ICI->getOperand(0);
}
@@ -799,7 +799,7 @@ Value *SimplifyCFGOpt::isValueEqualityComparison(Instruction *TI) {
/// Given a value comparison instruction,
/// decode all of the 'cases' that it represents and return the 'default' block.
-BasicBlock *SimplifyCFGOpt::GetValueEqualityComparisonCases(
+BasicBlock *SimplifyCFGOpt::getValueEqualityComparisonCases(
Instruction *TI, std::vector<ValueEqualityComparisonCase> &Cases) {
if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
Cases.reserve(SI->getNumCases());
@@ -813,20 +813,20 @@ BasicBlock *SimplifyCFGOpt::GetValueEqualityComparisonCases(
ICmpInst *ICI = cast<ICmpInst>(BI->getCondition());
BasicBlock *Succ = BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_NE);
Cases.push_back(ValueEqualityComparisonCase(
- GetConstantInt(ICI->getOperand(1), DL), Succ));
+ getConstantInt(ICI->getOperand(1), DL), Succ));
return BI->getSuccessor(ICI->getPredicate() == ICmpInst::ICMP_EQ);
}
/// Given a vector of bb/value pairs, remove any entries
/// in the list that match the specified block.
static void
-EliminateBlockCases(BasicBlock *BB,
+eliminateBlockCases(BasicBlock *BB,
std::vector<ValueEqualityComparisonCase> &Cases) {
llvm::erase(Cases, BB);
}
/// Return true if there are any keys in C1 that exist in C2 as well.
-static bool ValuesOverlap(std::vector<ValueEqualityComparisonCase> &C1,
+static bool valuesOverlap(std::vector<ValueEqualityComparisonCase> &C1,
std::vector<ValueEqualityComparisonCase> &C2) {
std::vector<ValueEqualityComparisonCase> *V1 = &C1, *V2 = &C2;
@@ -891,7 +891,7 @@ static void setBranchWeights(Instruction *I, uint32_t TrueWeight,
/// also a value comparison with the same value, and if that comparison
/// determines the outcome of this comparison. If so, simplify TI. This does a
/// very limited form of jump threading.
-bool SimplifyCFGOpt::SimplifyEqualityComparisonWithOnlyPredecessor(
+bool SimplifyCFGOpt::simplifyEqualityComparisonWithOnlyPredecessor(
Instruction *TI, BasicBlock *Pred, IRBuilder<> &Builder) {
Value *PredVal = isValueEqualityComparison(Pred->getTerminator());
if (!PredVal)
@@ -903,18 +903,18 @@ bool SimplifyCFGOpt::SimplifyEqualityComparisonWithOnlyPredecessor(
return false; // Different predicates.
// TODO: Preserve branch weight metadata, similarly to how
- // FoldValueComparisonIntoPredecessors preserves it.
+ // foldValueComparisonIntoPredecessors preserves it.
// Find out information about when control will move from Pred to TI's block.
std::vector<ValueEqualityComparisonCase> PredCases;
BasicBlock *PredDef =
- GetValueEqualityComparisonCases(Pred->getTerminator(), PredCases);
- EliminateBlockCases(PredDef, PredCases); // Remove default from cases.
+ getValueEqualityComparisonCases(Pred->getTerminator(), PredCases);
+ eliminateBlockCases(PredDef, PredCases); // Remove default from cases.
// Find information about how control leaves this block.
std::vector<ValueEqualityComparisonCase> ThisCases;
- BasicBlock *ThisDef = GetValueEqualityComparisonCases(TI, ThisCases);
- EliminateBlockCases(ThisDef, ThisCases); // Remove default from cases.
+ BasicBlock *ThisDef = getValueEqualityComparisonCases(TI, ThisCases);
+ eliminateBlockCases(ThisDef, ThisCases); // Remove default from cases.
// If TI's block is the default block from Pred's comparison, potentially
// simplify TI based on this knowledge.
@@ -922,7 +922,7 @@ bool SimplifyCFGOpt::SimplifyEqualityComparisonWithOnlyPredecessor(
// If we are here, we know that the value is none of those cases listed in
// PredCases. If there are any cases in ThisCases that are in PredCases, we
// can simplify TI.
- if (!ValuesOverlap(PredCases, ThisCases))
+ if (!valuesOverlap(PredCases, ThisCases))
return false;
if (isa<BranchInst>(TI)) {
@@ -940,7 +940,7 @@ bool SimplifyCFGOpt::SimplifyEqualityComparisonWithOnlyPredecessor(
<< "Through successor TI: " << *TI << "Leaving: " << *NI
<< "\n");
- EraseTerminatorAndDCECond(TI);
+ eraseTerminatorAndDCECond(TI);
if (DTU)
DTU->applyUpdates(
@@ -1029,7 +1029,7 @@ bool SimplifyCFGOpt::SimplifyEqualityComparisonWithOnlyPredecessor(
<< "Through successor TI: " << *TI << "Leaving: " << *NI
<< "\n");
- EraseTerminatorAndDCECond(TI);
+ eraseTerminatorAndDCECond(TI);
if (DTU) {
SmallVector<DominatorTree::UpdateType, 2> Updates;
Updates.reserve(RemovedSuccs.size());
@@ -1053,7 +1053,7 @@ struct ConstantIntOrdering {
} // end anonymous namespace
-static int ConstantIntSortPredicate(ConstantInt *const *P1,
+static int constantIntSortPredicate(ConstantInt *const *P1,
ConstantInt *const *P2) {
const ConstantInt *LHS = *P1;
const ConstantInt *RHS = *P2;
@@ -1065,7 +1065,7 @@ static int ConstantIntSortPredicate(ConstantInt *const *P1,
/// Get Weights of a given terminator, the default weight is at the front
/// of the vector. If TI is a conditional eq, we need to swap the branch-weight
/// metadata.
-static void GetBranchWeights(Instruction *TI,
+static void getBranchWeights(Instruction *TI,
SmallVectorImpl<uint64_t> &Weights) {
MDNode *MD = TI->getMetadata(LLVMContext::MD_prof);
assert(MD && "Invalid branch-weight metadata");
@@ -1083,7 +1083,7 @@ static void GetBranchWeights(Instruction *TI,
}
/// Keep halving the weights until all can fit in uint32_t.
-static void FitWeights(MutableArrayRef<uint64_t> Weights) {
+static void fitWeights(MutableArrayRef<uint64_t> Weights) {
uint64_t Max = *llvm::max_element(Weights);
if (Max > UINT_MAX) {
unsigned Offset = 32 - llvm::countl_zero(Max);
@@ -1092,7 +1092,7 @@ static void FitWeights(MutableArrayRef<uint64_t> Weights) {
}
}
-static void CloneInstructionsIntoPredecessorBlockAndUpdateSSAUses(
+static void cloneInstructionsIntoPredecessorBlockAndUpdateSSAUses(
BasicBlock *BB, BasicBlock *PredBlock, ValueToValueMapTy &VMap) {
Instruction *PTI = PredBlock->getTerminator();
@@ -1160,7 +1160,7 @@ static void CloneInstructionsIntoPredecessorBlockAndUpdateSSAUses(
}
}
-bool SimplifyCFGOpt::PerformValueComparisonIntoPredecessorFolding(
+bool SimplifyCFGOpt::performValueComparisonIntoPredecessorFolding(
Instruction *TI, Value *&CV, Instruction *PTI, IRBuilder<> &Builder) {
BasicBlock *BB = TI->getParent();
BasicBlock *Pred = PTI->getParent();
@@ -1169,10 +1169,10 @@ bool SimplifyCFGOpt::PerformValueComparisonIntoPredecessorFolding(
// Figure out which 'cases' to copy from SI to PSI.
std::vector<ValueEqualityComparisonCase> BBCases;
- BasicBlock *BBDefault = GetValueEqualityComparisonCases(TI, BBCases);
+ BasicBlock *BBDefault = getValueEqualityComparisonCases(TI, BBCases);
std::vector<ValueEqualityComparisonCase> PredCases;
- BasicBlock *PredDefault = GetValueEqualityComparisonCases(PTI, PredCases);
+ BasicBlock *PredDefault = getValueEqualityComparisonCases(PTI, PredCases);
// Based on whether the default edge from PTI goes to BB or not, fill in
// PredCases and PredDefault with the new switch cases we would like to
@@ -1185,7 +1185,7 @@ bool SimplifyCFGOpt::PerformValueComparisonIntoPredecessorFolding(
bool SuccHasWeights = hasBranchWeightMD(*TI);
if (PredHasWeights) {
- GetBranchWeights(PTI, Weights);
+ getBranchWeights(PTI, Weights);
// branch-weight metadata is inconsistent here.
if (Weights.size() != 1 + PredCases.size())
PredHasWeights = SuccHasWeights = false;
@@ -1197,7 +1197,7 @@ bool SimplifyCFGOpt::PerformValueComparisonIntoPredecessorFolding(
SmallVector<uint64_t, 8> SuccWeights;
if (SuccHasWeights) {
- GetBranchWeights(TI, SuccWeights);
+ getBranchWeights(TI, SuccWeights);
// branch-weight metadata is inconsistent here.
if (SuccWeights.size() != 1 + BBCases.size())
PredHasWeights = SuccHasWeights = false;
@@ -1315,7 +1315,7 @@ bool SimplifyCFGOpt::PerformValueComparisonIntoPredecessorFolding(
NewSuccessors) {
for (auto I : seq(NewSuccessor.second)) {
(void)I;
- AddPredecessorToBlock(NewSuccessor.first, Pred, BB);
+ addPredecessorToBlock(NewSuccessor.first, Pred, BB);
}
if (DTU && !SuccsOfPred.contains(NewSuccessor.first))
Updates.push_back({DominatorTree::Insert, Pred, NewSuccessor.first});
@@ -1336,14 +1336,14 @@ bool SimplifyCFGOpt::PerformValueComparisonIntoPredecessorFolding(
if (PredHasWeights || SuccHasWeights) {
// Halve the weights if any of them cannot fit in an uint32_t
- FitWeights(Weights);
+ fitWeights(Weights);
SmallVector<uint32_t, 8> MDWeights(Weights.begin(), Weights.end());
setBranchWeights(NewSI, MDWeights, /*IsExpected=*/false);
}
- EraseTerminatorAndDCECond(PTI);
+ eraseTerminatorAndDCECond(PTI);
// Okay, last check. If BB is still a successor of PSI, then we must
// have an infinite loop case. If so, add an infinitely looping block
@@ -1381,7 +1381,7 @@ bool SimplifyCFGOpt::PerformValueComparisonIntoPredecessorFolding(
/// (either a switch or a branch on "X == c").
/// See if any of the predecessors of the terminator block are value comparisons
/// on the same value. If so, and if safe to do so, fold them together.
-bool SimplifyCFGOpt::FoldValueComparisonIntoPredecessors(Instruction *TI,
+bool SimplifyCFGOpt::foldValueComparisonIntoPredecessors(Instruction *TI,
IRBuilder<> &Builder) {
BasicBlock *BB = TI->getParent();
Value *CV = isValueEqualityComparison(TI); // CondVal
@@ -1404,14 +1404,14 @@ bool SimplifyCFGOpt::FoldValueComparisonIntoPredecessors(Instruction *TI,
continue;
SmallSetVector<BasicBlock *, 4> FailBlocks;
- if (!SafeToMergeTerminators(TI, PTI, &FailBlocks)) {
+ if (!safeToMergeTerminators(TI, PTI, &FailBlocks)) {
for (auto *Succ : FailBlocks) {
if (!SplitBlockPredecessors(Succ, TI->getParent(), ".fold.split", DTU))
return false;
}
}
- PerformValueComparisonIntoPredecessorFolding(TI, CV, PTI, Builder);
+ performValueComparisonIntoPredecessorFolding(TI, CV, PTI, Builder);
Changed = true;
}
return Changed;
@@ -1889,7 +1889,7 @@ bool SimplifyCFGOpt::hoistSuccIdenticalTerminatorToSwitchOrIf(
// Update any PHI nodes in our new successors.
for (BasicBlock *Succ : successors(BB1)) {
- AddPredecessorToBlock(Succ, TIParent, BB1);
+ addPredecessorToBlock(Succ, TIParent, BB1);
if (DTU)
Updates.push_back({DominatorTree::Insert, TIParent, Succ});
}
@@ -1898,7 +1898,7 @@ bool SimplifyCFGOpt::hoistSuccIdenticalTerminatorToSwitchOrIf(
for (BasicBlock *Succ : successors(TI))
Updates.push_back({DominatorTree::Delete, TIParent, Succ});
- EraseTerminatorAndDCECond(TI);
+ eraseTerminatorAndDCECond(TI);
if (DTU)
DTU->applyUpdates(Updates);
return Changed;
@@ -2233,7 +2233,7 @@ namespace {
/// Check whether BB's predecessors end with unconditional branches. If it is
/// true, sink any common code from the predecessors to BB.
-static bool SinkCommonCodeFromPredecessors(BasicBlock *BB,
+static bool sinkCommonCodeFromPredecessors(BasicBlock *BB,
DomTreeUpdater *DTU) {
// We support two situations:
// (1) all incoming arcs are unconditional
@@ -2562,7 +2562,7 @@ bool CompatibleSets::shouldBelongToSameSet(ArrayRef<InvokeInst *> Invokes) {
// In the normal destination, the incoming values for these two `invoke`s
// must be compatible.
SmallPtrSet<Value *, 16> EquivalenceSet(Invokes.begin(), Invokes.end());
- if (!IncomingValuesAreCompatible(
+ if (!incomingValuesAreCompatible(
NormalBB, {Invokes[0]->getParent(), Invokes[1]->getParent()},
&EquivalenceSet))
return false;
@@ -2584,7 +2584,7 @@ bool CompatibleSets::shouldBelongToSameSet(ArrayRef<InvokeInst *> Invokes) {
// In the unwind destination, the incoming values for these two `invoke`s
// must be compatible.
- if (!IncomingValuesAreCompatible(
+ if (!incomingValuesAreCompatible(
Invokes.front()->getUnwindDest(),
{Invokes[0]->getParent(), Invokes[1]->getParent()}))
return false;
@@ -2618,7 +2618,7 @@ bool CompatibleSets::shouldBelongToSameSet(ArrayRef<InvokeInst *> Invokes) {
// Merge all invokes in the provided set, all of which are compatible
// as per the `CompatibleSets::shouldBelongToSameSet()`.
-static void MergeCompatibleInvokesImpl(ArrayRef<InvokeInst *> Invokes,
+static void mergeCompatibleInvokesImpl(ArrayRef<InvokeInst *> Invokes,
DomTreeUpdater *DTU) {
assert(Invokes.size() >= 2 && "Must have at least two invokes to merge.");
@@ -2712,7 +2712,7 @@ static void MergeCompatibleInvokesImpl(ArrayRef<InvokeInst *> Invokes,
// when coming from each of the `invoke`s in the current merge set,
// so update the PHI nodes accordingly.
for (BasicBlock *Succ : successors(MergedInvoke))
- AddPredecessorToBlock(Succ, /*NewPred=*/MergedInvoke->getParent(),
+ addPredecessorToBlock(Succ, /*NewPred=*/MergedInvoke->getParent(),
/*ExistPred=*/Invokes.front()->getParent());
// And finally, replace the original `invoke`s with an unconditional branch
@@ -2763,7 +2763,7 @@ static void MergeCompatibleInvokesImpl(ArrayRef<InvokeInst *> Invokes,
/// But of course we can only do that if the invokes share the `landingpad`,
/// edges invoke0->cont0 and invoke1->cont1 are "compatible",
/// and the invoked functions are "compatible".
-static bool MergeCompatibleInvokes(BasicBlock *BB, DomTreeUpdater *DTU) {
+static bool mergeCompatibleInvokes(BasicBlock *BB, DomTreeUpdater *DTU) {
if (!EnableMergeCompatibleInvokes)
return false;
@@ -2786,7 +2786,7 @@ static bool MergeCompatibleInvokes(BasicBlock *BB, DomTreeUpdater *DTU) {
if (Invokes.size() < 2)
continue;
Changed = true;
- MergeCompatibleInvokesImpl(Invokes, DTU);
+ mergeCompatibleInvokesImpl(Invokes, DTU);
}
return Changed;
@@ -2997,7 +2997,7 @@ static bool validateAndCostRequiredSelects(BasicBlock *BB, BasicBlock *ThenBB,
/// \endcode
///
/// \returns true if the conditional block is removed.
-bool SimplifyCFGOpt::SpeculativelyExecuteBB(BranchInst *BI,
+bool SimplifyCFGOpt::speculativelyExecuteBB(BranchInst *BI,
BasicBlock *ThenBB) {
if (!Options.SpeculateBlocks)
return false;
@@ -3246,7 +3246,7 @@ bool SimplifyCFGOpt::SpeculativelyExecuteBB(BranchInst *BI,
}
/// Return true if we can thread a branch across this block.
-static bool BlockIsSimpleEnoughToThreadThrough(BasicBlock *BB) {
+static bool blockIsSimpleEnoughToThreadThrough(BasicBlock *BB) {
int Size = 0;
EphemeralValueTracker EphTracker;
@@ -3302,7 +3302,7 @@ static ConstantInt *getKnownValueOnEdge(Value *V, BasicBlock *From,
/// value in predecessors (e.g. a phi node in the current block), thread edges
/// from the predecessor to their ultimate destination.
static std::optional<bool>
-FoldCondBranchOnValueKnownInPredecessorImpl(BranchInst *BI, DomTreeUpdater *DTU,
+foldCondBranchOnValueKnownInPredecessorImpl(BranchInst *BI, DomTreeUpdater *DTU,
const DataLayout &DL,
AssumptionCache *AC) {
SmallMapVector<ConstantInt *, SmallSetVector<BasicBlock *, 2>, 2> KnownValues;
@@ -3332,7 +3332,7 @@ FoldCondBranchOnValueKnownInPredecessorImpl(BranchInst *BI, DomTreeUpdater *DTU,
// Now we know that this block has multiple preds and two succs.
// Check that the block is small enough and values defined in the block are
// not used outside of it.
- if (!BlockIsSimpleEnoughToThreadThrough(BB))
+ if (!blockIsSimpleEnoughToThreadThrough(BB))
return false;
for (const auto &Pair : KnownValues) {
@@ -3368,7 +3368,7 @@ FoldCondBranchOnValueKnownInPredecessorImpl(BranchInst *BI, DomTreeUpdater *DTU,
EdgeBB->moveBefore(RealDest);
// Update PHI nodes.
- AddPredecessorToBlock(RealDest, EdgeBB, BB);
+ addPredecessorToBlock(RealDest, EdgeBB, BB);
// BB may have instructions that are being threaded over. Clone these
// instructions into EdgeBB. We know that there will be no uses of the
@@ -3459,7 +3459,7 @@ FoldCondBranchOnValueKnownInPredecessorImpl(BranchInst *BI, DomTreeUpdater *DTU,
return false;
}
-static bool FoldCondBranchOnValueKnownInPredecessor(BranchInst *BI,
+static bool foldCondBranchOnValueKnownInPredecessor(BranchInst *BI,
DomTreeUpdater *DTU,
const DataLayout &DL,
AssumptionCache *AC) {
@@ -3467,7 +3467,7 @@ static bool FoldCondBranchOnValueKnownInPredecessor(BranchInst *BI,
bool EverChanged = false;
do {
// Note that None means "we changed things, but recurse further."
- Result = FoldCondBranchOnValueKnownInPredecessorImpl(BI, DTU, DL, AC);
+ Result = foldCondBranchOnValueKnownInPredecessorImpl(BI, DTU, DL, AC);
EverChanged |= Result == std::nullopt || *Result;
} while (Result == std::nullopt);
return EverChanged;
@@ -3475,7 +3475,7 @@ static bool FoldCondBranchOnValueKnownInPredecessor(BranchInst *BI,
/// Given a BB that starts with the specified two-entry PHI node,
/// see if we can eliminate it.
-static bool FoldTwoEntryPHINode(PHINode *PN, const TargetTransformInfo &TTI,
+static bool foldTwoEntryPHINode(PHINode *PN, const TargetTransformInfo &TTI,
DomTreeUpdater *DTU, const DataLayout &DL,
bool SpeculateUnpredictables) {
// Ok, this is a two entry PHI node. Check to see if this is a simple "if
@@ -3786,7 +3786,7 @@ static bool performBranchToCommonDestFolding(BranchInst *BI, BranchInst *PBI,
// Before cloning instructions, notify the successor basic block that it
// is about to have a new predecessor. This will update PHI nodes,
// which will allow us to update live-out uses of bonus instructions.
- AddPredecessorToBlock(UniqueSucc, PredBlock, BB, MSSAU);
+ addPredecessorToBlock(UniqueSucc, PredBlock, BB, MSSAU);
// Try to update branch weights.
uint64_t PredTrueWeight, PredFalseWeight, SuccTrueWeight, SuccFalseWeight;
@@ -3818,7 +3818,7 @@ static bool performBranchToCommonDestFolding(BranchInst *BI, BranchInst *PBI,
}
// Halve the weights if any of them cannot fit in an uint32_t
- FitWeights(NewWeights);
+ fitWeights(NewWeights);
SmallVector<uint32_t, 8> MDWeights(NewWeights.begin(), NewWeights.end());
setBranchWeights(PBI, MDWeights[0], MDWeights[1], /*IsExpected=*/false);
@@ -3841,7 +3841,7 @@ static bool performBranchToCommonDestFolding(BranchInst *BI, BranchInst *PBI,
PBI->setMetadata(LLVMContext::MD_loop, LoopMD);
ValueToValueMapTy VMap; // maps original values to cloned values
- CloneInstructionsIntoPredecessorBlockAndUpdateSSAUses(BB, PredBlock, VMap);
+ cloneInstructionsIntoPredecessorBlockAndUpdateSSAUses(BB, PredBlock, VMap);
Module *M = BB->getModule();
@@ -3875,12 +3875,12 @@ static bool isVectorOp(Instruction &I) {
/// If this basic block is simple enough, and if a predecessor branches to us
/// and one of our successors, fold the block into the predecessor and use
/// logical operations to pick the right destination.
-bool llvm::FoldBranchToCommonDest(BranchInst *BI, DomTreeUpdater *DTU,
+bool llvm::foldBranchToCommonDest(BranchInst *BI, DomTreeUpdater *DTU,
MemorySSAUpdater *MSSAU,
const TargetTransformInfo *TTI,
unsigned BonusInstThreshold) {
// If this block ends with an unconditional branch,
- // let SpeculativelyExecuteBB() deal with it.
+ // let speculativelyExecuteBB() deal with it.
if (!BI->isConditional())
return false;
@@ -3909,7 +3909,7 @@ bool llvm::FoldBranchToCommonDest(BranchInst *BI, DomTreeUpdater *DTU,
// Check that we have two conditional branches. If there is a PHI node in
// the common successor, verify that the same value flows in from both
// blocks.
- if (!PBI || PBI->isUnconditional() || !SafeToMergeTerminators(BI, PBI))
+ if (!PBI || PBI->isUnconditional() || !safeToMergeTerminators(BI, PBI))
continue;
// Determine if the two branches share a common destination.
@@ -4400,7 +4400,7 @@ static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI,
PBI->getSuccessor(0) != PBI->getSuccessor(1)) {
// Okay, the outcome of this conditional branch is statically
// knowable. If this block had a single pred, handle specially, otherwise
- // FoldCondBranchOnValueKnownInPredecessor() will handle it.
+ // foldCondBranchOnValueKnownInPredecessor() will handle it.
if (BB->getSinglePredecessor()) {
// Turn this into a branch on constant.
bool CondIsTrue = PBI->getSuccessor(0) == BB;
@@ -4556,14 +4556,14 @@ static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI,
PredOther * SuccCommon,
PredOther * SuccOther};
// Halve the weights if any of them cannot fit in an uint32_t
- FitWeights(NewWeights);
+ fitWeights(NewWeights);
setBranchWeights(PBI, NewWeights[0], NewWeights[1], /*IsExpected=*/false);
}
// OtherDest may have phi nodes. If so, add an entry from PBI's
// block that are identical to the entries for BI's block.
- AddPredecessorToBlock(OtherDest, PBI->getParent(), BB);
+ addPredecessorToBlock(OtherDest, PBI->getParent(), BB);
// We know that the CommonDest already had an edge from PBI to
// it. If it has PHIs though, the PHIs may have
diff erent
@@ -4592,7 +4592,7 @@ static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI,
uint64_t NewWeights[2] = {PredCommon * (SuccCommon + SuccOther),
PredOther * SuccCommon};
- FitWeights(NewWeights);
+ fitWeights(NewWeights);
setBranchWeights(NV, NewWeights[0], NewWeights[1],
/*IsExpected=*/false);
@@ -4613,7 +4613,7 @@ static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI,
// Takes care of updating the successors and removing the old terminator.
// Also makes sure not to introduce new successors by assuming that edges to
// non-successor TrueBBs and FalseBBs aren't reachable.
-bool SimplifyCFGOpt::SimplifyTerminatorOnSelect(Instruction *OldTerm,
+bool SimplifyCFGOpt::simplifyTerminatorOnSelect(Instruction *OldTerm,
Value *Cond, BasicBlock *TrueBB,
BasicBlock *FalseBB,
uint32_t TrueWeight,
@@ -4677,7 +4677,7 @@ bool SimplifyCFGOpt::SimplifyTerminatorOnSelect(Instruction *OldTerm,
}
}
- EraseTerminatorAndDCECond(OldTerm);
+ eraseTerminatorAndDCECond(OldTerm);
if (DTU) {
SmallVector<DominatorTree::UpdateType, 2> Updates;
@@ -4694,7 +4694,7 @@ bool SimplifyCFGOpt::SimplifyTerminatorOnSelect(Instruction *OldTerm,
// (switch (select cond, X, Y)) on constant X, Y
// with a branch - conditional if X and Y lead to distinct BBs,
// unconditional otherwise.
-bool SimplifyCFGOpt::SimplifySwitchOnSelect(SwitchInst *SI,
+bool SimplifyCFGOpt::simplifySwitchOnSelect(SwitchInst *SI,
SelectInst *Select) {
// Check for constant integer values in the select.
ConstantInt *TrueVal = dyn_cast<ConstantInt>(Select->getTrueValue());
@@ -4712,7 +4712,7 @@ bool SimplifyCFGOpt::SimplifySwitchOnSelect(SwitchInst *SI,
SmallVector<uint64_t, 8> Weights;
bool HasWeights = hasBranchWeightMD(*SI);
if (HasWeights) {
- GetBranchWeights(SI, Weights);
+ getBranchWeights(SI, Weights);
if (Weights.size() == 1 + SI->getNumCases()) {
TrueWeight =
(uint32_t)Weights[SI->findCaseValue(TrueVal)->getSuccessorIndex()];
@@ -4722,7 +4722,7 @@ bool SimplifyCFGOpt::SimplifySwitchOnSelect(SwitchInst *SI,
}
// Perform the actual simplification.
- return SimplifyTerminatorOnSelect(SI, Condition, TrueBB, FalseBB, TrueWeight,
+ return simplifyTerminatorOnSelect(SI, Condition, TrueBB, FalseBB, TrueWeight,
FalseWeight);
}
@@ -4731,7 +4731,7 @@ bool SimplifyCFGOpt::SimplifySwitchOnSelect(SwitchInst *SI,
// blockaddress(@fn, BlockB)))
// with
// (br cond, BlockA, BlockB).
-bool SimplifyCFGOpt::SimplifyIndirectBrOnSelect(IndirectBrInst *IBI,
+bool SimplifyCFGOpt::simplifyIndirectBrOnSelect(IndirectBrInst *IBI,
SelectInst *SI) {
// Check that both operands of the select are block addresses.
BlockAddress *TBA = dyn_cast<BlockAddress>(SI->getTrueValue());
@@ -4744,7 +4744,7 @@ bool SimplifyCFGOpt::SimplifyIndirectBrOnSelect(IndirectBrInst *IBI,
BasicBlock *FalseBB = FBA->getBasicBlock();
// Perform the actual simplification.
- return SimplifyTerminatorOnSelect(IBI, SI->getCondition(), TrueBB, FalseBB, 0,
+ return simplifyTerminatorOnSelect(IBI, SI->getCondition(), TrueBB, FalseBB, 0,
0);
}
@@ -4875,7 +4875,7 @@ bool SimplifyCFGOpt::tryToSimplifyUncondBranchWithICmpInIt(
/// The specified branch is a conditional branch.
/// Check to see if it is branching on an or/and chain of icmp instructions, and
/// fold it into a switch instruction if so.
-bool SimplifyCFGOpt::SimplifyBranchOnICmpChain(BranchInst *BI,
+bool SimplifyCFGOpt::simplifyBranchOnICmpChain(BranchInst *BI,
IRBuilder<> &Builder,
const DataLayout &DL) {
Instruction *Cond = dyn_cast<Instruction>(BI->getCondition());
@@ -4906,7 +4906,7 @@ bool SimplifyCFGOpt::SimplifyBranchOnICmpChain(BranchInst *BI,
// There might be duplicate constants in the list, which the switch
// instruction can't handle, remove them now.
- array_pod_sort(Values.begin(), Values.end(), ConstantIntSortPredicate);
+ array_pod_sort(Values.begin(), Values.end(), constantIntSortPredicate);
Values.erase(llvm::unique(Values), Values.end());
// If Extra was used, we require at least two switch values to do the
@@ -4915,7 +4915,7 @@ bool SimplifyCFGOpt::SimplifyBranchOnICmpChain(BranchInst *BI,
return false;
// TODO: Preserve branch weight metadata, similarly to how
- // FoldValueComparisonIntoPredecessors preserves it.
+ // foldValueComparisonIntoPredecessors preserves it.
// Figure out which block is which destination.
BasicBlock *DefaultBB = BI->getSuccessor(1);
@@ -4964,7 +4964,7 @@ bool SimplifyCFGOpt::SimplifyBranchOnICmpChain(BranchInst *BI,
// If there are PHI nodes in EdgeBB, then we need to add a new entry to them
// for the edge we just added.
- AddPredecessorToBlock(EdgeBB, BB, NewBB);
+ addPredecessorToBlock(EdgeBB, BB, NewBB);
LLVM_DEBUG(dbgs() << " ** 'icmp' chain unhandled condition: " << *ExtraCase
<< "\nEXTRABB = " << *BB);
@@ -4996,7 +4996,7 @@ bool SimplifyCFGOpt::SimplifyBranchOnICmpChain(BranchInst *BI,
}
// Erase the old branch instruction.
- EraseTerminatorAndDCECond(BI);
+ eraseTerminatorAndDCECond(BI);
if (DTU)
DTU->applyUpdates(Updates);
@@ -5372,7 +5372,7 @@ bool SimplifyCFGOpt::simplifyUnreachable(UnreachableInst *UI) {
if (Options.AC)
Options.AC->registerAssumption(cast<AssumeInst>(Assumption));
- EraseTerminatorAndDCECond(BI);
+ eraseTerminatorAndDCECond(BI);
Changed = true;
}
if (DTU)
@@ -5479,10 +5479,10 @@ bool SimplifyCFGOpt::simplifyUnreachable(UnreachableInst *UI) {
return Changed;
}
-static bool CasesAreContiguous(SmallVectorImpl<ConstantInt *> &Cases) {
+static bool casesAreContiguous(SmallVectorImpl<ConstantInt *> &Cases) {
assert(Cases.size() >= 1);
- array_pod_sort(Cases.begin(), Cases.end(), ConstantIntSortPredicate);
+ array_pod_sort(Cases.begin(), Cases.end(), constantIntSortPredicate);
for (size_t I = 1, E = Cases.size(); I != E; ++I) {
if (Cases[I - 1]->getValue() != Cases[I]->getValue() + 1)
return false;
@@ -5516,7 +5516,7 @@ static void createUnreachableSwitchDefault(SwitchInst *Switch,
/// Turn a switch into an integer range comparison and branch.
/// Switches with more than 2 destinations are ignored.
/// Switches with 1 destination are also ignored.
-bool SimplifyCFGOpt::TurnSwitchRangeIntoICmp(SwitchInst *SI,
+bool SimplifyCFGOpt::turnSwitchRangeIntoICmp(SwitchInst *SI,
IRBuilder<> &Builder) {
assert(SI->getNumCases() > 1 && "Degenerate switch?");
@@ -5561,11 +5561,11 @@ bool SimplifyCFGOpt::TurnSwitchRangeIntoICmp(SwitchInst *SI,
SmallVectorImpl<ConstantInt *> *ContiguousCases = nullptr;
BasicBlock *ContiguousDest = nullptr;
BasicBlock *OtherDest = nullptr;
- if (!CasesA.empty() && CasesAreContiguous(CasesA)) {
+ if (!CasesA.empty() && casesAreContiguous(CasesA)) {
ContiguousCases = &CasesA;
ContiguousDest = DestA;
OtherDest = DestB;
- } else if (CasesAreContiguous(CasesB)) {
+ } else if (casesAreContiguous(CasesB)) {
ContiguousCases = &CasesB;
ContiguousDest = DestB;
OtherDest = DestA;
@@ -5593,7 +5593,7 @@ bool SimplifyCFGOpt::TurnSwitchRangeIntoICmp(SwitchInst *SI,
// Update weight for the newly-created conditional branch.
if (hasBranchWeightMD(*SI)) {
SmallVector<uint64_t, 8> Weights;
- GetBranchWeights(SI, Weights);
+ getBranchWeights(SI, Weights);
if (Weights.size() == 1 + SI->getNumCases()) {
uint64_t TrueWeight = 0;
uint64_t FalseWeight = 0;
@@ -5747,7 +5747,7 @@ static bool eliminateDeadSwitchCases(SwitchInst *SI, DomTreeUpdater *DTU,
/// by an unconditional branch), look at the phi node for BB in the successor
/// block and see if the incoming value is equal to CaseValue. If so, return
/// the phi node, and set PhiIndex to BB's index in the phi node.
-static PHINode *FindPHIForConditionForwarding(ConstantInt *CaseValue,
+static PHINode *findPHIForConditionForwarding(ConstantInt *CaseValue,
BasicBlock *BB, int *PhiIndex) {
if (BB->getFirstNonPHIOrDbg() != BB->getTerminator())
return nullptr; // BB must be empty to be a candidate for simplification.
@@ -5778,7 +5778,7 @@ static PHINode *FindPHIForConditionForwarding(ConstantInt *CaseValue,
/// Try to forward the condition of a switch instruction to a phi node
/// dominated by the switch, if that would mean that some of the destination
/// blocks of the switch can be folded away. Return true if a change is made.
-static bool ForwardSwitchConditionToPHI(SwitchInst *SI) {
+static bool forwardSwitchConditionToPHI(SwitchInst *SI) {
using ForwardingNodesMap = DenseMap<PHINode *, SmallVector<int, 4>>;
ForwardingNodesMap ForwardingNodes;
@@ -5815,7 +5815,7 @@ static bool ForwardSwitchConditionToPHI(SwitchInst *SI) {
// Collect phi nodes that are indirectly using this switch's case constants.
int PhiIdx;
- if (auto *Phi = FindPHIForConditionForwarding(CaseValue, CaseDest, &PhiIdx))
+ if (auto *Phi = findPHIForConditionForwarding(CaseValue, CaseDest, &PhiIdx))
ForwardingNodes[Phi].push_back(PhiIdx);
}
@@ -5836,7 +5836,7 @@ static bool ForwardSwitchConditionToPHI(SwitchInst *SI) {
/// Return true if the backend will be able to handle
/// initializing an array of constants like C.
-static bool ValidLookupTableConstant(Constant *C, const TargetTransformInfo &TTI) {
+static bool validLookupTableConstant(Constant *C, const TargetTransformInfo &TTI) {
if (C->isThreadDependent())
return false;
if (C->isDLLImportDependent())
@@ -5851,7 +5851,7 @@ static bool ValidLookupTableConstant(Constant *C, const TargetTransformInfo &TTI
// Pointer casts and in-bounds GEPs will not prohibit the backend from
// materializing the array of constants.
Constant *StrippedC = cast<Constant>(CE->stripInBoundsConstantOffsets());
- if (StrippedC == C || !ValidLookupTableConstant(StrippedC, TTI))
+ if (StrippedC == C || !validLookupTableConstant(StrippedC, TTI))
return false;
}
@@ -5864,7 +5864,7 @@ static bool ValidLookupTableConstant(Constant *C, const TargetTransformInfo &TTI
/// If V is a Constant, return it. Otherwise, try to look up
/// its constant value in ConstantPool, returning 0 if it's not there.
static Constant *
-LookupConstant(Value *V,
+lookupConstant(Value *V,
const SmallDenseMap<Value *, Constant *> &ConstantPool) {
if (Constant *C = dyn_cast<Constant>(V))
return C;
@@ -5876,22 +5876,22 @@ LookupConstant(Value *V,
/// constant or can be replaced by constants from the ConstantPool. Returns the
/// resulting constant on success, 0 otherwise.
static Constant *
-ConstantFold(Instruction *I, const DataLayout &DL,
+constantFold(Instruction *I, const DataLayout &DL,
const SmallDenseMap<Value *, Constant *> &ConstantPool) {
if (SelectInst *Select = dyn_cast<SelectInst>(I)) {
- Constant *A = LookupConstant(Select->getCondition(), ConstantPool);
+ Constant *A = lookupConstant(Select->getCondition(), ConstantPool);
if (!A)
return nullptr;
if (A->isAllOnesValue())
- return LookupConstant(Select->getTrueValue(), ConstantPool);
+ return lookupConstant(Select->getTrueValue(), ConstantPool);
if (A->isNullValue())
- return LookupConstant(Select->getFalseValue(), ConstantPool);
+ return lookupConstant(Select->getFalseValue(), ConstantPool);
return nullptr;
}
SmallVector<Constant *, 4> COps;
for (unsigned N = 0, E = I->getNumOperands(); N != E; ++N) {
- if (Constant *A = LookupConstant(I->getOperand(N), ConstantPool))
+ if (Constant *A = lookupConstant(I->getOperand(N), ConstantPool))
COps.push_back(A);
else
return nullptr;
@@ -5923,7 +5923,7 @@ getCaseResults(SwitchInst *SI, ConstantInt *CaseVal, BasicBlock *CaseDest,
return false;
Pred = CaseDest;
CaseDest = I.getSuccessor(0);
- } else if (Constant *C = ConstantFold(&I, DL, ConstantPool)) {
+ } else if (Constant *C = constantFold(&I, DL, ConstantPool)) {
// Instruction is side-effect free and constant.
// If the instruction has uses outside this block or a phi node slot for
@@ -5960,12 +5960,12 @@ getCaseResults(SwitchInst *SI, ConstantInt *CaseVal, BasicBlock *CaseDest,
continue;
Constant *ConstVal =
- LookupConstant(PHI.getIncomingValue(Idx), ConstantPool);
+ lookupConstant(PHI.getIncomingValue(Idx), ConstantPool);
if (!ConstVal)
return false;
// Be conservative about which kinds of constants we support.
- if (!ValidLookupTableConstant(ConstVal, TTI))
+ if (!validLookupTableConstant(ConstVal, TTI))
return false;
Res.push_back(std::make_pair(&PHI, ConstVal));
@@ -6202,11 +6202,11 @@ class SwitchLookupTable {
/// Build instructions with Builder to retrieve the value at
/// the position given by Index in the lookup table.
- Value *BuildLookup(Value *Index, IRBuilder<> &Builder);
+ Value *buildLookup(Value *Index, IRBuilder<> &Builder);
/// Return true if a table with TableSize elements of
/// type ElementType would fit in a target-legal register.
- static bool WouldFitInRegister(const DataLayout &DL, uint64_t TableSize,
+ static bool wouldFitInRegister(const DataLayout &DL, uint64_t TableSize,
Type *ElementType);
private:
@@ -6344,7 +6344,7 @@ SwitchLookupTable::SwitchLookupTable(
}
// If the type is integer and the table fits in a register, build a bitmap.
- if (WouldFitInRegister(DL, TableSize, ValueType)) {
+ if (wouldFitInRegister(DL, TableSize, ValueType)) {
IntegerType *IT = cast<IntegerType>(ValueType);
APInt TableInt(TableSize * IT->getBitWidth(), 0);
for (uint64_t I = TableSize; I > 0; --I) {
@@ -6376,7 +6376,7 @@ SwitchLookupTable::SwitchLookupTable(
Kind = ArrayKind;
}
-Value *SwitchLookupTable::BuildLookup(Value *Index, IRBuilder<> &Builder) {
+Value *SwitchLookupTable::buildLookup(Value *Index, IRBuilder<> &Builder) {
switch (Kind) {
case SingleValueKind:
return SingleValue;
@@ -6405,7 +6405,7 @@ Value *SwitchLookupTable::BuildLookup(Value *Index, IRBuilder<> &Builder) {
Value *ShiftAmt = Builder.CreateZExtOrTrunc(Index, MapTy, "switch.cast");
// Multiply the shift amount by the element width. NUW/NSW can always be
- // set, because WouldFitInRegister guarantees Index * ShiftAmt is in
+ // set, because wouldFitInRegister guarantees Index * ShiftAmt is in
// BitMap's bit width.
ShiftAmt = Builder.CreateMul(
ShiftAmt, ConstantInt::get(MapTy, BitMapElementTy->getBitWidth()),
@@ -6438,7 +6438,7 @@ Value *SwitchLookupTable::BuildLookup(Value *Index, IRBuilder<> &Builder) {
llvm_unreachable("Unknown lookup table kind!");
}
-bool SwitchLookupTable::WouldFitInRegister(const DataLayout &DL,
+bool SwitchLookupTable::wouldFitInRegister(const DataLayout &DL,
uint64_t TableSize,
Type *ElementType) {
auto *IT = dyn_cast<IntegerType>(ElementType);
@@ -6501,7 +6501,7 @@ static bool isSwitchDense(ArrayRef<int64_t> Values) {
// number of loads required and/or table size. If the constants are small we
// could use smaller table entries and extend after the load.
static bool
-ShouldBuildLookupTable(SwitchInst *SI, uint64_t TableSize,
+shouldBuildLookupTable(SwitchInst *SI, uint64_t TableSize,
const TargetTransformInfo &TTI, const DataLayout &DL,
const SmallDenseMap<PHINode *, Type *> &ResultTypes) {
if (SI->getNumCases() > TableSize)
@@ -6518,7 +6518,7 @@ ShouldBuildLookupTable(SwitchInst *SI, uint64_t TableSize,
// Saturate this flag to false.
AllTablesFitInRegister =
AllTablesFitInRegister &&
- SwitchLookupTable::WouldFitInRegister(DL, TableSize, Ty);
+ SwitchLookupTable::wouldFitInRegister(DL, TableSize, Ty);
// If both flags saturate, we're done. NOTE: This *only* works with
// saturating flags, and all flags have to saturate first due to the
@@ -6538,7 +6538,7 @@ ShouldBuildLookupTable(SwitchInst *SI, uint64_t TableSize,
return isSwitchDense(SI->getNumCases(), TableSize);
}
-static bool ShouldUseSwitchConditionAsTableIndex(
+static bool shouldUseSwitchConditionAsTableIndex(
ConstantInt &MinCaseVal, const ConstantInt &MaxCaseVal,
bool HasDefaultResults, const SmallDenseMap<PHINode *, Type *> &ResultTypes,
const DataLayout &DL, const TargetTransformInfo &TTI) {
@@ -6549,7 +6549,7 @@ static bool ShouldUseSwitchConditionAsTableIndex(
!HasDefaultResults)
return false;
return all_of(ResultTypes, [&](const auto &KV) {
- return SwitchLookupTable::WouldFitInRegister(
+ return SwitchLookupTable::wouldFitInRegister(
DL, MaxCaseVal.getLimitedValue() + 1 /* TableSize */,
KV.second /* ResultType */);
});
@@ -6640,7 +6640,7 @@ static void reuseTableCompare(
/// If the switch is only used to initialize one or more phi nodes in a common
/// successor block with
diff erent constant values, replace the switch with
/// lookup tables.
-static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
+static bool switchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
DomTreeUpdater *DTU, const DataLayout &DL,
const TargetTransformInfo &TTI) {
assert(SI->getNumCases() > 1 && "Degenerate switch?");
@@ -6725,7 +6725,7 @@ static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
DefaultResults[PHI] = Result;
}
- bool UseSwitchConditionAsTableIndex = ShouldUseSwitchConditionAsTableIndex(
+ bool UseSwitchConditionAsTableIndex = shouldUseSwitchConditionAsTableIndex(
*MinCaseVal, *MaxCaseVal, HasDefaultResults, ResultTypes, DL, TTI);
uint64_t TableSize;
if (UseSwitchConditionAsTableIndex)
@@ -6761,7 +6761,7 @@ static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
return false;
}
- if (!ShouldBuildLookupTable(SI, TableSize, TTI, DL, ResultTypes))
+ if (!shouldBuildLookupTable(SI, TableSize, TTI, DL, ResultTypes))
return false;
std::vector<DominatorTree::UpdateType> Updates;
@@ -6809,12 +6809,12 @@ static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
if (UseSwitchConditionAsTableIndex && HasDefaultResults) {
ConstantRange CR = computeConstantRange(TableIndex, /* ForSigned */ false);
// Grow the table shouldn't have any size impact by checking
- // WouldFitInRegister.
+ // wouldFitInRegister.
// TODO: Consider growing the table also when it doesn't fit in a register
// if no optsize is specified.
const uint64_t UpperBound = CR.getUpper().getLimitedValue();
if (!CR.isUpperWrapped() && all_of(ResultTypes, [&](const auto &KV) {
- return SwitchLookupTable::WouldFitInRegister(
+ return SwitchLookupTable::wouldFitInRegister(
DL, UpperBound, KV.second /* ResultType */);
})) {
// There may be some case index larger than the UpperBound (unreachable
@@ -6882,7 +6882,7 @@ static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
Updates.push_back({DominatorTree::Insert, MaskBB, SI->getDefaultDest()});
}
Builder.SetInsertPoint(LookupBB);
- AddPredecessorToBlock(SI->getDefaultDest(), MaskBB, BB);
+ addPredecessorToBlock(SI->getDefaultDest(), MaskBB, BB);
}
if (!DefaultIsReachable || GeneratingCoveredLookupTable) {
@@ -6904,7 +6904,7 @@ static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
SwitchLookupTable Table(Mod, TableSize, TableIndexOffset, ResultList, DV,
DL, FuncName);
- Value *Result = Table.BuildLookup(TableIndex, Builder);
+ Value *Result = Table.buildLookup(TableIndex, Builder);
// Do a small peephole optimization: re-use the switch table compare if
// possible.
@@ -6953,7 +6953,7 @@ static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
///
/// This converts a sparse switch into a dense switch which allows better
/// lowering and could also allow transforming into a lookup table.
-static bool ReduceSwitchRange(SwitchInst *SI, IRBuilder<> &Builder,
+static bool reduceSwitchRange(SwitchInst *SI, IRBuilder<> &Builder,
const DataLayout &DL,
const TargetTransformInfo &TTI) {
auto *CondTy = cast<IntegerType>(SI->getCondition()->getType());
@@ -7113,25 +7113,25 @@ bool SimplifyCFGOpt::simplifySwitch(SwitchInst *SI, IRBuilder<> &Builder) {
// If we only have one predecessor, and if it is a branch on this value,
// see if that predecessor totally determines the outcome of this switch.
if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
- if (SimplifyEqualityComparisonWithOnlyPredecessor(SI, OnlyPred, Builder))
+ if (simplifyEqualityComparisonWithOnlyPredecessor(SI, OnlyPred, Builder))
return requestResimplify();
Value *Cond = SI->getCondition();
if (SelectInst *Select = dyn_cast<SelectInst>(Cond))
- if (SimplifySwitchOnSelect(SI, Select))
+ if (simplifySwitchOnSelect(SI, Select))
return requestResimplify();
// If the block only contains the switch, see if we can fold the block
// away into any preds.
if (SI == &*BB->instructionsWithoutDebug(false).begin())
- if (FoldValueComparisonIntoPredecessors(SI, Builder))
+ if (foldValueComparisonIntoPredecessors(SI, Builder))
return requestResimplify();
}
// Try to transform the switch into an icmp and a branch.
// The conversion from switch to comparison may lose information on
// impossible switch values, so disable it early in the pipeline.
- if (Options.ConvertSwitchRangeToICmp && TurnSwitchRangeIntoICmp(SI, Builder))
+ if (Options.ConvertSwitchRangeToICmp && turnSwitchRangeIntoICmp(SI, Builder))
return requestResimplify();
// Remove unreachable cases.
@@ -7141,7 +7141,7 @@ bool SimplifyCFGOpt::simplifySwitch(SwitchInst *SI, IRBuilder<> &Builder) {
if (trySwitchToSelect(SI, Builder, DTU, DL, TTI))
return requestResimplify();
- if (Options.ForwardSwitchCondToPhi && ForwardSwitchConditionToPHI(SI))
+ if (Options.ForwardSwitchCondToPhi && forwardSwitchConditionToPHI(SI))
return requestResimplify();
// The conversion from switch to lookup tables results in
diff icult-to-analyze
@@ -7150,13 +7150,13 @@ bool SimplifyCFGOpt::simplifySwitch(SwitchInst *SI, IRBuilder<> &Builder) {
// CVP. Therefore, only apply this transformation during late stages of the
// optimisation pipeline.
if (Options.ConvertSwitchToLookupTable &&
- SwitchToLookupTable(SI, Builder, DTU, DL, TTI))
+ switchToLookupTable(SI, Builder, DTU, DL, TTI))
return requestResimplify();
if (simplifySwitchOfPowersOfTwo(SI, Builder, DL, TTI))
return requestResimplify();
- if (ReduceSwitchRange(SI, Builder, DL, TTI))
+ if (reduceSwitchRange(SI, Builder, DL, TTI))
return requestResimplify();
if (HoistCommon &&
@@ -7197,19 +7197,19 @@ bool SimplifyCFGOpt::simplifyIndirectBr(IndirectBrInst *IBI) {
if (IBI->getNumDestinations() == 0) {
// If the indirectbr has no successors, change it to unreachable.
new UnreachableInst(IBI->getContext(), IBI->getIterator());
- EraseTerminatorAndDCECond(IBI);
+ eraseTerminatorAndDCECond(IBI);
return true;
}
if (IBI->getNumDestinations() == 1) {
// If the indirectbr has one successor, change it to a direct branch.
BranchInst::Create(IBI->getDestination(0), IBI->getIterator());
- EraseTerminatorAndDCECond(IBI);
+ eraseTerminatorAndDCECond(IBI);
return true;
}
if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) {
- if (SimplifyIndirectBrOnSelect(IBI, SI))
+ if (simplifyIndirectBrOnSelect(IBI, SI))
return requestResimplify();
}
return Changed;
@@ -7236,7 +7236,7 @@ bool SimplifyCFGOpt::simplifyIndirectBr(IndirectBrInst *IBI) {
/// TODO - This transformation could remove entries from a phi in the target
/// block when the inputs in the phi are the same for the two blocks being
/// merged. In some cases, this could result in removal of the PHI entirely.
-static bool TryToMergeLandingPad(LandingPadInst *LPad, BranchInst *BI,
+static bool tryToMergeLandingPad(LandingPadInst *LPad, BranchInst *BI,
BasicBlock *BB, DomTreeUpdater *DTU) {
auto Succ = BB->getUniqueSuccessor();
assert(Succ);
@@ -7339,7 +7339,7 @@ bool SimplifyCFGOpt::simplifyUncondBranch(BranchInst *BI,
if (LandingPadInst *LPad = dyn_cast<LandingPadInst>(I)) {
for (++I; isa<DbgInfoIntrinsic>(I); ++I)
;
- if (I->isTerminator() && TryToMergeLandingPad(LPad, BI, BB, DTU))
+ if (I->isTerminator() && tryToMergeLandingPad(LPad, BI, BB, DTU))
return true;
}
@@ -7348,7 +7348,7 @@ bool SimplifyCFGOpt::simplifyUncondBranch(BranchInst *BI,
// predecessor and use logical operations to update the incoming value
// for PHI nodes in common successor.
if (Options.SpeculateBlocks &&
- FoldBranchToCommonDest(BI, DTU, /*MSSAU=*/nullptr, &TTI,
+ foldBranchToCommonDest(BI, DTU, /*MSSAU=*/nullptr, &TTI,
Options.BonusInstThreshold))
return requestResimplify();
return false;
@@ -7448,7 +7448,7 @@ static bool mergeNestedCondBranch(BranchInst *BI, DomTreeUpdater *DTU) {
if (HasWeight) {
uint64_t Weights[2] = {BBTWeight * BB1FWeight + BBFWeight * BB2TWeight,
BBTWeight * BB1TWeight + BBFWeight * BB2FWeight};
- FitWeights(Weights);
+ fitWeights(Weights);
setBranchWeights(BI, Weights[0], Weights[1], /*IsExpected=*/false);
}
return true;
@@ -7471,24 +7471,24 @@ bool SimplifyCFGOpt::simplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) {
// see if that predecessor totally determines the outcome of this
// switch.
if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
- if (SimplifyEqualityComparisonWithOnlyPredecessor(BI, OnlyPred, Builder))
+ if (simplifyEqualityComparisonWithOnlyPredecessor(BI, OnlyPred, Builder))
return requestResimplify();
// This block must be empty, except for the setcond inst, if it exists.
// Ignore dbg and pseudo intrinsics.
auto I = BB->instructionsWithoutDebug(true).begin();
if (&*I == BI) {
- if (FoldValueComparisonIntoPredecessors(BI, Builder))
+ if (foldValueComparisonIntoPredecessors(BI, Builder))
return requestResimplify();
} else if (&*I == cast<Instruction>(BI->getCondition())) {
++I;
- if (&*I == BI && FoldValueComparisonIntoPredecessors(BI, Builder))
+ if (&*I == BI && foldValueComparisonIntoPredecessors(BI, Builder))
return requestResimplify();
}
}
// Try to turn "br (X == 0 | X == 1), T, F" into a switch instruction.
- if (SimplifyBranchOnICmpChain(BI, Builder, DL))
+ if (simplifyBranchOnICmpChain(BI, Builder, DL))
return true;
// If this basic block has dominating predecessor blocks and the dominating
@@ -7508,7 +7508,7 @@ bool SimplifyCFGOpt::simplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) {
// branches to us and one of our successors, fold the comparison into the
// predecessor and use logical operations to pick the right destination.
if (Options.SpeculateBlocks &&
- FoldBranchToCommonDest(BI, DTU, /*MSSAU=*/nullptr, &TTI,
+ foldBranchToCommonDest(BI, DTU, /*MSSAU=*/nullptr, &TTI,
Options.BonusInstThreshold))
return requestResimplify();
@@ -7527,7 +7527,7 @@ bool SimplifyCFGOpt::simplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) {
Instruction *Succ0TI = BI->getSuccessor(0)->getTerminator();
if (Succ0TI->getNumSuccessors() == 1 &&
Succ0TI->getSuccessor(0) == BI->getSuccessor(1))
- if (SpeculativelyExecuteBB(BI, BI->getSuccessor(0)))
+ if (speculativelyExecuteBB(BI, BI->getSuccessor(0)))
return requestResimplify();
}
} else if (BI->getSuccessor(1)->getSinglePredecessor()) {
@@ -7536,14 +7536,14 @@ bool SimplifyCFGOpt::simplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) {
Instruction *Succ1TI = BI->getSuccessor(1)->getTerminator();
if (Succ1TI->getNumSuccessors() == 1 &&
Succ1TI->getSuccessor(0) == BI->getSuccessor(0))
- if (SpeculativelyExecuteBB(BI, BI->getSuccessor(1)))
+ if (speculativelyExecuteBB(BI, BI->getSuccessor(1)))
return requestResimplify();
}
// If this is a branch on something for which we know the constant value in
// predecessors (e.g. a phi node in the current block), thread control
// through this block.
- if (FoldCondBranchOnValueKnownInPredecessor(BI, DTU, DL, Options.AC))
+ if (foldCondBranchOnValueKnownInPredecessor(BI, DTU, DL, Options.AC))
return requestResimplify();
// Scan predecessor blocks for conditional branches.
@@ -7801,12 +7801,12 @@ bool SimplifyCFGOpt::simplifyOnce(BasicBlock *BB) {
return true;
if (SinkCommon && Options.SinkCommonInsts)
- if (SinkCommonCodeFromPredecessors(BB, DTU) ||
- MergeCompatibleInvokes(BB, DTU)) {
- // SinkCommonCodeFromPredecessors() does not automatically CSE PHI's,
+ if (sinkCommonCodeFromPredecessors(BB, DTU) ||
+ mergeCompatibleInvokes(BB, DTU)) {
+ // sinkCommonCodeFromPredecessors() does not automatically CSE PHI's,
// so we may now how duplicate PHI's.
// Let's rerun EliminateDuplicatePHINodes() first,
- // before FoldTwoEntryPHINode() potentially converts them into select's,
+ // before foldTwoEntryPHINode() potentially converts them into select's,
// after which we'd need a whole EarlyCSE pass run to cleanup them.
return true;
}
@@ -7819,7 +7819,7 @@ bool SimplifyCFGOpt::simplifyOnce(BasicBlock *BB) {
// eliminate it, do so now.
if (auto *PN = dyn_cast<PHINode>(BB->begin()))
if (PN->getNumIncomingValues() == 2)
- if (FoldTwoEntryPHINode(PN, TTI, DTU, DL,
+ if (foldTwoEntryPHINode(PN, TTI, DTU, DL,
Options.SpeculateUnpredictables))
return true;
}
More information about the llvm-commits
mailing list