1 //===---- BDCE.cpp - Bit-tracking dead code elimination -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Bit-Tracking Dead Code Elimination pass. Some
11 // instructions (shifts, some ands, ors, etc.) kill some of their input bits.
12 // We track these dead bits and remove instructions that compute only these
15 //===----------------------------------------------------------------------===//
17 #include "llvm/Transforms/Scalar.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/DepthFirstIterator.h"
20 #include "llvm/ADT/SmallPtrSet.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/Statistic.h"
23 #include "llvm/Analysis/AssumptionCache.h"
24 #include "llvm/Analysis/ValueTracking.h"
25 #include "llvm/IR/BasicBlock.h"
26 #include "llvm/IR/CFG.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/Dominators.h"
29 #include "llvm/IR/InstIterator.h"
30 #include "llvm/IR/Instructions.h"
31 #include "llvm/IR/IntrinsicInst.h"
32 #include "llvm/IR/Module.h"
33 #include "llvm/IR/Operator.h"
34 #include "llvm/Pass.h"
35 #include "llvm/Support/Debug.h"
36 #include "llvm/Support/raw_ostream.h"
40 #define DEBUG_TYPE "bdce"
42 STATISTIC(NumRemoved, "Number of instructions removed (unused)");
43 STATISTIC(NumSimplified, "Number of instructions trivialized (dead bits)");
46 struct BDCE : public FunctionPass {
47 static char ID; // Pass identification, replacement for typeid
48 BDCE() : FunctionPass(ID) {
49 initializeBDCEPass(*PassRegistry::getPassRegistry());
52 bool runOnFunction(Function& F) override;
54 void getAnalysisUsage(AnalysisUsage& AU) const override {
56 AU.addRequired<AssumptionCacheTracker>();
57 AU.addRequired<DominatorTreeWrapperPass>();
60 void determineLiveOperandBits(const Instruction *UserI,
61 const Instruction *I, unsigned OperandNo,
62 const APInt &AOut, APInt &AB,
63 APInt &KnownZero, APInt &KnownOne,
64 APInt &KnownZero2, APInt &KnownOne2);
72 INITIALIZE_PASS_BEGIN(BDCE, "bdce", "Bit-Tracking Dead Code Elimination",
74 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
75 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
76 INITIALIZE_PASS_END(BDCE, "bdce", "Bit-Tracking Dead Code Elimination",
79 static bool isAlwaysLive(Instruction *I) {
80 return isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) ||
81 isa<LandingPadInst>(I) || I->mayHaveSideEffects();
84 void BDCE::determineLiveOperandBits(const Instruction *UserI,
85 const Instruction *I, unsigned OperandNo,
86 const APInt &AOut, APInt &AB,
87 APInt &KnownZero, APInt &KnownOne,
88 APInt &KnownZero2, APInt &KnownOne2) {
89 unsigned BitWidth = AB.getBitWidth();
91 // We're called once per operand, but for some instructions, we need to
92 // compute known bits of both operands in order to determine the live bits of
93 // either (when both operands are instructions themselves). We don't,
94 // however, want to do this twice, so we cache the result in APInts that live
95 // in the caller. For the two-relevant-operands case, both operand values are
97 auto ComputeKnownBits =
98 [&](unsigned BitWidth, const Value *V1, const Value *V2) {
99 const DataLayout &DL = I->getModule()->getDataLayout();
100 KnownZero = APInt(BitWidth, 0);
101 KnownOne = APInt(BitWidth, 0);
102 computeKnownBits(const_cast<Value *>(V1), KnownZero, KnownOne, DL, 0,
106 KnownZero2 = APInt(BitWidth, 0);
107 KnownOne2 = APInt(BitWidth, 0);
108 computeKnownBits(const_cast<Value *>(V2), KnownZero2, KnownOne2, DL,
113 switch (UserI->getOpcode()) {
115 case Instruction::Call:
116 case Instruction::Invoke:
117 if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(UserI))
118 switch (II->getIntrinsicID()) {
120 case Intrinsic::bswap:
121 // The alive bits of the input are the swapped alive bits of
123 AB = AOut.byteSwap();
125 case Intrinsic::ctlz:
126 if (OperandNo == 0) {
127 // We need some output bits, so we need all bits of the
128 // input to the left of, and including, the leftmost bit
130 ComputeKnownBits(BitWidth, I, nullptr);
131 AB = APInt::getHighBitsSet(BitWidth,
132 std::min(BitWidth, KnownOne.countLeadingZeros()+1));
135 case Intrinsic::cttz:
136 if (OperandNo == 0) {
137 // We need some output bits, so we need all bits of the
138 // input to the right of, and including, the rightmost bit
140 ComputeKnownBits(BitWidth, I, nullptr);
141 AB = APInt::getLowBitsSet(BitWidth,
142 std::min(BitWidth, KnownOne.countTrailingZeros()+1));
147 case Instruction::Add:
148 case Instruction::Sub:
149 // Find the highest live output bit. We don't need any more input
150 // bits than that (adds, and thus subtracts, ripple only to the
152 AB = APInt::getLowBitsSet(BitWidth, AOut.getActiveBits());
154 case Instruction::Shl:
156 if (ConstantInt *CI =
157 dyn_cast<ConstantInt>(UserI->getOperand(1))) {
158 uint64_t ShiftAmt = CI->getLimitedValue(BitWidth-1);
159 AB = AOut.lshr(ShiftAmt);
161 // If the shift is nuw/nsw, then the high bits are not dead
162 // (because we've promised that they *must* be zero).
163 const ShlOperator *S = cast<ShlOperator>(UserI);
164 if (S->hasNoSignedWrap())
165 AB |= APInt::getHighBitsSet(BitWidth, ShiftAmt+1);
166 else if (S->hasNoUnsignedWrap())
167 AB |= APInt::getHighBitsSet(BitWidth, ShiftAmt);
170 case Instruction::LShr:
172 if (ConstantInt *CI =
173 dyn_cast<ConstantInt>(UserI->getOperand(1))) {
174 uint64_t ShiftAmt = CI->getLimitedValue(BitWidth-1);
175 AB = AOut.shl(ShiftAmt);
177 // If the shift is exact, then the low bits are not dead
178 // (they must be zero).
179 if (cast<LShrOperator>(UserI)->isExact())
180 AB |= APInt::getLowBitsSet(BitWidth, ShiftAmt);
183 case Instruction::AShr:
185 if (ConstantInt *CI =
186 dyn_cast<ConstantInt>(UserI->getOperand(1))) {
187 uint64_t ShiftAmt = CI->getLimitedValue(BitWidth-1);
188 AB = AOut.shl(ShiftAmt);
189 // Because the high input bit is replicated into the
190 // high-order bits of the result, if we need any of those
191 // bits, then we must keep the highest input bit.
192 if ((AOut & APInt::getHighBitsSet(BitWidth, ShiftAmt))
194 AB.setBit(BitWidth-1);
196 // If the shift is exact, then the low bits are not dead
197 // (they must be zero).
198 if (cast<AShrOperator>(UserI)->isExact())
199 AB |= APInt::getLowBitsSet(BitWidth, ShiftAmt);
202 case Instruction::And:
205 // For bits that are known zero, the corresponding bits in the
206 // other operand are dead (unless they're both zero, in which
207 // case they can't both be dead, so just mark the LHS bits as
209 if (OperandNo == 0) {
210 ComputeKnownBits(BitWidth, I, UserI->getOperand(1));
213 if (!isa<Instruction>(UserI->getOperand(0)))
214 ComputeKnownBits(BitWidth, UserI->getOperand(0), I);
215 AB &= ~(KnownZero & ~KnownZero2);
218 case Instruction::Or:
221 // For bits that are known one, the corresponding bits in the
222 // other operand are dead (unless they're both one, in which
223 // case they can't both be dead, so just mark the LHS bits as
225 if (OperandNo == 0) {
226 ComputeKnownBits(BitWidth, I, UserI->getOperand(1));
229 if (!isa<Instruction>(UserI->getOperand(0)))
230 ComputeKnownBits(BitWidth, UserI->getOperand(0), I);
231 AB &= ~(KnownOne & ~KnownOne2);
234 case Instruction::Xor:
235 case Instruction::PHI:
238 case Instruction::Trunc:
239 AB = AOut.zext(BitWidth);
241 case Instruction::ZExt:
242 AB = AOut.trunc(BitWidth);
244 case Instruction::SExt:
245 AB = AOut.trunc(BitWidth);
246 // Because the high input bit is replicated into the
247 // high-order bits of the result, if we need any of those
248 // bits, then we must keep the highest input bit.
249 if ((AOut & APInt::getHighBitsSet(AOut.getBitWidth(),
250 AOut.getBitWidth() - BitWidth))
252 AB.setBit(BitWidth-1);
254 case Instruction::Select:
261 bool BDCE::runOnFunction(Function& F) {
262 if (skipOptnoneFunction(F))
265 AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
266 DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
268 DenseMap<Instruction *, APInt> AliveBits;
269 SmallVector<Instruction*, 128> Worklist;
271 // The set of visited instructions (non-integer-typed only).
272 SmallPtrSet<Instruction*, 128> Visited;
274 // Collect the set of "root" instructions that are known live.
275 for (Instruction &I : inst_range(F)) {
276 if (!isAlwaysLive(&I))
279 DEBUG(dbgs() << "BDCE: Root: " << I << "\n");
280 // For integer-valued instructions, set up an initial empty set of alive
281 // bits and add the instruction to the work list. For other instructions
282 // add their operands to the work list (for integer values operands, mark
283 // all bits as live).
284 if (IntegerType *IT = dyn_cast<IntegerType>(I.getType())) {
285 if (!AliveBits.count(&I)) {
286 AliveBits[&I] = APInt(IT->getBitWidth(), 0);
287 Worklist.push_back(&I);
293 // Non-integer-typed instructions...
294 for (Use &OI : I.operands()) {
295 if (Instruction *J = dyn_cast<Instruction>(OI)) {
296 if (IntegerType *IT = dyn_cast<IntegerType>(J->getType()))
297 AliveBits[J] = APInt::getAllOnesValue(IT->getBitWidth());
298 Worklist.push_back(J);
301 // To save memory, we don't add I to the Visited set here. Instead, we
302 // check isAlwaysLive on every instruction when searching for dead
303 // instructions later (we need to check isAlwaysLive for the
304 // integer-typed instructions anyway).
307 // Propagate liveness backwards to operands.
308 while (!Worklist.empty()) {
309 Instruction *UserI = Worklist.pop_back_val();
311 DEBUG(dbgs() << "BDCE: Visiting: " << *UserI);
313 if (UserI->getType()->isIntegerTy()) {
314 AOut = AliveBits[UserI];
315 DEBUG(dbgs() << " Alive Out: " << AOut);
317 DEBUG(dbgs() << "\n");
319 if (!UserI->getType()->isIntegerTy())
320 Visited.insert(UserI);
322 APInt KnownZero, KnownOne, KnownZero2, KnownOne2;
323 // Compute the set of alive bits for each operand. These are anded into the
324 // existing set, if any, and if that changes the set of alive bits, the
325 // operand is added to the work-list.
326 for (Use &OI : UserI->operands()) {
327 if (Instruction *I = dyn_cast<Instruction>(OI)) {
328 if (IntegerType *IT = dyn_cast<IntegerType>(I->getType())) {
329 unsigned BitWidth = IT->getBitWidth();
330 APInt AB = APInt::getAllOnesValue(BitWidth);
331 if (UserI->getType()->isIntegerTy() && !AOut &&
332 !isAlwaysLive(UserI)) {
333 AB = APInt(BitWidth, 0);
335 // If all bits of the output are dead, then all bits of the input
336 // Bits of each operand that are used to compute alive bits of the
337 // output are alive, all others are dead.
338 determineLiveOperandBits(UserI, I, OI.getOperandNo(), AOut, AB,
340 KnownZero2, KnownOne2);
343 // If we've added to the set of alive bits (or the operand has not
344 // been previously visited), then re-queue the operand to be visited
346 APInt ABPrev(BitWidth, 0);
347 auto ABI = AliveBits.find(I);
348 if (ABI != AliveBits.end())
349 ABPrev = ABI->second;
351 APInt ABNew = AB | ABPrev;
352 if (ABNew != ABPrev || ABI == AliveBits.end()) {
353 AliveBits[I] = std::move(ABNew);
354 Worklist.push_back(I);
356 } else if (!Visited.count(I)) {
357 Worklist.push_back(I);
363 bool Changed = false;
364 // The inverse of the live set is the dead set. These are those instructions
365 // which have no side effects and do not influence the control flow or return
366 // value of the function, and may therefore be deleted safely.
367 // NOTE: We reuse the Worklist vector here for memory efficiency.
368 for (Instruction &I : inst_range(F)) {
369 // For live instructions that have all dead bits, first make them dead by
370 // replacing all uses with something else. Then, if they don't need to
371 // remain live (because they have side effects, etc.) we can remove them.
372 if (I.getType()->isIntegerTy()) {
373 auto ABI = AliveBits.find(&I);
374 if (ABI != AliveBits.end()) {
375 if (ABI->second.getBoolValue())
378 DEBUG(dbgs() << "BDCE: Trivializing: " << I << " (all bits dead)\n");
379 // FIXME: In theory we could substitute undef here instead of zero.
380 // This should be reconsidered once we settle on the semantics of
381 // undef, poison, etc.
382 Value *Zero = ConstantInt::get(I.getType(), 0);
384 I.replaceAllUsesWith(Zero);
387 } else if (Visited.count(&I)) {
391 if (isAlwaysLive(&I))
394 Worklist.push_back(&I);
395 I.dropAllReferences();
399 for (Instruction *&I : Worklist) {
401 I->eraseFromParent();
407 FunctionPass *llvm::createBitTrackingDCEPass() {