[mlir][LLVM] Allow scalable vectors in ShuffleVectorOp

[jsetoain]

Summary

The current implementation of ShuffleVectorOp assumes all vectors are
scalable. LLVM IR allows shufflevector operations on scalable vectors,
and the current translation between LLVM Dialect and LLVM IR does the
rigth thing when the shuffle mask is all zeroes. This is required to
do a splat operation on a scalable vector, but it doesn't make sense
for scalable vectors outside of that operation, i.e.: with non-all zero
masks.

[jsetoain]

This is a WiP for now. This patch comes with an issues I'd like to discuss (and fix) before it gets approved. The discussion thread is: Llvm.shufflevector operations for scalable vectors

[jsetoain]

Rebase on main

[jsetoain]

Add constraint for shuffles on scalable vectors

[aartbik]

looks good, except the error reported in verify

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

1949

I don't quite understand the error text (starting with "on").
Can you please rephrase?

[jsetoain]

Change error message

[jsetoain]

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

1949

In the end, the output would be something like "llvm.shufflevector` op on scalable vectors...", but you are right, I shouldn't abuse error handling like that. Phrasing still feels a bit awkward to me, but I hope it's clearer this way.

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 // Printing/parsing for LLVM::ShuffleVectorOp.
 //===----------------------------------------------------------------------===//
 // Expects vector to be of wrapped LLVM vector type and position to be of
 // wrapped LLVM i32 type.
 void LLVM::ShuffleVectorOp::build(OpBuilder &b, OperationState &result,
                                   Value v1, Value v2, ArrayAttr mask,
                                   ArrayRef<NamedAttribute> attrs) {
   auto containerType = v1.getType();
-  auto vType = LLVM::getFixedVectorType(
-      LLVM::getVectorElementType(containerType), mask.size());
+  auto vType = LLVM::getVectorType(
+      LLVM::getVectorElementType(containerType), mask.size(),
+      containerType.cast<VectorType>().isScalable());
   build(b, result, vType, v1, v2, mask);
   result.addAttributes(attrs);
 }
 
 static void printShuffleVectorOp(OpAsmPrinter &p, ShuffleVectorOp &op) {
   p << ' ' << op.getV1() << ", " << op.getV2() << " " << op.getMask();
   p.printOptionalAttrDict(op->getAttrs(), {"mask"});
   p << " : " << op.getV1().getType() << ", " << op.getV2().getType();
if (parser.getCurrentLocation(&loc) || parser.parseOperand(v1) ||
       parser.parseColonType(typeV1) || parser.parseComma() ||
       parser.parseType(typeV2) ||
       parser.resolveOperand(v1, typeV1, result.operands) ||
       parser.resolveOperand(v2, typeV2, result.operands))
     return failure();
   if (!LLVM::isCompatibleVectorType(typeV1))
     return parser.emitError(
         loc, "expected LLVM IR dialect vector type for operand #1");
-  auto vType = LLVM::getFixedVectorType(LLVM::getVectorElementType(typeV1),
-                                        maskAttr.size());
+  auto vType =
+      LLVM::getVectorType(LLVM::getVectorElementType(typeV1), maskAttr.size(),
+                          typeV1.cast<VectorType>().isScalable());
   result.addTypes(vType);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Implementations for LLVM::LLVMFuncOp.
 //===----------------------------------------------------------------------===//
 
 // Add the entry block to the function.
 Block *LLVMFuncOp::addEntryBlock() {
   assert(empty() && "function already has an entry block");
   assert(!isVarArg() && "unimplemented: non-external variadic functions");
 
   auto *entry = new Block;
   push_back(entry);
 
   // FIXME: Allow passing in proper locations for the entry arguments.