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_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.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "llvm/ProfileData/InstrProf.h"
  17 #include "llvm/Transforms/Instrumentation.h"
  18
  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"
  24
  25 using namespace llvm;
  26
  27 #define DEBUG_TYPE "instrprof"
  28
  29 namespace {
  30
  31 class InstrProfiling : public ModulePass {
  32 public:
  33   static char ID;
  34
  35   InstrProfiling() : ModulePass(ID) {}
  36
  37   InstrProfiling(const InstrProfOptions &Options)
  38       : ModulePass(ID), Options(Options) {}
  39
  40   const char *getPassName() const override {
  41     return "Frontend instrumentation-based coverage lowering";
  42   }
  43
  44   bool runOnModule(Module &M) override;
  45
  46   void getAnalysisUsage(AnalysisUsage &AU) const override {
  47     AU.setPreservesCFG();
  48   }
  49
  50 private:
  51   InstrProfOptions Options;
  52   Module *M;
  53   DenseMap<GlobalVariable *, GlobalVariable *> RegionCounters;
  54   std::vector<Value *> UsedVars;
  55
  56   bool isMachO() const {
  57     return Triple(M->getTargetTriple()).isOSBinFormatMachO();
  58   }
  59
  60   /// Get the section name for the counter variables.
  61   StringRef getCountersSection() const {
  62     return getInstrProfCountersSectionName(isMachO());
  63   }
  64
  65   /// Get the section name for the name variables.
  66   StringRef getNameSection() const {
  67     return getInstrProfNameSectionName(isMachO());
  68   }
  69
  70   /// Get the section name for the profile data variables.
  71   StringRef getDataSection() const {
  72     return getInstrProfDataSectionName(isMachO());
  73   }
  74
  75   /// Get the section name for the coverage mapping data.
  76   StringRef getCoverageSection() const {
  77     return getInstrProfCoverageSectionName(isMachO());
  78   }
  79
  80   /// Replace instrprof_increment with an increment of the appropriate value.
  81   void lowerIncrement(InstrProfIncrementInst *Inc);
  82
  83   /// Set up the section and uses for coverage data and its references.
  84   void lowerCoverageData(GlobalVariable *CoverageData);
  85
  86   /// Get the region counters for an increment, creating them if necessary.
  87   ///
  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);
  91
  92   /// Emit runtime registration functions for each profile data variable.
  93   void emitRegistration();
  94
  95   /// Emit the necessary plumbing to pull in the runtime initialization.
  96   void emitRuntimeHook();
  97
  98   /// Add uses of our data variables and runtime hook.
  99   void emitUses();
 100
 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();
 104 };
 105
 106 } // anonymous namespace
 107
 108 char InstrProfiling::ID = 0;
 109 INITIALIZE_PASS(InstrProfiling, "instrprof",
 110                 "Frontend instrumentation-based coverage lowering.", false,
 111                 false)
 112
 113 ModulePass *llvm::createInstrProfilingPass(const InstrProfOptions &Options) {
 114   return new InstrProfiling(Options);
 115 }
 116
 117 bool InstrProfiling::runOnModule(Module &M) {
 118   bool MadeChange = false;
 119
 120   this->M = &M;
 121   RegionCounters.clear();
 122   UsedVars.clear();
 123
 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++)) {
 128           lowerIncrement(Inc);
 129           MadeChange = true;
 130         }
 131   if (GlobalVariable *Coverage =
 132           M.getNamedGlobal(getCoverageMappingVarName())) {
 133     lowerCoverageData(Coverage);
 134     MadeChange = true;
 135   }
 136   if (!MadeChange)
 137     return false;
 138
 139   emitRegistration();
 140   emitRuntimeHook();
 141   emitUses();
 142   emitInitialization();
 143   return true;
 144 }
 145
 146 void InstrProfiling::lowerIncrement(InstrProfIncrementInst *Inc) {
 147   GlobalVariable *Counters = getOrCreateRegionCounters(Inc);
 148
 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();
 156 }
 157
 158 void InstrProfiling::lowerCoverageData(GlobalVariable *CoverageData) {
 159   CoverageData->setSection(getCoverageSection());
 160   CoverageData->setAlignment(8);
 161
 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();
 172
 173     assert(isa<GlobalVariable>(V) && "Missing reference to function name");
 174     GlobalVariable *Name = cast<GlobalVariable>(V);
 175
 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())
 179       continue;
 180
 181     // Move the name variable to the right section.
 182     Name->setSection(getNameSection());
 183     Name->setAlignment(1);
 184   }
 185 }
 186
 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();
 192 }
 193
 194 GlobalVariable *
 195 InstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {
 196   GlobalVariable *Name = Inc->getName();
 197   auto It = RegionCounters.find(Name);
 198   if (It != RegionCounters.end())
 199     return It->second;
 200
 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
 204   // linking.
 205   Function *Fn = Inc->getParent()->getParent();
 206   Comdat *ProfileVarsComdat = nullptr;
 207   if (Fn->hasComdat())
 208     ProfileVarsComdat = M->getOrInsertComdat(
 209         StringRef(getVarName(Inc, getInstrProfComdatPrefix())));
 210   Name->setSection(getNameSection());
 211   Name->setAlignment(1);
 212   Name->setComdat(ProfileVarsComdat);
 213
 214   uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
 215   LLVMContext &Ctx = M->getContext();
 216   ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
 217
 218   // Create the counters variable.
 219   auto *Counters =
 220       new GlobalVariable(*M, CounterTy, false, Name->getLinkage(),
 221                          Constant::getNullValue(CounterTy),
 222                          getVarName(Inc, getInstrProfCountersVarPrefix()));
 223   Counters->setVisibility(Name->getVisibility());
 224   Counters->setSection(getCountersSection());
 225   Counters->setAlignment(8);
 226   Counters->setComdat(ProfileVarsComdat);
 227
 228   RegionCounters[Inc->getName()] = Counters;
 229
 230   // Create data variable.
 231   auto *NameArrayTy = Name->getType()->getPointerElementType();
 232   auto *Int32Ty = Type::getInt32Ty(Ctx);
 233   auto *Int64Ty = Type::getInt64Ty(Ctx);
 234   auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
 235   auto *Int64PtrTy = Type::getInt64PtrTy(Ctx);
 236
 237   Type *DataTypes[] = {Int32Ty, Int32Ty, Int64Ty, Int8PtrTy, Int64PtrTy};
 238   auto *DataTy = StructType::get(Ctx, makeArrayRef(DataTypes));
 239   Constant *DataVals[] = {
 240       ConstantInt::get(Int32Ty, NameArrayTy->getArrayNumElements()),
 241       ConstantInt::get(Int32Ty, NumCounters),
 242       ConstantInt::get(Int64Ty, Inc->getHash()->getZExtValue()),
 243       ConstantExpr::getBitCast(Name, Int8PtrTy),
 244       ConstantExpr::getBitCast(Counters, Int64PtrTy)};
 245   auto *Data = new GlobalVariable(*M, DataTy, true, Name->getLinkage(),
 246                                   ConstantStruct::get(DataTy, DataVals),
 247                                   getVarName(Inc, getInstrProfDataVarPrefix()));
 248   Data->setVisibility(Name->getVisibility());
 249   Data->setSection(getDataSection());
 250   Data->setAlignment(8);
 251   Data->setComdat(ProfileVarsComdat);
 252
 253   // Mark the data variable as used so that it isn't stripped out.
 254   UsedVars.push_back(Data);
 255
 256   return Counters;
 257 }
 258
 259 void InstrProfiling::emitRegistration() {
 260   // Don't do this for Darwin.  compiler-rt uses linker magic.
 261   if (Triple(M->getTargetTriple()).isOSDarwin())
 262     return;
 263
 264   // Use linker script magic to get data/cnts/name start/end.
 265   if (Triple(M->getTargetTriple()).isOSLinux() ||
 266       Triple(M->getTargetTriple()).isOSFreeBSD())
 267     return;
 268
 269   // Construct the function.
 270   auto *VoidTy = Type::getVoidTy(M->getContext());
 271   auto *VoidPtrTy = Type::getInt8PtrTy(M->getContext());
 272   auto *RegisterFTy = FunctionType::get(VoidTy, false);
 273   auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage,
 274                                      getInstrProfRegFuncsName(), M);
 275   RegisterF->setUnnamedAddr(true);
 276   if (Options.NoRedZone) RegisterF->addFnAttr(Attribute::NoRedZone);
 277
 278   auto *RuntimeRegisterTy = FunctionType::get(VoidTy, VoidPtrTy, false);
 279   auto *RuntimeRegisterF =
 280       Function::Create(RuntimeRegisterTy, GlobalVariable::ExternalLinkage,
 281                        getInstrProfRegFuncName(), M);
 282
 283   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", RegisterF));
 284   for (Value *Data : UsedVars)
 285     IRB.CreateCall(RuntimeRegisterF, IRB.CreateBitCast(Data, VoidPtrTy));
 286   IRB.CreateRetVoid();
 287 }
 288
 289 void InstrProfiling::emitRuntimeHook() {
 290
 291   // If the module's provided its own runtime, we don't need to do anything.
 292   if (M->getGlobalVariable(getInstrProfRuntimeHookVarName())) return;
 293
 294   // Declare an external variable that will pull in the runtime initialization.
 295   auto *Int32Ty = Type::getInt32Ty(M->getContext());
 296   auto *Var =
 297       new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
 298                          nullptr, getInstrProfRuntimeHookVarName());
 299
 300   // Make a function that uses it.
 301   auto *User = Function::Create(FunctionType::get(Int32Ty, false),
 302                                 GlobalValue::LinkOnceODRLinkage,
 303                                 getInstrProfRuntimeHookVarUseFuncName(), M);
 304   User->addFnAttr(Attribute::NoInline);
 305   if (Options.NoRedZone) User->addFnAttr(Attribute::NoRedZone);
 306   User->setVisibility(GlobalValue::HiddenVisibility);
 307
 308   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", User));
 309   auto *Load = IRB.CreateLoad(Var);
 310   IRB.CreateRet(Load);
 311
 312   // Mark the user variable as used so that it isn't stripped out.
 313   UsedVars.push_back(User);
 314 }
 315
 316 void InstrProfiling::emitUses() {
 317   if (UsedVars.empty())
 318     return;
 319
 320   GlobalVariable *LLVMUsed = M->getGlobalVariable("llvm.used");
 321   std::vector<Constant *> MergedVars;
 322   if (LLVMUsed) {
 323     // Collect the existing members of llvm.used.
 324     ConstantArray *Inits = cast<ConstantArray>(LLVMUsed->getInitializer());
 325     for (unsigned I = 0, E = Inits->getNumOperands(); I != E; ++I)
 326       MergedVars.push_back(Inits->getOperand(I));
 327     LLVMUsed->eraseFromParent();
 328   }
 329
 330   Type *i8PTy = Type::getInt8PtrTy(M->getContext());
 331   // Add uses for our data.
 332   for (auto *Value : UsedVars)
 333     MergedVars.push_back(
 334         ConstantExpr::getBitCast(cast<Constant>(Value), i8PTy));
 335
 336   // Recreate llvm.used.
 337   ArrayType *ATy = ArrayType::get(i8PTy, MergedVars.size());
 338   LLVMUsed =
 339       new GlobalVariable(*M, ATy, false, GlobalValue::AppendingLinkage,
 340                          ConstantArray::get(ATy, MergedVars), "llvm.used");
 341
 342   LLVMUsed->setSection("llvm.metadata");
 343 }
 344
 345 void InstrProfiling::emitInitialization() {
 346   std::string InstrProfileOutput = Options.InstrProfileOutput;
 347
 348   Constant *RegisterF = M->getFunction(getInstrProfRegFuncsName());
 349   if (!RegisterF && InstrProfileOutput.empty()) return;
 350
 351   // Create the initialization function.
 352   auto *VoidTy = Type::getVoidTy(M->getContext());
 353   auto *F = Function::Create(FunctionType::get(VoidTy, false),
 354                              GlobalValue::InternalLinkage,
 355                              getInstrProfInitFuncName(), M);
 356   F->setUnnamedAddr(true);
 357   F->addFnAttr(Attribute::NoInline);
 358   if (Options.NoRedZone) F->addFnAttr(Attribute::NoRedZone);
 359
 360   // Add the basic block and the necessary calls.
 361   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", F));
 362   if (RegisterF)
 363     IRB.CreateCall(RegisterF, {});
 364   if (!InstrProfileOutput.empty()) {
 365     auto *Int8PtrTy = Type::getInt8PtrTy(M->getContext());
 366     auto *SetNameTy = FunctionType::get(VoidTy, Int8PtrTy, false);
 367     auto *SetNameF = Function::Create(SetNameTy, GlobalValue::ExternalLinkage,
 368                                       getInstrProfFileOverriderFuncName(), M);
 369
 370     // Create variable for profile name.
 371     Constant *ProfileNameConst =
 372         ConstantDataArray::getString(M->getContext(), InstrProfileOutput, true);
 373     GlobalVariable *ProfileName =
 374         new GlobalVariable(*M, ProfileNameConst->getType(), true,
 375                            GlobalValue::PrivateLinkage, ProfileNameConst);
 376
 377     IRB.CreateCall(SetNameF, IRB.CreatePointerCast(ProfileName, Int8PtrTy));
 378   }
 379   IRB.CreateRetVoid();
 380
 381   appendToGlobalCtors(*M, F, 0);
 382 }