• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===---- DemandedBits.cpp - Determine demanded bits ----------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This pass implements a demanded bits analysis. A demanded bit is one that
11 // contributes to a result; bits that are not demanded can be either zero or
12 // one without affecting control or data flow. For example in this sequence:
13 //
14 //   %1 = add i32 %x, %y
15 //   %2 = trunc i32 %1 to i16
16 //
17 // Only the lowest 16 bits of %1 are demanded; the rest are removed by the
18 // trunc.
19 //
20 //===----------------------------------------------------------------------===//
21 
22 #include "llvm/Analysis/DemandedBits.h"
23 #include "llvm/ADT/DepthFirstIterator.h"
24 #include "llvm/ADT/SmallPtrSet.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/ADT/StringExtras.h"
27 #include "llvm/Analysis/AssumptionCache.h"
28 #include "llvm/Analysis/ValueTracking.h"
29 #include "llvm/IR/BasicBlock.h"
30 #include "llvm/IR/CFG.h"
31 #include "llvm/IR/DataLayout.h"
32 #include "llvm/IR/Dominators.h"
33 #include "llvm/IR/InstIterator.h"
34 #include "llvm/IR/Instructions.h"
35 #include "llvm/IR/IntrinsicInst.h"
36 #include "llvm/IR/Module.h"
37 #include "llvm/IR/Operator.h"
38 #include "llvm/Pass.h"
39 #include "llvm/Support/Debug.h"
40 #include "llvm/Support/raw_ostream.h"
41 using namespace llvm;
42 
43 #define DEBUG_TYPE "demanded-bits"
44 
45 char DemandedBitsWrapperPass::ID = 0;
46 INITIALIZE_PASS_BEGIN(DemandedBitsWrapperPass, "demanded-bits",
47                       "Demanded bits analysis", false, false)
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)48 INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
49 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
50 INITIALIZE_PASS_END(DemandedBitsWrapperPass, "demanded-bits",
51                     "Demanded bits analysis", false, false)
52 
53 DemandedBitsWrapperPass::DemandedBitsWrapperPass() : FunctionPass(ID) {
54   initializeDemandedBitsWrapperPassPass(*PassRegistry::getPassRegistry());
55 }
56 
getAnalysisUsage(AnalysisUsage & AU) const57 void DemandedBitsWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
58   AU.setPreservesCFG();
59   AU.addRequired<AssumptionCacheTracker>();
60   AU.addRequired<DominatorTreeWrapperPass>();
61   AU.setPreservesAll();
62 }
63 
print(raw_ostream & OS,const Module * M) const64 void DemandedBitsWrapperPass::print(raw_ostream &OS, const Module *M) const {
65   DB->print(OS);
66 }
67 
isAlwaysLive(Instruction * I)68 static bool isAlwaysLive(Instruction *I) {
69   return isa<TerminatorInst>(I) || isa<DbgInfoIntrinsic>(I) ||
70       I->isEHPad() || I->mayHaveSideEffects();
71 }
72 
determineLiveOperandBits(const Instruction * UserI,const Instruction * I,unsigned OperandNo,const APInt & AOut,APInt & AB,APInt & KnownZero,APInt & KnownOne,APInt & KnownZero2,APInt & KnownOne2)73 void DemandedBits::determineLiveOperandBits(
74     const Instruction *UserI, const Instruction *I, unsigned OperandNo,
75     const APInt &AOut, APInt &AB, APInt &KnownZero, APInt &KnownOne,
76     APInt &KnownZero2, APInt &KnownOne2) {
77   unsigned BitWidth = AB.getBitWidth();
78 
79   // We're called once per operand, but for some instructions, we need to
80   // compute known bits of both operands in order to determine the live bits of
81   // either (when both operands are instructions themselves). We don't,
82   // however, want to do this twice, so we cache the result in APInts that live
83   // in the caller. For the two-relevant-operands case, both operand values are
84   // provided here.
85   auto ComputeKnownBits =
86       [&](unsigned BitWidth, const Value *V1, const Value *V2) {
87         const DataLayout &DL = I->getModule()->getDataLayout();
88         KnownZero = APInt(BitWidth, 0);
89         KnownOne = APInt(BitWidth, 0);
90         computeKnownBits(const_cast<Value *>(V1), KnownZero, KnownOne, DL, 0,
91                          &AC, UserI, &DT);
92 
93         if (V2) {
94           KnownZero2 = APInt(BitWidth, 0);
95           KnownOne2 = APInt(BitWidth, 0);
96           computeKnownBits(const_cast<Value *>(V2), KnownZero2, KnownOne2, DL,
97                            0, &AC, UserI, &DT);
98         }
99       };
100 
101   switch (UserI->getOpcode()) {
102   default: break;
103   case Instruction::Call:
104   case Instruction::Invoke:
105     if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(UserI))
106       switch (II->getIntrinsicID()) {
107       default: break;
108       case Intrinsic::bswap:
109         // The alive bits of the input are the swapped alive bits of
110         // the output.
111         AB = AOut.byteSwap();
112         break;
113       case Intrinsic::ctlz:
114         if (OperandNo == 0) {
115           // We need some output bits, so we need all bits of the
116           // input to the left of, and including, the leftmost bit
117           // known to be one.
118           ComputeKnownBits(BitWidth, I, nullptr);
119           AB = APInt::getHighBitsSet(BitWidth,
120                  std::min(BitWidth, KnownOne.countLeadingZeros()+1));
121         }
122         break;
123       case Intrinsic::cttz:
124         if (OperandNo == 0) {
125           // We need some output bits, so we need all bits of the
126           // input to the right of, and including, the rightmost bit
127           // known to be one.
128           ComputeKnownBits(BitWidth, I, nullptr);
129           AB = APInt::getLowBitsSet(BitWidth,
130                  std::min(BitWidth, KnownOne.countTrailingZeros()+1));
131         }
132         break;
133       }
134     break;
135   case Instruction::Add:
136   case Instruction::Sub:
137   case Instruction::Mul:
138     // Find the highest live output bit. We don't need any more input
139     // bits than that (adds, and thus subtracts, ripple only to the
140     // left).
141     AB = APInt::getLowBitsSet(BitWidth, AOut.getActiveBits());
142     break;
143   case Instruction::Shl:
144     if (OperandNo == 0)
145       if (ConstantInt *CI =
146             dyn_cast<ConstantInt>(UserI->getOperand(1))) {
147         uint64_t ShiftAmt = CI->getLimitedValue(BitWidth-1);
148         AB = AOut.lshr(ShiftAmt);
149 
150         // If the shift is nuw/nsw, then the high bits are not dead
151         // (because we've promised that they *must* be zero).
152         const ShlOperator *S = cast<ShlOperator>(UserI);
153         if (S->hasNoSignedWrap())
154           AB |= APInt::getHighBitsSet(BitWidth, ShiftAmt+1);
155         else if (S->hasNoUnsignedWrap())
156           AB |= APInt::getHighBitsSet(BitWidth, ShiftAmt);
157       }
158     break;
159   case Instruction::LShr:
160     if (OperandNo == 0)
161       if (ConstantInt *CI =
162             dyn_cast<ConstantInt>(UserI->getOperand(1))) {
163         uint64_t ShiftAmt = CI->getLimitedValue(BitWidth-1);
164         AB = AOut.shl(ShiftAmt);
165 
166         // If the shift is exact, then the low bits are not dead
167         // (they must be zero).
168         if (cast<LShrOperator>(UserI)->isExact())
169           AB |= APInt::getLowBitsSet(BitWidth, ShiftAmt);
170       }
171     break;
172   case Instruction::AShr:
173     if (OperandNo == 0)
174       if (ConstantInt *CI =
175             dyn_cast<ConstantInt>(UserI->getOperand(1))) {
176         uint64_t ShiftAmt = CI->getLimitedValue(BitWidth-1);
177         AB = AOut.shl(ShiftAmt);
178         // Because the high input bit is replicated into the
179         // high-order bits of the result, if we need any of those
180         // bits, then we must keep the highest input bit.
181         if ((AOut & APInt::getHighBitsSet(BitWidth, ShiftAmt))
182             .getBoolValue())
183           AB.setBit(BitWidth-1);
184 
185         // If the shift is exact, then the low bits are not dead
186         // (they must be zero).
187         if (cast<AShrOperator>(UserI)->isExact())
188           AB |= APInt::getLowBitsSet(BitWidth, ShiftAmt);
189       }
190     break;
191   case Instruction::And:
192     AB = AOut;
193 
194     // For bits that are known zero, the corresponding bits in the
195     // other operand are dead (unless they're both zero, in which
196     // case they can't both be dead, so just mark the LHS bits as
197     // dead).
198     if (OperandNo == 0) {
199       ComputeKnownBits(BitWidth, I, UserI->getOperand(1));
200       AB &= ~KnownZero2;
201     } else {
202       if (!isa<Instruction>(UserI->getOperand(0)))
203         ComputeKnownBits(BitWidth, UserI->getOperand(0), I);
204       AB &= ~(KnownZero & ~KnownZero2);
205     }
206     break;
207   case Instruction::Or:
208     AB = AOut;
209 
210     // For bits that are known one, the corresponding bits in the
211     // other operand are dead (unless they're both one, in which
212     // case they can't both be dead, so just mark the LHS bits as
213     // dead).
214     if (OperandNo == 0) {
215       ComputeKnownBits(BitWidth, I, UserI->getOperand(1));
216       AB &= ~KnownOne2;
217     } else {
218       if (!isa<Instruction>(UserI->getOperand(0)))
219         ComputeKnownBits(BitWidth, UserI->getOperand(0), I);
220       AB &= ~(KnownOne & ~KnownOne2);
221     }
222     break;
223   case Instruction::Xor:
224   case Instruction::PHI:
225     AB = AOut;
226     break;
227   case Instruction::Trunc:
228     AB = AOut.zext(BitWidth);
229     break;
230   case Instruction::ZExt:
231     AB = AOut.trunc(BitWidth);
232     break;
233   case Instruction::SExt:
234     AB = AOut.trunc(BitWidth);
235     // Because the high input bit is replicated into the
236     // high-order bits of the result, if we need any of those
237     // bits, then we must keep the highest input bit.
238     if ((AOut & APInt::getHighBitsSet(AOut.getBitWidth(),
239                                       AOut.getBitWidth() - BitWidth))
240         .getBoolValue())
241       AB.setBit(BitWidth-1);
242     break;
243   case Instruction::Select:
244     if (OperandNo != 0)
245       AB = AOut;
246     break;
247   }
248 }
249 
runOnFunction(Function & F)250 bool DemandedBitsWrapperPass::runOnFunction(Function &F) {
251   auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
252   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
253   DB.emplace(F, AC, DT);
254   return false;
255 }
256 
releaseMemory()257 void DemandedBitsWrapperPass::releaseMemory() {
258   DB.reset();
259 }
260 
performAnalysis()261 void DemandedBits::performAnalysis() {
262   if (Analyzed)
263     // Analysis already completed for this function.
264     return;
265   Analyzed = true;
266 
267   Visited.clear();
268   AliveBits.clear();
269 
270   SmallVector<Instruction*, 128> Worklist;
271 
272   // Collect the set of "root" instructions that are known live.
273   for (Instruction &I : instructions(F)) {
274     if (!isAlwaysLive(&I))
275       continue;
276 
277     DEBUG(dbgs() << "DemandedBits: Root: " << I << "\n");
278     // For integer-valued instructions, set up an initial empty set of alive
279     // bits and add the instruction to the work list. For other instructions
280     // add their operands to the work list (for integer values operands, mark
281     // all bits as live).
282     if (IntegerType *IT = dyn_cast<IntegerType>(I.getType())) {
283       if (!AliveBits.count(&I)) {
284         AliveBits[&I] = APInt(IT->getBitWidth(), 0);
285         Worklist.push_back(&I);
286       }
287 
288       continue;
289     }
290 
291     // Non-integer-typed instructions...
292     for (Use &OI : I.operands()) {
293       if (Instruction *J = dyn_cast<Instruction>(OI)) {
294         if (IntegerType *IT = dyn_cast<IntegerType>(J->getType()))
295           AliveBits[J] = APInt::getAllOnesValue(IT->getBitWidth());
296         Worklist.push_back(J);
297       }
298     }
299     // To save memory, we don't add I to the Visited set here. Instead, we
300     // check isAlwaysLive on every instruction when searching for dead
301     // instructions later (we need to check isAlwaysLive for the
302     // integer-typed instructions anyway).
303   }
304 
305   // Propagate liveness backwards to operands.
306   while (!Worklist.empty()) {
307     Instruction *UserI = Worklist.pop_back_val();
308 
309     DEBUG(dbgs() << "DemandedBits: Visiting: " << *UserI);
310     APInt AOut;
311     if (UserI->getType()->isIntegerTy()) {
312       AOut = AliveBits[UserI];
313       DEBUG(dbgs() << " Alive Out: " << AOut);
314     }
315     DEBUG(dbgs() << "\n");
316 
317     if (!UserI->getType()->isIntegerTy())
318       Visited.insert(UserI);
319 
320     APInt KnownZero, KnownOne, KnownZero2, KnownOne2;
321     // Compute the set of alive bits for each operand. These are anded into the
322     // existing set, if any, and if that changes the set of alive bits, the
323     // operand is added to the work-list.
324     for (Use &OI : UserI->operands()) {
325       if (Instruction *I = dyn_cast<Instruction>(OI)) {
326         if (IntegerType *IT = dyn_cast<IntegerType>(I->getType())) {
327           unsigned BitWidth = IT->getBitWidth();
328           APInt AB = APInt::getAllOnesValue(BitWidth);
329           if (UserI->getType()->isIntegerTy() && !AOut &&
330               !isAlwaysLive(UserI)) {
331             AB = APInt(BitWidth, 0);
332           } else {
333             // If all bits of the output are dead, then all bits of the input
334             // Bits of each operand that are used to compute alive bits of the
335             // output are alive, all others are dead.
336             determineLiveOperandBits(UserI, I, OI.getOperandNo(), AOut, AB,
337                                      KnownZero, KnownOne,
338                                      KnownZero2, KnownOne2);
339           }
340 
341           // If we've added to the set of alive bits (or the operand has not
342           // been previously visited), then re-queue the operand to be visited
343           // again.
344           APInt ABPrev(BitWidth, 0);
345           auto ABI = AliveBits.find(I);
346           if (ABI != AliveBits.end())
347             ABPrev = ABI->second;
348 
349           APInt ABNew = AB | ABPrev;
350           if (ABNew != ABPrev || ABI == AliveBits.end()) {
351             AliveBits[I] = std::move(ABNew);
352             Worklist.push_back(I);
353           }
354         } else if (!Visited.count(I)) {
355           Worklist.push_back(I);
356         }
357       }
358     }
359   }
360 }
361 
getDemandedBits(Instruction * I)362 APInt DemandedBits::getDemandedBits(Instruction *I) {
363   performAnalysis();
364 
365   const DataLayout &DL = I->getParent()->getModule()->getDataLayout();
366   if (AliveBits.count(I))
367     return AliveBits[I];
368   return APInt::getAllOnesValue(DL.getTypeSizeInBits(I->getType()));
369 }
370 
isInstructionDead(Instruction * I)371 bool DemandedBits::isInstructionDead(Instruction *I) {
372   performAnalysis();
373 
374   return !Visited.count(I) && AliveBits.find(I) == AliveBits.end() &&
375     !isAlwaysLive(I);
376 }
377 
print(raw_ostream & OS)378 void DemandedBits::print(raw_ostream &OS) {
379   performAnalysis();
380   for (auto &KV : AliveBits) {
381     OS << "DemandedBits: 0x" << utohexstr(KV.second.getLimitedValue()) << " for "
382        << *KV.first << "\n";
383   }
384 }
385 
createDemandedBitsWrapperPass()386 FunctionPass *llvm::createDemandedBitsWrapperPass() {
387   return new DemandedBitsWrapperPass();
388 }
389 
390 char DemandedBitsAnalysis::PassID;
391 
run(Function & F,AnalysisManager<Function> & AM)392 DemandedBits DemandedBitsAnalysis::run(Function &F,
393                                              AnalysisManager<Function> &AM) {
394   auto &AC = AM.getResult<AssumptionAnalysis>(F);
395   auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
396   return DemandedBits(F, AC, DT);
397 }
398 
run(Function & F,FunctionAnalysisManager & AM)399 PreservedAnalyses DemandedBitsPrinterPass::run(Function &F,
400                                                FunctionAnalysisManager &AM) {
401   AM.getResult<DemandedBitsAnalysis>(F).print(OS);
402   return PreservedAnalyses::all();
403 }
404