LLVM 18.0.0git
Go to the documentation of this file.
1//===- LowerConstantIntrinsics.cpp - Lower constant intrinsic calls -------===//
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
9// This pass lowers all remaining 'objectsize' 'is.constant' intrinsic calls
10// and provides constant propagation and basic CFG cleanup on the result.
16#include "llvm/ADT/SetVector.h"
17#include "llvm/ADT/Statistic.h"
23#include "llvm/IR/BasicBlock.h"
24#include "llvm/IR/Constants.h"
25#include "llvm/IR/Dominators.h"
26#include "llvm/IR/Function.h"
31#include "llvm/Pass.h"
32#include "llvm/Support/Debug.h"
35#include <optional>
37using namespace llvm;
38using namespace llvm::PatternMatch;
40#define DEBUG_TYPE "lower-is-constant-intrinsic"
43 "Number of 'is.constant' intrinsic calls handled");
45 "Number of 'objectsize' intrinsic calls handled");
48 if (auto *C = dyn_cast<Constant>(II->getOperand(0)))
49 if (C->isManifestConstant())
50 return ConstantInt::getTrue(II->getType());
51 return ConstantInt::getFalse(II->getType());
55 Value *NewValue,
56 DomTreeUpdater *DTU) {
57 bool HasDeadBlocks = false;
58 SmallSetVector<Instruction *, 8> UnsimplifiedUsers;
59 replaceAndRecursivelySimplify(II, NewValue, nullptr, nullptr, nullptr,
60 &UnsimplifiedUsers);
61 // UnsimplifiedUsers can contain PHI nodes that may be removed when
62 // replacing the branch instructions, so use a value handle worklist
63 // to handle those possibly removed instructions.
64 SmallVector<WeakVH, 8> Worklist(UnsimplifiedUsers.begin(),
65 UnsimplifiedUsers.end());
67 for (auto &VH : Worklist) {
68 BranchInst *BI = dyn_cast_or_null<BranchInst>(VH);
69 if (!BI)
70 continue;
71 if (BI->isUnconditional())
72 continue;
75 if (match(BI->getOperand(0), m_Zero())) {
76 Target = BI->getSuccessor(1);
77 Other = BI->getSuccessor(0);
78 } else if (match(BI->getOperand(0), m_One())) {
79 Target = BI->getSuccessor(0);
80 Other = BI->getSuccessor(1);
81 } else {
82 Target = nullptr;
83 Other = nullptr;
84 }
85 if (Target && Target != Other) {
86 BasicBlock *Source = BI->getParent();
87 Other->removePredecessor(Source);
88 BI->eraseFromParent();
90 if (DTU)
91 DTU->applyUpdates({{DominatorTree::Delete, Source, Other}});
92 if (pred_empty(Other))
93 HasDeadBlocks = true;
94 }
95 }
96 return HasDeadBlocks;
100 DominatorTree *DT) {
101 std::optional<DomTreeUpdater> DTU;
102 if (DT)
103 DTU.emplace(DT, DomTreeUpdater::UpdateStrategy::Lazy);
105 bool HasDeadBlocks = false;
106 const auto &DL = F.getParent()->getDataLayout();
110 for (BasicBlock *BB : RPOT) {
111 for (Instruction &I: *BB) {
112 IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I);
113 if (!II)
114 continue;
115 switch (II->getIntrinsicID()) {
116 default:
117 break;
118 case Intrinsic::is_constant:
119 case Intrinsic::objectsize:
120 Worklist.push_back(WeakTrackingVH(&I));
121 break;
122 }
123 }
124 }
125 for (WeakTrackingVH &VH: Worklist) {
126 // Items on the worklist can be mutated by earlier recursive replaces.
127 // This can remove the intrinsic as dead (VH == null), but also replace
128 // the intrinsic in place.
129 if (!VH)
130 continue;
131 IntrinsicInst *II = dyn_cast<IntrinsicInst>(&*VH);
132 if (!II)
133 continue;
134 Value *NewValue;
135 switch (II->getIntrinsicID()) {
136 default:
137 continue;
138 case Intrinsic::is_constant:
139 NewValue = lowerIsConstantIntrinsic(II);
140 LLVM_DEBUG(dbgs() << "Folding " << *II << " to " << *NewValue << "\n");
141 IsConstantIntrinsicsHandled++;
142 break;
143 case Intrinsic::objectsize:
144 NewValue = lowerObjectSizeCall(II, DL, &TLI, true);
145 LLVM_DEBUG(dbgs() << "Folding " << *II << " to " << *NewValue << "\n");
146 ObjectSizeIntrinsicsHandled++;
147 break;
148 }
150 II, NewValue, DTU ? &*DTU : nullptr);
151 }
152 if (HasDeadBlocks)
153 removeUnreachableBlocks(F, DTU ? &*DTU : nullptr);
154 return !Worklist.empty();
163 return PA;
164 }
166 return PreservedAnalyses::all();
169namespace {
170/// Legacy pass for lowering is.constant intrinsics out of the IR.
172/// When this pass is run over a function it converts is.constant intrinsics
173/// into 'true' or 'false'. This complements the normal constant folding
174/// to 'true' as part of Instruction Simplify passes.
175class LowerConstantIntrinsics : public FunctionPass {
177 static char ID;
178 LowerConstantIntrinsics() : FunctionPass(ID) {
180 }
182 bool runOnFunction(Function &F) override {
183 const TargetLibraryInfo &TLI =
184 getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
185 DominatorTree *DT = nullptr;
186 if (auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>())
187 DT = &DTWP->getDomTree();
188 return lowerConstantIntrinsics(F, TLI, DT);
189 }
191 void getAnalysisUsage(AnalysisUsage &AU) const override {
195 }
197} // namespace
199char LowerConstantIntrinsics::ID = 0;
200INITIALIZE_PASS_BEGIN(LowerConstantIntrinsics, "lower-constant-intrinsics",
201 "Lower constant intrinsics", false, false)
204INITIALIZE_PASS_END(LowerConstantIntrinsics, "lower-constant-intrinsics",
208 return new LowerConstantIntrinsics();
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file contains the declarations for the subclasses of Constant, which represent the different fla...
#define LLVM_DEBUG(X)
Definition: Debug.h:101
std::optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1272
static bool runOnFunction(Function &F, bool PostInlining)
expand Expand reduction intrinsics
This is the interface for a simple mod/ref and alias analysis over globals.
static bool lowerConstantIntrinsics(Function &F, const TargetLibraryInfo &TLI, DominatorTree *DT)
static bool replaceConditionalBranchesOnConstant(Instruction *II, Value *NewValue, DomTreeUpdater *DTU)
static Value * lowerIsConstantIntrinsic(IntrinsicInst *II)
The header file for the LowerConstantIntrinsics pass as used by the new pass manager.
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Definition: PassSupport.h:55
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:59
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.
This file implements a set that has insertion order iteration characteristics.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
Definition: Statistic.h:167
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:620
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
Definition: PassManager.h:793
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:774
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.
LLVM Basic Block Representation.
Definition: BasicBlock.h:56
Conditional or Unconditional Branch instruction.
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
BasicBlock * getSuccessor(unsigned i) const
bool isUnconditional() const
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:833
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:840
void applyUpdates(ArrayRef< DominatorTree::UpdateType > Updates)
Submit updates to all available trees.
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:279
Legacy analysis pass which computes a DominatorTree.
Definition: Dominators.h:314
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
Legacy wrapper pass to provide the GlobalsAAResult object.
const BasicBlock * getParent() const
Definition: Instruction.h:90
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:83
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:47
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:54
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: PassManager.h:152
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:158
void preserve()
Mark an analysis as preserved.
Definition: PassManager.h:173
iterator end()
Get an iterator to the end of the SetVector.
Definition: SetVector.h:113
iterator begin()
Get an iterator to the beginning of the SetVector.
Definition: SetVector.h:103
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:370
bool empty() const
Definition: SmallVector.h:94
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
Analysis pass providing the TargetLibraryInfo.
Provides information about what library functions are available for the current target.
Target - Wrapper for Target specific information.
Value * getOperand(unsigned i) const
Definition: User.h:169
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
Value handle that is nullable, but tries to track the Value.
Definition: ValueHandle.h:204
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:49
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:525
is_zero m_Zero()
Match any null constant or a vector with all elements equal to 0.
Definition: PatternMatch.h:545
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
Value * lowerObjectSizeCall(IntrinsicInst *ObjectSize, const DataLayout &DL, const TargetLibraryInfo *TLI, bool MustSucceed)
Try to turn a call to @llvm.objectsize into an integer value of the given Type.
void initializeLowerConstantIntrinsicsPass(PassRegistry &)
bool replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, SmallSetVector< Instruction *, 8 > *UnsimplifiedUsers=nullptr)
Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
FunctionPass * createLowerConstantIntrinsicsPass()
bool pred_empty(const BasicBlock *BB)
Definition: CFG.h:118
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:2670
PreservedAnalyses run(Function &F, FunctionAnalysisManager &)
Run the pass over the function.