[mlir][Vector] Introduce the MaskingOpInterface

[dcaballe]

Summary

This MaskingOpInterface provides masking cababilitites to those
operations that implement it. For only is only implemented by the vector.mask
operation and it's used to break the dependency between the Vector
dialect (where the vector.mask op lives) and operations implementing
the MaskableOpInterface.

This is part of masking proposal described in
https://discourse.llvm.org/t/rfc-vector-masking-representation-in-mlir/64964.

[jsetoain]

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

2144–2146

...operation that predicates...

2148–2149

Why only one? Isn't it the point of vector.mask to simplify the handling of blocks of masked operations? Or are you trying to say that a *maskable* operation can be masked only by one vector.mask operation at a time?

[dcaballe]

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

2148–2149

It's the former. A vector.mask can only mask a single operation. We started with the latter approach and things got complicated quickly, especially during the lowering because we had to split or extract ops from the vector.mask operation and rewire all the U-D chain. Also different masked ops may need different passthru values (and, in the future, vector length values) so there is also a semantic reason to mask only one op.

[dcaballe]

Fix typo

[nicolasvasilache]

Great to see this taking shape, thanks Diego!

mlir/include/mlir/Dialect/Vector/Interfaces/MaskableOpInterface.td

27

nit: bit more indentation to make this less monolithic and easier to parse?

mlir/include/mlir/Dialect/Vector/Interfaces/MaskingOpInterface.td

26

nit: bit more indentation to make this less monolithic and easier to parse?

mlir/include/mlir/Dialect/Vector/IR/VectorOps.h

 //===- VectorOps.h - MLIR Vector Dialect Operations -------------*- C++ -*-===//
 //
 // 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 defines the Vector dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_VECTOR_IR_VECTOROPS_H
 #define MLIR_DIALECT_VECTOR_IR_VECTOROPS_H
 
-#include "mlir/Dialect/Vector/Interfaces/MaskingInterfaces.h"
+#include "mlir/Dialect/Vector/Interfaces/MaskableOpInterface.h"
+#include "mlir/Dialect/Vector/Interfaces/MaskingOpInterface.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

 //===- VectorOps.td - Vector op definitions ---------------*- tablegen -*-====//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines MLIR vector operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef VECTOR_OPS
 #define VECTOR_OPS
 
-include "mlir/Dialect/Vector/Interfaces/MaskingInterfaces.td"
+include "mlir/Dialect/Vector/Interfaces/MaskableOpInterface.td"
+include "mlir/Dialect/Vector/Interfaces/MaskingOpInterface.td"
 include "mlir/IR/EnumAttr.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 include "mlir/Interfaces/ViewLikeInterface.td"
 
 def Vector_Dialect : Dialect {
def Vector_CreateMaskOp :
   }];
 
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
   let assemblyFormat = "$operands attr-dict `:` type(results)";
 }
 
 def Vector_MaskOp : Vector_Op<"mask", [
-  SingleBlockImplicitTerminator<"vector::YieldOp">, RecursiveMemoryEffects,
-  NoRegionArguments
+  SingleBlockImplicitTerminator<"vector::YieldOp">,
+  DeclareOpInterfaceMethods<MaskingOpInterface>,
+  RecursiveMemoryEffects, NoRegionArguments
 ]> {
   let summary = "Predicates a maskable vector operation";
   let description = [{
-    The `vector.mask` operation predicates the execution of another operation.
-    It takes an `i1` vector mask and an optional pass-thru vector as arguments.
+    The `vector.mask` is a `MaskingOpInterface` operation that predicates the
+    execution of another operation. It takes an `i1` vector mask and an
+    optional passthru vector as arguments.
     A `vector.yield`-terminated region encloses the operation to be masked.
     Values used within the region are captured from above. Only one *maskable*
     operation can be masked with a `vector.mask` operation at a time. An
     operation is *maskable* if it implements the `MaskableOpInterface`.
 
     The vector mask argument holds a bit for each vector lane and determines
     which vector lanes should execute the maskable operation and which ones
     should not. The `vector.mask` operation returns the value produced by the
     masked execution of the nested operation, if any. The masked-off lanes in
     the result vector are taken from the corresponding lanes of the pass-thru
     argument, if provided, or left unmodified, otherwise.

mlir/include/mlir/Dialect/Vector/Interfaces/CMakeLists.txt

-add_mlir_interface(MaskingInterfaces)
+add_mlir_interface(MaskableOpInterface)
+add_mlir_interface(MaskingOpInterface)

mlir/include/mlir/Dialect/Vector/Interfaces/MaskableOpInterface.h

+//===- MaskableOpInterface.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 implements the MaskableOpInterface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_VECTOR_INTERFACES_MASKABLEOPINTERFACE_H_
+#define MLIR_DIALECT_VECTOR_INTERFACES_MASKABLEOPINTERFACE_H_
+
+#include "mlir/Dialect/Vector/Interfaces/MaskingOpInterface.h"
+#include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/OpDefinition.h"
+
+// Include the generated interface declarations.
+#include "mlir/Dialect/Vector/Interfaces/MaskableOpInterface.h.inc"
+
+#endif // MLIR_DIALECT_VECTOR_INTERFACES_MASKABLEOPINTERFACE_H_

mlir/include/mlir/Dialect/Vector/Interfaces/MaskableOpInterface.td

+//===- MaskableOpInterfaces.td - Masking Interfaces Decls  -*- tablegen -*-===//
+//
+// 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 is the definition file for the MaskableOpInterface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_VECTOR_INTERFACES_MASKABLEOPINTERFACE_TD
+#define MLIR_DIALECT_VECTOR_INTERFACES_MASKABLEOPINTERFACE_TD
+
+include "mlir/IR/OpBase.td"
+
+def MaskableOpInterface : OpInterface<"MaskableOpInterface"> {
+  let description = [{
+    The 'MaskableOpInterface' defines an operation that can be masked using a
+    MaskingOpInterface (e.g., `vector.mask`) and provides information about its
+    masking constraints and semantics.
+  }];
+  let cppNamespace = "::mlir::vector";
+  let methods = [
+    InterfaceMethod<
+    /*desc=*/"Returns true if the operation is masked by a MaskingOpInterface.",
+    /*retTy=*/"bool",
+    /*methodName=*/"isMasked",
+    /*args=*/(ins),
+    /*methodBody=*/"",
+    /*defaultImplementation=*/[{
+      return mlir::isa<mlir::vector::MaskingOpInterface>($_op->getParentOp());
+    }]>,
+    InterfaceMethod<
+    /*desc=*/"Returns the MaskingOpInterface masking this operation.",
+    /*retTy=*/"mlir::vector::MaskingOpInterface",
+    /*methodName=*/"getMaskingOp",
+    /*args=*/(ins),
+    /*methodBody=*/"",
+    /*defaultImplementation=*/[{
+      return mlir::cast<mlir::vector::MaskingOpInterface>($_op->getParentOp());
+    }]>,
+    InterfaceMethod<
+    /*desc=*/"Returns true if the operation can have a passthru argument when "
+             "masked.",
+    /*retTy=*/"bool",
+    /*methodName=*/"supportsPassthru",
+    /*args=*/(ins),
+    /*methodBody=*/"",
+    /*defaultImplementation=*/[{
+      return false;
+    }]>,
+    InterfaceMethod<
+    /*desc=*/"Returns the mask type expected by this operation. It requires "
+             "the operation to be vectorized.",
+    /*retTy=*/"mlir::VectorType",
+    /*methodName=*/"getExpectedMaskType",
+    /*args=*/(ins),
+    /*methodBody=*/"",
+    /*defaultImplementation=*/[{
+    // Default implementation is only aimed for operations that implement the
+    // `getVectorType()` method.
+      return $_op.getVectorType().cloneWith(
+        /*shape=*/llvm::None, IntegerType::get($_op.getContext(), /*width=*/1));
+    }]>,
+  ];
+}
+
+#endif // MLIR_DIALECT_VECTOR_INTERFACES_MASKABLEOPINTERFACE_TD

mlir/include/mlir/Dialect/Vector/Interfaces/MaskingInterfaces.td

-//===- MaskingInterfaces.td - Masking Interfaces Decls === -*- tablegen -*-===//
-//
-// 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 is the definition file for vector masking related interfaces.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_DIALECT_VECTOR_INTERFACES_MASKINGINTERFACES
-#define MLIR_DIALECT_VECTOR_INTERFACES_MASKINGINTERFACES
-
-include "mlir/IR/OpBase.td"
-
-def MaskableOpInterface : OpInterface<"MaskableOpInterface"> {
-  let description = [{
-    The 'MaskableOpInterface' define an operation that can be masked using the
-    `vector.mask` operation and provides information about its masking
-    constraints and semantics.
-  }];
-  let cppNamespace = "::mlir::vector";
-  let methods = [
-    InterfaceMethod<
-    /*desc=*/"Returns true if the operation may have a passthru argument when"
-             " masked.",
-    /*retTy=*/"bool",
-    /*methodName=*/"supportsPassthru",
-    /*args=*/(ins),
-    /*methodBody=*/"",
-    /*defaultImplementation=*/[{
-      return false;
-    }]>,
-    InterfaceMethod<
-    /*desc=*/"Returns the mask type expected by this operation. It requires the"
-             " operation to be vectorized.",
-    /*retTy=*/"mlir::VectorType",
-    /*methodName=*/"getExpectedMaskType",
-    /*args=*/(ins),
-    /*methodBody=*/"",
-    /*defaultImplementation=*/[{
-    // Default implementation is only aimed for operations that implement the
-    // `getVectorType()` method.
-      return $_op.getVectorType().cloneWith(
-        /*shape=*/llvm::None, IntegerType::get($_op.getContext(), /*width=*/1));
-    }]>,
-  ];
-}
-
-#endif // MLIR_DIALECT_VECTOR_INTERFACES_MASKINGINTERFACES

mlir/include/mlir/Dialect/Vector/Interfaces/MaskingOpInterface.h

-//===- MaskingInterfaces.h - Masking interfaces ---------------------------===//
+//===- MaskingOpInterface.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 implements the interfaces for masking operations.
+// This file implements the MaskingOpInterface.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_VECTOR_INTERFACES_MASKINGINTERFACES_H_
-#define MLIR_DIALECT_VECTOR_INTERFACES_MASKINGINTERFACES_H_
+#ifndef MLIR_DIALECT_VECTOR_INTERFACES_MASKINGOPINTERFACE_H_
+#define MLIR_DIALECT_VECTOR_INTERFACES_MASKINGOPINTERFACE_H_
 
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpDefinition.h"
 
-/// Include the generated interface declarations.
-#include "mlir/Dialect/Vector/Interfaces/MaskingInterfaces.h.inc"
+// Include the generated interface declarations.
+#include "mlir/Dialect/Vector/Interfaces/MaskingOpInterface.h.inc"
 
-#endif // MLIR_DIALECT_VECTOR_INTERFACES_MASKINGINTERFACES_H_
+#endif // MLIR_DIALECT_VECTOR_INTERFACES_MASKINGOPINTERFACE_H_

mlir/include/mlir/Dialect/Vector/Interfaces/MaskingOpInterface.td

+//===- MaskingOpInterfaces.td - MaskingOpInterface Decls = -*- tablegen -*-===//
+//
+// 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 is the definition file for the MaskingOpInterface.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_VECTOR_INTERFACES_MASKINGOPINTERFACE_TD
+#define MLIR_DIALECT_VECTOR_INTERFACES_MASKINGOPINTERFACE_TD
+
+include "mlir/IR/OpBase.td"
+
+def MaskingOpInterface : OpInterface<"MaskingOpInterface"> {
+  let description = [{
+    The 'MaskingOpInterface' defines an vector operation that can apply masking
+    to its own or other vector operations.
+  }];
+  let cppNamespace = "::mlir::vector";
+  let methods = [
+    InterfaceMethod<
+    /*desc=*/"Returns the mask value of this masking operation.",
+    /*retTy=*/"mlir::Value",
+    /*methodName=*/"getMask",
+    /*args=*/(ins),
+    /*methodBody=*/"",
+    /*defaultImplementation=*/"">,
+    InterfaceMethod<
+    /*desc=*/"Returns the operation masked by this masking operation.",
+    // TODO: Return a MaskableOpInterface when interface infra can handle
+    // dependences between interfaces.
+    /*retTy=*/"Operation *",
+    /*methodName=*/"getMaskableOp",
+    /*args=*/(ins),
+    /*methodBody=*/"",
+    /*defaultImplementation=*/"">,
+    InterfaceMethod<
+    /*desc=*/"Returns true if the masking operation has a passthru value.",
+    /*retTy=*/"bool",
+    /*methodName=*/"hasPassthru",
+    /*args=*/(ins),
+    /*methodBody=*/"",
+    /*defaultImplementation=*/"">,
+    InterfaceMethod<
+    /*desc=*/"Returns the passthru value of this masking operation.",
+    /*retTy=*/"mlir::Value",
+    /*methodName=*/"getPassthru",
+    /*args=*/(ins),
+    /*methodBody=*/"",
+    /*defaultImplementation=*/"">,
+  ];
+}
+
+#endif // MLIR_DIALECT_VECTOR_INTERFACES_MASKINGOPINTERFACE_TD

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

 add_mlir_dialect_library(MLIRVectorDialect
   VectorOps.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Vector/IR
 
   DEPENDS
   MLIRVectorOpsIncGen
   MLIRVectorOpsEnumsIncGen
 
   LINK_LIBS PUBLIC
   MLIRArithDialect
   MLIRControlFlowInterfaces
   MLIRDataLayoutInterfaces
   MLIRDialectUtils
   MLIRIR
-  MLIRMaskingInterfaces
+  MLIRMaskableOpInterface
+  MLIRMaskingOpInterface
   MLIRMemRefDialect
   MLIRSideEffectInterfaces
   MLIRTensorDialect
   MLIRVectorInterfaces
   )

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

if (passthru) {
 
     if (passthru.getType() != maskableOp->getResultTypes()[0])
       return emitOpError("expects passthru type to match result type");
   }
 
   return success();
 }
 
+// MaskingOpInterface definitions.
+
+/// Returns the operation masked by this 'vector.mask'.
+Operation *MaskOp::getMaskableOp() { return &getMaskRegion().front().front(); }
+
+/// Returns true if 'vector.mask' has a passthru value.
+bool MaskOp::hasPassthru() { return getPassthru() != Value(); }
+
 //===----------------------------------------------------------------------===//
 // ScanOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult ScanOp::verify() {
   VectorType srcType = getSourceType();
   VectorType initialType = getInitialValueType();
   // Check reduction dimension < rank.

mlir/lib/Dialect/Vector/Interfaces/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
-  MaskingInterfaces.cpp
+  MaskableOpInterface.cpp
+  MaskingOpInterface.cpp
   )
 
 function(add_mlir_interface_library name)
   add_mlir_library(MLIR${name}
     ${name}.cpp
 
     ADDITIONAL_HEADER_DIRS
     ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/Vector/Interfaces
 
     DEPENDS
     MLIR${name}IncGen
 
     LINK_LIBS PUBLIC
     MLIRIR
     )
 endfunction(add_mlir_interface_library)
 
-add_mlir_interface_library(MaskingInterfaces)
-
+add_mlir_interface_library(MaskableOpInterface)
+add_mlir_interface_library(MaskingOpInterface)

mlir/lib/Dialect/Vector/Interfaces/MaskableOpInterface.cpp

-//===- MaskingInterfaces.cpp - Masking interfaces ----------====-*- C++ -*-===//
+//===- MaskableOpInterfaces.cpp - MaskableOpInterface Defs -====-*- C++ -*-===//
 //
 // 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/Vector/Interfaces/MaskingInterfaces.h"
+#include "mlir/Dialect/Vector/Interfaces/MaskableOpInterface.h"
+
+using namespace mlir;
+using namespace mlir::vector;
 
 //===----------------------------------------------------------------------===//
-// Masking Interfaces
+// MaskableOpInterface Defs
 //===----------------------------------------------------------------------===//
 
-/// Include the definitions of the masking interfaces.
-#include "mlir/Dialect/Vector/Interfaces/MaskingInterfaces.cpp.inc"
+#include "mlir/Dialect/Vector/Interfaces/MaskableOpInterface.cpp.inc"

mlir/lib/Dialect/Vector/Interfaces/MaskingOpInterface.cpp

-//===- MaskingInterfaces.cpp - Masking interfaces ----------====-*- C++ -*-===//
+//===- MaskingOpInterface.cpp - MaskingOpInterface Defs -----====-*- C++-*-===//
 //
 // 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/Vector/Interfaces/MaskingInterfaces.h"
+#include "mlir/Dialect/Vector/Interfaces/MaskingOpInterface.h"
+
+using namespace mlir;
+using namespace mlir::vector;
 
 //===----------------------------------------------------------------------===//
-// Masking Interfaces
+// MaskingOpInterface Defs
 //===----------------------------------------------------------------------===//
 
-/// Include the definitions of the masking interfaces.
-#include "mlir/Dialect/Vector/Interfaces/MaskingInterfaces.cpp.inc"
+#include "mlir/Dialect/Vector/Interfaces/MaskingOpInterface.cpp.inc"

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

cc_library(
     includes = ["include"],
     deps = [
         ":ArithDialect",
         ":ArithUtils",
         ":ControlFlowInterfaces",
         ":DialectUtils",
         ":IR",
         ":InferTypeOpInterface",
-        ":MaskingInterfaces",
+        ":MaskableOpInterface",
+        ":MaskingOpInterface",
         ":MemRefDialect",
         ":SideEffectInterfaces",
         ":Support",
         ":TensorDialect",
         ":VectorInterfaces",
         ":VectorOpsIncGen",
         ":ViewLikeInterface",
         "//llvm:Support",
cc_library(
     ],
 )
 
 ##---------------------------------------------------------------------------##
 # Vector dialect.
 ##---------------------------------------------------------------------------##
 
 td_library(
-    name = "MaskingInterfacesTdFiles",
-    srcs = ["include/mlir/Dialect/Vector/Interfaces/MaskingInterfaces.td"],
+    name = "MaskingOpInterfaceTdFiles",
+    srcs = ["include/mlir/Dialect/Vector/Interfaces/MaskingOpInterface.td"],
+    includes = ["include"],
+    deps = [":OpBaseTdFiles"],
+)
+
+td_library(
+    name = "MaskableOpInterfaceTdFiles",
+    srcs = ["include/mlir/Dialect/Vector/Interfaces/MaskableOpInterface.td"],
     includes = ["include"],
     deps = [":OpBaseTdFiles"],
 )
 
 td_library(
     name = "VectorOpsTdFiles",
     srcs = ["include/mlir/Dialect/Vector/IR/VectorOps.td"],
     includes = ["include"],
     deps = [
         ":ControlFlowInterfacesTdFiles",
         ":InferTypeOpInterfaceTdFiles",
-        ":MaskingInterfacesTdFiles",
+        ":MaskableOpInterfaceTdFiles",
+        ":MaskingOpInterfaceTdFiles",
         ":OpBaseTdFiles",
         ":SideEffectInterfacesTdFiles",
         ":VectorInterfacesTdFiles",
         ":ViewLikeInterfaceTdFiles",
     ],
 )
 
 gentbl_cc_library(
-    name = "MaskingInterfacesIncGen",
+    name = "MaskableOpInterfaceIncGen",
     strip_include_prefix = "include",
     tbl_outs = [
         (
             ["-gen-op-interface-decls"],
-            "include/mlir/Dialect/Vector/Interfaces/MaskingInterfaces.h.inc",
+            "include/mlir/Dialect/Vector/Interfaces/MaskableOpInterface.h.inc",
         ),
         (
             ["-gen-op-interface-defs"],
-            "include/mlir/Dialect/Vector/Interfaces/MaskingInterfaces.cpp.inc",
+            "include/mlir/Dialect/Vector/Interfaces/MaskableOpInterface.cpp.inc",
         ),
     ],
     tblgen = ":mlir-tblgen",
-    td_file = "include/mlir/Dialect/Vector/Interfaces/MaskingInterfaces.td",
-    deps = [":MaskingInterfacesTdFiles"],
+    td_file = "include/mlir/Dialect/Vector/Interfaces/MaskableOpInterface.td",
+    deps = [":MaskableOpInterfaceTdFiles"],
+)
+
+gentbl_cc_library(
+    name = "MaskingOpInterfaceIncGen",
+    strip_include_prefix = "include",
+    tbl_outs = [
+        (
+            ["-gen-op-interface-decls"],
+            "include/mlir/Dialect/Vector/Interfaces/MaskingOpInterface.h.inc",
+        ),
+        (
+            ["-gen-op-interface-defs"],
+            "include/mlir/Dialect/Vector/Interfaces/MaskingOpInterface.cpp.inc",
+        ),
+    ],
+    tblgen = ":mlir-tblgen",
+    td_file = "include/mlir/Dialect/Vector/Interfaces/MaskingOpInterface.td",
+    deps = [":MaskingOpInterfaceTdFiles"],
 )
 
 gentbl_cc_library(
     name = "VectorOpsIncGen",
     strip_include_prefix = "include",
     tbl_outs = [
         (
             ["-gen-op-decls"],
tbl_outs = [
         ),
     ],
     tblgen = ":mlir-tblgen",
     td_file = "include/mlir/Dialect/Vector/IR/VectorOps.td",
     deps = [":VectorOpsTdFiles"],
 )
 
 cc_library(
-    name = "MaskingInterfaces",
-    srcs = ["lib/Dialect/Vector/Interfaces/MaskingInterfaces.cpp"],
-    hdrs = ["include/mlir/Dialect/Vector/Interfaces/MaskingInterfaces.h"],
+    name = "MaskableOpInterface",
+    srcs = ["lib/Dialect/Vector/Interfaces/MaskableOpInterface.cpp"],
+    hdrs = ["include/mlir/Dialect/Vector/Interfaces/MaskableOpInterface.h"],
+    includes = ["include"],
+    deps = [
+        ":IR",
+        ":MaskableOpInterfaceIncGen",
+        ":MaskingOpInterface",
+        ":Support",
+        "//llvm:Support",
+    ],
+)
+
+cc_library(
+    name = "MaskingOpInterface",
+    srcs = ["lib/Dialect/Vector/Interfaces/MaskingOpInterface.cpp"],
+    hdrs = ["include/mlir/Dialect/Vector/Interfaces/MaskingOpInterface.h"],
     includes = ["include"],
     deps = [
         ":IR",
-        ":MaskingInterfacesIncGen",
+        ":MaskingOpInterfaceIncGen",
         ":Support",
         "//llvm:Support",
     ],
 )
 
 cc_library(
     name = "VectorToLLVM",
     srcs = glob([