1//===- InstSimplifyPass.cpp -----------------------------------------------===// 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 7//===----------------------------------------------------------------------===// 24#define DEBUG_TYPE "instsimplify" 26STATISTIC(NumSimplified,
"Number of redundant instructions removed");
34// Unreachable code can take on strange forms that we are not prepared to 35// handle. For example, an instruction may have itself as an operand. 41// The first time through the loop, ToSimplify is empty and we try to 42// simplify all instructions. On later iterations, ToSimplify is not 43// empty and we only bother simplifying instructions that are in it. 47// Don't waste time simplifying dead/unused instructions. 51 }
elseif (!
I.use_empty()) {
53// Mark all uses for resimplification next time round the loop. 54for (
User *U :
I.users())
55 Next->insert(cast<Instruction>(U));
56I.replaceAllUsesWith(V);
59// A call can get simplified, but it may not be trivially dead. 68// Place the list of instructions to simplify on the next loop iteration 79staticcharID;
// Pass identification, replacement for typeid 91 /// Remove instructions that simplify. 97 &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
99 &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(
F);
101 &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
F);
109char InstSimplifyLegacyPass::ID = 0;
111"Remove redundant instructions",
false,
false)
118// Public interface to the simplify instructions pass. 120returnnew InstSimplifyLegacyPass();
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static bool runImpl(Function &F, const TargetLowering &TLI)
static bool runImpl(Function &F, const SimplifyQuery &SQ)
Remove redundant instructions
Defines passes for running instruction simplification across chunks of IR.
SmallVector< Instruction *, 4 > ToSimplify
#define INITIALIZE_PASS_DEPENDENCY(depName)
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
This file defines the SmallPtrSet class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
void setPreservesCFG()
This function should be called by the pass, iff they do not:
A function analysis which provides an AssumptionCache.
An immutable pass that tracks lazily created AssumptionCache objects.
A cache of @llvm.assume calls within a function.
LLVM Basic Block Representation.
Represents analyses that only rely on functions' control flow.
A parsed version of the target data layout string in and methods for querying it.
Analysis pass which computes a DominatorTree.
Legacy analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
FunctionPass class - This class is used to implement most global optimizations.
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
bool skipFunction(const Function &F) const
Optional passes call this function to check whether the pass should be skipped.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
void preserveSet()
Mark an analysis set as preserved.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Analysis pass providing the TargetLibraryInfo.
Provides information about what library functions are available for the current target.
LLVM Value Representation.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
This is an optimization pass for GlobalISel generic memory operations.
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())
If the specified value is a trivially dead instruction, delete it.
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)
See if we can compute a simplified version of this instruction.
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction is not used, and the instruction will return.
void initializeInstSimplifyLegacyPassPass(PassRegistry &)
FunctionPass * createInstSimplifyLegacyPass()
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
const TargetLibraryInfo * TLI
