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/Transforms/Instrumentation.h"
  17
  18 #include "llvm/ADT/Triple.h"
  19 #include "llvm/IR/IRBuilder.h"
  20 #include "llvm/IR/IntrinsicInst.h"
  21 #include "llvm/IR/Module.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   DenseMap<GlobalVariable *, GlobalVariable *> RegionCounters;
  53   std::vector<Value *> UsedVars;
  54
  55   bool isMachO() const {
  56     return Triple(M->getTargetTriple()).isOSBinFormatMachO();
  57   }
  58
  59   /// Get the section name for the counter variables.
  60   StringRef getCountersSection() const {
  61     return isMachO() ? "__DATA,__llvm_prf_cnts" : "__llvm_prf_cnts";
  62   }
  63
  64   /// Get the section name for the name variables.
  65   StringRef getNameSection() const {
  66     return isMachO() ? "__DATA,__llvm_prf_names" : "__llvm_prf_names";
  67   }
  68
  69   /// Get the section name for the profile data variables.
  70   StringRef getDataSection() const {
  71     return isMachO() ? "__DATA,__llvm_prf_data" : "__llvm_prf_data";
  72   }
  73
  74   /// Replace instrprof_increment with an increment of the appropriate value.
  75   void lowerIncrement(InstrProfIncrementInst *Inc);
  76
  77   /// Get the region counters for an increment, creating them if necessary.
  78   ///
  79   /// If the counter array doesn't yet exist, the profile data variables
  80   /// referring to them will also be created.
  81   GlobalVariable *getOrCreateRegionCounters(InstrProfIncrementInst *Inc);
  82
  83   /// Emit runtime registration functions for each profile data variable.
  84   void emitRegistration();
  85
  86   /// Emit the necessary plumbing to pull in the runtime initialization.
  87   void emitRuntimeHook();
  88
  89   /// Add uses of our data variables and runtime hook.
  90   void emitUses();
  91
  92   /// Create a static initializer for our data, on platforms that need it.
  93   void emitInitialization();
  94 };
  95
  96 } // anonymous namespace
  97
  98 char InstrProfiling::ID = 0;
  99 INITIALIZE_PASS(InstrProfiling, "instrprof",
 100                 "Frontend instrumentation-based coverage lowering.", false,
 101                 false)
 102
 103 ModulePass *llvm::createInstrProfilingPass(const InstrProfOptions &Options) {
 104   return new InstrProfiling(Options);
 105 }
 106
 107 bool InstrProfiling::runOnModule(Module &M) {
 108   bool MadeChange = false;
 109
 110   this->M = &M;
 111   RegionCounters.clear();
 112   UsedVars.clear();
 113
 114   for (Function &F : M)
 115     for (BasicBlock &BB : F)
 116       for (auto I = BB.begin(), E = BB.end(); I != E;)
 117         if (auto *Inc = dyn_cast<InstrProfIncrementInst>(I++)) {
 118           lowerIncrement(Inc);
 119           MadeChange = true;
 120         }
 121   if (!MadeChange)
 122     return false;
 123
 124   emitRegistration();
 125   emitRuntimeHook();
 126   emitUses();
 127   emitInitialization();
 128   return true;
 129 }
 130
 131 void InstrProfiling::lowerIncrement(InstrProfIncrementInst *Inc) {
 132   GlobalVariable *Counters = getOrCreateRegionCounters(Inc);
 133
 134   IRBuilder<> Builder(Inc->getParent(), *Inc);
 135   uint64_t Index = Inc->getIndex()->getZExtValue();
 136   llvm::Value *Addr = Builder.CreateConstInBoundsGEP2_64(Counters, 0, Index);
 137   llvm::Value *Count = Builder.CreateLoad(Addr, "pgocount");
 138   Count = Builder.CreateAdd(Count, Builder.getInt64(1));
 139   Inc->replaceAllUsesWith(Builder.CreateStore(Count, Addr));
 140   Inc->eraseFromParent();
 141 }
 142
 143 /// Get the name of a profiling variable for a particular function.
 144 static std::string getVarName(InstrProfIncrementInst *Inc, StringRef VarName) {
 145   auto *Arr = cast<ConstantDataArray>(Inc->getName()->getInitializer());
 146   StringRef Name = Arr->isCString() ? Arr->getAsCString() : Arr->getAsString();
 147   return ("__llvm_profile_" + VarName + "_" + Name).str();
 148 }
 149
 150 GlobalVariable *
 151 InstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {
 152   GlobalVariable *Name = Inc->getName();
 153   auto It = RegionCounters.find(Name);
 154   if (It != RegionCounters.end())
 155     return It->second;
 156
 157   // Move the name variable to the right section.
 158   Name->setSection(getNameSection());
 159   Name->setAlignment(1);
 160
 161   uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
 162   LLVMContext &Ctx = M->getContext();
 163   ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
 164
 165   // Create the counters variable.
 166   auto *Counters = new GlobalVariable(*M, CounterTy, false, Name->getLinkage(),
 167                                       Constant::getNullValue(CounterTy),
 168                                       getVarName(Inc, "counters"));
 169   Counters->setVisibility(Name->getVisibility());
 170   Counters->setSection(getCountersSection());
 171   Counters->setAlignment(8);
 172
 173   RegionCounters[Inc->getName()] = Counters;
 174
 175   // Create data variable.
 176   auto *NameArrayTy = Name->getType()->getPointerElementType();
 177   auto *Int32Ty = Type::getInt32Ty(Ctx);
 178   auto *Int64Ty = Type::getInt64Ty(Ctx);
 179   auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
 180   auto *Int64PtrTy = Type::getInt64PtrTy(Ctx);
 181
 182   Type *DataTypes[] = {Int32Ty, Int32Ty, Int64Ty, Int8PtrTy, Int64PtrTy};
 183   auto *DataTy = StructType::get(Ctx, makeArrayRef(DataTypes));
 184   Constant *DataVals[] = {
 185       ConstantInt::get(Int32Ty, NameArrayTy->getArrayNumElements()),
 186       ConstantInt::get(Int32Ty, NumCounters),
 187       ConstantInt::get(Int64Ty, Inc->getHash()->getZExtValue()),
 188       ConstantExpr::getBitCast(Name, Int8PtrTy),
 189       ConstantExpr::getBitCast(Counters, Int64PtrTy)};
 190   auto *Data = new GlobalVariable(*M, DataTy, true, Name->getLinkage(),
 191                                   ConstantStruct::get(DataTy, DataVals),
 192                                   getVarName(Inc, "data"));
 193   Data->setVisibility(Name->getVisibility());
 194   Data->setSection(getDataSection());
 195   Data->setAlignment(8);
 196
 197   // Mark the data variable as used so that it isn't stripped out.
 198   UsedVars.push_back(Data);
 199
 200   return Counters;
 201 }
 202
 203 void InstrProfiling::emitRegistration() {
 204   // Don't do this for Darwin.  compiler-rt uses linker magic.
 205   if (Triple(M->getTargetTriple()).isOSDarwin())
 206     return;
 207
 208   // Construct the function.
 209   auto *VoidTy = Type::getVoidTy(M->getContext());
 210   auto *VoidPtrTy = Type::getInt8PtrTy(M->getContext());
 211   auto *RegisterFTy = FunctionType::get(VoidTy, false);
 212   auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage,
 213                                      "__llvm_profile_register_functions", M);
 214   RegisterF->setUnnamedAddr(true);
 215   if (Options.NoRedZone)
 216     RegisterF->addFnAttr(Attribute::NoRedZone);
 217
 218   auto *RuntimeRegisterTy = llvm::FunctionType::get(VoidTy, VoidPtrTy, false);
 219   auto *RuntimeRegisterF =
 220       Function::Create(RuntimeRegisterTy, GlobalVariable::ExternalLinkage,
 221                        "__llvm_profile_register_function", M);
 222
 223   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", RegisterF));
 224   for (Value *Data : UsedVars)
 225     IRB.CreateCall(RuntimeRegisterF, IRB.CreateBitCast(Data, VoidPtrTy));
 226   IRB.CreateRetVoid();
 227 }
 228
 229 void InstrProfiling::emitRuntimeHook() {
 230   const char *const RuntimeVarName = "__llvm_profile_runtime";
 231   const char *const RuntimeUserName = "__llvm_profile_runtime_user";
 232
 233   // If the module's provided its own runtime, we don't need to do anything.
 234   if (M->getGlobalVariable(RuntimeVarName))
 235     return;
 236
 237   // Declare an external variable that will pull in the runtime initialization.
 238   auto *Int32Ty = Type::getInt32Ty(M->getContext());
 239   auto *Var =
 240       new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
 241                          nullptr, RuntimeVarName);
 242
 243   // Make a function that uses it.
 244   auto *User =
 245       Function::Create(FunctionType::get(Int32Ty, false),
 246                        GlobalValue::LinkOnceODRLinkage, RuntimeUserName, M);
 247   User->addFnAttr(Attribute::NoInline);
 248   if (Options.NoRedZone)
 249     User->addFnAttr(Attribute::NoRedZone);
 250
 251   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", User));
 252   auto *Load = IRB.CreateLoad(Var);
 253   IRB.CreateRet(Load);
 254
 255   // Mark the user variable as used so that it isn't stripped out.
 256   UsedVars.push_back(User);
 257 }
 258
 259 void InstrProfiling::emitUses() {
 260   if (UsedVars.empty())
 261     return;
 262
 263   GlobalVariable *LLVMUsed = M->getGlobalVariable("llvm.used");
 264   std::vector<Constant*> MergedVars;
 265   if (LLVMUsed) {
 266     // Collect the existing members of llvm.used.
 267     ConstantArray *Inits = cast<ConstantArray>(LLVMUsed->getInitializer());
 268     for (unsigned I = 0, E = Inits->getNumOperands(); I != E; ++I)
 269       MergedVars.push_back(Inits->getOperand(I));
 270     LLVMUsed->eraseFromParent();
 271   }
 272
 273   Type *i8PTy = Type::getInt8PtrTy(M->getContext());
 274   // Add uses for our data.
 275   for (auto *Value : UsedVars)
 276     MergedVars.push_back(
 277         ConstantExpr::getBitCast(cast<llvm::Constant>(Value), i8PTy));
 278
 279   // Recreate llvm.used.
 280   ArrayType *ATy = ArrayType::get(i8PTy, MergedVars.size());
 281   LLVMUsed = new llvm::GlobalVariable(
 282       *M, ATy, false, llvm::GlobalValue::AppendingLinkage,
 283       llvm::ConstantArray::get(ATy, MergedVars), "llvm.used");
 284
 285   LLVMUsed->setSection("llvm.metadata");
 286 }
 287
 288 void InstrProfiling::emitInitialization() {
 289   Constant *RegisterF = M->getFunction("__llvm_profile_register_functions");
 290   if (!RegisterF)
 291     return;
 292
 293   // Create the initialization function.
 294   auto *VoidTy = Type::getVoidTy(M->getContext());
 295   auto *F =
 296       Function::Create(FunctionType::get(VoidTy, false),
 297                        GlobalValue::InternalLinkage, "__llvm_profile_init", M);
 298   F->setUnnamedAddr(true);
 299   F->addFnAttr(Attribute::NoInline);
 300   if (Options.NoRedZone)
 301     F->addFnAttr(Attribute::NoRedZone);
 302
 303   // Add the basic block and the necessary calls.
 304   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", F));
 305   IRB.CreateCall(RegisterF);
 306   IRB.CreateRetVoid();
 307
 308   appendToGlobalCtors(*M, F, 0);
 309 }