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