xref: /llvm-project/llvm/lib/Transforms/Scalar/LowerConstantIntrinsics.cpp (revision a78d8feb48a536f50736f97a9ae28d5bae94e8ed)
1 //===- LowerConstantIntrinsics.cpp - Lower constant intrinsic calls -------===//
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 pass lowers all remaining 'objectsize' 'is.constant' intrinsic calls
10 // and provides constant propagation and basic CFG cleanup on the result.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
15 #include "llvm/ADT/PostOrderIterator.h"
16 #include "llvm/ADT/SetVector.h"
17 #include "llvm/ADT/Statistic.h"
18 #include "llvm/Analysis/DomTreeUpdater.h"
19 #include "llvm/Analysis/GlobalsModRef.h"
20 #include "llvm/Analysis/InstructionSimplify.h"
21 #include "llvm/Analysis/MemoryBuiltins.h"
22 #include "llvm/Analysis/TargetLibraryInfo.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"
27 #include "llvm/IR/Instructions.h"
28 #include "llvm/IR/IntrinsicInst.h"
29 #include "llvm/IR/Intrinsics.h"
30 #include "llvm/IR/PatternMatch.h"
31 #include "llvm/InitializePasses.h"
32 #include "llvm/Pass.h"
33 #include "llvm/Support/Debug.h"
34 #include "llvm/Transforms/Scalar.h"
35 #include "llvm/Transforms/Utils/Local.h"
36 
37 using namespace llvm;
38 using namespace llvm::PatternMatch;
39 
40 #define DEBUG_TYPE "lower-is-constant-intrinsic"
41 
42 STATISTIC(IsConstantIntrinsicsHandled,
43           "Number of 'is.constant' intrinsic calls handled");
44 STATISTIC(ObjectSizeIntrinsicsHandled,
45           "Number of 'objectsize' intrinsic calls handled");
46 
47 static Value *lowerIsConstantIntrinsic(IntrinsicInst *II) {
48   Value *Op = II->getOperand(0);
49 
50   return isa<Constant>(Op) ? ConstantInt::getTrue(II->getType())
51                            : ConstantInt::getFalse(II->getType());
52 }
53 
54 static bool replaceConditionalBranchesOnConstant(Instruction *II,
55                                                  Value *NewValue,
56                                                  DomTreeUpdater *DTU) {
57   bool HasDeadBlocks = false;
58   SmallSetVector<Instruction *, 8> Worklist;
59   replaceAndRecursivelySimplify(II, NewValue, nullptr, nullptr, nullptr,
60                                 &Worklist);
61   for (auto I : Worklist) {
62     BranchInst *BI = dyn_cast<BranchInst>(I);
63     if (!BI)
64       continue;
65     if (BI->isUnconditional())
66       continue;
67 
68     BasicBlock *Target, *Other;
69     if (match(BI->getOperand(0), m_Zero())) {
70       Target = BI->getSuccessor(1);
71       Other = BI->getSuccessor(0);
72     } else if (match(BI->getOperand(0), m_One())) {
73       Target = BI->getSuccessor(0);
74       Other = BI->getSuccessor(1);
75     } else {
76       Target = nullptr;
77       Other = nullptr;
78     }
79     if (Target && Target != Other) {
80       BasicBlock *Source = BI->getParent();
81       Other->removePredecessor(Source);
82       BI->eraseFromParent();
83       BranchInst::Create(Target, Source);
84       if (DTU)
85         DTU->applyUpdates({{DominatorTree::Delete, Source, Other}});
86       if (pred_empty(Other))
87         HasDeadBlocks = true;
88     }
89   }
90   return HasDeadBlocks;
91 }
92 
93 static bool lowerConstantIntrinsics(Function &F, const TargetLibraryInfo *TLI,
94                                     DominatorTree *DT) {
95   Optional<DomTreeUpdater> DTU;
96   if (DT)
97     DTU.emplace(DT, DomTreeUpdater::UpdateStrategy::Lazy);
98 
99   bool HasDeadBlocks = false;
100   const auto &DL = F.getParent()->getDataLayout();
101   SmallVector<WeakTrackingVH, 8> Worklist;
102 
103   ReversePostOrderTraversal<Function *> RPOT(&F);
104   for (BasicBlock *BB : RPOT) {
105     for (Instruction &I: *BB) {
106       IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I);
107       if (!II)
108         continue;
109       switch (II->getIntrinsicID()) {
110       default:
111         break;
112       case Intrinsic::is_constant:
113       case Intrinsic::objectsize:
114         Worklist.push_back(WeakTrackingVH(&I));
115         break;
116       }
117     }
118   }
119   for (WeakTrackingVH &VH: Worklist) {
120     // Items on the worklist can be mutated by earlier recursive replaces.
121     // This can remove the intrinsic as dead (VH == null), but also replace
122     // the intrinsic in place.
123     if (!VH)
124       continue;
125     IntrinsicInst *II = dyn_cast<IntrinsicInst>(&*VH);
126     if (!II)
127       continue;
128     Value *NewValue;
129     switch (II->getIntrinsicID()) {
130     default:
131       continue;
132     case Intrinsic::is_constant:
133       NewValue = lowerIsConstantIntrinsic(II);
134       IsConstantIntrinsicsHandled++;
135       break;
136     case Intrinsic::objectsize:
137       NewValue = lowerObjectSizeCall(II, DL, TLI, true);
138       ObjectSizeIntrinsicsHandled++;
139       break;
140     }
141     HasDeadBlocks |= replaceConditionalBranchesOnConstant(
142         II, NewValue, DTU.hasValue() ? DTU.getPointer() : nullptr);
143   }
144   if (HasDeadBlocks)
145     removeUnreachableBlocks(F, DTU.hasValue() ? DTU.getPointer() : nullptr);
146   return !Worklist.empty();
147 }
148 
149 PreservedAnalyses
150 LowerConstantIntrinsicsPass::run(Function &F, FunctionAnalysisManager &AM) {
151   if (lowerConstantIntrinsics(F, AM.getCachedResult<TargetLibraryAnalysis>(F),
152                               AM.getCachedResult<DominatorTreeAnalysis>(F))) {
153     PreservedAnalyses PA;
154     PA.preserve<GlobalsAA>();
155     PA.preserve<DominatorTreeAnalysis>();
156     return PA;
157   }
158 
159   return PreservedAnalyses::all();
160 }
161 
162 namespace {
163 /// Legacy pass for lowering is.constant intrinsics out of the IR.
164 ///
165 /// When this pass is run over a function it converts is.constant intrinsics
166 /// into 'true' or 'false'. This complements the normal constant folding
167 /// to 'true' as part of Instruction Simplify passes.
168 class LowerConstantIntrinsics : public FunctionPass {
169 public:
170   static char ID;
171   LowerConstantIntrinsics() : FunctionPass(ID) {
172     initializeLowerConstantIntrinsicsPass(*PassRegistry::getPassRegistry());
173   }
174 
175   bool runOnFunction(Function &F) override {
176     auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
177     const TargetLibraryInfo *TLI = TLIP ? &TLIP->getTLI(F) : nullptr;
178     DominatorTree *DT = nullptr;
179     if (auto *DTWP = getAnalysisIfAvailable<DominatorTreeWrapperPass>())
180       DT = &DTWP->getDomTree();
181     return lowerConstantIntrinsics(F, TLI, DT);
182   }
183 
184   void getAnalysisUsage(AnalysisUsage &AU) const override {
185     AU.addPreserved<GlobalsAAWrapperPass>();
186     AU.addPreserved<DominatorTreeWrapperPass>();
187   }
188 };
189 } // namespace
190 
191 char LowerConstantIntrinsics::ID = 0;
192 INITIALIZE_PASS_BEGIN(LowerConstantIntrinsics, "lower-constant-intrinsics",
193                       "Lower constant intrinsics", false, false)
194 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
195 INITIALIZE_PASS_END(LowerConstantIntrinsics, "lower-constant-intrinsics",
196                     "Lower constant intrinsics", false, false)
197 
198 FunctionPass *llvm::createLowerConstantIntrinsicsPass() {
199   return new LowerConstantIntrinsics();
200 }
201