llvm/unittests/IR/PassManagerTest.cpp

//===- llvm/unittest/IR/PassManager.cpp - PassManager tests ---------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "llvm/Assembly/Parser.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Support/SourceMgr.h"
#include "gtest/gtest.h"

using namespace llvm;

namespace {

class TestAnalysisPass {
public:
  typedef Function IRUnitT;

  struct Result {
    Result(int Count) : InstructionCount(Count) {}
    bool invalidate(Function *) { return true; }
    int InstructionCount;
  };

  /// \brief Returns an opaque, unique ID for this pass type.
  static void *ID() { return (void *)&PassID; }

  /// \brief Run the analysis pass over the function and return a result.
  Result run(Function *F) {
    int Count = 0;
    for (Function::iterator BBI = F->begin(), BBE = F->end(); BBI != BBE; ++BBI)
      for (BasicBlock::iterator II = BBI->begin(), IE = BBI->end(); II != IE;
           ++II)
        ++Count;
    return Result(Count);
  }

private:
  /// \brief Private static data to provide unique ID.
  static char PassID;
};

char TestAnalysisPass::PassID;

struct TestModulePass {
  TestModulePass(int &RunCount) : RunCount(RunCount) {}

  bool run(Module *M) {
    ++RunCount;
    return true;
  }

  int &RunCount;
};

struct TestFunctionPass {
  TestFunctionPass(FunctionAnalysisManager &AM, int &RunCount,
                   int &AnalyzedInstrCount)
      : AM(AM), RunCount(RunCount), AnalyzedInstrCount(AnalyzedInstrCount) {}

  bool run(Function *F) {
    ++RunCount;

    const TestAnalysisPass::Result &AR = AM.getResult<TestAnalysisPass>(F);
    AnalyzedInstrCount += AR.InstructionCount;

    return true;
  }

  FunctionAnalysisManager &AM;
  int &RunCount;
  int &AnalyzedInstrCount;
};

Module *parseIR(const char *IR) {
  LLVMContext &C = getGlobalContext();
  SMDiagnostic Err;
  return ParseAssemblyString(IR, 0, Err, C);
}

class PassManagerTest : public ::testing::Test {
protected:
  OwningPtr<Module> M;

public:
  PassManagerTest()
      : M(parseIR("define void @f() {\n"
                  "entry:\n"
                  "  call void @g()\n"
                  "  call void @h()\n"
                  "  ret void\n"
                  "}\n"
                  "define void @g() {\n"
                  "  ret void\n"
                  "}\n"
                  "define void @h() {\n"
                  "  ret void\n"
                  "}\n")) {}
};

TEST_F(PassManagerTest, Basic) {
  FunctionAnalysisManager AM;
  AM.registerPass(TestAnalysisPass());

  ModulePassManager MPM;
  FunctionPassManager FPM(&AM);

  // Count the runs over a module.
  int ModulePassRunCount = 0;
  MPM.addPass(TestModulePass(ModulePassRunCount));

  // Count the runs over a Function.
  int FunctionPassRunCount = 0;
  int AnalyzedInstrCount = 0;
  FPM.addPass(TestFunctionPass(AM, FunctionPassRunCount, AnalyzedInstrCount));
  MPM.addPass(createModuleToFunctionPassAdaptor(FPM));

  MPM.run(M.get());
  EXPECT_EQ(1, ModulePassRunCount);
  EXPECT_EQ(3, FunctionPassRunCount);
  EXPECT_EQ(5, AnalyzedInstrCount);
}
}