[mlir][llvm] Fix conversion of scalable vectors of rank > 1

[c-rhodes]

Summary

Vector types of rank > 1 are converted to array(s) of vector type(s).
Arrays in LLVM cannot contain scalable vectors since the size is unknown
at compile-time, but it's currently trying to do so and creating 1-D
vector types where the number of scalable dims is greater than the rank,
triggering an assert in llvm-project/llvm/include/llvm/ADT/ArrayRef.h:255:

Assertion `Index < Length && "Invalid index!"' failed.

This patch fixes this so there's only a single scalable dim. This needs
fixing properly by adding support for converting scalable vectors of
rank > 1 to LLVM but at least now it will fail expectedly during
conversion to LLVM with:

Assertion `isValidElementType(ElementType) && "Invalid type for array
element!"' failed.

rather than with a cryptic assert.

[c-rhodes]

D153412 fixes this by removing numScalableDims.

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

 ///    `!llvm.array<ax...array<jxvector<kxT>>>`.
 Type LLVMTypeConverter::convertVectorType(VectorType type) {
   auto elementType = convertType(type.getElementType());
   if (!elementType)
     return {};
   if (type.getShape().empty())
     return VectorType::get({1}, elementType);
   Type vectorType = VectorType::get(type.getShape().back(), elementType,
-                                    type.getNumScalableDims());
+                                    type.isScalable());
   assert(LLVM::isCompatibleVectorType(vectorType) &&
          "expected vector type compatible with the LLVM dialect");
   auto shape = type.getShape();
   for (int i = shape.size() - 2; i >= 0; --i)
     vectorType = LLVM::LLVMArrayType::get(vectorType, shape[i]);
   return vectorType;
 }
 

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

 // CHECK:       %[[T1:.*]] = llvm.shufflevector %[[T0]]
 // CHECK:       %[[T2:.*]] = llvm.insertvalue %[[T1]], %{{.*}}[0] : !llvm.array<2 x vector<3xf32>>
 // CHECK:       %[[T3:.*]] = llvm.insertvalue %[[T1]], %{{.*}}[1] : !llvm.array<2 x vector<3xf32>>
 // CHECK:       %[[T4:.*]] = builtin.unrealized_conversion_cast %[[T3]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32>
 // CHECK:       return %[[T4]] : vector<2x3xf32>
 
 // -----
 
+func.func @broadcast_scalable_vec2d_from_scalar(%arg0: f32) -> vector<[2x3]xf32> {
+  %0 = vector.broadcast %arg0 : f32 to vector<[2x3]xf32>
+  return %0 : vector<[2x3]xf32>
+}
+// CHECK-LABEL: @broadcast_scalable_vec2d_from_scalar(
+// CHECK-SAME:  %[[A:.*]]: f32)
+// CHECK:       %[[T0:.*]] = llvm.insertelement %[[A]]
+// CHECK:       %[[T1:.*]] = llvm.shufflevector %[[T0]]
+// CHECK:       %[[T2:.*]] = llvm.insertvalue %[[T1]], %{{.*}}[0] : !llvm.array<2 x vector<[3]xf32>>
+// CHECK:       %[[T3:.*]] = llvm.insertvalue %[[T1]], %{{.*}}[1] : !llvm.array<2 x vector<[3]xf32>>
+// CHECK:       %[[T4:.*]] = builtin.unrealized_conversion_cast %[[T3]] : !llvm.array<2 x vector<[3]xf32>> to vector<[2x3]xf32>
+// CHECK:       return %[[T4]] : vector<[2x3]xf32>
+
+// -----
+
 func.func @broadcast_vec3d_from_scalar(%arg0: f32) -> vector<2x3x4xf32> {
   %0 = vector.broadcast %arg0 : f32 to vector<2x3x4xf32>
   return %0 : vector<2x3x4xf32>
 }
 // CHECK-LABEL: @broadcast_vec3d_from_scalar(
 // CHECK-SAME:  %[[A:.*]]: f32)
 // CHECK:       %[[T0:.*]] = llvm.insertelement %[[A]]
 // CHECK:       %[[T1:.*]] = llvm.shufflevector %[[T0]]