[VectorOps] Fixed typo in lowering code

[aartbik]

Summary

(also first test CL using phabricator)

[nicolasvasilache]

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

27

Note: we use llvm::errs/outs/dbgs consistently across the codebase, not iostream

[aartbik]

This uploaded a default CL not the required CL. Abandoning.....

[merge_guards_bot]

Unit tests: pass. 61744 tests passed, 0 failed and 780 were skipped.

clang-tidy: unknown.

clang-format: pass.

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

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/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/Support/MathExtras.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
+#include <iostream>
 
 #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;
for (int64_t off = offset, e = offset + size * stride, idx = 0; off < e;
       }
       res = insertOne(rewriter, loc, extracted, res, idx);
     }
     rewriter.replaceOp(op, {res});
     return matchSuccess();
   }
 };
 
+class VectorExtractSlicesOpConversion
+    : public OpRewritePattern<ExtractSlicesOp> {
+public:
+  using OpRewritePattern<ExtractSlicesOp>::OpRewritePattern;
+
+  PatternMatchResult matchAndRewrite(ExtractSlicesOp op,
+                                     PatternRewriter &rewriter) const override {
+    auto loc = op.getLoc();
+
+    VectorType vectorType = op.getSourceVectorType();
+    unsigned rank = vectorType.getRank();
+
+    SmallVector<int64_t, 4> sizes;
+    op.getSizes(sizes);
+    SmallVector<int64_t, 4> strides;
+    op.getStrides(strides);
+
+    // Compute the number of slices in each dimension.
+    auto shape = vectorType.getShape();
+    SmallVector<int64_t, 4> dimSliceCounts(rank);
+    for (unsigned i = 0; i < rank; ++i)
+      dimSliceCounts[i] = ceilDiv(shape[i], sizes[i]);
+
+    // Compute the strides between slices in each dimension.
+    SmallVector<int64_t, 4> sliceStrides(rank);
+    sliceStrides[rank - 1] = 1;
+    for (int i = rank - 2; i >= 0; --i)
+      sliceStrides[i] = sliceStrides[i + 1] * dimSliceCounts[i + 1];
+
+    std::cout << "// Slices in each dim" << std::endl;
+    for (unsigned i = 0; i < rank; ++i)
+      std::cout << "//  " << dimSliceCounts[i] << std::endl;
+    std::cout << "// Strides in each dim" << std::endl;
+    for (unsigned i = 0; i < rank; ++i)
+      std::cout << "//  " << sliceStrides[i] << std::endl;
+
+    // For each element in the tuple, generate the proper extraction.
+    TupleType tupleType = op.getResultTupleType();
+
+    auto elemType = vectorType.getElementType();
+    Value zero = rewriter.create<ConstantOp>(loc, elemType,
+                                             rewriter.getZeroAttr(elemType));
+    Value res = rewriter.create<SplatOp>(loc, vectorType, zero);
+    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<VectorInsertStridedSliceOpDifferentRankRewritePattern,
-                  VectorInsertStridedSliceOpSameRankRewritePattern,
-                  VectorStridedSliceOpConversion>(ctx);
+  patterns
+      .insert<VectorInsertStridedSliceOpDifferentRankRewritePattern,
+              VectorStridedSliceOpConversion, VectorExtractSlicesOpConversion>(
+          ctx);
   patterns.insert<VectorBroadcastOpConversion, VectorShuffleOpConversion,
                   VectorExtractElementOpConversion, VectorExtractOpConversion,
                   VectorInsertElementOpConversion, VectorInsertOpConversion,
                   VectorOuterProductOpConversion, VectorTypeCastOpConversion,
                   VectorPrintOpConversion>(ctx, converter);
 }
 
 namespace {