Pass.h

Go to the documentation of this file.

//===- Pass.h - Base classes for compiler passes ----------------*- C++ -*-===//
//
// Part of the MLIR 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
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_PASS_PASS_H
#define MLIR_PASS_PASS_H

#include "mlir/IR/Function.h"
#include "mlir/Pass/AnalysisManager.h"
#include "mlir/Pass/PassRegistry.h"
#include "mlir/Support/LogicalResult.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/Statistic.h"

namespace mlir {
namespace detail {
struct PassExecutionState {
  PassExecutionState(Operation *ir, AnalysisManager analysisManager)
      : irAndPassFailed(ir, false), analysisManager(analysisManager) {}

  llvm::PointerIntPair<Operation *, 1, bool> irAndPassFailed;

  AnalysisManager analysisManager;

  detail::PreservedAnalyses preservedAnalyses;
};
} // namespace detail

class Pass {
public:
  virtual ~Pass() = default;

  const PassID *getPassID() const { return passID; }

  static const PassInfo *lookupPassInfo(const PassID *passID);
  template <typename PassT> static const PassInfo *lookupPassInfo() {
    return lookupPassInfo(PassID::getID<PassT>());
  }

  const PassInfo *lookupPassInfo() const { return lookupPassInfo(getPassID()); }

  virtual StringRef getName() = 0;

  Optional<StringRef> getOpName() const { return opName; }

  //===--------------------------------------------------------------------===//
  // Options
  //===--------------------------------------------------------------------===//

  template <typename DataType>
  struct Option : public detail::PassOptions::Option<DataType> {
    template <typename... Args>
    Option(Pass &parent, StringRef arg, Args &&... args)
        : detail::PassOptions::Option<DataType>(parent.passOptions, arg,
                                                std::forward<Args>(args)...) {}
    using detail::PassOptions::Option<DataType>::operator=;
  };
  template <typename DataType>
  struct ListOption : public detail::PassOptions::ListOption<DataType> {
    template <typename... Args>
    ListOption(Pass &parent, StringRef arg, Args &&... args)
        : detail::PassOptions::ListOption<DataType>(
              parent.passOptions, arg, std::forward<Args>(args)...) {}
    using detail::PassOptions::ListOption<DataType>::operator=;
  };

  LogicalResult initializeOptions(StringRef options);

  void printAsTextualPipeline(raw_ostream &os);

  //===--------------------------------------------------------------------===//
  // Statistics
  //===--------------------------------------------------------------------===//

  class Statistic : public llvm::Statistic {
  public:
    Statistic(Pass *owner, const char *name, const char *description);

    Statistic &operator=(unsigned value);

  private:
    using llvm::Statistic::getDebugType;
  };

  ArrayRef<Statistic *> getStatistics() const { return statistics; }
  MutableArrayRef<Statistic *> getStatistics() { return statistics; }

protected:
  explicit Pass(const PassID *passID, Optional<StringRef> opName = llvm::None)
      : passID(passID), opName(opName) {}

  detail::PassExecutionState &getPassState() {
    assert(passState && "pass state was never initialized");
    return *passState;
  }

  MLIRContext &getContext() { return *getOperation()->getContext(); }

  virtual void runOnOperation() = 0;

  virtual std::unique_ptr<Pass> clone() const = 0;

  Operation *getOperation() {
    return getPassState().irAndPassFailed.getPointer();
  }

  AnalysisManager getAnalysisManager() {
    return getPassState().analysisManager;
  }

  void copyOptionValuesFrom(const Pass *other);

private:
  LLVM_NODISCARD
  LogicalResult run(Operation *op, AnalysisManager am);

  virtual void anchor();

  const PassID *passID;

  Optional<StringRef> opName;

  Optional<detail::PassExecutionState> passState;

  std::vector<Statistic *> statistics;

  detail::PassOptions passOptions;

  friend class OpPassManager;
};

//===----------------------------------------------------------------------===//
// Pass Model Definitions
//===----------------------------------------------------------------------===//
namespace detail {
template <typename PassT, typename BasePassT>
class PassModel : public BasePassT {
public:
  static bool classof(const Pass *pass) {
    return pass->getPassID() == PassID::getID<PassT>();
  }

protected:
  explicit PassModel(Optional<StringRef> opName = llvm::None)
      : BasePassT(PassID::getID<PassT>(), opName) {}

  void signalPassFailure() {
    this->getPassState().irAndPassFailed.setInt(true);
  }

  template <typename AnalysisT> AnalysisT &getAnalysis() {
    return this->getAnalysisManager().template getAnalysis<AnalysisT>();
  }

  template <typename AnalysisT>
  Optional<std::reference_wrapper<AnalysisT>> getCachedAnalysis() {
    return this->getAnalysisManager().template getCachedAnalysis<AnalysisT>();
  }

  void markAllAnalysesPreserved() {
    this->getPassState().preservedAnalyses.preserveAll();
  }

  template <typename... AnalysesT> void markAnalysesPreserved() {
    this->getPassState().preservedAnalyses.template preserve<AnalysesT...>();
  }
  void markAnalysesPreserved(const AnalysisID *id) {
    this->getPassState().preservedAnalyses.preserve(id);
  }

  StringRef getName() override {
    StringRef name = llvm::getTypeName<PassT>();
    if (!name.consume_front("mlir::"))
      name.consume_front("(anonymous namespace)::");
    return name;
  }

  std::unique_ptr<Pass> clone() const override {
    auto newInst = std::make_unique<PassT>(*static_cast<const PassT *>(this));
    newInst->copyOptionValuesFrom(this);
    return newInst;
  }

  template <typename AnalysisT>
  Optional<std::reference_wrapper<AnalysisT>>
  getCachedParentAnalysis(Operation *parent) {
    return this->getAnalysisManager()
        .template getCachedParentAnalysis<AnalysisT>(parent);
  }
  template <typename AnalysisT>
  Optional<std::reference_wrapper<AnalysisT>> getCachedParentAnalysis() {
    return this->getAnalysisManager()
        .template getCachedParentAnalysis<AnalysisT>(
            this->getOperation()->getParentOp());
  }

  template <typename AnalysisT>
  Optional<std::reference_wrapper<AnalysisT>>
  getCachedChildAnalysis(Operation *child) {
    return this->getAnalysisManager()
        .template getCachedChildAnalysis<AnalysisT>(child);
  }

  template <typename AnalysisT> AnalysisT &getChildAnalysis(Operation *child) {
    return this->getAnalysisManager().template getChildAnalysis<AnalysisT>(
        child);
  }
};
} // end namespace detail

template <typename OpT> class OpPassBase : public Pass {
public:
  using Pass::Pass;

  static bool classof(const Pass *pass) {
    return pass->getOpName() == OpT::getOperationName();
  }
};

template <typename PassT, typename OpT = void>
class OperationPass : public detail::PassModel<PassT, OpPassBase<OpT>> {
protected:
  OperationPass()
      : detail::PassModel<PassT, OpPassBase<OpT>>(OpT::getOperationName()) {}

  OpT getOperation() { return cast<OpT>(Pass::getOperation()); }
};

template <typename PassT>
struct OperationPass<PassT, void> : public detail::PassModel<PassT, Pass> {};

template <typename T> struct FunctionPass : public OperationPass<T, FuncOp> {
  virtual void runOnFunction() = 0;

  void runOnOperation() final {
    if (!getFunction().isExternal())
      runOnFunction();
  }

  FuncOp getFunction() { return this->getOperation(); }
};

template <typename T> struct ModulePass : public OperationPass<T, ModuleOp> {
  virtual void runOnModule() = 0;

  void runOnOperation() final { runOnModule(); }

  ModuleOp getModule() { return this->getOperation(); }
};
} // end namespace mlir

#endif // MLIR_PASS_PASS_H