PassInstrumentation.h

Go to the documentation of this file.

//===- PassInstrumentation.h ------------------------------------*- 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_PASSINSTRUMENTATION_H_
#define MLIR_PASS_PASSINSTRUMENTATION_H_

#include "mlir/Support/LLVM.h"
#include "mlir/Support/STLExtras.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/StringRef.h"

namespace mlir {
using AnalysisID = ClassID;
class Operation;
class OperationName;
class Pass;

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

class PassInstrumentation {
public:
  struct PipelineParentInfo {
    uint64_t parentThreadID;

    Pass *parentPass;
  };

  virtual ~PassInstrumentation() = 0;

  virtual void runBeforePipeline(const OperationName &name,
                                 const PipelineParentInfo &parentInfo) {}

  virtual void runAfterPipeline(const OperationName &name,
                                const PipelineParentInfo &parentInfo) {}

  virtual void runBeforePass(Pass *pass, Operation *op) {}

  virtual void runAfterPass(Pass *pass, Operation *op) {}

  virtual void runAfterPassFailed(Pass *pass, Operation *op) {}

  virtual void runBeforeAnalysis(StringRef name, AnalysisID *id,
                                 Operation *op) {}

  virtual void runAfterAnalysis(StringRef name, AnalysisID *id, Operation *op) {
  }
};

class PassInstrumentor {
public:
  PassInstrumentor();
  PassInstrumentor(PassInstrumentor &&) = delete;
  PassInstrumentor(const PassInstrumentor &) = delete;
  ~PassInstrumentor();

  void
  runBeforePipeline(const OperationName &name,
                    const PassInstrumentation::PipelineParentInfo &parentInfo);

  void
  runAfterPipeline(const OperationName &name,
                   const PassInstrumentation::PipelineParentInfo &parentInfo);

  void runBeforePass(Pass *pass, Operation *op);

  void runAfterPass(Pass *pass, Operation *op);

  void runAfterPassFailed(Pass *pass, Operation *op);

  void runBeforeAnalysis(StringRef name, AnalysisID *id, Operation *op);

  void runAfterAnalysis(StringRef name, AnalysisID *id, Operation *op);

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

private:
  std::unique_ptr<detail::PassInstrumentorImpl> impl;
};

} // end namespace mlir

namespace llvm {
template <> struct DenseMapInfo<mlir::PassInstrumentation::PipelineParentInfo> {
  using T = mlir::PassInstrumentation::PipelineParentInfo;
  using PairInfo = DenseMapInfo<std::pair<uint64_t, void *>>;

  static T getEmptyKey() {
    auto pair = PairInfo::getEmptyKey();
    return {pair.first, reinterpret_cast<mlir::Pass *>(pair.second)};
  }
  static T getTombstoneKey() {
    auto pair = PairInfo::getTombstoneKey();
    return {pair.first, reinterpret_cast<mlir::Pass *>(pair.second)};
  }
  static unsigned getHashValue(T val) {
    return PairInfo::getHashValue({val.parentThreadID, val.parentPass});
  }
  static bool isEqual(T lhs, T rhs) {
    return lhs.parentThreadID == rhs.parentThreadID &&
           lhs.parentPass == rhs.parentPass;
  }
};
} // end namespace llvm

#endif // MLIR_PASS_PASSINSTRUMENTATION_H_