PassOptions.h

Go to the documentation of this file.

//===- PassOptions.h - Pass Option 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 options with compiler passes and
// pipelines.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_PASS_PASSOPTIONS_H_
#define MLIR_PASS_PASSOPTIONS_H_

#include "mlir/Support/LLVM.h"
#include "mlir/Support/LogicalResult.h"
#include "mlir/Support/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include <memory>

namespace mlir {
namespace detail {
class PassOptions : protected llvm::cl::SubCommand {
private:
  class OptionBase {
  public:
    virtual ~OptionBase() = default;

    virtual void anchor();

    virtual void print(raw_ostream &os) = 0;

    StringRef getArgStr() const { return getOption()->ArgStr; }

  protected:
    virtual const llvm::cl::Option *getOption() const = 0;

    virtual void copyValueFrom(const OptionBase &other) = 0;

    friend PassOptions;
  };

  template <typename DataType>
  struct GenericOptionParser : public llvm::cl::parser<DataType> {
    using llvm::cl::parser<DataType>::parser;

    Optional<StringRef> findArgStrForValue(const DataType &value) {
      for (auto &it : this->Values)
        if (it.V.compare(value))
          return it.Name;
      return llvm::None;
    }
  };

  template <typename DataType>
  using OptionParser =
      std::conditional_t<std::is_base_of<llvm::cl::generic_parser_base,
                                         llvm::cl::parser<DataType>>::value,
                         GenericOptionParser<DataType>,
                         llvm::cl::parser<DataType>>;

  template <typename DataT>
  static void printValue(raw_ostream &os, GenericOptionParser<DataT> &parser,
                         const DataT &value) {
    if (Optional<StringRef> argStr = parser.findArgStrForValue(value))
      os << argStr;
    else
      llvm_unreachable("unknown data value for option");
  }
  template <typename DataT, typename ParserT>
  static void printValue(raw_ostream &os, ParserT &parser, const DataT &value) {
    os << value;
  }
  template <typename ParserT>
  static void printValue(raw_ostream &os, ParserT &parser, const bool &value) {
    os << (value ? StringRef("true") : StringRef("false"));
  }

public:
  template <typename DataType>
  class Option : public llvm::cl::opt<DataType, /*ExternalStorage=*/false,
                                      OptionParser<DataType>>,
                 public OptionBase {
  public:
    template <typename... Args>
    Option(PassOptions &parent, StringRef arg, Args &&... args)
        : llvm::cl::opt<DataType, /*ExternalStorage=*/false,
                        OptionParser<DataType>>(arg, llvm::cl::sub(parent),
                                                std::forward<Args>(args)...) {
      assert(!this->isPositional() && !this->isSink() &&
             "sink and positional options are not supported");
      parent.options.push_back(this);
    }
    using llvm::cl::opt<DataType, /*ExternalStorage=*/false,
                        OptionParser<DataType>>::operator=;
    ~Option() override = default;

  private:
    const llvm::cl::Option *getOption() const final { return this; }

    void print(raw_ostream &os) final {
      os << this->ArgStr << '=';
      printValue(os, this->getParser(), this->getValue());
    }

    void copyValueFrom(const OptionBase &other) final {
      this->setValue(static_cast<const Option<DataType> &>(other).getValue());
    }
  };

  template <typename DataType>
  class ListOption : public llvm::cl::list<DataType, /*StorageClass=*/bool,
                                           OptionParser<DataType>>,
                     public OptionBase {
  public:
    template <typename... Args>
    ListOption(PassOptions &parent, StringRef arg, Args &&... args)
        : llvm::cl::list<DataType, /*StorageClass=*/bool,
                         OptionParser<DataType>>(arg, llvm::cl::sub(parent),
                                                 std::forward<Args>(args)...) {
      assert(!this->isPositional() && !this->isSink() &&
             "sink and positional options are not supported");
      parent.options.push_back(this);
    }
    ~ListOption() override = default;

    ListOption<DataType> &operator=(ArrayRef<DataType> values) {
      (*this)->assign(values.begin(), values.end());
      return *this;
    }

    std::vector<DataType> *operator->() { return &*this; }

  private:
    const llvm::cl::Option *getOption() const final { return this; }

    void print(raw_ostream &os) final {
      os << this->ArgStr << '=';
      auto printElementFn = [&](const DataType &value) {
        printValue(os, this->getParser(), value);
      };
      interleave(*this, os, printElementFn, ",");
    }

    void copyValueFrom(const OptionBase &other) final {
      (*this) = ArrayRef<DataType>(
          (ListOption<DataType> &)(const_cast<OptionBase &>(other)));
    }
  };

  PassOptions() = default;

  void copyOptionValuesFrom(const PassOptions &other);

  LogicalResult parseFromString(StringRef options);

  void print(raw_ostream &os);

private:
  std::vector<OptionBase *> options;
};
} // end namespace detail

//===----------------------------------------------------------------------===//
// PassPipelineOptions
//===----------------------------------------------------------------------===//

template <typename T> class PassPipelineOptions : public detail::PassOptions {
public:
  static std::unique_ptr<T> createFromString(StringRef options) {
    auto result = std::make_unique<T>();
    if (failed(result->parseFromString(options)))
      return nullptr;
    return result;
  }
};

struct EmptyPipelineOptions : public PassPipelineOptions<EmptyPipelineOptions> {
};

} // end namespace mlir

#endif // MLIR_PASS_PASSOPTIONS_H_