[mlir] [VectorOps] Lowering of vector.extract/insert_slices to LLVM IR

[aartbik]

Summary

Uses progressive lowering to convert vector.extract_slices and vector_insert_slices to equivalent vector operations that can be subsequently lowered into LLVM.

[merge_guards_bot]

Unit tests: pass. 61804 tests passed, 0 failed and 781 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[nicolasvasilache]

Please provide much more explanation in the commit message because the progressive lowering behavior may be unexpected for most people.

Nothing profound in my comments, just some things I think we should reorganize to keep our house in order.
This looks great, thanks Aart for pushing this forward!

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

899

This looks more like a rewrite / folding pattern than a conversion to me (i.e. the types don't change).
I would prob go for a folding pattern in VectorOps.cpp but we also need to make sure it is accessible and
In any case please document with a before / after IR example.

900

Well on second inspection you already have that in the VectorToVectorOps conversion.
So please don't duplicate here and just make the vectorToVector canonicalization patterns "insert" the "foldingPatterns".

Structurally this is also an indication that VectorToLLVM should start including all the VectorToVector rewrites so that things compose properly.

910

We should assert(operands[0].getDefiningOp is non-null.
In the current design, tuples do not pass function boundaries and do not lower to LLVMIR so we want to fail hard so use cases pop up and we can reevaluate the decision with concrete evidence.

Please also make sure the message is informative enough to surface the context I just explained.

At that point, the whole things should look like:

assert(...);
rewriter.replaceOp(cast<...>);
return matchSuccess();

i.e. no need to dyn_cast + check, this is guaranteed by the pattern rewrite infra.

919

Doc please, with before / after IR.

929

Yes that is hacky indeed :)

You could just return failure if the uses are not empty:

if (!op->getResult()->use_empty())
  return matchFailure();

The pattern will fail to apply until all canonicalizations occured at which point it will apply.
This will also error out gracefully by using the pattern rewrite infrastructure and fail a "full conversion" if things don't canonicalize.

952

Very cool, yay intuition :) !

Same comments as above apply still: bit more doc with before/after IR.
I may not have set a good example myself here in the past, sorry about that!
As the number of patterns grow we want short and intuitive examples to just get what these do without going deep in code.

Also, this should go through VectorToVector patterns and be included in the VectorToLLVM patterns (e.g. what if the target is not LLVM, some of our friends at Xilinx seem to be in this case for example).

976

Strides is probably become overloaded, maybe we should rename strided_slice and insert_strided_slice as Insert/ExtractSlice and these ops as Insert/ExtractSliceTuple or something along those lines?
In particular the stride attribute is not really a stride but a step.

In any case, we should have help functions for computing this.
Could you please reuse/refactor/adapt the first functions in VectorTransforms.cpp and move the to VectorOps/Utils.h as appropriate?
Thanks!

987

We should have help functions for computing this.
Could you please reuse/refactor/adapt the first functions in VectorTransforms.cpp and move the to VectorOps/Utils.h as appropriate?
Thanks!

1007

Great, hooray for progressive lowering and pattern/canonicalization compositions !

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1701 ↗

(On Diff #238363)

This can be called directly from other getXXXPatterns that want to use it, no need to duplicate the pattern.

mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir

548

This should be made into a VectorToVector test, that more directly tests "extract_slices" -> "strided_slices" + the removal of the tuple op.
Atm it tests too much at a distance and involves multiple patterns coming together.
Testing those patterns coming together could be done in a separate test pass where canonicalization, DCE and pattern interaction would kick in too and many things would get simplified.

[aartbik]

addressed comments

[aartbik]

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

899

Agreed in isolation, but since we introduce vector.tuple in other rewritings, I really need a ConversionPattern here, so that I see the newly introduced operands.

900

I avoided the duplication for now by just having the lowering change. Once we have a proper vector2vector rewriting, we can move it into folding again and populate.

929

Two complications I added to the comments. For newly introduced tuples, neither the op nor the op.getResult use_empty call is up-to-date (it is always empty). However, since this is a lowering pass, such new nodes need to be legalized anyway, so removing them is the right way. We still could assert if our rules somehow introduce a tuple we don't consume.

952

It sounds like we really need to move some of this into a vector to vector pass. That will also avoid some of the complications above.

976

I see similar TODOs elsewhere, so let's postpone that into one CL later.

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1701 ↗

(On Diff #238363)

For now I do everything in lowering, leaving proper interaction with folding/canonicalization for later.

mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir

548

I agree. Once we have a proper vector to vector pass, we should test this (and others) in intermediate stages too.

[rriddle]

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

899

// -> ///

924

getOperand(tupleGetOp.getIndex())

931

Same here.

940

Note, we don't run DCE during dialect conversion.

1016

replaceOpWithNewOp?

[merge_guards_bot]

Unit tests: pass. 61909 tests passed, 0 failed and 782 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[aartbik]

addressed comments

[aartbik]

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

940

I was under the impression we may introduce that in the future. Rephrased this a bit.

[nicolasvasilache]

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

976

I think with the changes and proto we discussed offline, this will change significantly before landing?
I can't remember whether you'll still need to use existing utils.

Marking as "request changes" until we see the new E2E impl.

[aartbik]

Lowering of vector.extract/insert_slices to LLVM IR

[aartbik]

PTAL

This new approach directly uses the canonicalization for vector.tuple_get on a tuple (so no need to dup the rule!). Furthermore, by using the vector to vector rewriting prior to the lowering, the introduction of a vector tuple is completely transparent, since subsequent rewriting removes them again. An additional advantage is that we get DCE for free, so need to introduce a DCE for just vector.tuple. The introduction of DCE forced me to fix a few test cases with dead code (good to do that anyway).

Note, since this code is much more structured, I also introduced vector.insert_slices in addition to vector_extract_slices, so that the final mechanism becomes more apparent.

[merge_guards_bot]

Unit tests: pass. 62017 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[aartbik]

fixed a few minor typos

[merge_guards_bot]

Unit tests: pass. 62017 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[rriddle]

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1699 ↗

(On Diff #239447)

This should just be in the 'fold' method instead of a canonicalization pattern.

[rriddle]

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1699 ↗

(On Diff #239447)

'fold' should be used whenever possible because it is applicable in many more places, e.g. during dialect conversion and OpBuilder::createOrFold.

[rriddle]

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1699 ↗

(On Diff #239447)

Also, please split this out into a different revision as this is unrelated.

[aartbik]

sounds good, one question though

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1699 ↗

(On Diff #239447)

I followed the other "canonicalization" patterns in VectorOps. Just for my own understanding, should these strictly speaking have been written as folders too (the name "Folder" seems to imply that)?

[aartbik]

sounds good, one question though

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1699 ↗

(On Diff #239447)

Other question, isn't fold for constants only? Here the tuple itself does not need to be constant, the only thing that matters is that get-on-tuple becomes a pass through of the value at the corresponding index?

[andydavis1]

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

1072

We need a TODO to move this code into a VectorOpsUtils class, we have various versions of it floating around in VectorOps.cp and VectorTransforms.cpp

[rriddle]

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1699 ↗

(On Diff #239447)

fold has a slightly different contract than canonicalization patterns, and can be used (generally) for the following:

• In-place canonicalization
• Folding to an existing SSA value(does not have to be constant)
• Folding to an attribute value

So with that being said, if the canonicalization relies on creating new operations then it must use a pattern.

[aartbik]

Hold off on reviewing this CL, since it will be broken up in three.
The final remaining part for the lowering will be super small :=)

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

1072

The TODO is already there, see line 1038

[mehdi_amini]

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1699 ↗

(On Diff #239447)

River: do we have a doc on this? Seems like potentially a good entry for the FAQ otherwise?

[aartbik]

mlir/lib/Dialect/VectorOps/VectorOps.cpp

1699 ↗

(On Diff #239447)

In particular, it was not immediately apparent to me that we *always* call fold(), passing in constants as arguments when available, but also allowing access to the non-constant operands through the regular getters (giving it potentially "two sources of truth"). Now that I have working, it makes sense, but a bit more API doc would have been helpful.

[aartbik]

integrate new lowering mechanism in LLVM lowering

[aartbik]

PTAL (note, this will not build yet, but it shows how small this CL has become by defining the progressive lowering in a separate patterns)

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: fail. clang-tidy found 2 errors and 0 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[aartbik]

synced with latest update

[aartbik]

\o/ yeah, it has been a long road, but PTAL

this CL is much, much smaller now; extra test added, and rewritten some existing tests to ensure code is not dead on entry

[merge_guards_bot]

Unit tests: pass. 62194 tests passed, 0 failed and 815 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

private:
   Operation *getPrintComma(Operation *op) const {
     return getPrint(op, lowering.getDialect(), "print_comma", {});
   }
   Operation *getPrintNewline(Operation *op) const {
     return getPrint(op, lowering.getDialect(), "print_newline", {});
   }
 };
 
 /// Progressive lowering of StridedSliceOp to either:
 ///   1. extractelement + insertelement for the 1-D case
 ///   2. extract + optional strided_slice + insert for the n-D case.
 class VectorStridedSliceOpConversion : public OpRewritePattern<StridedSliceOp> {
 public:
   using OpRewritePattern<StridedSliceOp>::OpRewritePattern;
 
   PatternMatchResult matchAndRewrite(StridedSliceOp op,
                                      PatternRewriter &rewriter) const override {
     auto dstType = op.getResult().getType().cast<VectorType>();
 
     assert(!op.offsets().getValue().empty() && "Unexpected empty offsets");
 
     int64_t offset =
         op.offsets().getValue().front().cast<IntegerAttr>().getInt();
     int64_t size = op.sizes().getValue().front().cast<IntegerAttr>().getInt();
     int64_t stride =
         op.strides().getValue().front().cast<IntegerAttr>().getInt();
 
     auto loc = op.getLoc();
     auto elemType = dstType.getElementType();
     assert(elemType.isIntOrIndexOrFloat());
     Value zero = rewriter.create<ConstantOp>(loc, elemType,
                                              rewriter.getZeroAttr(elemType));
     Value res = rewriter.create<SplatOp>(loc, dstType, zero);
     for (int64_t off = offset, e = offset + size * stride, idx = 0; off < e;
          off += stride, ++idx) {
       Value extracted = extractOne(rewriter, loc, op.vector(), off);
       if (op.offsets().getValue().size() > 1) {
         StridedSliceOp stridedSliceOp = rewriter.create<StridedSliceOp>(
             loc, extracted, getI64SubArray(op.offsets(), /* dropFront=*/1),
             getI64SubArray(op.sizes(), /* dropFront=*/1),
             getI64SubArray(op.strides(), /* dropFront=*/1));
         // Call matchAndRewrite recursively from within the pattern. This
         // circumvents the current limitation that a given pattern cannot
         // be called multiple times by the PatternRewrite infrastructure (to
         // avoid infinite recursion, but in this case, infinite recursion
         // cannot happen because the rank is strictly decreasing).
         // TODO(rriddle, nicolasvasilache) Implement something like a hook for
         // a potential function that must decrease and allow the same pattern
         // multiple times.
         auto success = matchAndRewrite(stridedSliceOp, rewriter);
         (void)success;
         assert(success && "Unexpected failure");
         extracted = stridedSliceOp;
       }
       res = insertOne(rewriter, loc, extracted, res, idx);
     }
     rewriter.replaceOp(op, {res});
     return matchSuccess();
   }
 };
 
 } // namespace
 
 /// Populate the given list with patterns that convert from Vector to LLVM.
 void mlir::populateVectorToLLVMConversionPatterns(
     LLVMTypeConverter &converter, OwningRewritePatternList &patterns) {
   MLIRContext *ctx = converter.getDialect()->getContext();
   patterns.insert<VectorInsertStridedSliceOpDifferentRankRewritePattern,
                   VectorInsertStridedSliceOpSameRankRewritePattern,
                   VectorStridedSliceOpConversion>(ctx);
   patterns.insert<VectorBroadcastOpConversion, VectorShuffleOpConversion,
                   VectorExtractElementOpConversion, VectorExtractOpConversion,
                   VectorInsertElementOpConversion, VectorInsertOpConversion,
                   VectorOuterProductOpConversion, VectorTypeCastOpConversion,
                   VectorPrintOpConversion>(ctx, converter);
 }
 
 namespace {
 struct LowerVectorToLLVMPass : public ModulePass<LowerVectorToLLVMPass> {
   void runOnModule() override;
 };
 } // namespace
 
 void LowerVectorToLLVMPass::runOnModule() {
-  // Convert to the LLVM IR dialect using the converter defined above.
+  // Perform progressive lowering of operations on "slices".
+  // Folding and DCE get rid of all non-leaking tuple ops.
+  {
     OwningRewritePatternList patterns;
+    populateVectorSlicesLoweringPatterns(patterns, &getContext());
+    applyPatternsGreedily(getModule(), patterns);
+  }
+
+  // Convert to the LLVM IR dialect.
   LLVMTypeConverter converter(&getContext());
+  OwningRewritePatternList patterns;
   populateVectorToLLVMConversionPatterns(converter, patterns);
   populateStdToLLVMConversionPatterns(converter, patterns);
 
   ConversionTarget target(getContext());
   target.addLegalDialect<LLVM::LLVMDialect>();
   target.addDynamicallyLegalOp<FuncOp>(
       [&](FuncOp op) { return converter.isSignatureLegal(op.getType()); });
   if (failed(
           applyPartialConversion(getModule(), target, patterns, &converter))) {
     signalPassFailure();
   }
 }
 
 OpPassBase<ModuleOp> *mlir::createLowerVectorToLLVMPass() {
   return new LowerVectorToLLVMPass();
 }
 
 static PassRegistration<LowerVectorToLLVMPass>
     pass("convert-vector-to-llvm",
          "Lower the operations from the vector dialect into the LLVM dialect");

mlir/test/Conversion/VectorToLLVM/vector-to-llvm.mlir

 //       CHECK:    llvm.call @print_comma() : () -> ()
 //       CHECK:    %[[x8:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
 //       CHECK:    %[[x9:.*]] = llvm.extractelement %[[x5]][%[[x8]] : !llvm.i64] : !llvm<"<2 x float>">
 //       CHECK:    llvm.call @print_f32(%[[x9]]) : (!llvm.float) -> ()
 //       CHECK:    llvm.call @print_close() : () -> ()
 //       CHECK:    llvm.call @print_close() : () -> ()
 //       CHECK:    llvm.call @print_newline() : () -> ()
 
-
-func @strided_slice(%arg0: vector<4xf32>, %arg1: vector<4x8xf32>, %arg2: vector<4x8x16xf32>) {
-// CHECK-LABEL: llvm.func @strided_slice(
+func @strided_slice1(%arg0: vector<4xf32>) -> vector<2xf32> {
   %0 = vector.strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32>
+  return %0 : vector<2xf32>
+}
+// CHECK-LABEL: llvm.func @strided_slice1
 //       CHECK:    llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
 //       CHECK:    llvm.mlir.constant(dense<0.000000e+00> : vector<2xf32>) : !llvm<"<2 x float>">
 //       CHECK:    llvm.mlir.constant(2 : index) : !llvm.i64
 //       CHECK:    llvm.extractelement %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
 //       CHECK:    llvm.mlir.constant(0 : index) : !llvm.i64
 //       CHECK:    llvm.insertelement %{{.*}}, %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
 //       CHECK:    llvm.mlir.constant(3 : index) : !llvm.i64
 //       CHECK:    llvm.extractelement %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
 //       CHECK:    llvm.mlir.constant(1 : index) : !llvm.i64
 //       CHECK:    llvm.insertelement %{{.*}}, %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
 
-  %1 = vector.strided_slice %arg1 {offsets = [2], sizes = [2], strides = [1]} : vector<4x8xf32> to vector<2x8xf32>
+func @strided_slice2(%arg0: vector<4x8xf32>) -> vector<2x8xf32> {
+  %0 = vector.strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4x8xf32> to vector<2x8xf32>
+  return %0 : vector<2x8xf32>
+}
+// CHECK-LABEL: llvm.func @strided_slice2
 //       CHECK:    llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
 //       CHECK:    llvm.mlir.constant(dense<0.000000e+00> : vector<2x8xf32>) : !llvm<"[2 x <8 x float>]">
 //       CHECK:    llvm.extractvalue %{{.*}}[2] : !llvm<"[4 x <8 x float>]">
 //       CHECK:    llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"[2 x <8 x float>]">
 //       CHECK:    llvm.extractvalue %{{.*}}[3] : !llvm<"[4 x <8 x float>]">
 //       CHECK:    llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"[2 x <8 x float>]">
 
-  %2 = vector.strided_slice %arg1 {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8xf32> to vector<2x2xf32>
+func @strided_slice3(%arg0: vector<4x8xf32>) -> vector<2x2xf32> {
+  %0 = vector.strided_slice %arg0 {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8xf32> to vector<2x2xf32>
+  return %0 : vector<2x2xf32>
+}
+// CHECK-LABEL: llvm.func @strided_slice3
 //       CHECK:    llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
 //       CHECK:    llvm.mlir.constant(dense<0.000000e+00> : vector<2x2xf32>) : !llvm<"[2 x <2 x float>]">
 //
 // Subvector vector<8xf32> @2
 //       CHECK:    llvm.extractvalue {{.*}}[2] : !llvm<"[4 x <8 x float>]">
 //       CHECK:    llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
 //       CHECK:    llvm.mlir.constant(dense<0.000000e+00> : vector<2xf32>) : !llvm<"<2 x float>">
 //       CHECK:    llvm.mlir.constant(2 : index) : !llvm.i64

 //       CHECK:    llvm.mlir.constant(0 : index) : !llvm.i64
 //       CHECK:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
 //       CHECK:    llvm.mlir.constant(3 : index) : !llvm.i64
 //       CHECK:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 x float>">
 //       CHECK:    llvm.mlir.constant(1 : index) : !llvm.i64
 //       CHECK:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
 //       CHECK:    llvm.insertvalue {{.*}}, {{.*}}[1] : !llvm<"[2 x <2 x float>]">
 
-  return
-}
-
-func @insert_strided_slice(%a: vector<2x2xf32>, %b: vector<4x4xf32>, %c: vector<4x4x4xf32>) {
-// CHECK-LABEL: @insert_strided_slice
-
+func @insert_strided_slice1(%b: vector<4x4xf32>, %c: vector<4x4x4xf32>) -> vector<4x4x4xf32> {
   %0 = vector.insert_strided_slice %b, %c {offsets = [2, 0, 0], strides = [1, 1]} : vector<4x4xf32> into vector<4x4x4xf32>
+  return %0 : vector<4x4x4xf32>
+}
+// CHECK-LABEL: @insert_strided_slice1
 //       CHECK:    llvm.extractvalue {{.*}}[2] : !llvm<"[4 x [4 x <4 x float>]]">
 //  CHECK-NEXT:    llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm<"[4 x [4 x <4 x float>]]">
 
-  %1 = vector.insert_strided_slice %a, %b {offsets = [2, 2], strides = [1, 1]} : vector<2x2xf32> into vector<4x4xf32>
+func @insert_strided_slice2(%a: vector<2x2xf32>, %b: vector<4x4xf32>) -> vector<4x4xf32> {
+  %0 = vector.insert_strided_slice %a, %b {offsets = [2, 2], strides = [1, 1]} : vector<2x2xf32> into vector<4x4xf32>
+  return %0 : vector<4x4xf32>
+}
+// CHECK-LABEL: @insert_strided_slice2
 //
 // Subvector vector<2xf32> @0 into vector<4xf32> @2
 //       CHECK:    llvm.extractvalue {{.*}}[0] : !llvm<"[2 x <2 x float>]">
 //  CHECK-NEXT:    llvm.extractvalue {{.*}}[2] : !llvm<"[4 x <4 x float>]">
 // Element @0 -> element @2
 //  CHECK-NEXT:    llvm.mlir.constant(0 : index) : !llvm.i64
 //  CHECK-NEXT:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
 //  CHECK-NEXT:    llvm.mlir.constant(2 : index) : !llvm.i64

 //  CHECK-NEXT:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
 // Element @1 -> element @3
 //  CHECK-NEXT:    llvm.mlir.constant(1 : index) : !llvm.i64
 //  CHECK-NEXT:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
 //  CHECK-NEXT:    llvm.mlir.constant(3 : index) : !llvm.i64
 //  CHECK-NEXT:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
 //  CHECK-NEXT:    llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm<"[4 x <4 x float>]">
 
-  return
-}
-
+func @extract_strides(%arg0: vector<3x3xf32>) -> vector<1x1xf32> {
+  %0 = vector.extract_slices %arg0, [2, 2], [1, 1]
+    : vector<3x3xf32> into tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>>
+  %1 = vector.tuple_get %0, 3 : tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>>
+  return %1 : vector<1x1xf32>
+}
+// CHECK-LABEL: extract_strides(%arg0: !llvm<"[3 x <3 x float>]">)
+//      CHECK: %[[s0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<1x1xf32>) : !llvm<"[1 x <1 x float>]">
+//      CHECK: %[[s1:.*]] = llvm.extractvalue %arg0[2] : !llvm<"[3 x <3 x float>]">
+//      CHECK: %[[s3:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<1xf32>) : !llvm<"<1 x float>">
+//      CHECK: %[[s4:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64
+//      CHECK: %[[s5:.*]] = llvm.extractelement %[[s1]][%[[s4]] : !llvm.i64] : !llvm<"<3 x float>">
+//      CHECK: %[[s6:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
+//      CHECK: %[[s7:.*]] = llvm.insertelement %[[s5]], %[[s3]][%[[s6]] : !llvm.i64] : !llvm<"<1 x float>">
+//      CHECK: %[[s8:.*]] = llvm.insertvalue %[[s7]], %[[s0]][0] : !llvm<"[1 x <1 x float>]">
+//      CHECK: llvm.return %[[s8]] : !llvm<"[1 x <1 x float>]">