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