PassRegistry.h

Go to the documentation of this file.

//===- PassRegistry.h - Pass Registration Utilities -------------*- 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
//
//===----------------------------------------------------------------------===//
//
// This file contains utilities for registering information about compiler
// passes.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_PASS_PASSREGISTRY_H_
#define MLIR_PASS_PASSREGISTRY_H_

#include "mlir/Pass/PassOptions.h"
#include <functional>

namespace mlir {
class OpPassManager;
class Pass;

using PassRegistryFunction =
    std::function<LogicalResult(OpPassManager &, StringRef options)>;
using PassAllocatorFunction = std::function<std::unique_ptr<Pass>()>;

using PassID = ClassID;

//===----------------------------------------------------------------------===//
// PassRegistry
//===----------------------------------------------------------------------===//

class PassRegistryEntry {
public:
  LogicalResult addToPipeline(OpPassManager &pm, StringRef options) const {
    assert(builder &&
           "cannot call addToPipeline on PassRegistryEntry without builder");
    return builder(pm, options);
  }

  StringRef getPassArgument() const { return arg; }

  StringRef getPassDescription() const { return description; }

protected:
  PassRegistryEntry(StringRef arg, StringRef description,
                    const PassRegistryFunction &builder)
      : arg(arg), description(description), builder(builder) {}

private:
  // The argument with which to invoke the pass via mlir-opt.
  StringRef arg;

  // Description of the pass.
  StringRef description;

  // Function to register this entry to a pass manager pipeline.
  PassRegistryFunction builder;
};

class PassPipelineInfo : public PassRegistryEntry {
public:
  PassPipelineInfo(StringRef arg, StringRef description,
                   const PassRegistryFunction &builder)
      : PassRegistryEntry(arg, description, builder) {}
};

class PassInfo : public PassRegistryEntry {
public:
  PassInfo(StringRef arg, StringRef description, const PassID *passID,
           const PassAllocatorFunction &allocator);
};

//===----------------------------------------------------------------------===//
// PassRegistration
//===----------------------------------------------------------------------===//

void registerPassPipeline(StringRef arg, StringRef description,
                          const PassRegistryFunction &function);

void registerPass(StringRef arg, StringRef description, const PassID *passID,
                  const PassAllocatorFunction &function);

template <typename ConcretePass> struct PassRegistration {

  PassRegistration(StringRef arg, StringRef description,
                   const PassAllocatorFunction &constructor) {
    registerPass(arg, description, PassID::getID<ConcretePass>(), constructor);
  }

  PassRegistration(StringRef arg, StringRef description)
      : PassRegistration(arg, description,
                         [] { return std::make_unique<ConcretePass>(); }) {}
};

template <typename Options = EmptyPipelineOptions>
struct PassPipelineRegistration {
  PassPipelineRegistration(
      StringRef arg, StringRef description,
      std::function<void(OpPassManager &, const Options &options)> builder) {
    registerPassPipeline(arg, description,
                         [builder](OpPassManager &pm, StringRef optionsStr) {
                           Options options;
                           if (failed(options.parseFromString(optionsStr)))
                             return failure();
                           builder(pm, options);
                           return success();
                         });
  }
};

template <> struct PassPipelineRegistration<EmptyPipelineOptions> {
  PassPipelineRegistration(StringRef arg, StringRef description,
                           std::function<void(OpPassManager &)> builder) {
    registerPassPipeline(arg, description,
                         [builder](OpPassManager &pm, StringRef optionsStr) {
                           if (!optionsStr.empty())
                             return failure();
                           builder(pm);
                           return success();
                         });
  }
};

LogicalResult parsePassPipeline(StringRef pipeline, OpPassManager &pm,
                                raw_ostream &errorStream = llvm::errs());

//===----------------------------------------------------------------------===//
// PassPipelineCLParser
//===----------------------------------------------------------------------===//

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

class PassPipelineCLParser {
public:
  PassPipelineCLParser(StringRef arg, StringRef description);
  ~PassPipelineCLParser();

  bool hasAnyOccurrences() const;

  bool contains(const PassRegistryEntry *entry) const;

  LogicalResult addToPipeline(OpPassManager &pm) const;

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

} // end namespace mlir

#endif // MLIR_PASS_PASSREGISTRY_H_