Dialect.h

Go to the documentation of this file.

//===- Dialect.h - IR Dialect Description -----------------------*- 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 defines the 'dialect' abstraction.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_IR_DIALECT_H
#define MLIR_IR_DIALECT_H

#include "mlir/IR/OperationSupport.h"

namespace mlir {
class DialectAsmParser;
class DialectAsmPrinter;
class DialectInterface;
class OpBuilder;
class Type;

using DialectConstantDecodeHook =
    std::function<bool(const OpaqueElementsAttr, ElementsAttr &)>;
using DialectConstantFoldHook = std::function<LogicalResult(
    Operation *, ArrayRef<Attribute>, SmallVectorImpl<Attribute> &)>;
using DialectExtractElementHook =
    std::function<Attribute(const OpaqueElementsAttr, ArrayRef<uint64_t>)>;

class Dialect {
public:
  virtual ~Dialect();

  static bool isValidNamespace(StringRef str);

  MLIRContext *getContext() const { return context; }

  StringRef getNamespace() const { return name; }

  bool allowsUnknownOperations() const { return unknownOpsAllowed; }

  bool allowsUnknownTypes() const { return unknownTypesAllowed; }

  //===--------------------------------------------------------------------===//
  // Constant Hooks
  //===--------------------------------------------------------------------===//

  DialectConstantFoldHook constantFoldHook =
      [](Operation *op, ArrayRef<Attribute> operands,
         SmallVectorImpl<Attribute> &results) { return failure(); };

  DialectConstantDecodeHook decodeHook =
      [](const OpaqueElementsAttr input, ElementsAttr &output) { return true; };

  DialectExtractElementHook extractElementHook =
      [](const OpaqueElementsAttr input, ArrayRef<uint64_t> index) {
        return Attribute();
      };

  virtual Operation *materializeConstant(OpBuilder &builder, Attribute value,
                                         Type type, Location loc) {
    return nullptr;
  }

  //===--------------------------------------------------------------------===//
  // Parsing Hooks
  //===--------------------------------------------------------------------===//

  virtual Attribute parseAttribute(DialectAsmParser &parser, Type type) const;

  virtual void printAttribute(Attribute, DialectAsmPrinter &) const {
    llvm_unreachable("dialect has no registered attribute printing hook");
  }

  virtual Type parseType(DialectAsmParser &parser) const;

  virtual void printType(Type, DialectAsmPrinter &) const {
    llvm_unreachable("dialect has no registered type printing hook");
  }

  //===--------------------------------------------------------------------===//
  // Verification Hooks
  //===--------------------------------------------------------------------===//

  virtual LogicalResult verifyRegionArgAttribute(Operation *,
                                                 unsigned regionIndex,
                                                 unsigned argIndex,
                                                 NamedAttribute);

  virtual LogicalResult verifyRegionResultAttribute(Operation *,
                                                    unsigned regionIndex,
                                                    unsigned resultIndex,
                                                    NamedAttribute);

  virtual LogicalResult verifyOperationAttribute(Operation *, NamedAttribute) {
    return success();
  }

  //===--------------------------------------------------------------------===//
  // Interfaces
  //===--------------------------------------------------------------------===//

  const DialectInterface *getRegisteredInterface(ClassID *interfaceID) {
    auto it = registeredInterfaces.find(interfaceID);
    return it != registeredInterfaces.end() ? it->getSecond().get() : nullptr;
  }
  template <typename InterfaceT> const InterfaceT *getRegisteredInterface() {
    return static_cast<const InterfaceT *>(
        getRegisteredInterface(InterfaceT::getInterfaceID()));
  }

protected:
  Dialect(StringRef name, MLIRContext *context);

  template <typename... Args> void addOperations() {
    VariadicOperationAdder<Args...>::addToSet(*this);
  }

  // It would be nice to define this as variadic functions instead of a nested
  // variadic type, but we can't do that: function template partial
  // specialization is not allowed, and we can't define an overload set because
  // we don't have any arguments of the types we are pushing around.
  template <typename First, typename... Rest> class VariadicOperationAdder {
  public:
    static void addToSet(Dialect &dialect) {
      dialect.addOperation(AbstractOperation::get<First>(dialect));
      VariadicOperationAdder<Rest...>::addToSet(dialect);
    }
  };

  template <typename First> class VariadicOperationAdder<First> {
  public:
    static void addToSet(Dialect &dialect) {
      dialect.addOperation(AbstractOperation::get<First>(dialect));
    }
  };

  void addOperation(AbstractOperation opInfo);

  template <typename... Args> void addTypes() {
    VariadicSymbolAdder<Args...>::addToSet(*this);
  }

  template <typename... Args> void addAttributes() {
    VariadicSymbolAdder<Args...>::addToSet(*this);
  }

  // It would be nice to define this as variadic functions instead of a nested
  // variadic type, but we can't do that: function template partial
  // specialization is not allowed, and we can't define an overload set
  // because we don't have any arguments of the types we are pushing around.
  template <typename First, typename... Rest> struct VariadicSymbolAdder {
    static void addToSet(Dialect &dialect) {
      VariadicSymbolAdder<First>::addToSet(dialect);
      VariadicSymbolAdder<Rest...>::addToSet(dialect);
    }
  };

  template <typename First> struct VariadicSymbolAdder<First> {
    static void addToSet(Dialect &dialect) {
      dialect.addSymbol(First::getClassID());
    }
  };

  void allowUnknownOperations(bool allow = true) { unknownOpsAllowed = allow; }

  void allowUnknownTypes(bool allow = true) { unknownTypesAllowed = allow; }

  void addInterface(std::unique_ptr<DialectInterface> interface);

  template <typename T, typename T2, typename... Tys> void addInterfaces() {
    addInterfaces<T>();
    addInterfaces<T2, Tys...>();
  }
  template <typename T> void addInterfaces() {
    addInterface(std::make_unique<T>(this));
  }

private:
  // Register a symbol(e.g. type) with its given unique class identifier.
  void addSymbol(const ClassID *const classID);

  Dialect(const Dialect &) = delete;
  void operator=(Dialect &) = delete;

  void registerDialect(MLIRContext *context);

  StringRef name;

  MLIRContext *context;

  bool unknownOpsAllowed = false;

  bool unknownTypesAllowed = false;

  DenseMap<ClassID *, std::unique_ptr<DialectInterface>> registeredInterfaces;
};

using DialectAllocatorFunction = std::function<void(MLIRContext *)>;

void registerDialectAllocator(const DialectAllocatorFunction &function);

void registerAllDialects(MLIRContext *context);

template <typename ConcreteDialect> void registerDialect() {
  registerDialectAllocator([](MLIRContext *ctx) {
    // Just allocate the dialect, the context takes ownership of it.
    new ConcreteDialect(ctx);
  });
}

template <typename ConcreteDialect> struct DialectRegistration {
  DialectRegistration() { registerDialect<ConcreteDialect>(); }
};

} // namespace mlir

#endif