[mlir][linalg] Add support for arbitrary element types for named operations

[andidr]

Summary

Linalg named operations are currently limited to tensors and memrefs
composed of floating point, integer or index elements and using any
other element type triggers an assertion.

This change adds support for arbitrary element types for named
operations through a new type interface
LinalgArithmeticOperatorTypeInterface and two operation interfaces
LinalgAddOpInterface and LinalgMulOpInterface.

The type interface is used to instantiate operations that implement
arithmetic operations for a type (e.g., instantiating arith::AddFOp
for an addition on floats) transparently. The two operation interfaces
allow for the identification of instances of operations implementing
additions and multiplications, required by ContractionOpInterface.

Implementations of LinalgArithmeticOperatorTypeInterface are
provided for the builtin float and integer types and implementations
of LinalgAddOpInterface and LinalgAddOpInterface are provided for
arith::AddFOp, arith::AddIOp, arith::MulFOp, and
arith::MulIOp, respectively.

[andidr]

Fixed formatting issue in mlir/lib/Dialect/Linalg/IR/LinalgTypeInterfaces.cpp.

[gysit]

Thanks for moving this forward!

I added a few detail comments but I would like to ask a high-level question first. Wouldn't it make sense to have a single main interface method that takes the enum value, op builder, and a value range and then do the dispatch/error handling etc internally in the interface? Ideally, when adding a new operation we want to touch as little places as possible. At the moment, we need to adapt the enum, the applyfn_, the interface, and at least one interface implementation. Having an interface that takes an enum instead of having one method per operation time should reduce that by one and also simplifies a follow up refactoring to remove applyfn_

iface.create(builder, ArithFn::Add, ValueRange{lhs, rhs})
iface.create(builder, ArithFn::Exp, ValueRange{x})

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

1068

I would probably go with LinalgArithmeticOpTypeInterface or even LinalgArithOpTypeInterface? If you prefer the long name I would probably use Operation rather than Operator since add / mul are really operations in the MLIR sense. I associate operators to matmul, convolution, etc...

1105

nit: Shouldn't this be "::mlir::OpBuilder &"?

mlir/include/mlir/Dialect/Linalg/IR/LinalgTypeInterfaces.h

2

nit: type

38

nit: comments should always end with a '.'

below as well.

mlir/lib/Dialect/Linalg/IR/LinalgDefaultTypeInterfaceImplementations.cpp

22

nit: . missing at the end of the comment.

28

I think 't', 'lhs', and 'rhs' can be passed in by value?

73

nit: . point at the end of the comment missing.

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

245

I think - possibly in a follow up revision - we may want to drop the arithfn_add and co and call the interface directly from the yaml generation tool (https://github.com/llvm/llvm-project/blob/bb1fe369774adb86a6bdeec3f56684b6a01c7ff3/mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp#L960).

336

nit: . missing at the end of the comment.

348

nit: . missing at the end of the comment.

353

if possible I would use the strings we use in the yaml files (https://github.com/llvm/llvm-project/blob/bb1fe369774adb86a6bdeec3f56684b6a01c7ff3/mlir/python/mlir/dialects/linalg/opdsl/lang/comprehension.py#L377). These are also the post fixes used for arithfn_add, arithfn_mul etc.

[gysit]

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

1068

Another alternative is also ArithFnTypeInterface to name stuff similar to the Python side.

[andidr]

Thanks for the feedback!

I added a few detail comments but I would like to ask a high-level question first. Wouldn't it make sense to have a single main interface method that takes the enum value, op builder, and a value range and then do the dispatch/error handling etc internally in the interface? Ideally, when adding a new operation we want to touch as little places as possible. At the moment, we need to adapt the enum, the applyfn_, the interface, and at least one interface implementation. Having an interface that takes an enum instead of having one method per operation time should reduce that by one and also simplifies a follow up refactoring to remove applyfn_

iface.create(builder, ArithFn::Add, ValueRange{lhs, rhs})
iface.create(builder, ArithFn::Exp, ValueRange{x})

I agree that having separate interface methods results in a rather large interface and that directly using the enum is more compact. However, when extending the set of arithmetic operators, handling the enum in a generic interface method results either in a compilation error for all implementations due to the new value not being handled in the switch statement or requires a boilerplate default: branch that is the same across all implementations. The former breaks modularity, as it requires all implementations to be adapted upon a change in Linalg itself, while the latter requires re-implementation of the default behavior in many places.

I also found that using separate interface methods is more true to the spirit of interfaces: what the interface is used for is directly specified in the interface without an additional level of abstraction and default behavior is specified by the default implementation.

All in all, I am not strongly against a generic interface method, but found the current implementation more elegant despite the fact that it is more verbose.

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

245

Yes, indeed. I was thinking about doing this right away in this revision, but I came to the conclusion that it's more transparent to have that change in a separate commit.

[andidr]

Addressed comments by @gysit

[andidr]

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

1068

Agreed that the name is probably too long. I refrained from abbreviating Operator with Op, since Op is usually used to refer to an operation. Also, I'd like to keep the term operator, since the interface is really a mapping from an operator to an operation.

[gysit]

However, when extending the set of arithmetic operators, handling the enum in a generic interface method results either in a compilation error for all implementations due to the new value not being handled in the switch statement or requires a boilerplate default: branch that is the same across all implementations.

I was thinking of having a default: branch in all implementations that calls a handleNotImplemented method that is part of 'LinalgArithmeticOperatorTypeInterface' (similarly there could be a handleNotSupported. It may be possible to combine the two approaches and have an additional method on the interface that implements the switch case and calls the createAdd, createSub, etc. methods.

Agreed that the name is probably too long. I refrained from abbreviating Operator with Op, since Op is usually used to refer to an operation. Also, I'd like to keep the term operator, since the interface is really a mapping from an operator to an operation.

Right Op is a bit overused. That is actually the reason why we went for function respectively its abbreviation Fn in OpDSL.

Also since this is quite a deep change, let me tag a more experienced reviewer as well @nicolasvasilache

[mehdi_amini]

Can you re-upload the patch with full-context please? (arc manages this all automatically).

More immediate question to the patch: it isn't clear to me how much it this fundamentally coupled to the dialect. It seems from the interface description that it is intended to help named op decomposition.
In general interfaces correspond to something that is defined/required by transformations, and implemented by the dialect that owns the operations. The positioning of this interface in the Linalg/IR folder does not match this view directly, this isn't defining the "IR".

mlir/include/mlir/Dialect/Linalg/IR/LinalgOpInterfaces.h

52

Why does it need to be publicly exposed?

[andidr]

Updated according to @mehdi_amini's comments.

[andidr]

Thanks @mehdi_amini for the feedback!

In D118022#3271621, @mehdi_amini wrote:

Can you re-upload the patch with full-context please? (arc manages this all automatically).

Done.

In D118022#3271621, @mehdi_amini wrote:

More immediate question to the patch: it isn't clear to me how much it this fundamentally coupled to the dialect. It seems from the interface description that it is intended to help named op decomposition.
In general interfaces correspond to something that is defined/required by transformations, and implemented by the dialect that owns the operations. The positioning of this interface in the Linalg/IR folder does not match this view directly, this isn't defining the "IR".

In the current implementation, one could argue that the interfaces do
indeed define the IR, since they define, for which types named
operations can be instantiated. They exist for the rather pratical
goal of enabling linalg to choose the correct operation in order to
apply an arithmetic operator on operands of a given type.

From a more abstract perspective, the purpose of the type interface is
to attach the semantics of arithmetic operators to the operations of a
type. It is a fundamental question to me whether such semantics should
be lifted out of the dialect and exist as a concept within MLIR itself
(e.g., in the form of separate type interfaces for the different
arithmetic operators, which can be implemented idividually for a given
type). I assume that this is only justified if there is a need for
such a concept across multiple dialects or within the basic
infrastructure itself. Until now, this doesn't seem to be the case,
but I'd be interested to hear your thoughts on this.

The current implementation with
LinalgArithmeticOperatorTypeInterface is an attempt to establish a
mapping from arithmetic operators to operations without invading the
global space of concepts in MLIR. Your response suggests that this may
not be a proper use of type interfaces. Let me know if you think that
there are better alternatives.

mlir/include/mlir/Dialect/Linalg/IR/LinalgOpInterfaces.h

52

It doesn't. Thanks for spotting this! Updated the revision, such that the definition does not become visible outside of the linalg code itself.

[andidr]

Superseded by D120027. See also the discussion at https://discourse.llvm.org/t/rfc-extend-linalg-named-operations-for-arbitrary-element-types/5631/13.

mlir/include/mlir/Dialect/Linalg/IR/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS LinalgStructuredOps.td)
 mlir_tablegen(LinalgStructuredOps.h.inc -gen-op-decls)
 mlir_tablegen(LinalgStructuredOps.cpp.inc -gen-op-defs)
 add_public_tablegen_target(MLIRLinalgStructuredOpsIncGen)
 add_dependencies(MLIRLinalgStructuredOpsIncGen LinalgOdsGen)
 add_dependencies(mlir-headers MLIRLinalgStructuredOpsIncGen)
 
 set(LLVM_TARGET_DEFINITIONS LinalgInterfaces.td)
-mlir_tablegen(LinalgInterfaces.h.inc -gen-op-interface-decls)
-mlir_tablegen(LinalgInterfaces.cpp.inc -gen-op-interface-defs)
+mlir_tablegen(LinalgOpInterfaces.h.inc -gen-op-interface-decls)
+mlir_tablegen(LinalgOpInterfaces.cpp.inc -gen-op-interface-defs)
+mlir_tablegen(LinalgTypeInterfaces.h.inc -gen-type-interface-decls)
+mlir_tablegen(LinalgTypeInterfaces.cpp.inc -gen-type-interface-defs)
 add_public_tablegen_target(MLIRLinalgInterfacesIncGen)
 add_dependencies(mlir-headers MLIRLinalgInterfacesIncGen)

mlir/include/mlir/Dialect/Linalg/IR/Linalg.h

 
 //===----------------------------------------------------------------------===//
 // Linalg Dialect
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/IR/LinalgOpsDialect.h.inc"
 
 //===----------------------------------------------------------------------===//
-// Linalg Interfaces
+// Linalg Op Interfaces
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Linalg/IR/LinalgInterfaces.h"
+#include "mlir/Dialect/Linalg/IR/LinalgOpInterfaces.h"
+
+//===----------------------------------------------------------------------===//
+// Linalg Type Interfaces
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/Linalg/IR/LinalgTypeInterfaces.h"
 
 //===----------------------------------------------------------------------===//
 // Linalg Dialect Operations
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.h.inc"
 
 #endif // MLIR_DIALECT_LINALG_LINALG_H_

mlir/include/mlir/Dialect/Linalg/IR/LinalgDefaultInterfaceImplementations.h

+//===- LinalgDefaultInterfaceImplementations.h ----------------------------===//
+//
+// Part of the LLVM 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 declares functions to attach default implementations for
+// Linalg interfaces to builtin types and operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_LINALG_IR_LINALGDEFAULTINTERFACEIMPLEMENTATIONS_H_
+#define MLIR_DIALECT_LINALG_IR_LINALGDEFAULTINTERFACEIMPLEMENTATIONS_H_
+
+#include "mlir/IR/MLIRContext.h"
+
+namespace mlir {
+namespace linalg {
+/// Attaches the linalg op interfaces to builtin ops.
+void attachDefaultOpInterfaceImplementations(MLIRContext &ctx);
+
+/// Attaches the linalg type interfaces to builtin types.
+void attachDefaultTypeInterfaceImplementations(MLIRContext &ctx);
+} // namespace linalg
+} // namespace mlir
+
+#endif // MLIR_DIALECT_LINALG_IR_LINALGDEFAULTINTERFACEIMPLEMENTATIONS_H_

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

void setOperandSegmentAt(unsigned idx, unsigned val) {
         [&](const APInt &v) { return (i++ == idx) ? APInt(32, val) : v; });
       getOperation()->setAttr("operand_segment_sizes", newAttr);
     }
   }];
 
   let verify = [{ return detail::verifyStructuredOpInterface($_op); }];
 }
 
+def LinalgAddOpInterface : OpInterface<"LinalgAddOpInterface"> {
+  let description = [{
+    Operation interface that allows for the identification of
+    operations that qualify as an addition on two tensor elements.
+  }];
+
+  let cppNamespace = "::mlir::linalg";
+}
+
+def LinalgMulOpInterface : OpInterface<"LinalgMulOpInterface"> {
+  let description = [{
+    Operation interface that allows for the identification of
+    operations that qualify as a multiplication of two tensor
+    elements.
+  }];
+  let cppNamespace = "::mlir::linalg";
+}
+
+def LinalgArithmeticOperatorTypeInterface : TypeInterface<"LinalgArithmeticOperatorTypeInterface"> {
+  let cppNamespace = "::mlir::linalg";
+
+  let description = [{
+    Type interface that allows for the instantiation of operations
+    implementing arithmetic operators for scalars. This allows Linalg
+    named operations to instantiate the correct operation for scalar
+    operators, e.g., to instantiate an operation implementing an
+    addition for a custom type when building the body of a matrix
+    multiplication.
+
+    The set of interface methods covers all scalar operations required
+    by named operations. A type may provide implementations of only a
+    subset of the interface methods, in which case only those Linalg
+    named operations become available for tensors of that type that
+    use the implemented subset. Instantiation of other named
+    operations that require at least one arithmetic operator tensor
+    elements, for which no interface method has been provided, results
+    in an error at execution time.
+
+    The absence of an implementation of an arithmetic operator can be
+    indicated in two ways. If there is no sensible possible
+    implementation of an operator for the type, the respective
+    interface method should return
+    `LinalgArithmeticOperatorInstantiationResult::undefined()`. If a
+    sensible definition may exist, but has not been implemented, the
+    method should return
+    `LinalgArithmeticOperatorInstantiationResult::notImplemented()`. This
+    is also the default return value for any interface method not
+    overriden by a type.
+  }];
+
+  let methods = [
+    InterfaceMethod<
+      /*description=*/"Returns an operation implementing an addition.",
+      /*retTy=*/"::mlir::linalg::LinalgArithmeticOperatorInstantiationResult",
+      /*methodName=*/"createAdd",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Value":$lhs,
+                    "::mlir::Value":$rhs),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::linalg::LinalgArithmeticOperatorInstantiationResult::notImplemented();
+      }]
+    >,
+    InterfaceMethod<
+      /*description=*/"Returns an operation implementing a subtraction.",
+      /*retTy=*/"::mlir::linalg::LinalgArithmeticOperatorInstantiationResult",
+      /*methodName=*/"createSub",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Value":$lhs,
+                    "::mlir::Value":$rhs),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::linalg::LinalgArithmeticOperatorInstantiationResult::notImplemented();
+      }]
+    >,
+    InterfaceMethod<
+      /*description=*/"Returns an operation implementing a multiplication.",
+      /*retTy=*/"::mlir::linalg::LinalgArithmeticOperatorInstantiationResult",
+      /*methodName=*/"createMul",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Value":$lhs,
+                    "::mlir::Value":$rhs),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::linalg::LinalgArithmeticOperatorInstantiationResult::notImplemented();
+      }]
+    >,
+    InterfaceMethod<
+      /*description=*/"Returns an operation returning the maximum of two values.",
+      /*retTy=*/"::mlir::linalg::LinalgArithmeticOperatorInstantiationResult",
+      /*methodName=*/"createMax",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Value":$lhs,
+                    "::mlir::Value":$rhs),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::linalg::LinalgArithmeticOperatorInstantiationResult::notImplemented();
+      }]
+    >,
+    InterfaceMethod<
+      /*description=*/"Returns an operation returning the unsigned maximum of two values.",
+      /*retTy=*/"::mlir::linalg::LinalgArithmeticOperatorInstantiationResult",
+      /*methodName=*/"createUnsignedMax",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Value":$lhs,
+                    "::mlir::Value":$rhs),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::linalg::LinalgArithmeticOperatorInstantiationResult::notImplemented();
+      }]
+    >,
+    InterfaceMethod<
+      /*description=*/"Returns an operation returning the minimum of two values.",
+      /*retTy=*/"::mlir::linalg::LinalgArithmeticOperatorInstantiationResult",
+      /*methodName=*/"createMin",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Value":$lhs,
+                    "::mlir::Value":$rhs),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::linalg::LinalgArithmeticOperatorInstantiationResult::notImplemented();
+      }]
+    >,
+    InterfaceMethod<
+      /*description=*/"Returns an operation returning the unsigned minimum of two values.",
+      /*retTy=*/"::mlir::linalg::LinalgArithmeticOperatorInstantiationResult",
+      /*methodName=*/"createUnsignedMin",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Value":$lhs,
+                    "::mlir::Value":$rhs),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::linalg::LinalgArithmeticOperatorInstantiationResult::notImplemented();
+      }]
+    >,
+    InterfaceMethod<
+      /*description=*/"Returns an operation returning e raised to the power of x.",
+      /*retTy=*/"::mlir::linalg::LinalgArithmeticOperatorInstantiationResult",
+      /*methodName=*/"createExp",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Value":$x),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::linalg::LinalgArithmeticOperatorInstantiationResult::notImplemented();
+      }]
+    >,
+    InterfaceMethod<
+      /*description=*/"Returns an operation calculating the e-based logarithm of x.",
+      /*retTy=*/"::mlir::linalg::LinalgArithmeticOperatorInstantiationResult",
+      /*methodName=*/"createLog",
+      /*args=*/(ins "::mlir::OpBuilder &":$builder,
+                    "::mlir::Value":$x),
+      /*methodBody=*/"",
+      /*defaultImplementation=*/[{
+        return ::mlir::linalg::LinalgArithmeticOperatorInstantiationResult::notImplemented();
+      }]
+    >
+  ];
+}
+
 #endif // LINALG_IR_LINALGINTERFACES

mlir/include/mlir/Dialect/Linalg/IR/LinalgOpInterfaces.h

 //===- LinalgInterface.h - Linalg operations interfaces -------------------===//
 //
 // Part of the LLVM 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 implements the operation interfaces for Linalg operations.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_LINALG_IR_LINALGINTERFACES_H_
-#define MLIR_DIALECT_LINALG_IR_LINALGINTERFACES_H_
+#ifndef MLIR_DIALECT_LINALG_IR_LINALGOPINTERFACES_H_
+#define MLIR_DIALECT_LINALG_IR_LINALGOPINTERFACES_H_
 
 #include "mlir/Dialect/Utils/StructuredOpsUtils.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/ImplicitLocOpBuilder.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"

 LogicalResult verifyConvolutionInterface(Operation *op);
 
 /// Verify that `op` conforms to the invariants of StructuredOpInterface
 LogicalResult verifyStructuredOpInterface(Operation *op);
 
 } // namespace detail
 } // namespace linalg
 } // namespace mlir
 
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.h.inc"
 
 /// Include the generated interface declarations.
-#include "mlir/Dialect/Linalg/IR/LinalgInterfaces.h.inc"
+#include "mlir/Dialect/Linalg/IR/LinalgOpInterfaces.h.inc"
 
 #endif // MLIR_DIALECT_LINALG_IR_LINALGINTERFACES_H_

mlir/include/mlir/Dialect/Linalg/IR/LinalgTypeInterfaces.h

+//===- LinalgTypeInterfaces.h - Linalg type interfaces --------------------===//
+//
+// Part of the LLVM 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 implements the type interfaces for Linalg operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_LINALG_IR_LINALGTYPEINTERFACES_H_
+#define MLIR_DIALECT_LINALG_IR_LINALGTYPEINTERFACES_H_
+
+#include "mlir/IR/Builders.h"
+#include "llvm/ADT/Optional.h"
+
+namespace mlir {
+namespace linalg {
+
+/// Result for an attempt to instantiate an arithmetic operator via
+/// `LinalgArithmeticOperatorTypeInterface`.
+///
+/// On successful instantiation, the result holds a value
+/// corresponding to the result of an operation implementing the
+/// operator.
+///
+/// If the instantiation fails, the result indicates whether this is
+/// because the operator is not implemented for the type (e.g.,
+/// because of an incomplete implementation of
+/// `LinalgArithmeticOperatorTypeInterface`) or because there is no
+/// sensible implementation of the operator for the type.
+class LinalgArithmeticOperatorInstantiationResult {
+protected:
+  enum class Status {
+    /// Arithmetic operator is implemented for the type.
+    IMPLEMENTED,
+
+    /// Arithmetic operator has not been implemented for the type.
+    NOT_IMPLEMENTED,
+
+    /// No sensible implementation of the arithmetic operator for the
+    /// type.
+    UNDEFINED
+  };
+
+  LinalgArithmeticOperatorInstantiationResult(Status s, llvm::Optional<Value> v)
+      : value(v), status(s) {}
+
+  llvm::Optional<Value> value;
+  Status status;
+
+public:
+  /// Constructor generating a result indicating a successful
+  /// instantiation. The result of the operation implementing the
+  /// operator is specified by `v`.
+  LinalgArithmeticOperatorInstantiationResult(Value v)
+      : value(v), status(Status::IMPLEMENTED) {}
+
+  /// Creates a result indicating that the arithmetic operator is not
+  /// implemented for the type (e.g., due to an incomplete
+  /// implementation of `LinalgArithmeticOperatorTypeInterface`).
+  static LinalgArithmeticOperatorInstantiationResult notImplemented() {
+    LinalgArithmeticOperatorInstantiationResult res(Status::NOT_IMPLEMENTED,
+                                                    llvm::None);
+
+    return res;
+  }
+
+  /// Creates a result indicating that there is no sensible
+  /// implementation of the arithmetic operator for the type.
+  static LinalgArithmeticOperatorInstantiationResult undefined() {
+    LinalgArithmeticOperatorInstantiationResult res(Status::UNDEFINED,
+                                                    llvm::None);
+
+    return res;
+  }
+
+  /// Returns the result of the operation implementing the arithmetic
+  /// operator. If the instantiation was a failure, the instance of
+  /// `Optional` is empty.
+  llvm::Optional<Value> getValue() { return this->value; }
+
+  /// Returns true if the arithmetic operator is implemented and
+  /// instantiation was a success.
+  bool isImplemented() { return this->status == Status::IMPLEMENTED; }
+
+  /// Returns true if the instantiation was a failure due to arithmetic
+  /// operator is not being implemented for the type.
+  bool isNotImplemented() { return this->status == Status::NOT_IMPLEMENTED; }
+
+  /// Returns true if the instantiation was a failure because no
+  /// sensible implementation of the arithmetic operator exists for the
+  /// type.
+  bool isUndefined() { return this->status == Status::UNDEFINED; }
+};
+} // namespace linalg
+} // namespace mlir
+
+/// Include the generated type interface declarations.
+#include "mlir/Dialect/Linalg/IR/LinalgTypeInterfaces.h.inc"
+
+#endif // MLIR_DIALECT_LINALG_IR_LINALGTYPEINTERFACES_H_

mlir/lib/Dialect/Linalg/IR/CMakeLists.txt

 add_mlir_dialect_library(MLIRLinalg
-  LinalgInterfaces.cpp
+  LinalgOpInterfaces.cpp
+  LinalgTypeInterfaces.cpp
+  LinalgDefaultTypeInterfaceImplementations.cpp
+  LinalgDefaultOpInterfaceImplementations.cpp
   LinalgOps.cpp
   LinalgDialect.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Linalg
 
   DEPENDS
   MLIRLinalgInterfacesIncGen

mlir/lib/Dialect/Linalg/IR/LinalgDefaultOpInterfaceImplementations.cpp

+//===- LinalgDefaultOpInterfaceImplementations.cpp ----------------------===//
+//
+// Part of the LLVM 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 provides implementations of the linalg op interfaces for
+// builtin ops.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Linalg/IR/LinalgOpInterfaces.h"
+
+namespace mlir {
+namespace linalg {
+namespace {
+/// Implementation of LinalgAddOpInterface for arith::AddFOp.
+struct AddFOpAddOpInterface
+    : public LinalgAddOpInterface::ExternalModel<AddFOpAddOpInterface,
+                                                 arith::AddFOp> {};
+
+/// Implementation of LinalgAddOpInterface for arith::AddIOp.
+struct AddIOpAddOpInterface
+    : public LinalgAddOpInterface::ExternalModel<AddIOpAddOpInterface,
+                                                 arith::AddIOp> {};
+
+/// Implementation of LinalgMulOpInterface for arith::MulFOp.
+struct MulFOpMulOpInterface
+    : public LinalgMulOpInterface::ExternalModel<MulFOpMulOpInterface,
+                                                 arith::MulFOp> {};
+
+/// Implementation of LinalgMulOpInterface for arith::MulIOp.
+struct MulIOpMulOpInterface
+    : public LinalgMulOpInterface::ExternalModel<MulIOpMulOpInterface,
+                                                 arith::MulIOp> {};
+} // namespace
+
+void attachDefaultOpInterfaceImplementations(MLIRContext &ctx) {
+  arith::AddFOp::attachInterface<AddFOpAddOpInterface>(ctx);
+  arith::AddIOp::attachInterface<AddIOpAddOpInterface>(ctx);
+  arith::MulFOp::attachInterface<MulFOpMulOpInterface>(ctx);
+  arith::MulIOp::attachInterface<MulIOpMulOpInterface>(ctx);
+}
+} // namespace linalg
+} // namespace mlir

mlir/lib/Dialect/Linalg/IR/LinalgDefaultTypeInterfaceImplementations.cpp

+//===- LinalgDefaultTypeInterfaceImplementations.cpp ----------------------===//
+//
+// Part of the LLVM 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 provides implementations of the linalg type interfaces
+// for builtin types.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
+#include "mlir/Dialect/Linalg/IR/LinalgTypeInterfaces.h"
+#include "mlir/Dialect/Math/IR/Math.h"
+#include "mlir/IR/BuiltinTypes.h"
+
+namespace mlir {
+namespace linalg {
+namespace {
+/// Implementation of ArithmeticOperatorTypeInterface for floats.
+template <typename FloatTy>
+struct FloatArithmeticOperatorTypeInterface
+    : public LinalgArithmeticOperatorTypeInterface::ExternalModel<
+          FloatArithmeticOperatorTypeInterface<FloatTy>, FloatTy> {
+  LinalgArithmeticOperatorInstantiationResult
+  createAdd(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::AddFOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createSub(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::SubFOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createMul(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MulFOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createMax(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MaxFOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createUnsignedMax(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MaxFOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createMin(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MinFOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createUnsignedMin(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MinFOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createExp(Type t, OpBuilder &builder, Value x) const {
+    return builder.create<math::ExpOp>(x.getLoc(), x).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createLog(Type t, OpBuilder &builder, Value x) const {
+    return builder.create<math::LogOp>(x.getLoc(), x).getResult();
+  }
+};
+
+/// Implementation of ArithmeticOperatorTypeInterface for integers.
+struct IntegerArithmeticOperatorTypeInterface
+    : public LinalgArithmeticOperatorTypeInterface::ExternalModel<
+          IntegerArithmeticOperatorTypeInterface, IntegerType> {
+  LinalgArithmeticOperatorInstantiationResult
+  createAdd(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::AddIOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createSub(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::SubIOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createMul(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MulIOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createMax(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MaxSIOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createUnsignedMax(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MaxUIOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createMin(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MinSIOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createUnsignedMin(Type t, OpBuilder &builder, Value lhs, Value rhs) const {
+    return builder.create<arith::MinUIOp>(lhs.getLoc(), lhs, rhs).getResult();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createExp(Type t, OpBuilder &builder, Value x) const {
+    return LinalgArithmeticOperatorInstantiationResult::notImplemented();
+  }
+
+  LinalgArithmeticOperatorInstantiationResult
+  createLog(Type t, OpBuilder &builder, Value x) const {
+    return LinalgArithmeticOperatorInstantiationResult::notImplemented();
+  }
+};
+} // namespace
+
+void attachDefaultTypeInterfaceImplementations(MLIRContext &ctx) {
+  BFloat16Type::attachInterface<
+      FloatArithmeticOperatorTypeInterface<BFloat16Type>>(ctx);
+  Float16Type::attachInterface<
+      FloatArithmeticOperatorTypeInterface<Float16Type>>(ctx);
+  Float32Type::attachInterface<
+      FloatArithmeticOperatorTypeInterface<Float32Type>>(ctx);
+  Float64Type::attachInterface<
+      FloatArithmeticOperatorTypeInterface<Float64Type>>(ctx);
+  Float80Type::attachInterface<
+      FloatArithmeticOperatorTypeInterface<Float80Type>>(ctx);
+  Float128Type::attachInterface<
+      FloatArithmeticOperatorTypeInterface<Float128Type>>(ctx);
+
+  IntegerType::attachInterface<IntegerArithmeticOperatorTypeInterface>(ctx);
+}
+} // namespace linalg
+} // namespace mlir

mlir/lib/Dialect/Linalg/IR/LinalgDialect.cpp

 //===- Dialect.cpp - Implementation of the linalg dialect and types -------===//
 //
 // Part of the LLVM 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 implements the Linalg dialect types and dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
+#include "mlir/Dialect/Linalg/IR/LinalgDefaultInterfaceImplementations.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/FunctionSupport.h"
 #include "mlir/Parser.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/InliningUtils.h"
 
#include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
 
   // Fill the Linalg-specific OpName to RegionBuilder map.
   addNamedOpBuilders<
 #define GET_OP_LIST
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
       >(namedStructuredOpRegionBuilders);
 
   addInterfaces<LinalgInlinerInterface>();
+  attachDefaultTypeInterfaceImplementations(*getContext());
+  attachDefaultOpInterfaceImplementations(*getContext());
 }
 
 LogicalResult LinalgDialect::verifyOperationAttribute(Operation *op,
                                                       NamedAttribute attr) {
   using comprehensive_bufferize::BufferizableOpInterface;
 
   if (attr.getName() == BufferizableOpInterface::kInplaceableAttrName) {
     if (!attr.getValue().isa<BoolAttr>()) {

mlir/lib/Dialect/Linalg/IR/LinalgOpInterfaces.cpp

 //===- LinalgInterfaces.cpp - Linalg interfaces implementation ------------===//
 //
 // Part of the LLVM 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Linalg/IR/LinalgInterfaces.h"
+#include "mlir/Dialect/Linalg/IR/LinalgOpInterfaces.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/AffineExprVisitor.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "llvm/ADT/SmallSet.h"
 
 using namespace mlir;
 using namespace mlir::linalg;
 
 /// Include the definitions of the copy operation interface.
-#include "mlir/Dialect/Linalg/IR/LinalgInterfaces.cpp.inc"
+#include "mlir/Dialect/Linalg/IR/LinalgOpInterfaces.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // ContractionOpInterface implementation
 //===----------------------------------------------------------------------===//
 
 /// Return true if the use-def chain from `v` to `from` consists of 0 or more
 /// unary single-operand operations.
 // TODO: relax to multi-operands with constants, which are technically unary ops
 // as needed (e.g. add5).
 static bool isChainOfUnaryOpsFrom(Value v, Value from) {
   while (true) {
     if (v == from)
       return true;
     Operation *op = v.getDefiningOp();
     if (!op || op->getNumOperands() != 1)
       return false;
     v = op->getOperand(0);
   };
 }
 
-/// Return the unique instance of OpType in `block` if it is indeed unique.
-/// Return null if none or more than 1 instances exist.
-template <typename OpType>
-static OpType getSingleOpOfType(Block &block) {
-  OpType res = nullptr;
-  block.walk([&](OpType op) {
-    if (res) {
-      res = nullptr;
+/// Return the unique operation in `block` implementing the interface
+/// `OpIface` if it is indeed unique.  Return null if none or more
+/// than 1 instances exist.
+template <typename OpIface>
+static Operation *getSingleOpImplementingInterface(Block &block) {
+  Operation *res = nullptr;
+
+  block.walk([&](Operation *op) {
+    if (!dyn_cast<OpIface>(op))
+      return WalkResult::advance();
+
+    if (res)
       return WalkResult::interrupt();
-    }
+
     res = op;
     return WalkResult::advance();
   });
   return res;
 }
 
 /// Detect whether res is any permutation of `u5(u1(c) + u2(u3(a) * u4(b)))`
 /// on the field (AddOpType, MulOpType), where u1, u2, u3, u4 and u5 represent
 /// unary operations that may change the type.
-template <typename AddOpType, typename MulOpType>
 static bool isAddMul(Block &block) {
   if (block.getNumArguments() != 3)
     return false;
   Operation *yieldOp = block.getTerminator();
   if (yieldOp->getNumOperands() != 1)
     return false;
 
-  AddOpType addOp = getSingleOpOfType<AddOpType>(block);
-  MulOpType mulOp = getSingleOpOfType<MulOpType>(block);
+  Operation *addOp =
+      getSingleOpImplementingInterface<LinalgAddOpInterface>(block);
+  Operation *mulOp =
+      getSingleOpImplementingInterface<LinalgMulOpInterface>(block);
+
   if (!addOp || !mulOp)
     return false;
 
   Value argA = block.getArgument(0), argB = block.getArgument(1);
   Value a = mulOp->getOperand(0), b = mulOp->getOperand(1);
   Value mul = mulOp->getResult(0);
   Value argC = block.getArgument(2);
   Value c1 = addOp->getOperand(0), c2 = addOp->getOperand(1);
static MatchContractionResult isContractionInterfaceImpl(Operation *op) {
   if (linalgOp.getNumInputs() != 2 || linalgOp.getNumOutputs() != 1)
     return MatchContractionResult::WrongNumOperands;
   auto mapRange = linalgOp.indexing_maps().getAsValueRange<AffineMapAttr>();
   if (linalgOp.getNumReductionLoops() == 0)
     return MatchContractionResult::NoReduction;
   if (llvm::any_of(mapRange,
                    [](AffineMap m) { return !m.isProjectedPermutation(); }))
     return MatchContractionResult::NotProjectedPermutations;
+
   // TODO: more fields than add/mul.
-  if (!isAddMul<arith::AddFOp, arith::MulFOp>(linalgOp->getRegion(0).front()) &&
-      !isAddMul<arith::AddIOp, arith::MulIOp>(linalgOp->getRegion(0).front()))
+  if (!isAddMul(linalgOp->getRegion(0).front()))
     return MatchContractionResult::NotAddMul;
+
   return MatchContractionResult::Success;
 }
 
 bool mlir::linalg::isaContractionOpInterface(LinalgOp linalgOp) {
   if (!linalgOp)
     return false;
   Operation *op = linalgOp.getOperation();
   return isa<ContractionOpInterface>(op) ||

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

public:
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value typefn__cast_unsigned(Type toType, Value operand) {
     return cast(toType, operand, true);
   }
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value arithfn__add(Value lhs, Value rhs) {
-    OpBuilder builder = getBuilder();
-    if (isFloatingPoint(lhs))
-      return builder.create<arith::AddFOp>(lhs.getLoc(), lhs, rhs);
-    if (isInteger(lhs))
-      return builder.create<arith::AddIOp>(lhs.getLoc(), lhs, rhs);
-    llvm_unreachable("unsupported non numeric type");
+    return createBinaryArithmeticOperator(BinaryArithmeticOperator::ADD, lhs,
+                                          rhs);
   }
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value arithfn__exp(Value x) {
-    OpBuilder builder = getBuilder();
-    if (isFloatingPoint(x))
-      return builder.create<math::ExpOp>(x.getLoc(), x);
-    llvm_unreachable("unsupported non numeric type");
+    return createUnaryArithmeticOperator(UnaryArithmeticOperator::EXP, x);
   }
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value arithfn__log(Value x) {
-    OpBuilder builder = getBuilder();
-    if (isFloatingPoint(x))
-      return builder.create<math::LogOp>(x.getLoc(), x);
-    llvm_unreachable("unsupported non numeric type");
+    return createUnaryArithmeticOperator(UnaryArithmeticOperator::LOG, x);
   }
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value arithfn__sub(Value lhs, Value rhs) {
-    OpBuilder builder = getBuilder();
-    if (isFloatingPoint(lhs))
-      return builder.create<arith::SubFOp>(lhs.getLoc(), lhs, rhs);
-    if (isInteger(lhs))
-      return builder.create<arith::SubIOp>(lhs.getLoc(), lhs, rhs);
-    llvm_unreachable("unsupported non numeric type");
+    return createBinaryArithmeticOperator(BinaryArithmeticOperator::SUB, lhs,
+                                          rhs);
   }
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value arithfn__mul(Value lhs, Value rhs) {
-    OpBuilder builder = getBuilder();
-    if (isFloatingPoint(lhs))
-      return builder.create<arith::MulFOp>(lhs.getLoc(), lhs, rhs);
-    if (isInteger(lhs))
-      return builder.create<arith::MulIOp>(lhs.getLoc(), lhs, rhs);
-    llvm_unreachable("unsupported non numeric type");
+    return createBinaryArithmeticOperator(BinaryArithmeticOperator::MUL, lhs,
+                                          rhs);
   }
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value arithfn__max(Value lhs, Value rhs) {
-    OpBuilder builder = getBuilder();
-    if (isFloatingPoint(lhs))
-      return builder.create<arith::MaxFOp>(lhs.getLoc(), lhs, rhs);
-    if (isInteger(lhs))
-      return builder.create<arith::MaxSIOp>(lhs.getLoc(), lhs, rhs);
-    llvm_unreachable("unsupported non numeric type");
+    return createBinaryArithmeticOperator(BinaryArithmeticOperator::MAX, lhs,
+                                          rhs);
   }
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value arithfn__max_unsigned(Value lhs, Value rhs) {
-    OpBuilder builder = getBuilder();
-    if (isFloatingPoint(lhs))
-      return builder.create<arith::MaxFOp>(lhs.getLoc(), lhs, rhs);
-    if (isInteger(lhs))
-      return builder.create<arith::MaxUIOp>(lhs.getLoc(), lhs, rhs);
-    llvm_unreachable("unsupported non numeric type");
+    return createBinaryArithmeticOperator(
+        BinaryArithmeticOperator::UNSIGNED_MAX, lhs, rhs);
   }
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value arithfn__min(Value lhs, Value rhs) {
-    OpBuilder builder = getBuilder();
-    if (isFloatingPoint(lhs))
-      return builder.create<arith::MinFOp>(lhs.getLoc(), lhs, rhs);
-    if (isInteger(lhs))
-      return builder.create<arith::MinSIOp>(lhs.getLoc(), lhs, rhs);
-    llvm_unreachable("unsupported non numeric type");
+    return createBinaryArithmeticOperator(BinaryArithmeticOperator::MIN, lhs,
+                                          rhs);
   }
 
   // NOLINTNEXTLINE(*-identifier-naming): externally called.
   Value arithfn__min_unsigned(Value lhs, Value rhs) {
-    OpBuilder builder = getBuilder();
-    if (isFloatingPoint(lhs))
-      return builder.create<arith::MinFOp>(lhs.getLoc(), lhs, rhs);
-    if (isInteger(lhs))
-      return builder.create<arith::MinUIOp>(lhs.getLoc(), lhs, rhs);
-    llvm_unreachable("unsupported non numeric type");
+    return createBinaryArithmeticOperator(
+        BinaryArithmeticOperator::UNSIGNED_MIN, lhs, rhs);
   }
 
   void yieldOutputs(ValueRange values) {
     assert(!values.empty() && "linalg ops must yield outputs");
     if (values.empty())
       return;
     Value first = values.front();
     OpBuilder builder = getBuilder();
public:
   Type getFloat32Type() { return Float32Type::get(context); }
 
   Type getFloat64Type() { return Float64Type::get(context); }
 
 private:
   MLIRContext *context;
   Block &block;
 
-  bool isFloatingPoint(Value value) { return value.getType().isa<FloatType>(); }
-  bool isInteger(Value value) { return value.getType().isa<IntegerType>(); }
-
   OpBuilder getBuilder() {
     OpBuilder builder(context);
     builder.setInsertionPointToEnd(&block);
     return builder;
   }
+
+  /// All binary arithmetic operators that can be instantiated through
+  /// `LinalgArithmeticOperatorTypeInterface`.
+  enum class BinaryArithmeticOperator {
+    ADD,
+    SUB,
+    MUL,
+    MAX,
+    UNSIGNED_MAX,
+    MIN,
+    UNSIGNED_MIN
+  };
+
+  /// Mapping from binary arithmetic operators to human-readable names,
+  /// e.g., for error messages.
+  static const char *
+  binaryArithmeticOperatorName(BinaryArithmeticOperator oper) {
+    switch (oper) {
+    case BinaryArithmeticOperator::ADD:
+      return "add";
+    case BinaryArithmeticOperator::SUB:
+      return "sub";
+    case BinaryArithmeticOperator::MUL:
+      return "mul";
+    case BinaryArithmeticOperator::MAX:
+      return "max";
+    case BinaryArithmeticOperator::UNSIGNED_MAX:
+      return "max_unsigned";
+    case BinaryArithmeticOperator::MIN:
+      return "min";
+    case BinaryArithmeticOperator::UNSIGNED_MIN:
+      return "min_unsigned";
+    }
+
+    llvm_unreachable("Unknown binary arithmetic operator");
+  }
+
+  /// All unary arithmetic operators that can be instantiated through
+  /// `LinalgArithmeticOperatorTypeInterface`.
+  enum class UnaryArithmeticOperator { EXP, LOG };
+
+  /// Mapping from unary arithmetic operators to human-readable names,
+  /// e.g., for error messages.
+  static const char *unaryArithmeticOperatorName(UnaryArithmeticOperator oper) {
+    switch (oper) {
+    case UnaryArithmeticOperator::EXP:
+      return "exp";
+    case UnaryArithmeticOperator::LOG:
+      return "log";
+    }
+
+    llvm_unreachable("Unknown unary arithmetic operator");
+  }
+
+  /// Helper method that attempts to create an operation with the
+  /// human-readable name `operatorName` for the type `operandType`
+  /// through invocation of `instFun` with a suitable builder and an
+  /// instance of `LinalgArithmeticOperatorTypeInterface` to be used
+  /// for instantiation.
+  Value createArithmeticOperator(
+      StringRef operatorName, Type operandType,
+      function_ref<LinalgArithmeticOperatorInstantiationResult(
+          OpBuilder &, LinalgArithmeticOperatorTypeInterface &)>
+          instFun) {
+    std::string errBuf;
+    llvm::raw_string_ostream errSos(errBuf);
+
+    LinalgArithmeticOperatorTypeInterface aoty =
+        operandType.dyn_cast<LinalgArithmeticOperatorTypeInterface>();
+
+    if (!aoty) {
+      errSos << "Unsupported numeric type: ";
+      operandType.print(errSos);
+      errSos << " does not implement LinalgArithmeticOperatorTypeInterface";
+      llvm_unreachable(errSos.str().c_str());
+    }
+
+    OpBuilder builder = getBuilder();
+    LinalgArithmeticOperatorInstantiationResult res = instFun(builder, aoty);
+
+    if (!res.isImplemented()) {
+      errSos << operatorName << " is ";
+
+      if (res.isNotImplemented())
+        errSos << "not implemented";
+      else if (res.isUndefined())
+        errSos << "undefined";
+
+      errSos << " for type ";
+      operandType.print(errSos);
+
+      llvm_unreachable(errSos.str().c_str());
+    }
+
+    return res.getValue().getValue();
+  }
+
+  /// Creates a single instance of the binary arithmetic operator
+  /// specified by `oper` through invocation of the respective method
+  /// of `LinalgArithmeticOperatorTypeInterface` on the type of `lhs`.
+  Value createBinaryArithmeticOperator(BinaryArithmeticOperator oper, Value lhs,
+                                       Value rhs) {
+    auto instFun = [&](OpBuilder &builder,
+                       LinalgArithmeticOperatorTypeInterface &aoty) {
+      switch (oper) {
+      case BinaryArithmeticOperator::ADD:
+        return aoty.createAdd(builder, lhs, rhs);
+      case BinaryArithmeticOperator::SUB:
+        return aoty.createSub(builder, lhs, rhs);
+      case BinaryArithmeticOperator::MUL:
+        return aoty.createMul(builder, lhs, rhs);
+      case BinaryArithmeticOperator::MAX:
+        return aoty.createMax(builder, lhs, rhs);
+      case BinaryArithmeticOperator::UNSIGNED_MAX:
+        return aoty.createUnsignedMax(builder, lhs, rhs);
+      case BinaryArithmeticOperator::MIN:
+        return aoty.createMin(builder, lhs, rhs);
+      case BinaryArithmeticOperator::UNSIGNED_MIN:
+        return aoty.createUnsignedMin(builder, lhs, rhs);
+      }
+
+      return LinalgArithmeticOperatorInstantiationResult::notImplemented();
+    };
+
+    const char *operName = binaryArithmeticOperatorName(oper);
+    return createArithmeticOperator(operName, lhs.getType(), instFun);
+  }
+
+  /// Creates a single instance of the unary arithmetic operator
+  /// specified by `oper` by invoking
+  /// `LinalgArithmeticOperatorTypeInterface` on the type of `x`.
+  Value createUnaryArithmeticOperator(UnaryArithmeticOperator oper, Value x) {
+    auto instFun = [&](OpBuilder &builder,
+                       LinalgArithmeticOperatorTypeInterface &aoty) {
+      switch (oper) {
+      case UnaryArithmeticOperator::EXP:
+        return aoty.createExp(builder, x);
+      case UnaryArithmeticOperator::LOG:
+        return aoty.createLog(builder, x);
+      }
+
+      return LinalgArithmeticOperatorInstantiationResult::notImplemented();
     };
 
+    const char *operName = unaryArithmeticOperatorName(oper);
+
+    return createArithmeticOperator(operName, x.getType(), instFun);
+  }
+};
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // CopyOp
 //===----------------------------------------------------------------------===//
 void CopyOp::regionBuilder(ImplicitLocOpBuilder &b, Block &block) {
   assert(block.getNumArguments() == 2 && "CopyOp regionBuilder expects 2 args");
   b.create<linalg::YieldOp>(block.getArgument(0));

mlir/lib/Dialect/Linalg/IR/LinalgTypeInterfaces.cpp

+//===- LinalgTypeInterfaces.cpp - Linalg type interfaces implementation ---===//
+//
+// Part of the LLVM 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/Linalg/IR/LinalgTypeInterfaces.h"
+
+#include "mlir/Dialect/Linalg/IR/LinalgTypeInterfaces.cpp.inc"