lib/Transforms/Instrumentation/LineProfiling.cpp

//===- LineProfiling.cpp - Insert counters for line profiling -------------===//
//
//                      The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This pass creates counters for the number of times that the original source
// lines of code were executed.
//
// The lines are found from existing debug info in the LLVM IR. Iterating
// through LLVM instructions, every time the debug location changes we insert a
// new counter and instructions to increment the counter there. A global
// destructor runs to dump the counters out to a file.
//
//===----------------------------------------------------------------------===//

#define DEBUG_TYPE "insert-line-profiling"

#include "ProfilingUtils.h"
#include "llvm/Transforms/Instrumentation.h"
#include "llvm/Analysis/DebugInfo.h"
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Instructions.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/DebugLoc.h"
#include "llvm/Support/InstIterator.h"
#include "llvm/Support/IRBuilder.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
#include <set>
#include <string>
using namespace llvm;

STATISTIC(NumUpdatesInserted, "The # of counter increments inserted.");

namespace {
  class LineProfiler : public ModulePass {
    bool runOnModule(Module &M);
  public:
    static char ID;
    LineProfiler() : ModulePass(ID) {
      initializeLineProfilerPass(*PassRegistry::getPassRegistry());
    }
    virtual const char *getPassName() const {
      return "Line Profiler";
    }

  private:
    // Get pointers to the functions in the runtime library.
    Constant *getStartFileFunc();
    Constant *getCounterFunc();
    Constant *getEndFileFunc();

    // Insert an increment of the counter before instruction I.
    void InsertCounterUpdateBefore(Instruction *I);

    // Add the function to write out all our counters to the global destructor
    // list.
    void InsertCounterWriteout();

    // Mapping from the source location to the counter tracking that location.
    DenseMap<DebugLoc, GlobalVariable *> counters;

    Module *Mod;
    LLVMContext *Ctx;
  };
}

char LineProfiler::ID = 0;
INITIALIZE_PASS(LineProfiler, "insert-line-profiling",
                "Insert instrumentation for line profiling", false, false)

ModulePass *llvm::createLineProfilerPass() { return new LineProfiler(); }

bool LineProfiler::runOnModule(Module &M) {
  Mod = &M;
  Ctx = &M.getContext();

  DebugLoc last_line;  // initializes to unknown
  bool Changed = false;
  for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
    for (inst_iterator II = inst_begin(F), IE = inst_end(F); II != IE; ++II) {
      const DebugLoc &loc = II->getDebugLoc();
      if (loc.isUnknown()) continue;
      if (loc == last_line) continue;
      last_line = loc;

      InsertCounterUpdateBefore(&*II);
      ++NumUpdatesInserted;
      Changed = true;
    }
  }

  if (Changed) {
    InsertCounterWriteout();
  }

  return Changed;
}

void LineProfiler::InsertCounterUpdateBefore(Instruction *I) {
  const DebugLoc &loc = I->getDebugLoc();
  GlobalVariable *&counter = counters[loc];
  const Type *Int64Ty = Type::getInt64Ty(*Ctx);
  if (!counter) {
    counter = new GlobalVariable(*Mod, Int64Ty, false,
                                 GlobalValue::InternalLinkage,
                                 Constant::getNullValue(Int64Ty),
                                 "__llvm_prof_linecov_ctr", 0, false, 0);
    counter->setVisibility(GlobalVariable::HiddenVisibility);
    counter->setUnnamedAddr(true);
  }

  if (isa<PHINode>(I)) {
    // We may not error out or crash in this case, because a module could put
    // changing line numbers on phi nodes and still pass the verifier.
    dbgs() << "Refusing to insert code before phi: " << *I << "\n";
    I = I->getParent()->getFirstNonPHI();
  }

  IRBuilder<> builder(I);
  Value *ctr = builder.CreateLoad(counter);
  ctr = builder.CreateAdd(ctr, ConstantInt::get(Int64Ty, 1));
  builder.CreateStore(ctr, counter);
}

static DISubprogram FindSubprogram(DIScope scope) {
  while (!scope.isSubprogram()) {
    assert(scope.isLexicalBlock() &&
           "Debug location not lexical block or subprogram");
    scope = DILexicalBlock(scope).getContext();
  }
  return DISubprogram(scope);
}

Constant *LineProfiler::getStartFileFunc() {
  const Type *Args[1] = { Type::getInt8PtrTy(*Ctx) };
  const FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx),
                                              Args, false);
  return Mod->getOrInsertFunction("llvm_prof_linectr_start_file", FTy);
}

Constant *LineProfiler::getCounterFunc() {
  const Type *Args[] = {
    Type::getInt8PtrTy(*Ctx),   // const char *dir
    Type::getInt8PtrTy(*Ctx),   // const char *file
    Type::getInt32Ty(*Ctx),     // uint32_t line
    Type::getInt32Ty(*Ctx),     // uint32_t column
    Type::getInt64PtrTy(*Ctx),  // int64_t *counter
  };
  const FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx),
                                              Args, false);
  return Mod->getOrInsertFunction("llvm_prof_linectr_emit_counter", FTy);
}

Constant *LineProfiler::getEndFileFunc() {
  const FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
  return Mod->getOrInsertFunction("llvm_prof_linectr_end_file", FTy);
}

void LineProfiler::InsertCounterWriteout() {
  std::set<std::string> compile_units;
  for (DenseMap<DebugLoc, GlobalVariable *>::iterator I = counters.begin(),
           E = counters.end(); I != E; ++I) {
    const DebugLoc &loc = I->first;
    DISubprogram subprogram(FindSubprogram(DIScope(loc.getScope(*Ctx))));
    compile_units.insert(subprogram.getCompileUnit().getFilename().str());
  }

  const FunctionType *WriteoutFTy =
      FunctionType::get(Type::getVoidTy(*Ctx), false);
  Function *WriteoutF = Function::Create(WriteoutFTy,
                                         GlobalValue::InternalLinkage,
                                         "__llvm_prof_linecov_dtor",
                                         Mod);
  WriteoutF->setUnnamedAddr(true);
  BasicBlock *BB = BasicBlock::Create(*Ctx, "", WriteoutF);
  IRBuilder<> builder(BB);

  Constant *StartFile = getStartFileFunc();
  Constant *EmitCounter = getCounterFunc();
  Constant *EndFile = getEndFileFunc();

  for (std::set<std::string>::const_iterator CUI = compile_units.begin(),
           CUE = compile_units.end(); CUI != CUE; ++CUI) {
    builder.CreateCall(StartFile,
                       builder.CreateGlobalStringPtr(*CUI));
    for (DenseMap<DebugLoc, GlobalVariable *>::iterator I = counters.begin(),
             E = counters.end(); I != E; ++I) {
      const DebugLoc &loc = I->first;
      DISubprogram subprogram(FindSubprogram(DIScope(loc.getScope(*Ctx))));
      DICompileUnit compileunit(subprogram.getCompileUnit());

      if (compileunit.getFilename() != *CUI)
        continue;

      Value *Args[] = {
        builder.CreateGlobalStringPtr(subprogram.getDirectory()),
        builder.CreateGlobalStringPtr(subprogram.getFilename()),
        ConstantInt::get(Type::getInt32Ty(*Ctx), loc.getLine()),
        ConstantInt::get(Type::getInt32Ty(*Ctx), loc.getCol()),
        I->second
      };
      builder.CreateCall(EmitCounter, Args);
    }
    builder.CreateCall(EndFile);
  }
  builder.CreateRetVoid();

  InsertProfilingShutdownCall(WriteoutF, Mod);
}