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 <vector>
20
21#if defined(__GNUC__) && defined(__linux__) && !defined(ANDROID)
22inline void *getDFSanArgTLSPtrForJIT() {
23  extern __thread __attribute__((tls_model("initial-exec")))
24    void *__dfsan_arg_tls;
25  return (void *)&__dfsan_arg_tls;
26}
27
28inline void *getDFSanRetValTLSPtrForJIT() {
29  extern __thread __attribute__((tls_model("initial-exec")))
30    void *__dfsan_retval_tls;
31  return (void *)&__dfsan_retval_tls;
32}
33#endif
34
35namespace llvm {
36
37class TargetMachine;
38
39/// Instrumentation passes often insert conditional checks into entry blocks.
40/// Call this function before splitting the entry block to move instructions
41/// that must remain in the entry block up before the split point. Static
42/// allocas and llvm.localescape calls, for example, must remain in the entry
43/// block.
44BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB,
45                                              BasicBlock::iterator IP);
46
47class ModulePass;
48class FunctionPass;
49
50// Insert GCOV profiling instrumentation
51struct GCOVOptions {
52  static GCOVOptions getDefault();
53
54  // Specify whether to emit .gcno files.
55  bool EmitNotes;
56
57  // Specify whether to modify the program to emit .gcda files when run.
58  bool EmitData;
59
60  // A four-byte version string. The meaning of a version string is described in
61  // gcc's gcov-io.h
62  char Version[4];
63
64  // Emit a "cfg checksum" that follows the "line number checksum" of a
65  // function. This affects both .gcno and .gcda files.
66  bool UseCfgChecksum;
67
68  // Add the 'noredzone' attribute to added runtime library calls.
69  bool NoRedZone;
70
71  // Emit the name of the function in the .gcda files. This is redundant, as
72  // the function identifier can be used to find the name from the .gcno file.
73  bool FunctionNamesInData;
74
75  // Emit the exit block immediately after the start block, rather than after
76  // all of the function body's blocks.
77  bool ExitBlockBeforeBody;
78};
79ModulePass *createGCOVProfilerPass(const GCOVOptions &Options =
80                                   GCOVOptions::getDefault());
81
82// PGO Instrumention
83ModulePass *createPGOInstrumentationGenLegacyPass();
84ModulePass *
85createPGOInstrumentationUseLegacyPass(StringRef Filename = StringRef(""));
86ModulePass *createPGOIndirectCallPromotionLegacyPass(bool InLTO = false);
87
88/// Options for the frontend instrumentation based profiling pass.
89struct InstrProfOptions {
90  InstrProfOptions() : NoRedZone(false) {}
91
92  // Add the 'noredzone' attribute to added runtime library calls.
93  bool NoRedZone;
94
95  // Name of the profile file to use as output
96  std::string InstrProfileOutput;
97};
98
99/// Insert frontend instrumentation based profiling.
100ModulePass *createInstrProfilingLegacyPass(
101    const InstrProfOptions &Options = InstrProfOptions());
102
103// Insert AddressSanitizer (address sanity checking) instrumentation
104FunctionPass *createAddressSanitizerFunctionPass(bool CompileKernel = false,
105                                                 bool Recover = false,
106                                                 bool UseAfterScope = false);
107ModulePass *createAddressSanitizerModulePass(bool CompileKernel = false,
108                                             bool Recover = false);
109
110// Insert MemorySanitizer instrumentation (detection of uninitialized reads)
111FunctionPass *createMemorySanitizerPass(int TrackOrigins = 0);
112
113// Insert ThreadSanitizer (race detection) instrumentation
114FunctionPass *createThreadSanitizerPass();
115
116// Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation
117ModulePass *createDataFlowSanitizerPass(
118    const std::vector<std::string> &ABIListFiles = std::vector<std::string>(),
119    void *(*getArgTLS)() = nullptr, void *(*getRetValTLS)() = nullptr);
120
121// Options for EfficiencySanitizer sub-tools.
122struct EfficiencySanitizerOptions {
123  EfficiencySanitizerOptions() : ToolType(ESAN_None) {}
124  enum Type {
125    ESAN_None = 0,
126    ESAN_CacheFrag,
127    ESAN_WorkingSet,
128  } ToolType;
129};
130
131// Insert EfficiencySanitizer instrumentation.
132ModulePass *createEfficiencySanitizerPass(
133    const EfficiencySanitizerOptions &Options = EfficiencySanitizerOptions());
134
135// Options for sanitizer coverage instrumentation.
136struct SanitizerCoverageOptions {
137  SanitizerCoverageOptions()
138      : CoverageType(SCK_None), IndirectCalls(false), TraceBB(false),
139        TraceCmp(false), Use8bitCounters(false), TracePC(false) {}
140
141  enum Type {
142    SCK_None = 0,
143    SCK_Function,
144    SCK_BB,
145    SCK_Edge
146  } CoverageType;
147  bool IndirectCalls;
148  bool TraceBB;
149  bool TraceCmp;
150  bool Use8bitCounters;
151  bool TracePC;
152};
153
154// Insert SanitizerCoverage instrumentation.
155ModulePass *createSanitizerCoverageModulePass(
156    const SanitizerCoverageOptions &Options = SanitizerCoverageOptions());
157
158#if defined(__GNUC__) && defined(__linux__) && !defined(ANDROID)
159inline ModulePass *createDataFlowSanitizerPassForJIT(
160    const std::vector<std::string> &ABIListFiles = std::vector<std::string>()) {
161  return createDataFlowSanitizerPass(ABIListFiles, getDFSanArgTLSPtrForJIT,
162                                     getDFSanRetValTLSPtrForJIT);
163}
164#endif
165
166// BoundsChecking - This pass instruments the code to perform run-time bounds
167// checking on loads, stores, and other memory intrinsics.
168FunctionPass *createBoundsCheckingPass();
169
170/// \brief Calculate what to divide by to scale counts.
171///
172/// Given the maximum count, calculate a divisor that will scale all the
173/// weights to strictly less than UINT32_MAX.
174static inline uint64_t calculateCountScale(uint64_t MaxCount) {
175  return MaxCount < UINT32_MAX ? 1 : MaxCount / UINT32_MAX + 1;
176}
177
178/// \brief Scale an individual branch count.
179///
180/// Scale a 64-bit weight down to 32-bits using \c Scale.
181///
182static inline uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale) {
183  uint64_t Scaled = Count / Scale;
184  assert(Scaled <= UINT32_MAX && "overflow 32-bits");
185  return Scaled;
186}
187
188} // End llvm namespace
189
190#endif
191