LLVM 20.0.0git
SimplifyCFGPass.cpp
Go to the documentation of this file.
1//===- SimplifyCFGPass.cpp - CFG Simplification Pass ----------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements dead code elimination and basic block merging, along
10// with a collection of other peephole control flow optimizations. For example:
11//
12// * Removes basic blocks with no predecessors.
13// * Merges a basic block into its predecessor if there is only one and the
14// predecessor only has one successor.
15// * Eliminates PHI nodes for basic blocks with a single predecessor.
16// * Eliminates a basic block that only contains an unconditional branch.
17// * Changes invoke instructions to nounwind functions to be calls.
18// * Change things like "if (x) if (y)" into "if (x&y)".
19// * etc..
20//
21//===----------------------------------------------------------------------===//
22
23#include "llvm/ADT/MapVector.h"
26#include "llvm/ADT/Statistic.h"
28#include "llvm/Analysis/CFG.h"
32#include "llvm/IR/Attributes.h"
33#include "llvm/IR/CFG.h"
35#include "llvm/IR/Dominators.h"
38#include "llvm/IR/ValueHandle.h"
40#include "llvm/Pass.h"
46#include <utility>
47using namespace llvm;
48
49#define DEBUG_TYPE "simplifycfg"
50
52 "bonus-inst-threshold", cl::Hidden, cl::init(1),
53 cl::desc("Control the number of bonus instructions (default = 1)"));
54
56 "keep-loops", cl::Hidden, cl::init(true),
57 cl::desc("Preserve canonical loop structure (default = true)"));
58
60 "switch-range-to-icmp", cl::Hidden, cl::init(false),
62 "Convert switches into an integer range comparison (default = false)"));
63
65 "switch-to-lookup", cl::Hidden, cl::init(false),
66 cl::desc("Convert switches to lookup tables (default = false)"));
67
69 "forward-switch-cond", cl::Hidden, cl::init(false),
70 cl::desc("Forward switch condition to phi ops (default = false)"));
71
73 "hoist-common-insts", cl::Hidden, cl::init(false),
74 cl::desc("hoist common instructions (default = false)"));
75
77 "sink-common-insts", cl::Hidden, cl::init(false),
78 cl::desc("Sink common instructions (default = false)"));
79
81 "speculate-unpredictables", cl::Hidden, cl::init(false),
82 cl::desc("Speculate unpredictable branches (default = false)"));
83
84STATISTIC(NumSimpl, "Number of blocks simplified");
85
86static bool
88 std::vector<DominatorTree::UpdateType> *Updates) {
90
91 // We don't want to change IR just because we can.
92 // Only do that if there are at least two blocks we'll tail-merge.
93 if (BBs.size() < 2)
94 return false;
95
96 if (Updates)
97 Updates->reserve(Updates->size() + BBs.size());
98
99 BasicBlock *CanonicalBB;
100 Instruction *CanonicalTerm;
101 {
102 auto *Term = BBs[0]->getTerminator();
103
104 // Create a canonical block for this function terminator type now,
105 // placing it *before* the first block that will branch to it.
106 CanonicalBB = BasicBlock::Create(
107 F.getContext(), Twine("common.") + Term->getOpcodeName(), &F, BBs[0]);
108 // We'll also need a PHI node per each operand of the terminator.
109 NewOps.resize(Term->getNumOperands());
110 for (auto I : zip(Term->operands(), NewOps)) {
111 std::get<1>(I) = PHINode::Create(std::get<0>(I)->getType(),
112 /*NumReservedValues=*/BBs.size(),
113 CanonicalBB->getName() + ".op");
114 std::get<1>(I)->insertInto(CanonicalBB, CanonicalBB->end());
115 }
116 // Make it so that this canonical block actually has the right
117 // terminator.
118 CanonicalTerm = Term->clone();
119 CanonicalTerm->insertInto(CanonicalBB, CanonicalBB->end());
120 // If the canonical terminator has operands, rewrite it to take PHI's.
121 for (auto I : zip(NewOps, CanonicalTerm->operands()))
122 std::get<1>(I) = std::get<0>(I);
123 }
124
125 // Now, go through each block (with the current terminator type)
126 // we've recorded, and rewrite it to branch to the new common block.
127 DILocation *CommonDebugLoc = nullptr;
128 for (BasicBlock *BB : BBs) {
129 auto *Term = BB->getTerminator();
130 assert(Term->getOpcode() == CanonicalTerm->getOpcode() &&
131 "All blocks to be tail-merged must be the same "
132 "(function-terminating) terminator type.");
133
134 // Aha, found a new non-canonical function terminator. If it has operands,
135 // forward them to the PHI nodes in the canonical block.
136 for (auto I : zip(Term->operands(), NewOps))
137 std::get<1>(I)->addIncoming(std::get<0>(I), BB);
138
139 // Compute the debug location common to all the original terminators.
140 if (!CommonDebugLoc)
141 CommonDebugLoc = Term->getDebugLoc();
142 else
143 CommonDebugLoc =
144 DILocation::getMergedLocation(CommonDebugLoc, Term->getDebugLoc());
145
146 // And turn BB into a block that just unconditionally branches
147 // to the canonical block.
148 Instruction *BI = BranchInst::Create(CanonicalBB, BB);
149 BI->setDebugLoc(Term->getDebugLoc());
150 Term->eraseFromParent();
151
152 if (Updates)
153 Updates->push_back({DominatorTree::Insert, BB, CanonicalBB});
154 }
155
156 CanonicalTerm->setDebugLoc(CommonDebugLoc);
157
158 return true;
159}
160
162 DomTreeUpdater *DTU) {
163 SmallMapVector<unsigned /*TerminatorOpcode*/, SmallVector<BasicBlock *, 2>, 4>
164 Structure;
165
166 // Scan all the blocks in the function, record the interesting-ones.
167 for (BasicBlock &BB : F) {
168 if (DTU && DTU->isBBPendingDeletion(&BB))
169 continue;
170
171 // We are only interested in function-terminating blocks.
172 if (!succ_empty(&BB))
173 continue;
174
175 auto *Term = BB.getTerminator();
176
177 // Fow now only support `ret`/`resume` function terminators.
178 // FIXME: lift this restriction.
179 switch (Term->getOpcode()) {
180 case Instruction::Ret:
181 case Instruction::Resume:
182 break;
183 default:
184 continue;
185 }
186
187 // We can't tail-merge block that contains a musttail call.
188 if (BB.getTerminatingMustTailCall())
189 continue;
190
191 // Calls to experimental_deoptimize must be followed by a return
192 // of the value computed by experimental_deoptimize.
193 // I.e., we can not change `ret` to `br` for this block.
194 if (auto *CI =
195 dyn_cast_or_null<CallInst>(Term->getPrevNonDebugInstruction())) {
196 if (Function *F = CI->getCalledFunction())
197 if (Intrinsic::ID ID = F->getIntrinsicID())
198 if (ID == Intrinsic::experimental_deoptimize)
199 continue;
200 }
201
202 // PHI nodes cannot have token type, so if the terminator has an operand
203 // with token type, we can not tail-merge this kind of function terminators.
204 if (any_of(Term->operands(),
205 [](Value *Op) { return Op->getType()->isTokenTy(); }))
206 continue;
207
208 // Canonical blocks are uniqued based on the terminator type (opcode).
209 Structure[Term->getOpcode()].emplace_back(&BB);
210 }
211
212 bool Changed = false;
213
214 std::vector<DominatorTree::UpdateType> Updates;
215
216 for (ArrayRef<BasicBlock *> BBs : make_second_range(Structure))
217 Changed |= performBlockTailMerging(F, BBs, DTU ? &Updates : nullptr);
218
219 if (DTU)
220 DTU->applyUpdates(Updates);
221
222 return Changed;
223}
224
225/// Call SimplifyCFG on all the blocks in the function,
226/// iterating until no more changes are made.
228 DomTreeUpdater *DTU,
230 bool Changed = false;
231 bool LocalChange = true;
232
234 FindFunctionBackedges(F, Edges);
235 SmallPtrSet<BasicBlock *, 16> UniqueLoopHeaders;
236 for (const auto &Edge : Edges)
237 UniqueLoopHeaders.insert(const_cast<BasicBlock *>(Edge.second));
238
239 SmallVector<WeakVH, 16> LoopHeaders(UniqueLoopHeaders.begin(),
240 UniqueLoopHeaders.end());
241
242 unsigned IterCnt = 0;
243 (void)IterCnt;
244 while (LocalChange) {
245 assert(IterCnt++ < 1000 && "Iterative simplification didn't converge!");
246 LocalChange = false;
247
248 // Loop over all of the basic blocks and remove them if they are unneeded.
249 for (Function::iterator BBIt = F.begin(); BBIt != F.end(); ) {
250 BasicBlock &BB = *BBIt++;
251 if (DTU) {
252 assert(
253 !DTU->isBBPendingDeletion(&BB) &&
254 "Should not end up trying to simplify blocks marked for removal.");
255 // Make sure that the advanced iterator does not point at the blocks
256 // that are marked for removal, skip over all such blocks.
257 while (BBIt != F.end() && DTU->isBBPendingDeletion(&*BBIt))
258 ++BBIt;
259 }
260 if (simplifyCFG(&BB, TTI, DTU, Options, LoopHeaders)) {
261 LocalChange = true;
262 ++NumSimpl;
263 }
264 }
265 Changed |= LocalChange;
266 }
267 return Changed;
268}
269
271 DominatorTree *DT,
273 DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager);
274
275 bool EverChanged = removeUnreachableBlocks(F, DT ? &DTU : nullptr);
276 EverChanged |=
278 EverChanged |= iterativelySimplifyCFG(F, TTI, DT ? &DTU : nullptr, Options);
279
280 // If neither pass changed anything, we're done.
281 if (!EverChanged) return false;
282
283 // iterativelySimplifyCFG can (rarely) make some loops dead. If this happens,
284 // removeUnreachableBlocks is needed to nuke them, which means we should
285 // iterate between the two optimizations. We structure the code like this to
286 // avoid rerunning iterativelySimplifyCFG if the second pass of
287 // removeUnreachableBlocks doesn't do anything.
288 if (!removeUnreachableBlocks(F, DT ? &DTU : nullptr))
289 return true;
290
291 do {
292 EverChanged = iterativelySimplifyCFG(F, TTI, DT ? &DTU : nullptr, Options);
293 EverChanged |= removeUnreachableBlocks(F, DT ? &DTU : nullptr);
294 } while (EverChanged);
295
296 return true;
297}
298
300 DominatorTree *DT,
303 (DT && DT->verify(DominatorTree::VerificationLevel::Full))) &&
304 "Original domtree is invalid?");
305
306 bool Changed = simplifyFunctionCFGImpl(F, TTI, DT, Options);
307
309 (DT && DT->verify(DominatorTree::VerificationLevel::Full))) &&
310 "Failed to maintain validity of domtree!");
311
312 return Changed;
313}
314
315// Command-line settings override compile-time settings.
317 if (UserBonusInstThreshold.getNumOccurrences())
318 Options.BonusInstThreshold = UserBonusInstThreshold;
319 if (UserForwardSwitchCond.getNumOccurrences())
320 Options.ForwardSwitchCondToPhi = UserForwardSwitchCond;
321 if (UserSwitchRangeToICmp.getNumOccurrences())
322 Options.ConvertSwitchRangeToICmp = UserSwitchRangeToICmp;
323 if (UserSwitchToLookup.getNumOccurrences())
324 Options.ConvertSwitchToLookupTable = UserSwitchToLookup;
325 if (UserKeepLoops.getNumOccurrences())
326 Options.NeedCanonicalLoop = UserKeepLoops;
327 if (UserHoistCommonInsts.getNumOccurrences())
328 Options.HoistCommonInsts = UserHoistCommonInsts;
329 if (UserSinkCommonInsts.getNumOccurrences())
330 Options.SinkCommonInsts = UserSinkCommonInsts;
331 if (UserSpeculateUnpredictables.getNumOccurrences())
332 Options.SpeculateUnpredictables = UserSpeculateUnpredictables;
333}
334
337}
338
340 : Options(Opts) {
342}
343
345 raw_ostream &OS, function_ref<StringRef(StringRef)> MapClassName2PassName) {
346 static_cast<PassInfoMixin<SimplifyCFGPass> *>(this)->printPipeline(
347 OS, MapClassName2PassName);
348 OS << '<';
349 OS << "bonus-inst-threshold=" << Options.BonusInstThreshold << ';';
350 OS << (Options.ForwardSwitchCondToPhi ? "" : "no-") << "forward-switch-cond;";
351 OS << (Options.ConvertSwitchRangeToICmp ? "" : "no-")
352 << "switch-range-to-icmp;";
353 OS << (Options.ConvertSwitchToLookupTable ? "" : "no-")
354 << "switch-to-lookup;";
355 OS << (Options.NeedCanonicalLoop ? "" : "no-") << "keep-loops;";
356 OS << (Options.HoistCommonInsts ? "" : "no-") << "hoist-common-insts;";
357 OS << (Options.SinkCommonInsts ? "" : "no-") << "sink-common-insts;";
358 OS << (Options.SpeculateBlocks ? "" : "no-") << "speculate-blocks;";
359 OS << (Options.SimplifyCondBranch ? "" : "no-") << "simplify-cond-branch;";
360 OS << (Options.SpeculateUnpredictables ? "" : "no-")
361 << "speculate-unpredictables";
362 OS << '>';
363}
364
367 auto &TTI = AM.getResult<TargetIRAnalysis>(F);
368 Options.AC = &AM.getResult<AssumptionAnalysis>(F);
369 DominatorTree *DT = nullptr;
372 if (!simplifyFunctionCFG(F, TTI, DT, Options))
373 return PreservedAnalyses::all();
377 return PA;
378}
379
380namespace {
381struct CFGSimplifyPass : public FunctionPass {
382 static char ID;
384 std::function<bool(const Function &)> PredicateFtor;
385
386 CFGSimplifyPass(SimplifyCFGOptions Options_ = SimplifyCFGOptions(),
387 std::function<bool(const Function &)> Ftor = nullptr)
388 : FunctionPass(ID), Options(Options_), PredicateFtor(std::move(Ftor)) {
389
391
392 // Check for command-line overrides of options for debug/customization.
394 }
395
396 bool runOnFunction(Function &F) override {
397 if (skipFunction(F) || (PredicateFtor && !PredicateFtor(F)))
398 return false;
399
400 Options.AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
401 DominatorTree *DT = nullptr;
403 DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
404
405 auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
406 return simplifyFunctionCFG(F, TTI, DT, Options);
407 }
408 void getAnalysisUsage(AnalysisUsage &AU) const override {
416 }
417};
418}
419
420char CFGSimplifyPass::ID = 0;
421INITIALIZE_PASS_BEGIN(CFGSimplifyPass, "simplifycfg", "Simplify the CFG", false,
422 false)
426INITIALIZE_PASS_END(CFGSimplifyPass, "simplifycfg", "Simplify the CFG", false,
427 false)
428
429// Public interface to the CFGSimplification pass
432 std::function<bool(const Function &)> Ftor) {
433 return new CFGSimplifyPass(Options, std::move(Ftor));
434}
aarch64 promote const
This file contains the simple types necessary to represent the attributes associated with functions a...
Performs the initial survey of the specified function
static bool runOnFunction(Function &F, bool PostInlining)
Flatten the CFG
This is the interface for a simple mod/ref and alias analysis over globals.
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
static LVOptions Options
Definition: LVOptions.cpp:25
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
This file implements a map that provides insertion order iteration.
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:55
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:57
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
static cl::opt< bool > UserSwitchRangeToICmp("switch-range-to-icmp", cl::Hidden, cl::init(false), cl::desc("Convert switches into an integer range comparison (default = false)"))
static cl::opt< bool > UserSinkCommonInsts("sink-common-insts", cl::Hidden, cl::init(false), cl::desc("Sink common instructions (default = false)"))
static bool iterativelySimplifyCFG(Function &F, const TargetTransformInfo &TTI, DomTreeUpdater *DTU, const SimplifyCFGOptions &Options)
Call SimplifyCFG on all the blocks in the function, iterating until no more changes are made.
static cl::opt< unsigned > UserBonusInstThreshold("bonus-inst-threshold", cl::Hidden, cl::init(1), cl::desc("Control the number of bonus instructions (default = 1)"))
static bool simplifyFunctionCFGImpl(Function &F, const TargetTransformInfo &TTI, DominatorTree *DT, const SimplifyCFGOptions &Options)
static bool simplifyFunctionCFG(Function &F, const TargetTransformInfo &TTI, DominatorTree *DT, const SimplifyCFGOptions &Options)
static cl::opt< bool > UserSwitchToLookup("switch-to-lookup", cl::Hidden, cl::init(false), cl::desc("Convert switches to lookup tables (default = false)"))
static cl::opt< bool > UserKeepLoops("keep-loops", cl::Hidden, cl::init(true), cl::desc("Preserve canonical loop structure (default = true)"))
static cl::opt< bool > UserHoistCommonInsts("hoist-common-insts", cl::Hidden, cl::init(false), cl::desc("hoist common instructions (default = false)"))
simplifycfg
static cl::opt< bool > UserSpeculateUnpredictables("speculate-unpredictables", cl::Hidden, cl::init(false), cl::desc("Speculate unpredictable branches (default = false)"))
static void applyCommandLineOverridesToOptions(SimplifyCFGOptions &Options)
static bool tailMergeBlocksWithSimilarFunctionTerminators(Function &F, DomTreeUpdater *DTU)
static cl::opt< bool > UserForwardSwitchCond("forward-switch-cond", cl::Hidden, cl::init(false), cl::desc("Forward switch condition to phi ops (default = false)"))
static bool performBlockTailMerging(Function &F, ArrayRef< BasicBlock * > BBs, std::vector< DominatorTree::UpdateType > *Updates)
This file provides the interface for the pass responsible for both simplifying and canonicalizing the...
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:166
static SymbolRef::Type getType(const Symbol *Sym)
Definition: TapiFile.cpp:40
This pass exposes codegen information to IR-level passes.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:253
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:405
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
A function analysis which provides an AssumptionCache.
An immutable pass that tracks lazily created AssumptionCache objects.
LLVM Basic Block Representation.
Definition: BasicBlock.h:61
iterator end()
Definition: BasicBlock.h:461
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:212
static BranchInst * Create(BasicBlock *IfTrue, InsertPosition InsertBefore=nullptr)
Debug location.
static DILocation * getMergedLocation(DILocation *LocA, DILocation *LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
This class represents an Operation in the Expression.
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:279
bool verify(VerificationLevel VL=VerificationLevel::Full) const
verify - checks if the tree is correct.
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:317
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:162
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:310
BasicBlockListType::iterator iterator
Definition: Function.h:69
void applyUpdates(ArrayRef< typename DomTreeT::UpdateType > Updates)
Submit updates to all available trees.
bool isBBPendingDeletion(BasicBlockT *DelBB) const
Returns true if DelBB is awaiting deletion.
Legacy wrapper pass to provide the GlobalsAAResult object.
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:274
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:463
InstListType::iterator insertInto(BasicBlock *ParentBB, InstListType::iterator It)
Inserts an unlinked instruction into ParentBB at position It and returns the iterator of the inserted...
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:111
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: Analysis.h:117
void preserve()
Mark an analysis as preserved.
Definition: Analysis.h:131
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
Run the pass over the function.
SimplifyCFGPass()
The default constructor sets the pass options to create canonical IR, rather than optimal IR.
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
iterator end() const
Definition: SmallPtrSet.h:460
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:367
iterator begin() const
Definition: SmallPtrSet.h:455
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:502
void reserve(size_type N)
Definition: SmallVector.h:676
void resize(size_type N)
Definition: SmallVector.h:651
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Analysis pass providing the TargetTransformInfo.
Wrapper pass for TargetTransformInfo.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
op_range operands()
Definition: User.h:242
LLVM Value Representation.
Definition: Value.h:74
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
An efficient, type-erasing, non-owning reference to a callable.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:443
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
detail::zippy< detail::zip_shortest, T, U, Args... > zip(T &&t, U &&u, Args &&...args)
zip iterator for two or more iteratable types.
Definition: STLExtras.h:853
FunctionPass * createCFGSimplificationPass(SimplifyCFGOptions Options=SimplifyCFGOptions(), std::function< bool(const Function &)> Ftor=nullptr)
bool succ_empty(const Instruction *I)
Definition: CFG.h:255
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1729
void initializeCFGSimplifyPassPass(PassRegistry &)
cl::opt< bool > RequireAndPreserveDomTree
This function is used to do simplification of a CFG.
auto make_second_range(ContainerTy &&c)
Given a container of pairs, return a range over the second elements.
Definition: STLExtras.h:1432
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1856
bool simplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI, DomTreeUpdater *DTU=nullptr, const SimplifyCFGOptions &Options={}, ArrayRef< WeakVH > LoopHeaders={})
void FindFunctionBackedges(const Function &F, SmallVectorImpl< std::pair< const BasicBlock *, const BasicBlock * > > &Result)
Analyze the specified function to find all of the loop backedges in the function and return them.
Definition: CFG.cpp:34
bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)
Remove all blocks that can not be reached from the function's entry.
Definition: Local.cpp:3236
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:69
A MapVector that performs no allocations if smaller than a certain size.
Definition: MapVector.h:254