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) 22 inline void *getDFSanArgTLSPtrForJIT() { 23 extern __thread __attribute__((tls_model("initial-exec"))) 24 void *__dfsan_arg_tls; 25 return (void *)&__dfsan_arg_tls; 26 } 27 28 inline 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 35 namespace llvm { 36 37 class 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. 44 BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB, 45 BasicBlock::iterator IP); 46 47 class ModulePass; 48 class FunctionPass; 49 50 // Insert GCOV profiling instrumentation 51 struct 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 }; 79 ModulePass *createGCOVProfilerPass(const GCOVOptions &Options = 80 GCOVOptions::getDefault()); 81 82 // PGO Instrumention 83 ModulePass *createPGOInstrumentationGenLegacyPass(); 84 ModulePass * 85 createPGOInstrumentationUseLegacyPass(StringRef Filename = StringRef("")); 86 ModulePass *createPGOIndirectCallPromotionLegacyPass(bool InLTO = false); 87 88 /// Options for the frontend instrumentation based profiling pass. 89 struct 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. 100 ModulePass *createInstrProfilingLegacyPass( 101 const InstrProfOptions &Options = InstrProfOptions()); 102 103 // Insert AddressSanitizer (address sanity checking) instrumentation 104 FunctionPass *createAddressSanitizerFunctionPass(bool CompileKernel = false, 105 bool Recover = false, 106 bool UseAfterScope = false); 107 ModulePass *createAddressSanitizerModulePass(bool CompileKernel = false, 108 bool Recover = false); 109 110 // Insert MemorySanitizer instrumentation (detection of uninitialized reads) 111 FunctionPass *createMemorySanitizerPass(int TrackOrigins = 0); 112 113 // Insert ThreadSanitizer (race detection) instrumentation 114 FunctionPass *createThreadSanitizerPass(); 115 116 // Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation 117 ModulePass *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. 122 struct 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. 132 ModulePass *createEfficiencySanitizerPass( 133 const EfficiencySanitizerOptions &Options = EfficiencySanitizerOptions()); 134 135 // Options for sanitizer coverage instrumentation. 136 struct 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. 155 ModulePass *createSanitizerCoverageModulePass( 156 const SanitizerCoverageOptions &Options = SanitizerCoverageOptions()); 157 158 #if defined(__GNUC__) && defined(__linux__) && !defined(ANDROID) 159 inline 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. 168 FunctionPass *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. 174 static 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 /// 182 static 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
