LLVM  10.0.0svn
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"
18 #include <cassert>
19 #include <cstdint>
20 #include <limits>
21 #include <string>
22 #include <vector>
23 
24 namespace llvm {
25 
26 class Triple;
27 class FunctionPass;
28 class ModulePass;
29 class OptimizationRemarkEmitter;
30 class Comdat;
31 
32 /// Instrumentation passes often insert conditional checks into entry blocks.
33 /// Call this function before splitting the entry block to move instructions
34 /// that must remain in the entry block up before the split point. Static
35 /// allocas and llvm.localescape calls, for example, must remain in the entry
36 /// block.
39 
40 // Create a constant for Str so that we can pass it to the run-time lib.
41 GlobalVariable *createPrivateGlobalForString(Module &M, StringRef Str,
42  bool AllowMerging,
43  const char *NamePrefix = "");
44 
45 // Returns F.getComdat() if it exists.
46 // Otherwise creates a new comdat, sets F's comdat, and returns it.
47 // Returns nullptr on failure.
48 Comdat *GetOrCreateFunctionComdat(Function &F, Triple &T,
49  const std::string &ModuleId);
50 
51 // Insert GCOV profiling instrumentation
52 struct GCOVOptions {
53  static GCOVOptions getDefault();
54 
55  // Specify whether to emit .gcno files.
56  bool EmitNotes;
57 
58  // Specify whether to modify the program to emit .gcda files when run.
59  bool EmitData;
60 
61  // A four-byte version string. The meaning of a version string is described in
62  // gcc's gcov-io.h
63  char Version[4];
64 
65  // Emit a "cfg checksum" that follows the "line number checksum" of a
66  // function. This affects both .gcno and .gcda files.
68 
69  // Add the 'noredzone' attribute to added runtime library calls.
70  bool NoRedZone;
71 
72  // Emit the name of the function in the .gcda files. This is redundant, as
73  // the function identifier can be used to find the name from the .gcno file.
75 
76  // Emit the exit block immediately after the start block, rather than after
77  // all of the function body's blocks.
79 
80  // Regexes separated by a semi-colon to filter the files to instrument.
81  std::string Filter;
82 
83  // Regexes separated by a semi-colon to filter the files to not instrument.
84  std::string Exclude;
85 };
86 
89 
90 // PGO Instrumention. Parameter IsCS indicates if this is the context senstive
91 // instrumentation.
93 ModulePass *
95  bool IsCS = false);
97  StringRef CSInstrName = StringRef(""));
99  bool SamplePGO = false);
101 
102 // The pgo-specific indirect call promotion function declared below is used by
103 // the pgo-driven indirect call promotion and sample profile passes. It's a
104 // wrapper around llvm::promoteCall, et al. that additionally computes !prof
105 // metadata. We place it in a pgo namespace so it's not confused with the
106 // generic utilities.
107 namespace pgo {
108 
109 // Helper function that transforms Inst (either an indirect-call instruction, or
110 // an invoke instruction , to a conditional call to F. This is like:
111 // if (Inst.CalledValue == F)
112 // F(...);
113 // else
114 // Inst(...);
115 // end
116 // TotalCount is the profile count value that the instruction executes.
117 // Count is the profile count value that F is the target function.
118 // These two values are used to update the branch weight.
119 // If \p AttachProfToDirectCall is true, a prof metadata is attached to the
120 // new direct call to contain \p Count.
121 // Returns the promoted direct call instruction.
122 Instruction *promoteIndirectCall(Instruction *Inst, Function *F, uint64_t Count,
123  uint64_t TotalCount,
124  bool AttachProfToDirectCall,
126 } // namespace pgo
127 
128 /// Options for the frontend instrumentation based profiling pass.
130  // Add the 'noredzone' attribute to added runtime library calls.
131  bool NoRedZone = false;
132 
133  // Do counter register promotion
134  bool DoCounterPromotion = false;
135 
136  // Use atomic profile counter increments.
137  bool Atomic = false;
138 
139  // Use BFI to guide register promotion
140  bool UseBFIInPromotion = false;
141 
142  // Name of the profile file to use as output
143  std::string InstrProfileOutput;
144 
145  InstrProfOptions() = default;
146 };
147 
148 /// Insert frontend instrumentation based profiling. Parameter IsCS indicates if
149 // this is the context senstive instrumentation.
151  const InstrProfOptions &Options = InstrProfOptions(), bool IsCS = false);
152 
154 
155 // Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation
157  const std::vector<std::string> &ABIListFiles = std::vector<std::string>(),
158  void *(*getArgTLS)() = nullptr, void *(*getRetValTLS)() = nullptr);
159 
160 // Options for sanitizer coverage instrumentation.
162  enum Type {
163  SCK_None = 0,
166  SCK_Edge
167  } CoverageType = SCK_None;
168  bool IndirectCalls = false;
169  bool TraceBB = false;
170  bool TraceCmp = false;
171  bool TraceDiv = false;
172  bool TraceGep = false;
173  bool Use8bitCounters = false;
174  bool TracePC = false;
175  bool TracePCGuard = false;
176  bool Inline8bitCounters = false;
177  bool PCTable = false;
178  bool NoPrune = false;
179  bool StackDepth = false;
180 
181  SanitizerCoverageOptions() = default;
182 };
183 
184 /// Calculate what to divide by to scale counts.
185 ///
186 /// Given the maximum count, calculate a divisor that will scale all the
187 /// weights to strictly less than std::numeric_limits<uint32_t>::max().
188 static inline uint64_t calculateCountScale(uint64_t MaxCount) {
190  ? 1
191  : MaxCount / std::numeric_limits<uint32_t>::max() + 1;
192 }
193 
194 /// Scale an individual branch count.
195 ///
196 /// Scale a 64-bit weight down to 32-bits using \c Scale.
197 ///
198 static inline uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale) {
199  uint64_t Scaled = Count / Scale;
200  assert(Scaled <= std::numeric_limits<uint32_t>::max() && "overflow 32-bits");
201  return Scaled;
202 }
203 } // end namespace llvm
204 
205 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_H
ModulePass * createPGOInstrumentationGenLegacyPass(bool IsCS=false)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Various leaf nodes.
Definition: ISDOpcodes.h:59
ModulePass * createGCOVProfilerPass(const GCOVOptions &Options=GCOVOptions::getDefault())
FunctionPass * createPGOMemOPSizeOptLegacyPass()
static GCOVOptions getDefault()
F(f)
ModulePass * createPGOInstrumentationGenCreateVarLegacyPass(StringRef CSInstrName=StringRef(""))
ModulePass * createInstrProfilingLegacyPass(const InstrProfOptions &Options=InstrProfOptions(), bool IsCS=false)
Insert frontend instrumentation based profiling. Parameter IsCS indicates if.
std::string Filter
ModulePass * createInstrOrderFilePass()
Instruction * promoteIndirectCall(Instruction *Inst, Function *F, uint64_t Count, uint64_t TotalCount, bool AttachProfToDirectCall, OptimizationRemarkEmitter *ORE)
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:284
static uint64_t calculateCountScale(uint64_t MaxCount)
Calculate what to divide by to scale counts.
static uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale)
Scale an individual branch count.
std::string InstrProfileOutput
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:390
GlobalVariable * createPrivateGlobalForString(Module &M, StringRef Str, bool AllowMerging, const char *NamePrefix="")
BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB, BasicBlock::iterator IP)
Instrumentation passes often insert conditional checks into entry blocks.
ModulePass * createPGOInstrumentationUseLegacyPass(StringRef Filename=StringRef(""), bool IsCS=false)
Comdat * GetOrCreateFunctionComdat(Function &F, Triple &T, const std::string &ModuleId)
Options for the frontend instrumentation based profiling pass.
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:89
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:224
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ModulePass * createDataFlowSanitizerPass(const std::vector< std::string > &ABIListFiles=std::vector< std::string >(), void *(*getArgTLS)()=nullptr, void *(*getRetValTLS)()=nullptr)
std::string Exclude
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
ModulePass * createPGOIndirectCallPromotionLegacyPass(bool InLTO=false, bool SamplePGO=false)
The optimization diagnostic interface.