/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Transforms/Instrumentation.h
Line | Count | Source |
1 | | //===- Transforms/Instrumentation.h - Instrumentation passes ----*- 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 file defines constructor functions for instrumentation passes. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_H |
15 | | #define LLVM_TRANSFORMS_INSTRUMENTATION_H |
16 | | |
17 | | #include "llvm/ADT/StringRef.h" |
18 | | #include "llvm/IR/BasicBlock.h" |
19 | | #include <cassert> |
20 | | #include <cstdint> |
21 | | #include <limits> |
22 | | #include <string> |
23 | | #include <vector> |
24 | | |
25 | | #if defined(__GNUC__) && defined(__linux__) && !defined(ANDROID) |
26 | | inline void *getDFSanArgTLSPtrForJIT() { |
27 | | extern __thread __attribute__((tls_model("initial-exec"))) |
28 | | void *__dfsan_arg_tls; |
29 | | return (void *)&__dfsan_arg_tls; |
30 | | } |
31 | | |
32 | | inline void *getDFSanRetValTLSPtrForJIT() { |
33 | | extern __thread __attribute__((tls_model("initial-exec"))) |
34 | | void *__dfsan_retval_tls; |
35 | | return (void *)&__dfsan_retval_tls; |
36 | | } |
37 | | #endif |
38 | | |
39 | | namespace llvm { |
40 | | |
41 | | class FunctionPass; |
42 | | class ModulePass; |
43 | | class OptimizationRemarkEmitter; |
44 | | |
45 | | /// Instrumentation passes often insert conditional checks into entry blocks. |
46 | | /// Call this function before splitting the entry block to move instructions |
47 | | /// that must remain in the entry block up before the split point. Static |
48 | | /// allocas and llvm.localescape calls, for example, must remain in the entry |
49 | | /// block. |
50 | | BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB, |
51 | | BasicBlock::iterator IP); |
52 | | |
53 | | // Insert GCOV profiling instrumentation |
54 | | struct GCOVOptions { |
55 | | static GCOVOptions getDefault(); |
56 | | |
57 | | // Specify whether to emit .gcno files. |
58 | | bool EmitNotes; |
59 | | |
60 | | // Specify whether to modify the program to emit .gcda files when run. |
61 | | bool EmitData; |
62 | | |
63 | | // A four-byte version string. The meaning of a version string is described in |
64 | | // gcc's gcov-io.h |
65 | | char Version[4]; |
66 | | |
67 | | // Emit a "cfg checksum" that follows the "line number checksum" of a |
68 | | // function. This affects both .gcno and .gcda files. |
69 | | bool UseCfgChecksum; |
70 | | |
71 | | // Add the 'noredzone' attribute to added runtime library calls. |
72 | | bool NoRedZone; |
73 | | |
74 | | // Emit the name of the function in the .gcda files. This is redundant, as |
75 | | // the function identifier can be used to find the name from the .gcno file. |
76 | | bool FunctionNamesInData; |
77 | | |
78 | | // Emit the exit block immediately after the start block, rather than after |
79 | | // all of the function body's blocks. |
80 | | bool ExitBlockBeforeBody; |
81 | | }; |
82 | | |
83 | | ModulePass *createGCOVProfilerPass(const GCOVOptions &Options = |
84 | | GCOVOptions::getDefault()); |
85 | | |
86 | | // PGO Instrumention |
87 | | ModulePass *createPGOInstrumentationGenLegacyPass(); |
88 | | ModulePass * |
89 | | createPGOInstrumentationUseLegacyPass(StringRef Filename = StringRef("")); |
90 | | ModulePass *createPGOIndirectCallPromotionLegacyPass(bool InLTO = false, |
91 | | bool SamplePGO = false); |
92 | | FunctionPass *createPGOMemOPSizeOptLegacyPass(); |
93 | | |
94 | | // Helper function to check if it is legal to promote indirect call \p Inst |
95 | | // to a direct call of function \p F. Stores the reason in \p Reason. |
96 | | bool isLegalToPromote(Instruction *Inst, Function *F, const char **Reason); |
97 | | |
98 | | // Helper function that transforms Inst (either an indirect-call instruction, or |
99 | | // an invoke instruction , to a conditional call to F. This is like: |
100 | | // if (Inst.CalledValue == F) |
101 | | // F(...); |
102 | | // else |
103 | | // Inst(...); |
104 | | // end |
105 | | // TotalCount is the profile count value that the instruction executes. |
106 | | // Count is the profile count value that F is the target function. |
107 | | // These two values are used to update the branch weight. |
108 | | // If \p AttachProfToDirectCall is true, a prof metadata is attached to the |
109 | | // new direct call to contain \p Count. |
110 | | // Returns the promoted direct call instruction. |
111 | | Instruction *promoteIndirectCall(Instruction *Inst, Function *F, uint64_t Count, |
112 | | uint64_t TotalCount, |
113 | | bool AttachProfToDirectCall, |
114 | | OptimizationRemarkEmitter *ORE); |
115 | | |
116 | | /// Options for the frontend instrumentation based profiling pass. |
117 | | struct InstrProfOptions { |
118 | | // Add the 'noredzone' attribute to added runtime library calls. |
119 | | bool NoRedZone = false; |
120 | | |
121 | | // Do counter register promotion |
122 | | bool DoCounterPromotion = false; |
123 | | |
124 | | // Name of the profile file to use as output |
125 | | std::string InstrProfileOutput; |
126 | | |
127 | 143 | InstrProfOptions() = default; |
128 | | }; |
129 | | |
130 | | /// Insert frontend instrumentation based profiling. |
131 | | ModulePass *createInstrProfilingLegacyPass( |
132 | | const InstrProfOptions &Options = InstrProfOptions()); |
133 | | |
134 | | // Insert AddressSanitizer (address sanity checking) instrumentation |
135 | | FunctionPass *createAddressSanitizerFunctionPass(bool CompileKernel = false, |
136 | | bool Recover = false, |
137 | | bool UseAfterScope = false); |
138 | | ModulePass *createAddressSanitizerModulePass(bool CompileKernel = false, |
139 | | bool Recover = false, |
140 | | bool UseGlobalsGC = true); |
141 | | |
142 | | // Insert MemorySanitizer instrumentation (detection of uninitialized reads) |
143 | | FunctionPass *createMemorySanitizerPass(int TrackOrigins = 0, |
144 | | bool Recover = false); |
145 | | |
146 | | // Insert ThreadSanitizer (race detection) instrumentation |
147 | | FunctionPass *createThreadSanitizerPass(); |
148 | | |
149 | | // Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation |
150 | | ModulePass *createDataFlowSanitizerPass( |
151 | | const std::vector<std::string> &ABIListFiles = std::vector<std::string>(), |
152 | | void *(*getArgTLS)() = nullptr, void *(*getRetValTLS)() = nullptr); |
153 | | |
154 | | // Options for EfficiencySanitizer sub-tools. |
155 | | struct EfficiencySanitizerOptions { |
156 | | enum Type { |
157 | | ESAN_None = 0, |
158 | | ESAN_CacheFrag, |
159 | | ESAN_WorkingSet, |
160 | | } ToolType = ESAN_None; |
161 | | |
162 | 19 | EfficiencySanitizerOptions() = default; |
163 | | }; |
164 | | |
165 | | // Insert EfficiencySanitizer instrumentation. |
166 | | ModulePass *createEfficiencySanitizerPass( |
167 | | const EfficiencySanitizerOptions &Options = EfficiencySanitizerOptions()); |
168 | | |
169 | | // Options for sanitizer coverage instrumentation. |
170 | | struct SanitizerCoverageOptions { |
171 | | enum Type { |
172 | | SCK_None = 0, |
173 | | SCK_Function, |
174 | | SCK_BB, |
175 | | SCK_Edge |
176 | | } CoverageType = SCK_None; |
177 | | bool IndirectCalls = false; |
178 | | bool TraceBB = false; |
179 | | bool TraceCmp = false; |
180 | | bool TraceDiv = false; |
181 | | bool TraceGep = false; |
182 | | bool Use8bitCounters = false; |
183 | | bool TracePC = false; |
184 | | bool TracePCGuard = false; |
185 | | bool Inline8bitCounters = false; |
186 | | bool PCTable = false; |
187 | | bool NoPrune = false; |
188 | | bool StackDepth = false; |
189 | | |
190 | 62 | SanitizerCoverageOptions() = default; |
191 | | }; |
192 | | |
193 | | // Insert SanitizerCoverage instrumentation. |
194 | | ModulePass *createSanitizerCoverageModulePass( |
195 | | const SanitizerCoverageOptions &Options = SanitizerCoverageOptions()); |
196 | | |
197 | | #if defined(__GNUC__) && defined(__linux__) && !defined(ANDROID) |
198 | | inline ModulePass *createDataFlowSanitizerPassForJIT( |
199 | | const std::vector<std::string> &ABIListFiles = std::vector<std::string>()) { |
200 | | return createDataFlowSanitizerPass(ABIListFiles, getDFSanArgTLSPtrForJIT, |
201 | | getDFSanRetValTLSPtrForJIT); |
202 | | } |
203 | | #endif |
204 | | |
205 | | // BoundsChecking - This pass instruments the code to perform run-time bounds |
206 | | // checking on loads, stores, and other memory intrinsics. |
207 | | FunctionPass *createBoundsCheckingPass(); |
208 | | |
209 | | /// \brief Calculate what to divide by to scale counts. |
210 | | /// |
211 | | /// Given the maximum count, calculate a divisor that will scale all the |
212 | | /// weights to strictly less than std::numeric_limits<uint32_t>::max(). |
213 | 104 | static inline uint64_t calculateCountScale(uint64_t MaxCount) { |
214 | 104 | return MaxCount < std::numeric_limits<uint32_t>::max() |
215 | 102 | ? 1 |
216 | 2 | : MaxCount / std::numeric_limits<uint32_t>::max() + 1; |
217 | 104 | } Unexecuted instantiation: cc1_main.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: PassManagerBuilder.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: SampleProfile.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: AddressSanitizer.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: BoundsChecking.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: DataFlowSanitizer.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: GCOVProfiling.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: MemorySanitizer.cpp:llvm::calculateCountScale(unsigned long long) IndirectCallPromotion.cpp:llvm::calculateCountScale(unsigned long long) Line | Count | Source | 213 | 42 | static inline uint64_t calculateCountScale(uint64_t MaxCount) { | 214 | 42 | return MaxCount < std::numeric_limits<uint32_t>::max() | 215 | 42 | ? 1 | 216 | 0 | : MaxCount / std::numeric_limits<uint32_t>::max() + 1; | 217 | 42 | } |
Unexecuted instantiation: Instrumentation.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: InstrProfiling.cpp:llvm::calculateCountScale(unsigned long long) PGOInstrumentation.cpp:llvm::calculateCountScale(unsigned long long) Line | Count | Source | 213 | 62 | static inline uint64_t calculateCountScale(uint64_t MaxCount) { | 214 | 62 | return MaxCount < std::numeric_limits<uint32_t>::max() | 215 | 60 | ? 1 | 216 | 2 | : MaxCount / std::numeric_limits<uint32_t>::max() + 1; | 217 | 62 | } |
Unexecuted instantiation: PGOMemOPSizeOpt.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: SanitizerCoverage.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: ThreadSanitizer.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: EfficiencySanitizer.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: BackendUtil.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: PassBuilder.cpp:llvm::calculateCountScale(unsigned long long) Unexecuted instantiation: opt.cpp:llvm::calculateCountScale(unsigned long long) |
218 | | |
219 | | /// \brief Scale an individual branch count. |
220 | | /// |
221 | | /// Scale a 64-bit weight down to 32-bits using \c Scale. |
222 | | /// |
223 | 225 | static inline uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale) { |
224 | 225 | uint64_t Scaled = Count / Scale; |
225 | 225 | assert(Scaled <= std::numeric_limits<uint32_t>::max() && "overflow 32-bits"); |
226 | 225 | return Scaled; |
227 | 225 | } Unexecuted instantiation: cc1_main.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: PassManagerBuilder.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: SampleProfile.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: AddressSanitizer.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: BoundsChecking.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: DataFlowSanitizer.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: GCOVProfiling.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: MemorySanitizer.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) IndirectCallPromotion.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Line | Count | Source | 223 | 84 | static inline uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale) { | 224 | 84 | uint64_t Scaled = Count / Scale; | 225 | 84 | assert(Scaled <= std::numeric_limits<uint32_t>::max() && "overflow 32-bits"); | 226 | 84 | return Scaled; | 227 | 84 | } |
Unexecuted instantiation: Instrumentation.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: InstrProfiling.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) PGOInstrumentation.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Line | Count | Source | 223 | 141 | static inline uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale) { | 224 | 141 | uint64_t Scaled = Count / Scale; | 225 | 141 | assert(Scaled <= std::numeric_limits<uint32_t>::max() && "overflow 32-bits"); | 226 | 141 | return Scaled; | 227 | 141 | } |
Unexecuted instantiation: PGOMemOPSizeOpt.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: SanitizerCoverage.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: ThreadSanitizer.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: EfficiencySanitizer.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: BackendUtil.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: PassBuilder.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) Unexecuted instantiation: opt.cpp:llvm::scaleBranchCount(unsigned long long, unsigned long long) |
228 | | |
229 | | } // end namespace llvm |
230 | | |
231 | | #endif // LLVM_TRANSFORMS_INSTRUMENTATION_H |