1 //===-- InstrProfiling.cpp - Frontend instrumentation based profiling -----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This pass lowers instrprof_increment intrinsics emitted by a frontend for
11 // profiling. It also builds the data structures and initialization code needed
12 // for updating execution counts and emitting the profile at runtime.
14 //===----------------------------------------------------------------------===//
16 #include "llvm/ProfileData/InstrProf.h"
17 #include "llvm/Transforms/Instrumentation.h"
19 #include "llvm/ADT/Triple.h"
20 #include "llvm/IR/IRBuilder.h"
21 #include "llvm/IR/IntrinsicInst.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/Transforms/Utils/ModuleUtils.h"
27 #define DEBUG_TYPE "instrprof"
31 class InstrProfiling : public ModulePass {
35 InstrProfiling() : ModulePass(ID) {}
37 InstrProfiling(const InstrProfOptions &Options)
38 : ModulePass(ID), Options(Options) {}
40 const char *getPassName() const override {
41 return "Frontend instrumentation-based coverage lowering";
44 bool runOnModule(Module &M) override;
46 void getAnalysisUsage(AnalysisUsage &AU) const override {
51 InstrProfOptions Options;
53 DenseMap<GlobalVariable *, GlobalVariable *> RegionCounters;
54 std::vector<Value *> UsedVars;
56 bool isMachO() const {
57 return Triple(M->getTargetTriple()).isOSBinFormatMachO();
60 /// Get the section name for the counter variables.
61 StringRef getCountersSection() const {
62 return getInstrProfCountersSectionName(isMachO());
65 /// Get the section name for the name variables.
66 StringRef getNameSection() const {
67 return getInstrProfNameSectionName(isMachO());
70 /// Get the section name for the profile data variables.
71 StringRef getDataSection() const {
72 return getInstrProfDataSectionName(isMachO());
75 /// Get the section name for the coverage mapping data.
76 StringRef getCoverageSection() const {
77 return getInstrProfCoverageSectionName(isMachO());
80 /// Replace instrprof_increment with an increment of the appropriate value.
81 void lowerIncrement(InstrProfIncrementInst *Inc);
83 /// Set up the section and uses for coverage data and its references.
84 void lowerCoverageData(GlobalVariable *CoverageData);
86 /// Get the region counters for an increment, creating them if necessary.
88 /// If the counter array doesn't yet exist, the profile data variables
89 /// referring to them will also be created.
90 GlobalVariable *getOrCreateRegionCounters(InstrProfIncrementInst *Inc);
92 /// Emit runtime registration functions for each profile data variable.
93 void emitRegistration();
95 /// Emit the necessary plumbing to pull in the runtime initialization.
96 void emitRuntimeHook();
98 /// Add uses of our data variables and runtime hook.
101 /// Create a static initializer for our data, on platforms that need it,
102 /// and for any profile output file that was specified.
103 void emitInitialization();
106 } // anonymous namespace
108 char InstrProfiling::ID = 0;
109 INITIALIZE_PASS(InstrProfiling, "instrprof",
110 "Frontend instrumentation-based coverage lowering.", false,
113 ModulePass *llvm::createInstrProfilingPass(const InstrProfOptions &Options) {
114 return new InstrProfiling(Options);
117 bool InstrProfiling::runOnModule(Module &M) {
118 bool MadeChange = false;
121 RegionCounters.clear();
124 for (Function &F : M)
125 for (BasicBlock &BB : F)
126 for (auto I = BB.begin(), E = BB.end(); I != E;)
127 if (auto *Inc = dyn_cast<InstrProfIncrementInst>(I++)) {
131 if (GlobalVariable *Coverage =
132 M.getNamedGlobal(getCoverageMappingVarName())) {
133 lowerCoverageData(Coverage);
142 emitInitialization();
146 void InstrProfiling::lowerIncrement(InstrProfIncrementInst *Inc) {
147 GlobalVariable *Counters = getOrCreateRegionCounters(Inc);
149 IRBuilder<> Builder(Inc);
150 uint64_t Index = Inc->getIndex()->getZExtValue();
151 Value *Addr = Builder.CreateConstInBoundsGEP2_64(Counters, 0, Index);
152 Value *Count = Builder.CreateLoad(Addr, "pgocount");
153 Count = Builder.CreateAdd(Count, Builder.getInt64(1));
154 Inc->replaceAllUsesWith(Builder.CreateStore(Count, Addr));
155 Inc->eraseFromParent();
158 void InstrProfiling::lowerCoverageData(GlobalVariable *CoverageData) {
159 CoverageData->setSection(getCoverageSection());
160 CoverageData->setAlignment(8);
162 Constant *Init = CoverageData->getInitializer();
163 // We're expecting { i32, i32, i32, i32, [n x { i8*, i32, i32 }], [m x i8] }
164 // for some C. If not, the frontend's given us something broken.
165 assert(Init->getNumOperands() == 6 && "bad number of fields in coverage map");
166 assert(isa<ConstantArray>(Init->getAggregateElement(4)) &&
167 "invalid function list in coverage map");
168 ConstantArray *Records = cast<ConstantArray>(Init->getAggregateElement(4));
169 for (unsigned I = 0, E = Records->getNumOperands(); I < E; ++I) {
170 Constant *Record = Records->getOperand(I);
171 Value *V = const_cast<Value *>(Record->getOperand(0))->stripPointerCasts();
173 assert(isa<GlobalVariable>(V) && "Missing reference to function name");
174 GlobalVariable *Name = cast<GlobalVariable>(V);
176 // If we have region counters for this name, we've already handled it.
177 auto It = RegionCounters.find(Name);
178 if (It != RegionCounters.end())
181 // Move the name variable to the right section.
182 Name->setSection(getNameSection());
183 Name->setAlignment(1);
187 /// Get the name of a profiling variable for a particular function.
188 static std::string getVarName(InstrProfIncrementInst *Inc, StringRef Prefix) {
189 auto *Arr = cast<ConstantDataArray>(Inc->getName()->getInitializer());
190 StringRef Name = Arr->isCString() ? Arr->getAsCString() : Arr->getAsString();
191 return (Prefix + Name).str();
195 InstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {
196 GlobalVariable *NamePtr = Inc->getName();
197 auto It = RegionCounters.find(NamePtr);
198 if (It != RegionCounters.end())
201 // Move the name variable to the right section. Place them in a COMDAT group
202 // if the associated function is a COMDAT. This will make sure that
203 // only one copy of counters of the COMDAT function will be emitted after
205 Function *Fn = Inc->getParent()->getParent();
206 Comdat *ProfileVarsComdat = nullptr;
208 ProfileVarsComdat = M->getOrInsertComdat(
209 StringRef(getVarName(Inc, getInstrProfComdatPrefix())));
210 NamePtr->setSection(getNameSection());
211 NamePtr->setAlignment(1);
212 NamePtr->setComdat(ProfileVarsComdat);
214 uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
215 LLVMContext &Ctx = M->getContext();
216 ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
218 // Create the counters variable.
220 new GlobalVariable(*M, CounterTy, false, NamePtr->getLinkage(),
221 Constant::getNullValue(CounterTy),
222 getVarName(Inc, getInstrProfCountersVarPrefix()));
223 CounterPtr->setVisibility(NamePtr->getVisibility());
224 CounterPtr->setSection(getCountersSection());
225 CounterPtr->setAlignment(8);
226 CounterPtr->setComdat(ProfileVarsComdat);
228 RegionCounters[Inc->getName()] = CounterPtr;
230 // Create data variable.
232 Type *DataTypes[] = {
233 #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) LLVMType,
234 #include "llvm/ProfileData/InstrProfData.inc"
236 auto *DataTy = StructType::get(Ctx, makeArrayRef(DataTypes));
238 Constant *DataVals[] = {
239 #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) Init,
240 #include "llvm/ProfileData/InstrProfData.inc"
243 auto *Data = new GlobalVariable(*M, DataTy, true, NamePtr->getLinkage(),
244 ConstantStruct::get(DataTy, DataVals),
245 getVarName(Inc, getInstrProfDataVarPrefix()));
246 Data->setVisibility(NamePtr->getVisibility());
247 Data->setSection(getDataSection());
248 Data->setAlignment(8);
249 Data->setComdat(ProfileVarsComdat);
251 // Mark the data variable as used so that it isn't stripped out.
252 UsedVars.push_back(Data);
257 void InstrProfiling::emitRegistration() {
258 // Don't do this for Darwin. compiler-rt uses linker magic.
259 if (Triple(M->getTargetTriple()).isOSDarwin())
262 // Use linker script magic to get data/cnts/name start/end.
263 if (Triple(M->getTargetTriple()).isOSLinux() ||
264 Triple(M->getTargetTriple()).isOSFreeBSD())
267 // Construct the function.
268 auto *VoidTy = Type::getVoidTy(M->getContext());
269 auto *VoidPtrTy = Type::getInt8PtrTy(M->getContext());
270 auto *RegisterFTy = FunctionType::get(VoidTy, false);
271 auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage,
272 getInstrProfRegFuncsName(), M);
273 RegisterF->setUnnamedAddr(true);
274 if (Options.NoRedZone) RegisterF->addFnAttr(Attribute::NoRedZone);
276 auto *RuntimeRegisterTy = FunctionType::get(VoidTy, VoidPtrTy, false);
277 auto *RuntimeRegisterF =
278 Function::Create(RuntimeRegisterTy, GlobalVariable::ExternalLinkage,
279 getInstrProfRegFuncName(), M);
281 IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", RegisterF));
282 for (Value *Data : UsedVars)
283 IRB.CreateCall(RuntimeRegisterF, IRB.CreateBitCast(Data, VoidPtrTy));
287 void InstrProfiling::emitRuntimeHook() {
289 // We expect the linker to be invoked with -u<hook_var> flag for linux,
290 // for which case there is no need to emit the user function.
291 if (Triple(M->getTargetTriple()).isOSLinux())
294 // If the module's provided its own runtime, we don't need to do anything.
295 if (M->getGlobalVariable(getInstrProfRuntimeHookVarName())) return;
297 // Declare an external variable that will pull in the runtime initialization.
298 auto *Int32Ty = Type::getInt32Ty(M->getContext());
300 new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
301 nullptr, getInstrProfRuntimeHookVarName());
303 // Make a function that uses it.
304 auto *User = Function::Create(FunctionType::get(Int32Ty, false),
305 GlobalValue::LinkOnceODRLinkage,
306 getInstrProfRuntimeHookVarUseFuncName(), M);
307 User->addFnAttr(Attribute::NoInline);
308 if (Options.NoRedZone) User->addFnAttr(Attribute::NoRedZone);
309 User->setVisibility(GlobalValue::HiddenVisibility);
311 IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", User));
312 auto *Load = IRB.CreateLoad(Var);
315 // Mark the user variable as used so that it isn't stripped out.
316 UsedVars.push_back(User);
319 void InstrProfiling::emitUses() {
320 if (UsedVars.empty())
323 GlobalVariable *LLVMUsed = M->getGlobalVariable("llvm.used");
324 std::vector<Constant *> MergedVars;
326 // Collect the existing members of llvm.used.
327 ConstantArray *Inits = cast<ConstantArray>(LLVMUsed->getInitializer());
328 for (unsigned I = 0, E = Inits->getNumOperands(); I != E; ++I)
329 MergedVars.push_back(Inits->getOperand(I));
330 LLVMUsed->eraseFromParent();
333 Type *i8PTy = Type::getInt8PtrTy(M->getContext());
334 // Add uses for our data.
335 for (auto *Value : UsedVars)
336 MergedVars.push_back(
337 ConstantExpr::getBitCast(cast<Constant>(Value), i8PTy));
339 // Recreate llvm.used.
340 ArrayType *ATy = ArrayType::get(i8PTy, MergedVars.size());
342 new GlobalVariable(*M, ATy, false, GlobalValue::AppendingLinkage,
343 ConstantArray::get(ATy, MergedVars), "llvm.used");
345 LLVMUsed->setSection("llvm.metadata");
348 void InstrProfiling::emitInitialization() {
349 std::string InstrProfileOutput = Options.InstrProfileOutput;
351 Constant *RegisterF = M->getFunction(getInstrProfRegFuncsName());
352 if (!RegisterF && InstrProfileOutput.empty()) return;
354 // Create the initialization function.
355 auto *VoidTy = Type::getVoidTy(M->getContext());
356 auto *F = Function::Create(FunctionType::get(VoidTy, false),
357 GlobalValue::InternalLinkage,
358 getInstrProfInitFuncName(), M);
359 F->setUnnamedAddr(true);
360 F->addFnAttr(Attribute::NoInline);
361 if (Options.NoRedZone) F->addFnAttr(Attribute::NoRedZone);
363 // Add the basic block and the necessary calls.
364 IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", F));
366 IRB.CreateCall(RegisterF, {});
367 if (!InstrProfileOutput.empty()) {
368 auto *Int8PtrTy = Type::getInt8PtrTy(M->getContext());
369 auto *SetNameTy = FunctionType::get(VoidTy, Int8PtrTy, false);
370 auto *SetNameF = Function::Create(SetNameTy, GlobalValue::ExternalLinkage,
371 getInstrProfFileOverriderFuncName(), M);
373 // Create variable for profile name.
374 Constant *ProfileNameConst =
375 ConstantDataArray::getString(M->getContext(), InstrProfileOutput, true);
376 GlobalVariable *ProfileName =
377 new GlobalVariable(*M, ProfileNameConst->getType(), true,
378 GlobalValue::PrivateLinkage, ProfileNameConst);
380 IRB.CreateCall(SetNameF, IRB.CreatePointerCast(ProfileName, Int8PtrTy));
384 appendToGlobalCtors(*M, F, 0);