1 | //===- Transforms/Instrumentation.h - Instrumentation passes ----*- C++ -*-===// |
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 file defines constructor functions for instrumentation passes. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_H |
14 | #define LLVM_TRANSFORMS_INSTRUMENTATION_H |
15 | |
16 | #include "llvm/ADT/StringRef.h" |
17 | #include "llvm/IR/BasicBlock.h" |
18 | #include "llvm/IR/DebugInfoMetadata.h" |
19 | #include "llvm/IR/Function.h" |
20 | #include "llvm/IR/IRBuilder.h" |
21 | #include "llvm/IR/Instruction.h" |
22 | #include <cassert> |
23 | #include <cstdint> |
24 | #include <limits> |
25 | #include <string> |
26 | |
27 | namespace llvm { |
28 | |
29 | class Triple; |
30 | class ; |
31 | class Comdat; |
32 | class CallBase; |
33 | |
34 | /// Instrumentation passes often insert conditional checks into entry blocks. |
35 | /// Call this function before splitting the entry block to move instructions |
36 | /// that must remain in the entry block up before the split point. Static |
37 | /// allocas and llvm.localescape calls, for example, must remain in the entry |
38 | /// block. |
39 | BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB, |
40 | BasicBlock::iterator IP); |
41 | |
42 | // Create a constant for Str so that we can pass it to the run-time lib. |
43 | GlobalVariable *createPrivateGlobalForString(Module &M, StringRef Str, |
44 | bool AllowMerging, |
45 | const char *NamePrefix = "" ); |
46 | |
47 | // Returns F.getComdat() if it exists. |
48 | // Otherwise creates a new comdat, sets F's comdat, and returns it. |
49 | // Returns nullptr on failure. |
50 | Comdat *getOrCreateFunctionComdat(Function &F, Triple &T); |
51 | |
52 | // Place global in a large section for x86-64 ELF binaries to mitigate |
53 | // relocation overflow pressure. This can be be used for metadata globals that |
54 | // aren't directly accessed by code, which has no performance impact. |
55 | void setGlobalVariableLargeSection(const Triple &TargetTriple, |
56 | GlobalVariable &GV); |
57 | |
58 | // Insert GCOV profiling instrumentation |
59 | struct GCOVOptions { |
60 | static GCOVOptions getDefault(); |
61 | |
62 | // Specify whether to emit .gcno files. |
63 | bool EmitNotes; |
64 | |
65 | // Specify whether to modify the program to emit .gcda files when run. |
66 | bool EmitData; |
67 | |
68 | // A four-byte version string. The meaning of a version string is described in |
69 | // gcc's gcov-io.h |
70 | char Version[4]; |
71 | |
72 | // Add the 'noredzone' attribute to added runtime library calls. |
73 | bool NoRedZone; |
74 | |
75 | // Use atomic profile counter increments. |
76 | bool Atomic = false; |
77 | |
78 | // Regexes separated by a semi-colon to filter the files to instrument. |
79 | std::string Filter; |
80 | |
81 | // Regexes separated by a semi-colon to filter the files to not instrument. |
82 | std::string Exclude; |
83 | }; |
84 | |
85 | // The pgo-specific indirect call promotion function declared below is used by |
86 | // the pgo-driven indirect call promotion and sample profile passes. It's a |
87 | // wrapper around llvm::promoteCall, et al. that additionally computes !prof |
88 | // metadata. We place it in a pgo namespace so it's not confused with the |
89 | // generic utilities. |
90 | namespace pgo { |
91 | |
92 | // Helper function that transforms CB (either an indirect-call instruction, or |
93 | // an invoke instruction , to a conditional call to F. This is like: |
94 | // if (Inst.CalledValue == F) |
95 | // F(...); |
96 | // else |
97 | // Inst(...); |
98 | // end |
99 | // TotalCount is the profile count value that the instruction executes. |
100 | // Count is the profile count value that F is the target function. |
101 | // These two values are used to update the branch weight. |
102 | // If \p AttachProfToDirectCall is true, a prof metadata is attached to the |
103 | // new direct call to contain \p Count. |
104 | // Returns the promoted direct call instruction. |
105 | CallBase &(CallBase &CB, Function *F, uint64_t Count, |
106 | uint64_t TotalCount, bool AttachProfToDirectCall, |
107 | OptimizationRemarkEmitter *ORE); |
108 | } // namespace pgo |
109 | |
110 | /// Options for the frontend instrumentation based profiling pass. |
111 | struct InstrProfOptions { |
112 | // Add the 'noredzone' attribute to added runtime library calls. |
113 | bool NoRedZone = false; |
114 | |
115 | // Do counter register promotion |
116 | bool DoCounterPromotion = false; |
117 | |
118 | // Use atomic profile counter increments. |
119 | bool Atomic = false; |
120 | |
121 | // Use BFI to guide register promotion |
122 | bool UseBFIInPromotion = false; |
123 | |
124 | // Name of the profile file to use as output |
125 | std::string InstrProfileOutput; |
126 | |
127 | InstrProfOptions() = default; |
128 | }; |
129 | |
130 | // Options for sanitizer coverage instrumentation. |
131 | struct SanitizerCoverageOptions { |
132 | enum Type { |
133 | SCK_None = 0, |
134 | SCK_Function, |
135 | SCK_BB, |
136 | SCK_Edge |
137 | } CoverageType = SCK_None; |
138 | bool IndirectCalls = false; |
139 | bool TraceBB = false; |
140 | bool TraceCmp = false; |
141 | bool TraceDiv = false; |
142 | bool TraceGep = false; |
143 | bool Use8bitCounters = false; |
144 | bool TracePC = false; |
145 | bool TracePCGuard = false; |
146 | bool Inline8bitCounters = false; |
147 | bool InlineBoolFlag = false; |
148 | bool PCTable = false; |
149 | bool NoPrune = false; |
150 | bool StackDepth = false; |
151 | bool TraceLoads = false; |
152 | bool TraceStores = false; |
153 | bool CollectControlFlow = false; |
154 | |
155 | SanitizerCoverageOptions() = default; |
156 | }; |
157 | |
158 | /// Calculate what to divide by to scale counts. |
159 | /// |
160 | /// Given the maximum count, calculate a divisor that will scale all the |
161 | /// weights to strictly less than std::numeric_limits<uint32_t>::max(). |
162 | static inline uint64_t calculateCountScale(uint64_t MaxCount) { |
163 | return MaxCount < std::numeric_limits<uint32_t>::max() |
164 | ? 1 |
165 | : MaxCount / std::numeric_limits<uint32_t>::max() + 1; |
166 | } |
167 | |
168 | /// Scale an individual branch count. |
169 | /// |
170 | /// Scale a 64-bit weight down to 32-bits using \c Scale. |
171 | /// |
172 | static inline uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale) { |
173 | uint64_t Scaled = Count / Scale; |
174 | assert(Scaled <= std::numeric_limits<uint32_t>::max() && "overflow 32-bits" ); |
175 | return Scaled; |
176 | } |
177 | |
178 | // Use to ensure the inserted instrumentation has a DebugLocation; if none is |
179 | // attached to the source instruction, try to use a DILocation with offset 0 |
180 | // scoped to surrounding function (if it has a DebugLocation). |
181 | // |
182 | // Some non-call instructions may be missing debug info, but when inserting |
183 | // instrumentation calls, some builds (e.g. LTO) want calls to have debug info |
184 | // if the enclosing function does. |
185 | struct InstrumentationIRBuilder : IRBuilder<> { |
186 | static void ensureDebugInfo(IRBuilder<> &IRB, const Function &F) { |
187 | if (IRB.getCurrentDebugLocation()) |
188 | return; |
189 | if (DISubprogram *SP = F.getSubprogram()) |
190 | IRB.SetCurrentDebugLocation(DILocation::get(Context&: SP->getContext(), Line: 0, Column: 0, Scope: SP)); |
191 | } |
192 | |
193 | explicit InstrumentationIRBuilder(Instruction *IP) : IRBuilder<>(IP) { |
194 | ensureDebugInfo(IRB&: *this, F: *IP->getFunction()); |
195 | } |
196 | }; |
197 | } // end namespace llvm |
198 | |
199 | #endif // LLVM_TRANSFORMS_INSTRUMENTATION_H |
200 | |