LLVM  4.0.0
DemandedBits.h
Go to the documentation of this file.
1 //===-- llvm/Analysis/DemandedBits.h - Determine demanded bits --*- C++ -*-===//
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 #ifndef LLVM_ANALYSIS_DEMANDED_BITS_H
23 #define LLVM_ANALYSIS_DEMANDED_BITS_H
24 
25 #include "llvm/Pass.h"
26 #include "llvm/ADT/APInt.h"
27 #include "llvm/ADT/DenseMap.h"
28 #include "llvm/ADT/SmallPtrSet.h"
29 #include "llvm/IR/PassManager.h"
30 
31 namespace llvm {
32 
33 class FunctionPass;
34 class Function;
35 class Instruction;
36 class DominatorTree;
37 class AssumptionCache;
38 
39 class DemandedBits {
40 public:
42  F(F), AC(AC), DT(DT), Analyzed(false) {}
43 
44  /// Return the bits demanded from instruction I.
46 
47  /// Return true if, during analysis, I could not be reached.
49 
50  void print(raw_ostream &OS);
51 
52 private:
53  Function &F;
54  AssumptionCache ∾
55  DominatorTree &DT;
56 
57  void performAnalysis();
58  void determineLiveOperandBits(const Instruction *UserI,
59  const Instruction *I, unsigned OperandNo,
60  const APInt &AOut, APInt &AB,
61  APInt &KnownZero, APInt &KnownOne,
62  APInt &KnownZero2, APInt &KnownOne2);
63 
64  bool Analyzed;
65 
66  // The set of visited instructions (non-integer-typed only).
69 };
70 
72 private:
73  mutable Optional<DemandedBits> DB;
74 public:
75  static char ID; // Pass identification, replacement for typeid
77 
78  bool runOnFunction(Function &F) override;
79  void getAnalysisUsage(AnalysisUsage &AU) const override;
80 
81  /// Clean up memory in between runs
82  void releaseMemory() override;
83 
84  DemandedBits &getDemandedBits() { return *DB; }
85 
86  void print(raw_ostream &OS, const Module *M) const override;
87 };
88 
89 /// An analysis that produces \c DemandedBits for a function.
90 class DemandedBitsAnalysis : public AnalysisInfoMixin<DemandedBitsAnalysis> {
92  static AnalysisKey Key;
93 
94 public:
95  /// \brief Provide the result typedef for this analysis pass.
97 
98  /// \brief Run the analysis pass over a function and produce demanded bits
99  /// information.
101 };
102 
103 /// \brief Printer pass for DemandedBits
104 class DemandedBitsPrinterPass : public PassInfoMixin<DemandedBitsPrinterPass> {
105  raw_ostream &OS;
106 
107 public:
108  explicit DemandedBitsPrinterPass(raw_ostream &OS) : OS(OS) {}
110 };
111 
112 /// Create a demanded bits analysis pass.
113 FunctionPass *createDemandedBitsWrapperPass();
114 
115 } // End llvm namespace
116 
117 #endif
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
bool isInstructionDead(Instruction *I)
Return true if, during analysis, I could not be reached.
DemandedBitsPrinterPass(raw_ostream &OS)
Definition: DemandedBits.h:108
A cache of .assume calls within a function.
bool runOnFunction(Function &F) override
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
An analysis that produces DemandedBits for a function.
Definition: DemandedBits.h:90
This file implements a class to represent arbitrary precision integral constant values and operations...
#define F(x, y, z)
Definition: MD5.cpp:51
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:311
Function Alias Analysis false
DemandedBits run(Function &F, FunctionAnalysisManager &AM)
Run the analysis pass over a function and produce demanded bits information.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
DemandedBits Result
Provide the result typedef for this analysis pass.
Definition: DemandedBits.h:96
Printer pass for DemandedBits.
Definition: DemandedBits.h:104
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:328
Represent the analysis usage information of a pass.
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
DemandedBits & getDemandedBits()
Definition: DemandedBits.h:84
DemandedBits(Function &F, AssumptionCache &AC, DominatorTree &DT)
Definition: DemandedBits.h:41
APInt getDemandedBits(Instruction *I)
Return the bits demanded from instruction I.
Class for arbitrary precision integers.
Definition: APInt.h:77
void print(raw_ostream &OS, const Module *M) const override
print - Print out the internal state of the pass.
#define I(x, y, z)
Definition: MD5.cpp:54
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
A container for analyses that lazily runs them and caches their results.
This header defines various interfaces for pass management in LLVM.
FunctionPass * createDemandedBitsWrapperPass()
Create a demanded bits analysis pass.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:64
void releaseMemory() override
Clean up memory in between runs.
void print(raw_ostream &OS)