C API: support scalable vectors

This adds support for scalable vector types in the C API and in
llvm-c-test, and also adds a test to ensure that llvm-c-test can properly
roundtrip operations involving scalable vectors.

While creating this diff, I discovered that the C API cannot properly roundtrip
_constant expressions_ involving shufflevector / scalable vectors, but that
seems to be a separate enough issue that I plan to address it in a future diff
(unless reviewers feel it should be addressed here).

Differential Revision: https://reviews.llvm.org/D89816

llvm/include/llvm-c/Core.h

@@ -1444,9 +1444,21 @@ unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy);
 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
 
 /**
- * Obtain the number of elements in a vector type.
+ * Create a vector type that contains a defined type and has a scalable
+ * number of elements.
+ *
+ * The created type will exist in the context thats its element type
+ * exists in.
+ *
+ * @see llvm::ScalableVectorType::get()
+ */
+LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType,
+                                   unsigned ElementCount);
+
+/**
+ * Obtain the (possibly scalable) number of elements in a vector type.
  *
- * This only works on types that represent vectors.
+ * This only works on types that represent vectors (fixed or scalable).
  *
  * @see llvm::VectorType::getNumElements()
  */

llvm/lib/IR/Core.cpp

@@ -764,6 +764,11 @@ LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) {
   return wrap(FixedVectorType::get(unwrap(ElementType), ElementCount));
 }
 
+LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType,
+                                   unsigned ElementCount) {
+  return wrap(ScalableVectorType::get(unwrap(ElementType), ElementCount));
+}
+
 LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy) {
   auto *Ty = unwrap<Type>(WrappedTy);
   if (auto *PTy = dyn_cast<PointerType>(Ty))

llvm/test/Bindings/llvm-c/echo.ll

@@ -174,6 +174,19 @@ define i32 @vectorops(i32, i32) {
   ret i32 %p
 }
 
+define i32 @scalablevectorops(i32, <vscale x 4 x i32>) {
+  %a = insertelement <vscale x 4 x i32> undef, i32 %0, i32 0
+  %b = insertelement <vscale x 4 x i32> %a, i32 %0, i32 2
+  %c = shufflevector <vscale x 4 x i32> %b, <vscale x 4 x i32> undef, <vscale x 4 x i32> zeroinitializer
+  %e = add <vscale x 4 x i32> %a, %1
+  %f = mul <vscale x 4 x i32> %e, %b
+  %g = xor <vscale x 4 x i32> %f, %e
+  %h = or <vscale x 4 x i32> %g, %e
+  %i = lshr <vscale x 4 x i32> %h, undef
+  %j = extractelement <vscale x 4 x i32> %i, i32 3
+  ret i32 %j
+}
+
 declare void @personalityFn()
 
 define void @exn() personality void ()* @personalityFn {

llvm/tools/llvm-c-test/echo.cpp

@@ -139,14 +139,14 @@ struct TypeCloner {
           Clone(LLVMGetElementType(Src)),
           LLVMGetPointerAddressSpace(Src)
         );
-      case LLVMScalableVectorTypeKind:
-        // FIXME: scalable vectors unsupported
-        break;
       case LLVMVectorTypeKind:
         return LLVMVectorType(
           Clone(LLVMGetElementType(Src)),
           LLVMGetVectorSize(Src)
         );
+      case LLVMScalableVectorTypeKind:
+        return LLVMScalableVectorType(Clone(LLVMGetElementType(Src)),
+                                      LLVMGetVectorSize(Src));
       case LLVMMetadataTypeKind:
         return LLVMMetadataTypeInContext(Ctx);
       case LLVMX86_MMXTypeKind: