PassManager.h

Go to the documentation of this file.

//===- PassManager.h - Pass Management Interface ----------------*- 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_PASSMANAGER_H
#define MLIR_PASS_PASSMANAGER_H

#include "mlir/Support/LogicalResult.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/iterator.h"

#include <vector>

namespace llvm {
class Any;
} // end namespace llvm

namespace mlir {
class AnalysisManager;
class MLIRContext;
class ModuleOp;
class OperationName;
class Operation;
class Pass;
class PassInstrumentation;
class PassInstrumentor;

namespace detail {
struct OpPassManagerImpl;
} // end namespace detail

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

class OpPassManager {
public:
  OpPassManager(OpPassManager &&rhs);
  OpPassManager(const OpPassManager &rhs);
  ~OpPassManager();
  OpPassManager &operator=(const OpPassManager &rhs);

  using pass_iterator =
      llvm::pointee_iterator<std::vector<std::unique_ptr<Pass>>::iterator>;
  pass_iterator begin();
  pass_iterator end();
  iterator_range<pass_iterator> getPasses() { return {begin(), end()}; }

  LogicalResult run(Operation *op, AnalysisManager am);

  OpPassManager &nest(const OperationName &nestedName);
  OpPassManager &nest(StringRef nestedName);
  template <typename OpT> OpPassManager &nest() {
    return nest(OpT::getOperationName());
  }

  void addPass(std::unique_ptr<Pass> pass);

  template <typename OpT> void addNestedPass(std::unique_ptr<Pass> pass) {
    nest<OpT>().addPass(std::move(pass));
  }

  size_t size() const;

  MLIRContext *getContext() const;

  const OperationName &getOpName() const;

  detail::OpPassManagerImpl &getImpl();

  void printAsTextualPipeline(raw_ostream &os);

  void mergeStatisticsInto(OpPassManager &other);

private:
  OpPassManager(OperationName name, bool disableThreads, bool verifyPasses);

  std::unique_ptr<detail::OpPassManagerImpl> impl;

  friend class PassManager;
};

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

enum class PassDisplayMode {
  // In this mode the results are displayed in a list sorted by total,
  // with each pass/analysis instance aggregated into one unique result.
  List,

  // In this mode the results are displayed in a nested pipeline view that
  // mirrors the internal pass pipeline that is being executed in the pass
  // manager.
  Pipeline,
};

class PassManager : public OpPassManager {
public:
  // If verifyPasses is true, the verifier is run after each pass.
  PassManager(MLIRContext *ctx, bool verifyPasses = true);
  ~PassManager();

  LLVM_NODISCARD
  LogicalResult run(ModuleOp module);

  void disableMultithreading(bool disable = true);

  void enableCrashReproducerGeneration(StringRef outputFile);

  //===--------------------------------------------------------------------===//
  // Instrumentations
  //===--------------------------------------------------------------------===//

  void addInstrumentation(std::unique_ptr<PassInstrumentation> pi);

  //===--------------------------------------------------------------------===//
  // IR Printing

  class IRPrinterConfig {
  public:
    using PrintCallbackFn = function_ref<void(raw_ostream &)>;

    explicit IRPrinterConfig(bool printModuleScope = false,
                             bool printAfterOnlyOnChange = false);
    virtual ~IRPrinterConfig();

    virtual void printBeforeIfEnabled(Pass *pass, Operation *operation,
                                      PrintCallbackFn printCallback);

    virtual void printAfterIfEnabled(Pass *pass, Operation *operation,
                                     PrintCallbackFn printCallback);

    bool shouldPrintAtModuleScope() const { return printModuleScope; }

    bool shouldPrintAfterOnlyOnChange() const { return printAfterOnlyOnChange; }

  private:
    bool printModuleScope;

    bool printAfterOnlyOnChange;
  };

  void enableIRPrinting(std::unique_ptr<IRPrinterConfig> config);

  void enableIRPrinting(
      std::function<bool(Pass *, Operation *)> shouldPrintBeforePass,
      std::function<bool(Pass *, Operation *)> shouldPrintAfterPass,
      bool printModuleScope, bool printAfterOnlyOnChange, raw_ostream &out);

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

  void enableTiming(PassDisplayMode displayMode = PassDisplayMode::Pipeline);

  void
  enableStatistics(PassDisplayMode displayMode = PassDisplayMode::Pipeline);

private:
  void dumpStatistics();

  bool passTiming : 1;

  Optional<PassDisplayMode> passStatisticsMode;

  std::unique_ptr<PassInstrumentor> instrumentor;

  Optional<std::string> crashReproducerFileName;
};

void registerPassManagerCLOptions();

void applyPassManagerCLOptions(PassManager &pm);
} // end namespace mlir

#endif // MLIR_PASS_PASSMANAGER_H