Pass.cpp | Explore in Territory

//===- Pass.cpp - Pass infrastructure implementation ----------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file implements common pass infrastructure.
//
//===----------------------------------------------------------------------===//

#include "mlir/Pass/Pass.h"
#include "PassDetail.h"
#include "mlir/IR/Diagnostics.h"
#include "mlir/IR/Dialect.h"
#include "mlir/IR/OpDefinition.h"
#include "mlir/IR/Threading.h"
#include "mlir/IR/Verifier.h"
#include "mlir/Support/FileUtilities.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/CrashRecoveryContext.h"
#include "llvm/Support/Mutex.h"
#include "llvm/Support/Signals.h"
#include "llvm/Support/Threading.h"
#include "llvm/Support/ToolOutputFile.h"
#include <optional>

usingnamespacemlir;
usingnamespacemlir::detail;

//===----------------------------------------------------------------------===//
// PassExecutionAction
//===----------------------------------------------------------------------===//

PassExecutionAction::PassExecutionAction(ArrayRef<IRUnit> irUnits,
                                         const Pass &pass)
    : … { … }

void PassExecutionAction::print(raw_ostream &os) const { … }

Operation *PassExecutionAction::getOp() const { … }

//===----------------------------------------------------------------------===//
// Pass
//===----------------------------------------------------------------------===//

/// Out of line virtual method to ensure vtables and metadata are emitted to a
/// single .o file.
void Pass::anchor() { … }

/// Attempt to initialize the options of this pass from the given string.
LogicalResult Pass::initializeOptions(
    StringRef options,
    function_ref<LogicalResult(const Twine &)> errorHandler) { … }

/// Copy the option values from 'other', which is another instance of this
/// pass.
void Pass::copyOptionValuesFrom(const Pass *other) { … }

/// Prints out the pass in the textual representation of pipelines. If this is
/// an adaptor pass, print its pass managers.
void Pass::printAsTextualPipeline(raw_ostream &os) { … }

//===----------------------------------------------------------------------===//
// OpPassManagerImpl
//===----------------------------------------------------------------------===//

namespace mlir {
namespace detail {
struct OpPassManagerImpl { … };
} // namespace detail
} // namespace mlir

void OpPassManagerImpl::mergeInto(OpPassManagerImpl &rhs) { … }

OpPassManager &OpPassManagerImpl::nest(OpPassManager &&nested) { … }

void OpPassManagerImpl::addPass(std::unique_ptr<Pass> pass) { … }

void OpPassManagerImpl::clear() { … }

LogicalResult OpPassManagerImpl::finalizePassList(MLIRContext *ctx) { … }

bool OpPassManagerImpl::canScheduleOn(MLIRContext &context,
                                      OperationName opName) { … }

//===----------------------------------------------------------------------===//
// OpPassManager
//===----------------------------------------------------------------------===//

OpPassManager::OpPassManager(Nesting nesting)
    : … { … }
OpPassManager::OpPassManager(StringRef name, Nesting nesting)
    : … { … }
OpPassManager::OpPassManager(OperationName name, Nesting nesting)
    : … { … }
OpPassManager::OpPassManager(OpPassManager &&rhs) { … }
OpPassManager::OpPassManager(const OpPassManager &rhs) { … }
OpPassManager &OpPassManager::operator=(const OpPassManager &rhs) { … }
OpPassManager &OpPassManager::operator=(OpPassManager &&rhs) { … }

OpPassManager::~OpPassManager() = default;

OpPassManager::pass_iterator OpPassManager::begin() { … }
OpPassManager::pass_iterator OpPassManager::end() { … }

OpPassManager::const_pass_iterator OpPassManager::begin() const { … }
OpPassManager::const_pass_iterator OpPassManager::end() const { … }

/// Nest a new operation pass manager for the given operation kind under this
/// pass manager.
OpPassManager &OpPassManager::nest(OperationName nestedName) { … }
OpPassManager &OpPassManager::nest(StringRef nestedName) { … }
OpPassManager &OpPassManager::nestAny() { … }

/// Add the given pass to this pass manager. If this pass has a concrete
/// operation type, it must be the same type as this pass manager.
void OpPassManager::addPass(std::unique_ptr<Pass> pass) { … }

void OpPassManager::clear() { … }

/// Returns the number of passes held by this manager.
size_t OpPassManager::size() const { … }

/// Returns the internal implementation instance.
OpPassManagerImpl &OpPassManager::getImpl() { … }

/// Return the operation name that this pass manager operates on.
std::optional<StringRef> OpPassManager::getOpName() const { … }

/// Return the operation name that this pass manager operates on.
std::optional<OperationName>
OpPassManager::getOpName(MLIRContext &context) const { … }

StringRef OpPassManager::getOpAnchorName() const { … }

/// Prints out the passes of the pass manager as the textual representation
/// of pipelines.
void printAsTextualPipeline(
    raw_ostream &os, StringRef anchorName,
    const llvm::iterator_range<OpPassManager::pass_iterator> &passes) { … }
void OpPassManager::printAsTextualPipeline(raw_ostream &os) const { … }

void OpPassManager::dump() { … }

static void registerDialectsForPipeline(const OpPassManager &pm,
                                        DialectRegistry &dialects) { … }

void OpPassManager::getDependentDialects(DialectRegistry &dialects) const { … }

void OpPassManager::setNesting(Nesting nesting) { … }

OpPassManager::Nesting OpPassManager::getNesting() { … }

LogicalResult OpPassManager::initialize(MLIRContext *context,
                                        unsigned newInitGeneration) { … }

llvm::hash_code OpPassManager::hash() { … }


//===----------------------------------------------------------------------===//
// OpToOpPassAdaptor
//===----------------------------------------------------------------------===//

LogicalResult OpToOpPassAdaptor::run(Pass *pass, Operation *op,
                                     AnalysisManager am, bool verifyPasses,
                                     unsigned parentInitGeneration) { … }

/// Run the given operation and analysis manager on a provided op pass manager.
LogicalResult OpToOpPassAdaptor::runPipeline(
    OpPassManager &pm, Operation *op, AnalysisManager am, bool verifyPasses,
    unsigned parentInitGeneration, PassInstrumentor *instrumentor,
    const PassInstrumentation::PipelineParentInfo *parentInfo) { … }

/// Find an operation pass manager with the given anchor name, or nullptr if one
/// does not exist.
static OpPassManager *
findPassManagerWithAnchor(MutableArrayRef<OpPassManager> mgrs, StringRef name) { … }

/// Find an operation pass manager that can operate on an operation of the given
/// type, or nullptr if one does not exist.
static OpPassManager *findPassManagerFor(MutableArrayRef<OpPassManager> mgrs,
                                         OperationName name,
                                         MLIRContext &context) { … }

OpToOpPassAdaptor::OpToOpPassAdaptor(OpPassManager &&mgr) { … }

void OpToOpPassAdaptor::getDependentDialects(DialectRegistry &dialects) const { … }

LogicalResult OpToOpPassAdaptor::tryMergeInto(MLIRContext *ctx,
                                              OpToOpPassAdaptor &rhs) { … }

/// Returns the adaptor pass name.
std::string OpToOpPassAdaptor::getAdaptorName() { … }

void OpToOpPassAdaptor::runOnOperation() { … }

/// Run the held pipeline over all nested operations.
void OpToOpPassAdaptor::runOnOperation(bool verifyPasses) { … }

/// Run this pass adaptor synchronously.
void OpToOpPassAdaptor::runOnOperationImpl(bool verifyPasses) { … }

/// Utility functor that checks if the two ranges of pass managers have a size
/// mismatch.
static bool hasSizeMismatch(ArrayRef<OpPassManager> lhs,
                            ArrayRef<OpPassManager> rhs) { … }

/// Run this pass adaptor synchronously.
void OpToOpPassAdaptor::runOnOperationAsyncImpl(bool verifyPasses) { … }

//===----------------------------------------------------------------------===//
// PassManager
//===----------------------------------------------------------------------===//

PassManager::PassManager(MLIRContext *ctx, StringRef operationName,
                         Nesting nesting)
    : … { … }

PassManager::PassManager(OperationName operationName, Nesting nesting)
    : … { … }

PassManager::~PassManager() = default;

void PassManager::enableVerifier(bool enabled) { … }

/// Run the passes within this manager on the provided operation.
LogicalResult PassManager::run(Operation *op) { … }

/// Add the provided instrumentation to the pass manager.
void PassManager::addInstrumentation(std::unique_ptr<PassInstrumentation> pi) { … }

LogicalResult PassManager::runPasses(Operation *op, AnalysisManager am) { … }

//===----------------------------------------------------------------------===//
// AnalysisManager
//===----------------------------------------------------------------------===//

/// Get an analysis manager for the given operation, which must be a proper
/// descendant of the current operation represented by this analysis manager.
AnalysisManager AnalysisManager::nest(Operation *op) { … }

/// Get an analysis manager for the given immediately nested child operation.
AnalysisManager AnalysisManager::nestImmediate(Operation *op) { … }

/// Invalidate any non preserved analyses.
void detail::NestedAnalysisMap::invalidate(
    const detail::PreservedAnalyses &pa) { … }

//===----------------------------------------------------------------------===//
// PassInstrumentation
//===----------------------------------------------------------------------===//

PassInstrumentation::~PassInstrumentation() = default;

void PassInstrumentation::runBeforePipeline(
    std::optional<OperationName> name, const PipelineParentInfo &parentInfo) { … }

void PassInstrumentation::runAfterPipeline(
    std::optional<OperationName> name, const PipelineParentInfo &parentInfo) { … }

//===----------------------------------------------------------------------===//
// PassInstrumentor
//===----------------------------------------------------------------------===//

namespace mlir {
namespace detail {
struct PassInstrumentorImpl { … };
} // namespace detail
} // namespace mlir

PassInstrumentor::PassInstrumentor() : … { … }
PassInstrumentor::~PassInstrumentor() = default;

/// See PassInstrumentation::runBeforePipeline for details.
void PassInstrumentor::runBeforePipeline(
    std::optional<OperationName> name,
    const PassInstrumentation::PipelineParentInfo &parentInfo) { … }

/// See PassInstrumentation::runAfterPipeline for details.
void PassInstrumentor::runAfterPipeline(
    std::optional<OperationName> name,
    const PassInstrumentation::PipelineParentInfo &parentInfo) { … }

/// See PassInstrumentation::runBeforePass for details.
void PassInstrumentor::runBeforePass(Pass *pass, Operation *op) { … }

/// See PassInstrumentation::runAfterPass for details.
void PassInstrumentor::runAfterPass(Pass *pass, Operation *op) { … }

/// See PassInstrumentation::runAfterPassFailed for details.
void PassInstrumentor::runAfterPassFailed(Pass *pass, Operation *op) { … }

/// See PassInstrumentation::runBeforeAnalysis for details.
void PassInstrumentor::runBeforeAnalysis(StringRef name, TypeID id,
                                         Operation *op) { … }

/// See PassInstrumentation::runAfterAnalysis for details.
void PassInstrumentor::runAfterAnalysis(StringRef name, TypeID id,
                                        Operation *op) { … }

/// Add the given instrumentation to the collection.
void PassInstrumentor::addInstrumentation(
    std::unique_ptr<PassInstrumentation> pi) { … }
llvm/mlir/lib/Pass/Pass.cpp
