[PGO] Stop using invalid char in instr variable names.
[oota-llvm.git] / lib / Transforms / Instrumentation / InstrProfiling.cpp
1 //===-- InstrProfiling.cpp - Frontend instrumentation based profiling -----===//
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 pass lowers instrprof_* intrinsics emitted by a frontend for profiling.
11 // It also builds the data structures and initialization code needed for
12 // updating execution counts and emitting the profile at runtime.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #include "llvm/ADT/Triple.h"
17 #include "llvm/IR/IRBuilder.h"
18 #include "llvm/IR/IntrinsicInst.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/ProfileData/InstrProf.h"
21 #include "llvm/Transforms/Instrumentation.h"
22 #include "llvm/Transforms/Utils/ModuleUtils.h"
23
24 using namespace llvm;
25
26 #define DEBUG_TYPE "instrprof"
27
28 namespace {
29
30 class InstrProfiling : public ModulePass {
31 public:
32   static char ID;
33
34   InstrProfiling() : ModulePass(ID) {}
35
36   InstrProfiling(const InstrProfOptions &Options)
37       : ModulePass(ID), Options(Options) {}
38
39   const char *getPassName() const override {
40     return "Frontend instrumentation-based coverage lowering";
41   }
42
43   bool runOnModule(Module &M) override;
44
45   void getAnalysisUsage(AnalysisUsage &AU) const override {
46     AU.setPreservesCFG();
47   }
48
49 private:
50   InstrProfOptions Options;
51   Module *M;
52   typedef struct PerFunctionProfileData {
53     uint32_t NumValueSites[IPVK_Last+1];
54     GlobalVariable* RegionCounters;
55     GlobalVariable* DataVar;
56     PerFunctionProfileData() : RegionCounters(nullptr), DataVar(nullptr) {
57       memset(NumValueSites, 0, sizeof(uint32_t) * (IPVK_Last+1));
58     }
59   } PerFunctionProfileData;
60   DenseMap<GlobalVariable *, PerFunctionProfileData> ProfileDataMap;
61   std::vector<Value *> UsedVars;
62
63   bool isMachO() const {
64     return Triple(M->getTargetTriple()).isOSBinFormatMachO();
65   }
66
67   /// Get the section name for the counter variables.
68   StringRef getCountersSection() const {
69     return getInstrProfCountersSectionName(isMachO());
70   }
71
72   /// Get the section name for the name variables.
73   StringRef getNameSection() const {
74     return getInstrProfNameSectionName(isMachO());
75   }
76
77   /// Get the section name for the profile data variables.
78   StringRef getDataSection() const {
79     return getInstrProfDataSectionName(isMachO());
80   }
81
82   /// Get the section name for the coverage mapping data.
83   StringRef getCoverageSection() const {
84     return getInstrProfCoverageSectionName(isMachO());
85   }
86
87   /// Count the number of instrumented value sites for the function.
88   void computeNumValueSiteCounts(InstrProfValueProfileInst *Ins);
89
90   /// Replace instrprof_value_profile with a call to runtime library.
91   void lowerValueProfileInst(InstrProfValueProfileInst *Ins);
92
93   /// Replace instrprof_increment with an increment of the appropriate value.
94   void lowerIncrement(InstrProfIncrementInst *Inc);
95
96   /// Set up the section and uses for coverage data and its references.
97   void lowerCoverageData(GlobalVariable *CoverageData);
98
99   /// Get the region counters for an increment, creating them if necessary.
100   ///
101   /// If the counter array doesn't yet exist, the profile data variables
102   /// referring to them will also be created.
103   GlobalVariable *getOrCreateRegionCounters(InstrProfIncrementInst *Inc);
104
105   /// Emit runtime registration functions for each profile data variable.
106   void emitRegistration();
107
108   /// Emit the necessary plumbing to pull in the runtime initialization.
109   void emitRuntimeHook();
110
111   /// Add uses of our data variables and runtime hook.
112   void emitUses();
113
114   /// Create a static initializer for our data, on platforms that need it,
115   /// and for any profile output file that was specified.
116   void emitInitialization();
117 };
118
119 } // anonymous namespace
120
121 char InstrProfiling::ID = 0;
122 INITIALIZE_PASS(InstrProfiling, "instrprof",
123                 "Frontend instrumentation-based coverage lowering.", false,
124                 false)
125
126 ModulePass *llvm::createInstrProfilingPass(const InstrProfOptions &Options) {
127   return new InstrProfiling(Options);
128 }
129
130 bool InstrProfiling::runOnModule(Module &M) {
131   bool MadeChange = false;
132
133   this->M = &M;
134   ProfileDataMap.clear();
135   UsedVars.clear();
136
137   // We did not know how many value sites there would be inside
138   // the instrumented function. This is counting the number of instrumented
139   // target value sites to enter it as field in the profile data variable.
140   for (Function &F : M)
141     for (BasicBlock &BB : F)
142       for (auto I = BB.begin(), E = BB.end(); I != E;)
143         if (auto *Ind = dyn_cast<InstrProfValueProfileInst>(I++))
144           computeNumValueSiteCounts(Ind);
145
146   for (Function &F : M)
147     for (BasicBlock &BB : F)
148       for (auto I = BB.begin(), E = BB.end(); I != E;) {
149         auto Instr = I++;
150         if (auto *Inc = dyn_cast<InstrProfIncrementInst>(Instr)) {
151           lowerIncrement(Inc);
152           MadeChange = true;
153         } else if (auto *Ind = dyn_cast<InstrProfValueProfileInst>(Instr)) {
154           lowerValueProfileInst(Ind);
155           MadeChange = true;
156         }
157       }
158
159   if (GlobalVariable *Coverage =
160           M.getNamedGlobal(getCoverageMappingVarName())) {
161     lowerCoverageData(Coverage);
162     MadeChange = true;
163   }
164
165   if (!MadeChange)
166     return false;
167
168   emitRegistration();
169   emitRuntimeHook();
170   emitUses();
171   emitInitialization();
172   return true;
173 }
174
175 static Constant *getOrInsertValueProfilingCall(Module &M) {
176   LLVMContext &Ctx = M.getContext();
177   auto *ReturnTy = Type::getVoidTy(M.getContext());
178   Type *ParamTypes[] = {
179 #define VALUE_PROF_FUNC_PARAM(ParamType, ParamName, ParamLLVMType) ParamLLVMType
180 #include "llvm/ProfileData/InstrProfData.inc"
181   };
182   auto *ValueProfilingCallTy =
183       FunctionType::get(ReturnTy, makeArrayRef(ParamTypes), false);
184   return M.getOrInsertFunction(getInstrProfValueProfFuncName(),
185                                ValueProfilingCallTy);
186 }
187
188 void InstrProfiling::computeNumValueSiteCounts(InstrProfValueProfileInst *Ind) {
189
190   GlobalVariable *Name = Ind->getName();
191   uint64_t ValueKind = Ind->getValueKind()->getZExtValue();
192   uint64_t Index = Ind->getIndex()->getZExtValue();
193   auto It = ProfileDataMap.find(Name);
194   if (It == ProfileDataMap.end()) {
195     PerFunctionProfileData PD;
196     PD.NumValueSites[ValueKind] = Index + 1;
197     ProfileDataMap[Name] = PD;
198   } else if (It->second.NumValueSites[ValueKind] <= Index)
199     It->second.NumValueSites[ValueKind] = Index + 1;
200 }
201
202 void InstrProfiling::lowerValueProfileInst(InstrProfValueProfileInst *Ind) {
203
204   GlobalVariable *Name = Ind->getName();
205   auto It = ProfileDataMap.find(Name);
206   assert(It != ProfileDataMap.end() && It->second.DataVar &&
207     "value profiling detected in function with no counter incerement");
208
209   GlobalVariable *DataVar = It->second.DataVar;
210   uint64_t ValueKind = Ind->getValueKind()->getZExtValue();
211   uint64_t Index = Ind->getIndex()->getZExtValue();
212   for (uint32_t Kind = IPVK_First; Kind < ValueKind; ++Kind)
213     Index += It->second.NumValueSites[Kind];
214
215   IRBuilder<> Builder(Ind);
216   Value* Args[3] = {Ind->getTargetValue(),
217       Builder.CreateBitCast(DataVar, Builder.getInt8PtrTy()),
218       Builder.getInt32(Index)};
219   Ind->replaceAllUsesWith(
220       Builder.CreateCall(getOrInsertValueProfilingCall(*M), Args));
221   Ind->eraseFromParent();
222 }
223
224 void InstrProfiling::lowerIncrement(InstrProfIncrementInst *Inc) {
225   GlobalVariable *Counters = getOrCreateRegionCounters(Inc);
226
227   IRBuilder<> Builder(Inc);
228   uint64_t Index = Inc->getIndex()->getZExtValue();
229   Value *Addr = Builder.CreateConstInBoundsGEP2_64(Counters, 0, Index);
230   Value *Count = Builder.CreateLoad(Addr, "pgocount");
231   Count = Builder.CreateAdd(Count, Builder.getInt64(1));
232   Inc->replaceAllUsesWith(Builder.CreateStore(Count, Addr));
233   Inc->eraseFromParent();
234 }
235
236 void InstrProfiling::lowerCoverageData(GlobalVariable *CoverageData) {
237   CoverageData->setSection(getCoverageSection());
238   CoverageData->setAlignment(8);
239
240   Constant *Init = CoverageData->getInitializer();
241   // We're expecting { i32, i32, i32, i32, [n x { i8*, i32, i32 }], [m x i8] }
242   // for some C. If not, the frontend's given us something broken.
243   assert(Init->getNumOperands() == 6 && "bad number of fields in coverage map");
244   assert(isa<ConstantArray>(Init->getAggregateElement(4)) &&
245          "invalid function list in coverage map");
246   ConstantArray *Records = cast<ConstantArray>(Init->getAggregateElement(4));
247   for (unsigned I = 0, E = Records->getNumOperands(); I < E; ++I) {
248     Constant *Record = Records->getOperand(I);
249     Value *V = const_cast<Value *>(Record->getOperand(0))->stripPointerCasts();
250
251     assert(isa<GlobalVariable>(V) && "Missing reference to function name");
252     GlobalVariable *Name = cast<GlobalVariable>(V);
253
254     // If we have region counters for this name, we've already handled it.
255     auto It = ProfileDataMap.find(Name);
256     if (It != ProfileDataMap.end())
257       if (It->second.RegionCounters)
258         continue;
259
260     // Move the name variable to the right section.
261     Name->setSection(getNameSection());
262     Name->setAlignment(1);
263   }
264 }
265
266 /// Get the name of a profiling variable for a particular function.
267 static std::string getVarName(InstrProfIncrementInst *Inc, StringRef Prefix) {
268   StringRef NamePrefix = getInstrProfNameVarPrefix();
269   StringRef Name = Inc->getName()->getName().substr(NamePrefix.size());
270   return (Prefix + Name).str();
271 }
272
273 static inline bool shouldRecordFunctionAddr(Function *F) {
274   // Check the linkage
275   if (!F->hasLinkOnceLinkage() && !F->hasLocalLinkage() &&
276       !F->hasAvailableExternallyLinkage())
277     return true;
278   // Check uses of this function for other than direct calls or invokes to it.
279   return F->hasAddressTaken();
280 }
281
282 GlobalVariable *
283 InstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {
284   GlobalVariable *NamePtr = Inc->getName();
285   auto It = ProfileDataMap.find(NamePtr);
286   PerFunctionProfileData PD;
287   if (It != ProfileDataMap.end()) {
288     if (It->second.RegionCounters)
289       return It->second.RegionCounters;
290     PD = It->second;
291   }
292
293   // Move the name variable to the right section. Place them in a COMDAT group
294   // if the associated function is a COMDAT. This will make sure that
295   // only one copy of counters of the COMDAT function will be emitted after
296   // linking.
297   Function *Fn = Inc->getParent()->getParent();
298   Comdat *ProfileVarsComdat = nullptr;
299   if (Fn->hasComdat())
300     ProfileVarsComdat = M->getOrInsertComdat(
301         StringRef(getVarName(Inc, getInstrProfComdatPrefix())));
302   NamePtr->setSection(getNameSection());
303   NamePtr->setAlignment(1);
304   NamePtr->setComdat(ProfileVarsComdat);
305
306   uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
307   LLVMContext &Ctx = M->getContext();
308   ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
309
310   // Create the counters variable.
311   auto *CounterPtr =
312       new GlobalVariable(*M, CounterTy, false, NamePtr->getLinkage(),
313                          Constant::getNullValue(CounterTy),
314                          getVarName(Inc, getInstrProfCountersVarPrefix()));
315   CounterPtr->setVisibility(NamePtr->getVisibility());
316   CounterPtr->setSection(getCountersSection());
317   CounterPtr->setAlignment(8);
318   CounterPtr->setComdat(ProfileVarsComdat);
319
320   // Create data variable.
321   auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
322   auto *Int16Ty = Type::getInt16Ty(Ctx);
323   auto *Int16ArrayTy = ArrayType::get(Int16Ty, IPVK_Last+1);
324   Type *DataTypes[] = {
325     #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) LLVMType,
326     #include "llvm/ProfileData/InstrProfData.inc"
327   };
328   auto *DataTy = StructType::get(Ctx, makeArrayRef(DataTypes));
329
330   Constant *FunctionAddr = shouldRecordFunctionAddr(Fn) ?
331                            ConstantExpr::getBitCast(Fn, Int8PtrTy) :
332                            ConstantPointerNull::get(Int8PtrTy);
333
334   Constant *Int16ArrayVals[IPVK_Last+1];
335   for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
336     Int16ArrayVals[Kind] = ConstantInt::get(Int16Ty, PD.NumValueSites[Kind]);
337
338   Constant *DataVals[] = {
339     #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) Init,
340     #include "llvm/ProfileData/InstrProfData.inc"
341   };
342   auto *Data = new GlobalVariable(*M, DataTy, false, NamePtr->getLinkage(),
343                                   ConstantStruct::get(DataTy, DataVals),
344                                   getVarName(Inc, getInstrProfDataVarPrefix()));
345   Data->setVisibility(NamePtr->getVisibility());
346   Data->setSection(getDataSection());
347   Data->setAlignment(INSTR_PROF_DATA_ALIGNMENT);
348   Data->setComdat(ProfileVarsComdat);
349
350   PD.RegionCounters = CounterPtr;
351   PD.DataVar = Data;
352   ProfileDataMap[NamePtr] = PD;
353
354   // Mark the data variable as used so that it isn't stripped out.
355   UsedVars.push_back(Data);
356
357   return CounterPtr;
358 }
359
360 void InstrProfiling::emitRegistration() {
361   // Don't do this for Darwin.  compiler-rt uses linker magic.
362   if (Triple(M->getTargetTriple()).isOSDarwin())
363     return;
364
365   // Use linker script magic to get data/cnts/name start/end.
366   if (Triple(M->getTargetTriple()).isOSLinux() ||
367       Triple(M->getTargetTriple()).isOSFreeBSD())
368     return;
369
370   // Construct the function.
371   auto *VoidTy = Type::getVoidTy(M->getContext());
372   auto *VoidPtrTy = Type::getInt8PtrTy(M->getContext());
373   auto *RegisterFTy = FunctionType::get(VoidTy, false);
374   auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage,
375                                      getInstrProfRegFuncsName(), M);
376   RegisterF->setUnnamedAddr(true);
377   if (Options.NoRedZone) RegisterF->addFnAttr(Attribute::NoRedZone);
378
379   auto *RuntimeRegisterTy = FunctionType::get(VoidTy, VoidPtrTy, false);
380   auto *RuntimeRegisterF =
381       Function::Create(RuntimeRegisterTy, GlobalVariable::ExternalLinkage,
382                        getInstrProfRegFuncName(), M);
383
384   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", RegisterF));
385   for (Value *Data : UsedVars)
386     IRB.CreateCall(RuntimeRegisterF, IRB.CreateBitCast(Data, VoidPtrTy));
387   IRB.CreateRetVoid();
388 }
389
390 void InstrProfiling::emitRuntimeHook() {
391
392   // We expect the linker to be invoked with -u<hook_var> flag for linux,
393   // for which case there is no need to emit the user function.
394   if (Triple(M->getTargetTriple()).isOSLinux())
395     return;
396
397   // If the module's provided its own runtime, we don't need to do anything.
398   if (M->getGlobalVariable(getInstrProfRuntimeHookVarName())) return;
399
400   // Declare an external variable that will pull in the runtime initialization.
401   auto *Int32Ty = Type::getInt32Ty(M->getContext());
402   auto *Var =
403       new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
404                          nullptr, getInstrProfRuntimeHookVarName());
405
406   // Make a function that uses it.
407   auto *User = Function::Create(FunctionType::get(Int32Ty, false),
408                                 GlobalValue::LinkOnceODRLinkage,
409                                 getInstrProfRuntimeHookVarUseFuncName(), M);
410   User->addFnAttr(Attribute::NoInline);
411   if (Options.NoRedZone) User->addFnAttr(Attribute::NoRedZone);
412   User->setVisibility(GlobalValue::HiddenVisibility);
413
414   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", User));
415   auto *Load = IRB.CreateLoad(Var);
416   IRB.CreateRet(Load);
417
418   // Mark the user variable as used so that it isn't stripped out.
419   UsedVars.push_back(User);
420 }
421
422 void InstrProfiling::emitUses() {
423   if (UsedVars.empty())
424     return;
425
426   GlobalVariable *LLVMUsed = M->getGlobalVariable("llvm.used");
427   std::vector<Constant *> MergedVars;
428   if (LLVMUsed) {
429     // Collect the existing members of llvm.used.
430     ConstantArray *Inits = cast<ConstantArray>(LLVMUsed->getInitializer());
431     for (unsigned I = 0, E = Inits->getNumOperands(); I != E; ++I)
432       MergedVars.push_back(Inits->getOperand(I));
433     LLVMUsed->eraseFromParent();
434   }
435
436   Type *i8PTy = Type::getInt8PtrTy(M->getContext());
437   // Add uses for our data.
438   for (auto *Value : UsedVars)
439     MergedVars.push_back(
440         ConstantExpr::getBitCast(cast<Constant>(Value), i8PTy));
441
442   // Recreate llvm.used.
443   ArrayType *ATy = ArrayType::get(i8PTy, MergedVars.size());
444   LLVMUsed =
445       new GlobalVariable(*M, ATy, false, GlobalValue::AppendingLinkage,
446                          ConstantArray::get(ATy, MergedVars), "llvm.used");
447   LLVMUsed->setSection("llvm.metadata");
448 }
449
450 void InstrProfiling::emitInitialization() {
451   std::string InstrProfileOutput = Options.InstrProfileOutput;
452
453   Constant *RegisterF = M->getFunction(getInstrProfRegFuncsName());
454   if (!RegisterF && InstrProfileOutput.empty()) return;
455
456   // Create the initialization function.
457   auto *VoidTy = Type::getVoidTy(M->getContext());
458   auto *F = Function::Create(FunctionType::get(VoidTy, false),
459                              GlobalValue::InternalLinkage,
460                              getInstrProfInitFuncName(), M);
461   F->setUnnamedAddr(true);
462   F->addFnAttr(Attribute::NoInline);
463   if (Options.NoRedZone) F->addFnAttr(Attribute::NoRedZone);
464
465   // Add the basic block and the necessary calls.
466   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", F));
467   if (RegisterF)
468     IRB.CreateCall(RegisterF, {});
469   if (!InstrProfileOutput.empty()) {
470     auto *Int8PtrTy = Type::getInt8PtrTy(M->getContext());
471     auto *SetNameTy = FunctionType::get(VoidTy, Int8PtrTy, false);
472     auto *SetNameF = Function::Create(SetNameTy, GlobalValue::ExternalLinkage,
473                                       getInstrProfFileOverriderFuncName(), M);
474
475     // Create variable for profile name.
476     Constant *ProfileNameConst =
477         ConstantDataArray::getString(M->getContext(), InstrProfileOutput, true);
478     GlobalVariable *ProfileName =
479         new GlobalVariable(*M, ProfileNameConst->getType(), true,
480                            GlobalValue::PrivateLinkage, ProfileNameConst);
481
482     IRB.CreateCall(SetNameF, IRB.CreatePointerCast(ProfileName, Int8PtrTy));
483   }
484   IRB.CreateRetVoid();
485
486   appendToGlobalCtors(*M, F, 0);
487 }