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
27namespace llvm {
28
29class Triple;
30class OptimizationRemarkEmitter;
31class Comdat;
32class 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.
39BasicBlock::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.
43GlobalVariable *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.
50Comdat *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.
55void setGlobalVariableLargeSection(const Triple &TargetTriple,
56 GlobalVariable &GV);
57
58// Insert GCOV profiling instrumentation
59struct 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.
90namespace 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.
105CallBase &promoteIndirectCall(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.
111struct 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.
131struct 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().
162static 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///
172static 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.
185struct 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

source code of llvm/include/llvm/Transforms/Instrumentation.h