[mlir][VectorOps] Implement strided_slice conversion

[nicolasvasilache]

Summary

This diff implements the progressive lowering of strided_slice to either:

1. extractelement + insertelement for the 1-D case
2. extract + optional strided_slice + insert for the n-D case.

This combines properly with the other conversion patterns to lower all the way to LLVM.

Appropriate tests are added.

[merge_guards_bot]

Unit tests: pass. 61127 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

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

[nicolasvasilache]

Add comments.

[merge_guards_bot]

Unit tests: pass. 61127 tests passed, 0 failed and 728 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

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

[andydavis1]

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

737

These will be merged with other CL, yes?

794

Same comment as other CL, comment on how recursion terminates.

[rriddle]

mlir/include/mlir/IR/Attributes.h

1472

This needs more work. Will try to respond by end of day.

[rriddle]

mlir/include/mlir/IR/Attributes.h

1472

(sorry for the delay)

I would move the iterator, and anything related, to ArrayAttr itself. This is cluttering the global mlir namespace, which is something that we shouldn't do in general. I would imagine that we would have some 'get*<>' method on ArrayAttr that would hide this from the user(similarly to how we do for DenseElementsAttr). For the default behavior, many attributes already have a 'getValue' method which could be used directly. Otherwise, we could just return the derived attribute itself.

[nicolasvasilache]

Address review comments.

[nicolasvasilache]

Format.

[nicolasvasilache]

mlir/include/mlir/IR/Attributes.h

1472

getValue returns APInt so that does not work out of the box.
Returning an iterator over just the cast attribute to the proper type which simplifies the API.
Unpacking into the raw underlying type in the client where I have to materialize anyway.

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

737

yes, the other CL rebases on this.

[nicolasvasilache]

Drop spurious forward declaration.

[merge_guards_bot]

Unit tests: pass. 61305 tests passed, 0 failed and 736 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

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

[merge_guards_bot]

Unit tests: pass. 61305 tests passed, 0 failed and 736 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

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

[ftynse]

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

729

Why default 1 here, it's not obvious to me that getI64SubArray(attr) will drop the first element.

733

You need a range check, otherwise you risk reserving huge spaces when you drop more elements that you have due to unsigned arithmetic.

736

Would it->getValue() work ?

740

Please document this

803

What will happen to the operations we already inserted or deleted if we fail after modifying the IR? Have you tried it?

[nicolasvasilache]

Address review comments.

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

736

Unfortunately no, it hits the following error:

llvm/include/llvm/ADT/iterator.h:169:34: error: taking the address of a temporary object of type 'mlir::IntegerAttr' [-Waddress-of-temporary]
  PointerT operator->() { return &static_cast<DerivedT *>(this)->operator*(); }

[nicolasvasilache]

Typo.

[merge_guards_bot]

Unit tests: pass. 61319 tests passed, 0 failed and 736 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

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

[merge_guards_bot]

Unit tests: pass. 61319 tests passed, 0 failed and 736 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

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

[aganea]

Hi,
This patch fails to build with MSVC (here building with latest Visual Studio 2019 16.4.2).
Could you possibly take a look please? Thanks!

[801/3515] Building CXX object tools\mlir\lib\Conversion\VectorToLLVM\CMakeFiles\MLIRVectorToLLVM.dir\ConvertVectorToLLVM.cpp.obj
FAILED: tools/mlir/lib/Conversion/VectorToLLVM/CMakeFiles/MLIRVectorToLLVM.dir/ConvertVectorToLLVM.cpp.obj
C:\PROGRA~2\MIB055~1\2019\PROFES~1\VC\Tools\MSVC\1424~1.283\bin\HostX64\x64\cl.EXE  /nologo /TP -DGTEST_HAS_RTTI=0 -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_HAS_EXCEPTIONS=0 -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools\mlir\lib\Conversion\VectorToLLVM -ID:\llvm-project\mlir\lib\Conversion\VectorToLLVM -Iinclude -ID:\llvm-project\llvm\include -ID:\llvm-project\mlir\include -Itools\mlir\include /DWIN32 /D_WINDOWS   /Zc:inline /Zi /Zc:strictStrings /Oi /Zc:rvalueCast /W4 -wd4141 -wd4146 -wd4244 -wd4267 -wd4291 -wd4345 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd4324 -w14062 -we4238 /MT /O2 /Ob2   -UNDEBUG  /EHs-c- /GR- -std:c++14 /showIncludes /Fotools\mlir\lib\Conversion\VectorToLLVM\CMakeFiles\MLIRVectorToLLVM.dir\ConvertVectorToLLVM.cpp.obj /Fdtools\mlir\lib\Conversion\VectorToLLVM\CMakeFiles\MLIRVectorToLLVM.dir\MLIRVectorToLLVM.pdb /FS -c D:\llvm-project\mlir\lib\Conversion\VectorToLLVM\ConvertVectorToLLVM.cpp
D:\llvm-project\mlir\include\mlir/IR/Attributes.h(234): error C2440: '<function-style-cast>': cannot convert from 'mlir::ArrayAttr::iterator' to 'mlir::ArrayAttr::attr_value_iterator<mlir::IntegerAttr>'
D:\llvm-project\mlir\include\mlir/IR/Attributes.h(234): note: No constructor could take the source type, or constructor overload resolution was ambiguous
D:\llvm-project\mlir\lib\Conversion\VectorToLLVM\ConvertVectorToLLVM.cpp(117): note: see reference to function template instantiation 'llvm::iterator_range<mlir::ArrayAttr::attr_value_iterator<mlir::IntegerAttr>> mlir::ArrayAttr::getAsRange<mlir::IntegerAttr>(void)' being compiled
D:\llvm-project\mlir\include\mlir/IR/Attributes.h(235): error C2440: '<function-style-cast>': cannot convert from 'mlir::ArrayAttr::iterator' to 'mlir::ArrayAttr::attr_value_iterator<mlir::IntegerAttr>'
D:\llvm-project\mlir\include\mlir/IR/Attributes.h(235): note: No constructor could take the source type, or constructor overload resolution was ambiguous
D:\llvm-project\mlir\include\mlir/IR/Attributes.h(234): error C2672: 'llvm::make_range': no matching overloaded function found
D:\llvm-project\mlir\include\mlir/IR/Attributes.h(235): error C2780: 'llvm::iterator_range<IteratorT> llvm::make_range(T,T)': expects 2 arguments - 1 provided
D:\llvm-project\llvm\include\llvm/ADT/iterator_range.h(54): note: see declaration of 'llvm::make_range'
[874/2733] Building CXX object lib\Target\AArch64\CMakeFiles\LLVMAArch64CodeGen.dir\AArch64ISelDAGToDAG.cpp.obj
ninja: build stopped: subcommand failed.

[mehdi_amini]

In D72310#1815707, @aganea wrote:

Hi,
This patch fails to build with MSVC (here building with latest Visual Studio 2019 16.4.2).

If there is no fix readily available, I'll revert in the next few hours to unbreak.

[aartbik]

In D72310#1820368, @mehdi_amini wrote:

In D72310#1815707, @aganea wrote:

Hi,
This patch fails to build with MSVC (here building with latest Visual Studio 2019 16.4.2).

If there is no fix readily available, I'll revert in the next few hours to unbreak.

Let's try to fix this. Reverting this will break some end-to-end tests that went in later.

[nicolasvasilache]

my apologies, I lost track of this and do not have an easy repro atm, Aart is taking a shot at it.

[stella.stamenova]

In D72310#1820632, @nicolasvasilache wrote:

my apologies, I lost track of this and do not have an easy repro atm, Aart is taking a shot at it.

I have a repro if you need any information. The break looks the same as what was already shared (and we're also using latest VS):

##[error]mlir\include\mlir\IR\Attributes.h(234,0): Error C2440: '<function-style-cast>': cannot convert from 'mlir::ArrayAttr::iterator' to 'mlir::ArrayAttr::attr_value_iterator<mlir::IntegerAttr>'
   304>E:\agent\_work\4\s\mlir\include\mlir/IR/Attributes.h(234): error C2440: '<function-style-cast>': cannot convert from 'mlir::ArrayAttr::iterator' to 'mlir::ArrayAttr::attr_value_iterator<mlir::IntegerAttr>' [E:\agent\_work\4\b\tools\mlir\lib\Conversion\VectorToLLVM\MLIRVectorToLLVM.vcxproj]
   394>ClCompile:
         CGStmt.cpp
   304>ClCompile:
         E:\agent\_work\4\s\mlir\include\mlir/IR/Attributes.h(234): note: No constructor could take the source type, or constructor overload resolution was ambiguous
         E:\agent\_work\4\s\mlir\lib\Conversion\VectorToLLVM\ConvertVectorToLLVM.cpp(119): note: see reference to function template instantiation 'llvm::iterator_range<mlir::ArrayAttr::attr_value_iterator<mlir::IntegerAttr>> mlir::ArrayAttr::getAsRange<mlir::IntegerAttr>(void)' being compiled
##[error]mlir\include\mlir\IR\Attributes.h(235,0): Error C2440: '<function-style-cast>': cannot convert from 'mlir::ArrayAttr::iterator' to 'mlir::ArrayAttr::attr_value_iterator<mlir::IntegerAttr>'
   304>E:\agent\_work\4\s\mlir\include\mlir/IR/Attributes.h(235): error C2440: '<function-style-cast>': cannot convert from 'mlir::ArrayAttr::iterator' to 'mlir::ArrayAttr::attr_value_iterator<mlir::IntegerAttr>' [E:\agent\_work\4\b\tools\mlir\lib\Conversion\VectorToLLVM\MLIRVectorToLLVM.vcxproj]
         E:\agent\_work\4\s\mlir\include\mlir/IR/Attributes.h(235): note: No constructor could take the source type, or constructor overload resolution was ambiguous
##[error]mlir\include\mlir\IR\Attributes.h(234,0): Error C2672: 'llvm::make_range': no matching overloaded function found
   304>E:\agent\_work\4\s\mlir\include\mlir/IR/Attributes.h(234): error C2672: 'llvm::make_range': no matching overloaded function found [E:\agent\_work\4\b\tools\mlir\lib\Conversion\VectorToLLVM\MLIRVectorToLLVM.vcxproj]
##[error]mlir\include\mlir\IR\Attributes.h(235,0): Error C2780: 'llvm::iterator_range<IteratorT> llvm::make_range(T,T)': expects 2 arguments - 1 provided
   304>E:\agent\_work\4\s\mlir\include\mlir/IR/Attributes.h(235): error C2780: 'llvm::iterator_range<IteratorT> llvm::make_range(T,T)': expects 2 arguments - 1 provided [E:\agent\_work\4\b\tools\mlir\lib\Conversion\VectorToLLVM\MLIRVectorToLLVM.vcxproj]
         E:\agent\_work\4\s\llvm\include\llvm/ADT/iterator_range.h(54): note: see declaration of 'llvm::make_range'

mlir/include/mlir/IR/Attributes.h

public:
   iterator begin() const { return getValue().begin(); }
   iterator end() const { return getValue().end(); }
   size_t size() const { return getValue().size(); }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool kindof(unsigned kind) {
     return kind == StandardAttributes::Array;
   }
+
+private:
+  /// Class for underlying value iterator support.
+  template <typename AttrTy>
+  class attr_value_iterator final
+      : public llvm::mapped_iterator<iterator, AttrTy (*)(Attribute)> {
+  public:
+    explicit attr_value_iterator(iterator it)
+        : llvm::mapped_iterator<iterator, AttrTy (*)(Attribute)>(
+              it, [](Attribute attr) { return attr.cast<AttrTy>(); }) {}
+    AttrTy operator*() { return (*this->I).template cast<AttrTy>(); }
+  };
+
+public:
+  template <typename AttrTy>
+  llvm::iterator_range<attr_value_iterator<AttrTy>> getAsRange() {
+    return llvm::make_range(attr_value_iterator<AttrTy>(begin()),
+                            attr_value_iterator<AttrTy>(end()));
+  }
 };
 
 //===----------------------------------------------------------------------===//
 // BoolAttr
 //===----------------------------------------------------------------------===//
 
 class BoolAttr : public Attribute::AttrBase<BoolAttr, Attribute,
                                             detail::BoolAttributeStorage> {
struct PointerLikeTypeTraits<mlir::SymbolRefAttr>
   static inline mlir::SymbolRefAttr getFromVoidPointer(void *ptr) {
     return PointerLikeTypeTraits<mlir::Attribute>::getFromVoidPointer(ptr)
         .cast<mlir::SymbolRefAttr>();
   }
 };
 
 } // namespace llvm
 
 #endif

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

 //===- VectorToLLVM.cpp - Conversion from Vector to the LLVM dialect ------===//
 //
 // Part of the MLIR Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
 #include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
-#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/StandardOps/Ops.h"
 #include "mlir/Dialect/VectorOps/VectorOps.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace mlir;
+using namespace mlir::vector;
 
 template <typename T>
 static LLVM::LLVMType getPtrToElementType(T containerType,
                                           LLVMTypeConverter &lowering) {
   return lowering.convertType(containerType.getElementType())
       .template cast<LLVM::LLVMType>()
       .getPointerTo();
 }
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", {});
   }
 };
 
+// TODO(rriddle): Better support for attribute subtype forwarding + slicing.
+static SmallVector<int64_t, 4> getI64SubArray(ArrayAttr arrayAttr,
+                                              unsigned dropFront = 0,
+                                              unsigned dropBack = 0) {
+  assert(arrayAttr.size() > dropFront + dropBack && "Out of bounds");
+  auto range = arrayAttr.getAsRange<IntegerAttr>();
+  SmallVector<int64_t, 4> res;
+  res.reserve(arrayAttr.size() - dropFront - dropBack);
+  for (auto it = range.begin() + dropFront, eit = range.end() - dropBack;
+       it != eit; ++it)
+    res.push_back((*it).getValue().getSExtValue());
+  return res;
+}
+
+/// Emit the proper `ExtractOp` or `ExtractElementOp` depending on the rank
+/// of `vector`.
+static Value extractOne(PatternRewriter &rewriter, Location loc, Value vector,
+                        int64_t offset) {
+  auto vectorType = vector.getType().cast<VectorType>();
+  if (vectorType.getRank() > 1)
+    return rewriter.create<ExtractOp>(loc, vector, offset);
+  return rewriter.create<vector::ExtractElementOp>(
+      loc, vectorType.getElementType(), vector,
+      rewriter.create<ConstantIndexOp>(loc, offset));
+}
+
+/// Emit the proper `InsertOp` or `InsertElementOp` depending on the rank
+/// of `vector`.
+static Value insertOne(PatternRewriter &rewriter, Location loc, Value from,
+                       Value into, int64_t offset) {
+  auto vectorType = into.getType().cast<VectorType>();
+  if (vectorType.getRank() > 1)
+    return rewriter.create<InsertOp>(loc, from, into, offset);
+  return rewriter.create<vector::InsertElementOp>(
+      loc, vectorType, from, into,
+      rewriter.create<ConstantIndexOp>(loc, offset));
+}
+
+/// 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 VectorStridedSliceOpRewritePattern
+    : 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();
+  }
+};
+
 /// 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<VectorStridedSliceOpRewritePattern>(ctx);
   patterns.insert<VectorBroadcastOpConversion, VectorShuffleOpConversion,
                   VectorExtractElementOpConversion, VectorExtractOpConversion,
                   VectorInsertElementOpConversion, VectorInsertOpConversion,
                   VectorOuterProductOpConversion, VectorTypeCastOpConversion,
-                  VectorPrintOpConversion>(converter.getDialect()->getContext(),
-                                           converter);
+                  VectorPrintOpConversion>(ctx, converter);
 }
 
 namespace {
 struct LowerVectorToLLVMPass : public ModulePass<LowerVectorToLLVMPass> {
   void runOnModule() override;
 };
 } // namespace
 

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

 //       CHECK:    llvm.call @print_f32(%[[x7]]) : (!llvm.float) -> ()
 //       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(
+  
+  %0 = vector.strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32>
+//       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>
+//       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>
+//       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.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 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<"<8 x float>">
+//       CHECK:    llvm.mlir.constant(1 : index) : !llvm.i64
+//       CHECK:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
+//       CHECK:    llvm.insertvalue {{.*}}, {{.*}}[0] : !llvm<"[2 x <2 x float>]">
+//
+// Subvector vector<8xf32> @3
+//       CHECK:    llvm.extractvalue {{.*}}[3] : !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.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 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<"<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
+}
+
+