[SVE] Add Scalable vector support to C api

[ctetreau]

This is sort of just an MVP first draft of the C api support. This basically implements the original C++ api. This is a little better though because LLVMVectorType does not have the default IsScalable = true parameter.

I'm unsure of how much value exposing FixedVectorType and ScalableVectorType through the C api would have given the fact that everything is passed around by a LLVMTypeRef handle. This requires some more thought.

[CodaFi]

I see you’ve already abandoned the revision, but I want to say that if you wish to do this, please make a separate entry point in the C API for creating scalable vectors. We are still committed to ABI stability in the core bindings.

llvm/include/llvm-c/Core.h

  * Create a vector type that contains a defined type and has a specific
  * number of elements.
  *
  * The created type will exist in the context thats its element type
  * exists in.
  *
  * @see llvm::VectorType::get()
  */
-LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
+LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount,
+                           LLVMBool Scalable);
 
 /**
- * Obtain the number of elements in a vector type.
+ * Obtain the number of elements in a vector type. If the vector is scalable,
+ * then this is the minimum number of elements
  *
  * This only works on types that represent vectors.
  *
- * @see llvm::VectorType::getNumElements()
+ * @see llvm::VectorType::getElementCount()
+ * @see llvm::ElementCount
  */
 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy);
 
 /**
+ * Return true if this vector is scalable
+ *
+ * This only works on types that represent vectors.
+ *
+ * @see llvm::VectorType::getElementCount()
+ * @see llvm::ElementCount
+ */
+LLVMBool LLVMGetVectorIsScalable(LLVMTypeRef VectorTy);
+
+/**
  * @}
  */
 
 /**
  * @defgroup LLVMCCoreTypeOther Other Types
  *
  * @{
  */

llvm/lib/IR/Core.cpp

 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) {
   return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
 }
 
 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) {
   return wrap(PointerType::get(unwrap(ElementType), AddressSpace));
 }
 
-LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount) {
-  return wrap(VectorType::get(unwrap(ElementType), ElementCount));
+LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType, unsigned ElementCount,
+                           LLVMBool Scalable) {
+  return wrap(VectorType::get(unwrap(ElementType),
+                              {ElementCount, static_cast<bool>(Scalable)}));
 }
 
 LLVMTypeRef LLVMGetElementType(LLVMTypeRef WrappedTy) {
   auto *Ty = unwrap<Type>(WrappedTy);
   if (auto *PTy = dyn_cast<PointerType>(Ty))
     return wrap(PTy->getElementType());
   if (auto *ATy = dyn_cast<ArrayType>(Ty))
     return wrap(ATy->getElementType());
   return wrap(cast<VectorType>(Ty)->getElementType());
 }
 
 unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp) {
     return unwrap(Tp)->getNumContainedTypes();
 }
 
 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) {
   return unwrap<ArrayType>(ArrayTy)->getNumElements();
 }
 
 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) {
   return unwrap<PointerType>(PointerTy)->getAddressSpace();
 }
 
 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) {
-  return unwrap<VectorType>(VectorTy)->getNumElements();
+  return unwrap<VectorType>(VectorTy)->getElementCount().Min;
+}
+
+LLVMBool LLVMGetVectorIsScalable(LLVMTypeRef VectorTy) {
+  return unwrap<VectorType>(VectorTy)->getElementCount().Scalable;
 }
 
 /*--.. Operations on other types ...........................................--*/
 
 LLVMTypeRef LLVMVoidTypeInContext(LLVMContextRef C)  {
   return wrap(Type::getVoidTy(*unwrap(C)));
 }
 LLVMTypeRef LLVMLabelTypeInContext(LLVMContextRef C) {

llvm/tools/llvm-c-test/debuginfo.c

LLVMMetadataRef StructDbgTy =
     LLVMDWARFSourceLanguageC, NULL, "MyStruct", 8);
 
   LLVMMetadataRef StructDbgPtrTy =
     LLVMDIBuilderCreatePointerType(DIB, StructDbgTy, 192, 0, 0, "", 0);
 
   LLVMAddNamedMetadataOperand(M, "FooType",
     LLVMMetadataAsValue(LLVMGetModuleContext(M), StructDbgPtrTy));
 
-
   LLVMTypeRef FooParamTys[] = {
       LLVMInt64Type(),
       LLVMInt64Type(),
-    LLVMVectorType(LLVMInt64Type(), 10),
+      LLVMVectorType(LLVMInt64Type(), 10, false),
   };
   LLVMTypeRef FooFuncTy = LLVMFunctionType(LLVMInt64Type(), FooParamTys, 3, 0);
   LLVMValueRef FooFunction = LLVMAddFunction(M, "foo", FooFuncTy);
   LLVMBasicBlockRef FooEntryBlock = LLVMAppendBasicBlock(FooFunction, "entry");
 
   LLVMMetadataRef Subscripts[] = {
     LLVMDIBuilderGetOrCreateSubrange(DIB, 0, 10),
   };

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

switch (Kind) {
           Clone(LLVMGetElementType(Src)),
           LLVMGetArrayLength(Src)
         );
       case LLVMPointerTypeKind:
         return LLVMPointerType(
           Clone(LLVMGetElementType(Src)),
           LLVMGetPointerAddressSpace(Src)
         );
-      case LLVMScalableVectorTypeKind:
-        // FIXME: scalable vectors unsupported
-        break;
       case LLVMFixedVectorTypeKind:
-        return LLVMVectorType(
-          Clone(LLVMGetElementType(Src)),
-          LLVMGetVectorSize(Src)
-        );
+      case LLVMScalableVectorTypeKind:
+        return LLVMVectorType(Clone(LLVMGetElementType(Src)),
+                              LLVMGetVectorSize(Src),
+                              LLVMGetVectorIsScalable(Src));
       case LLVMMetadataTypeKind:
         return LLVMMetadataTypeInContext(Ctx);
       case LLVMX86_MMXTypeKind:
         return LLVMX86MMXTypeInContext(Ctx);
       case LLVMTokenTypeKind:
         return LLVMTokenTypeInContext(Ctx);
     }