PassBuilderCallbacksTest.cpp | Explore in Territory

//===- unittests/IR/PassBuilderCallbacksTest.cpp - PB Callback Tests --===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "llvm/Testing/Support/Error.h"
#include <functional>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <llvm/ADT/Any.h>
#include <llvm/Analysis/CGSCCPassManager.h>
#include <llvm/Analysis/LoopAnalysisManager.h>
#include <llvm/AsmParser/Parser.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/PassInstrumentation.h>
#include <llvm/IR/PassManager.h>
#include <llvm/Passes/PassBuilder.h>
#include <llvm/Support/Regex.h>
#include <llvm/Support/SourceMgr.h>
#include <llvm/Transforms/Scalar/LoopPassManager.h>

usingnamespacellvm;

namespace {
AnyNumber;
DoAll;
Not;
Return;
WithArgs;
_;

/// A CRTP base for analysis mock handles
///
/// This class reconciles mocking with the value semantics implementation of the
/// AnalysisManager. Analysis mock handles should derive from this class and
/// call \c setDefault() in their constroctur for wiring up the defaults defined
/// by this base with their mock run() and invalidate() implementations.
template <typename DerivedT, typename IRUnitT,
          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
          typename... ExtraArgTs>
class MockAnalysisHandleBase { … };

/// A CRTP base for pass mock handles
///
/// This class reconciles mocking with the value semantics implementation of the
/// PassManager. Pass mock handles should derive from this class and
/// call \c setDefault() in their constroctur for wiring up the defaults defined
/// by this base with their mock run() and invalidate() implementations.
template <typename DerivedT, typename IRUnitT, typename AnalysisManagerT,
          typename... ExtraArgTs>
AnalysisKey MockAnalysisHandleBase<DerivedT, IRUnitT, AnalysisManagerT,
                                   ExtraArgTs...>::Analysis::Key;

template <typename DerivedT, typename IRUnitT,
          typename AnalysisManagerT = AnalysisManager<IRUnitT>,
          typename... ExtraArgTs>
class MockPassHandleBase { … };

/// Mock handles for passes for the IRUnits Module, CGSCC, Function, Loop.
/// These handles define the appropriate run() mock interface for the respective
/// IRUnit type.
template <typename IRUnitT> struct MockPassHandle;
template <>
struct MockPassHandle<Loop>
    : MockPassHandleBase<MockPassHandle<Loop>, Loop, LoopAnalysisManager,
                         LoopStandardAnalysisResults &, LPMUpdater &> { … };

template <>
struct MockPassHandle<LoopNest>
    : MockPassHandleBase<MockPassHandle<LoopNest>, LoopNest,
                         LoopAnalysisManager, LoopStandardAnalysisResults &,
                         LPMUpdater &> { … };

template <>
struct MockPassHandle<Function>
    : MockPassHandleBase<MockPassHandle<Function>, Function> { … };

template <>
struct MockPassHandle<LazyCallGraph::SCC>
    : MockPassHandleBase<MockPassHandle<LazyCallGraph::SCC>, LazyCallGraph::SCC,
                         CGSCCAnalysisManager, LazyCallGraph &,
                         CGSCCUpdateResult &> { … };

template <>
struct MockPassHandle<Module>
    : MockPassHandleBase<MockPassHandle<Module>, Module> { … };

/// Mock handles for analyses for the IRUnits Module, CGSCC, Function, Loop.
/// These handles define the appropriate run() and invalidate() mock interfaces
/// for the respective IRUnit type.
template <typename IRUnitT> struct MockAnalysisHandle;
template <>
struct MockAnalysisHandle<Loop>
    : MockAnalysisHandleBase<MockAnalysisHandle<Loop>, Loop,
                             LoopAnalysisManager,
                             LoopStandardAnalysisResults &> { … };

template <>
struct MockAnalysisHandle<Function>
    : MockAnalysisHandleBase<MockAnalysisHandle<Function>, Function> { … };

template <>
struct MockAnalysisHandle<LazyCallGraph::SCC>
    : MockAnalysisHandleBase<MockAnalysisHandle<LazyCallGraph::SCC>,
                             LazyCallGraph::SCC, CGSCCAnalysisManager,
                             LazyCallGraph &> { … };

template <>
struct MockAnalysisHandle<Module>
    : MockAnalysisHandleBase<MockAnalysisHandle<Module>, Module> { … };

static std::unique_ptr<Module> parseIR(LLVMContext &C, const char *IR) { … }

/// Helper for HasName matcher that returns getName both for IRUnit and
/// for IRUnit pointer wrapper into llvm::Any (wrapped by PassInstrumentation).
template <typename IRUnitT> std::string getName(const IRUnitT &IR) { … }

template <> std::string getName(const StringRef &name) { … }

template <> std::string getName(const Any &WrappedIR) { … }
/// Define a custom matcher for objects which support a 'getName' method.
///
/// LLVM often has IR objects or analysis objects which expose a name
/// and in tests it is convenient to match these by name for readability.
/// Usually, this name is either a StringRef or a plain std::string. This
/// matcher supports any type exposing a getName() method of this form whose
/// return value is compatible with an std::ostream. For StringRef, this uses
/// the shift operator defined above.
///
/// It should be used as:
///
///   HasName("my_function")
///
/// No namespace or other qualification is required.
MATCHER_P(HasName, Name, "") { … }

MATCHER_P(HasNameRegex, Name, "") { … }

struct MockPassInstrumentationCallbacks { … };

ExtraMockPassHandle;

template <typename PassManagerT> class PassBuilderCallbacksTest;

/// This test fixture is shared between all the actual tests below and
/// takes care of setting up appropriate defaults.
///
/// The template specialization serves to extract the IRUnit and AM types from
/// the given PassManagerT.
PassBuilderCallbacksTest<PassManager<TestIRUnitT, AnalysisManager<TestIRUnitT, ExtraAnalysisArgTs...>, ExtraPassArgTs...>>;

ModuleCallbacksTest;
CGSCCCallbacksTest;
FunctionCallbacksTest;
LoopCallbacksTest;

/// Test parsing of the name of our mock pass for all IRUnits.
///
/// The pass should by default run our mock analysis and then preserve it.
TEST_F(ModuleCallbacksTest, Passes) { … }

TEST_F(ModuleCallbacksTest, InstrumentedPasses) { … }

TEST_F(ModuleCallbacksTest, InstrumentedSkippedPasses) { … }

TEST_F(FunctionCallbacksTest, Passes) { … }

TEST_F(FunctionCallbacksTest, InstrumentedPasses) { … }

TEST_F(FunctionCallbacksTest, InstrumentedSkippedPasses) { … }

TEST_F(LoopCallbacksTest, Passes) { … }

TEST_F(LoopCallbacksTest, InstrumentedPasses) { … }

TEST_F(LoopCallbacksTest, InstrumentedInvalidatingPasses) { … }

TEST_F(LoopCallbacksTest, InstrumentedInvalidatingLoopNestPasses) { … }

TEST_F(LoopCallbacksTest, InstrumentedSkippedPasses) { … }

TEST_F(CGSCCCallbacksTest, Passes) { … }

TEST_F(CGSCCCallbacksTest, InstrumentedPasses) { … }

TEST_F(CGSCCCallbacksTest, InstrumentedInvalidatingPasses) { … }

TEST_F(CGSCCCallbacksTest, InstrumentedSkippedPasses) { … }

/// Test parsing of the names of analysis utilities for our mock analysis
/// for all IRUnits.
///
/// We first require<>, then invalidate<> it, expecting the analysis to be run
/// once and subsequently invalidated.
TEST_F(ModuleCallbacksTest, AnalysisUtilities) { … }

TEST_F(CGSCCCallbacksTest, PassUtilities) { … }

TEST_F(FunctionCallbacksTest, AnalysisUtilities) { … }

TEST_F(LoopCallbacksTest, PassUtilities) { … }

/// Test parsing of the top-level pipeline.
///
/// The ParseTopLevelPipeline callback takes over parsing of the entire pipeline
/// from PassBuilder if it encounters an unknown pipeline entry at the top level
/// (i.e., the first entry on the pipeline).
/// This test parses a pipeline named 'another-pipeline', whose only elements
/// may be the test-transform pass or the analysis utilities
TEST_F(ModuleCallbacksTest, ParseTopLevelPipeline) { … }
} // end anonymous namespace
llvm/llvm/unittests/IR/PassBuilderCallbacksTest.cpp
