LLVM 19.0.0git
Instrumentation.h
Go to the documentation of this file.
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"
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.
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
60 static GCOVOptions getDefault();
61
62 // Specify whether to emit .gcno files.
64
65 // Specify whether to modify the program to emit .gcda files when run.
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.
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.
106 uint64_t TotalCount, bool AttachProfToDirectCall,
108} // namespace pgo
109
110/// Options for the frontend instrumentation based profiling pass.
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
126
127 InstrProfOptions() = default;
128};
129
130// Options for sanitizer coverage instrumentation.
132 enum Type {
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
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.
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(SP->getContext(), 0, 0, SP));
191 }
192
194 ensureDebugInfo(*this, *IP->getFunction());
195 }
196};
197} // end namespace llvm
198
199#endif // LLVM_TRANSFORMS_INSTRUMENTATION_H
@ Scaled
#define F(x, y, z)
Definition: MD5.cpp:55
Machine Check Debug Module
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:165
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1494
Subprogram description.
void SetCurrentDebugLocation(DebugLoc L)
Set location information used by debugging information.
Definition: IRBuilder.h:220
DebugLoc getCurrentDebugLocation() const
Get location information used by debugging information.
Definition: IRBuilder.cpp:63
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:2667
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:87
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1541
The optimization diagnostic interface.
CallBase & promoteIndirectCall(CallBase &CB, Function *F, uint64_t Count, uint64_t TotalCount, bool AttachProfToDirectCall, OptimizationRemarkEmitter *ORE)
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
GlobalVariable * createPrivateGlobalForString(Module &M, StringRef Str, bool AllowMerging, const char *NamePrefix="")
Comdat * getOrCreateFunctionComdat(Function &F, Triple &T)
static uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale)
Scale an individual branch count.
void setGlobalVariableLargeSection(const Triple &TargetTriple, GlobalVariable &GV)
static uint64_t calculateCountScale(uint64_t MaxCount)
Calculate what to divide by to scale counts.
BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB, BasicBlock::iterator IP)
Instrumentation passes often insert conditional checks into entry blocks.
static GCOVOptions getDefault()
std::string Exclude
std::string Filter
Options for the frontend instrumentation based profiling pass.
std::string InstrProfileOutput
InstrumentationIRBuilder(Instruction *IP)
static void ensureDebugInfo(IRBuilder<> &IRB, const Function &F)
enum llvm::SanitizerCoverageOptions::Type CoverageType