llvm: add C API methods to match 64bit ArrayType C++ API signatures

[nektro]

Summary

Fixes https://github.com/llvm/llvm-project/issues/56496

As mentioned in the issue, new functions LLVMArrayType2 and LLVMGetArrayLength2 are created so as to not break the old API. the old methods are then marked as deprecated and callers are updated.

[nektro]

This comment was removed by nektro.

[nektro]

not sure why llvm/include/llvm-c/Core.h and llvm/lib/IR/Core.cpp have such a large diff, the local .patch doesn't have all those +/-

hmm and the first diff before i fixed the typo looks fine

[nektro]

oh maybe it was line endings, leaving the file only edited by git show leaves a correct diff

[nektro]

ran git-clang-format

[nikic]

LGTM

[nikic]

If you need me to commit this for you, please specify the Name <email> to use.

[nektro]

yay 😁 my contact is Meghan Denny <[e-mail]>, that would be wonderful

llvm/bindings/ocaml/llvm/llvm_ocaml.c

 
 /* lltype -> int -> lltype */
 LLVMTypeRef llvm_vector_type(LLVMTypeRef ElementTy, value Count) {
   return LLVMVectorType(ElementTy, Int_val(Count));
 }
 
 /* lltype -> int */
 value llvm_array_length(LLVMTypeRef ArrayTy) {
-  return Val_int(LLVMGetArrayLength(ArrayTy));
+  return Val_int(LLVMGetArrayLength2(ArrayTy));
 }
 
 /* lltype -> int */
 value llvm_address_space(LLVMTypeRef PtrTy) {
   return Val_int(LLVMGetPointerAddressSpace(PtrTy));
 }
 
 /* lltype -> int */

llvm/include/llvm-c/Core.h

 unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp);
 
 /**
  * Create a fixed size array type that refers to a specific type.
  *
  * The created type will exist in the context that its element type
  * exists in.
  *
+ * @deprecated LLVMArrayType is deprecated in favor of the API accurate LLVMArrayType2
  * @see llvm::ArrayType::get()
  */
 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount);
 
 /**
+ * Create a fixed size array type that refers to a specific type.
+ *
+ * The created type will exist in the context that its element type
+ * exists in.
+ *
+ * @see llvm::ArrayType::get()
+ */
+LLVMTypeRef LLVMArrayType2(LLVMTypeRef ElementType, uint64_t ElementCount);
+
+/**
  * Obtain the length of an array type.
  *
  * This only works on types that represent arrays.
  *
+ * @deprecated LLVMGetArrayLength is deprecated in favor of the API accurate LLVMGetArrayLength2
  * @see llvm::ArrayType::getNumElements()
  */
 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy);
 
 /**
+ * Obtain the length of an array type.
+ *
+ * This only works on types that represent arrays.
+ *
+ * @see llvm::ArrayType::getNumElements()
+ */
+uint64_t LLVMGetArrayLength2(LLVMTypeRef ArrayTy);
+
+/**
  * Create a pointer type that points to a defined type.
  *
  * The created type will exist in the context that its pointee type
  * exists in.
  *
  * @see llvm::PointerType::get()
  */
 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace);

  * @see LLVMConstStructInContext()
  */
 LLVMValueRef LLVMConstStruct(LLVMValueRef *ConstantVals, unsigned Count,
                              LLVMBool Packed);
 
 /**
  * Create a ConstantArray from values.
  *
+ * @deprecated LLVMConstArray is deprecated in favor of the API accurate LLVMConstArray2
  * @see llvm::ConstantArray::get()
  */
 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
                             LLVMValueRef *ConstantVals, unsigned Length);
 
 /**
+ * Create a ConstantArray from values.
+ *
+ * @see llvm::ConstantArray::get()
+ */
+LLVMValueRef LLVMConstArray2(LLVMTypeRef ElementTy, LLVMValueRef *ConstantVals, uint64_t Length);
+
+/**
  * Create a non-anonymous ConstantStruct from values.
  *
  * @see llvm::ConstantStruct::get()
  */
 LLVMValueRef LLVMConstNamedStruct(LLVMTypeRef StructTy,
                                   LLVMValueRef *ConstantVals,
                                   unsigned Count);
 

llvm/lib/IR/Core.cpp

for (auto *T : unwrap(Tp)->subtypes()) {
         i++;
     }
 }
 
 LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount) {
   return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
 }
 
+LLVMTypeRef LLVMArrayType2(LLVMTypeRef ElementType, uint64_t ElementCount) {
+  return wrap(ArrayType::get(unwrap(ElementType), ElementCount));
+}
+
 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType, unsigned AddressSpace) {
   return wrap(PointerType::get(unwrap(ElementType), AddressSpace));
 }
 
 LLVMBool LLVMPointerTypeIsOpaque(LLVMTypeRef Ty) {
   return unwrap(Ty)->isOpaquePointerTy();
 }
 

 unsigned LLVMGetNumContainedTypes(LLVMTypeRef Tp) {
     return unwrap(Tp)->getNumContainedTypes();
 }
 
 unsigned LLVMGetArrayLength(LLVMTypeRef ArrayTy) {
   return unwrap<ArrayType>(ArrayTy)->getNumElements();
 }
 
+uint64_t LLVMGetArrayLength2(LLVMTypeRef ArrayTy) {
+  return unwrap<ArrayType>(ArrayTy)->getNumElements();
+}
+
+
 unsigned LLVMGetPointerAddressSpace(LLVMTypeRef PointerTy) {
   return unwrap<PointerType>(PointerTy)->getAddressSpace();
 }
 
 unsigned LLVMGetVectorSize(LLVMTypeRef VectorTy) {
   return unwrap<VectorType>(VectorTy)->getElementCount().getKnownMinValue();
 }
 

 }
 
 LLVMValueRef LLVMConstArray(LLVMTypeRef ElementTy,
                             LLVMValueRef *ConstantVals, unsigned Length) {
   ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length);
   return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
 }
 
+LLVMValueRef LLVMConstArray2(LLVMTypeRef ElementTy, LLVMValueRef *ConstantVals, uint64_t Length) {
+  ArrayRef<Constant*> V(unwrap<Constant>(ConstantVals, Length), Length);
+  return wrap(ConstantArray::get(ArrayType::get(unwrap(ElementTy), Length), V));
+}
+
 LLVMValueRef LLVMConstStructInContext(LLVMContextRef C,
                                       LLVMValueRef *ConstantVals,
                                       unsigned Count, LLVMBool Packed) {
   Constant **Elements = unwrap<Constant>(ConstantVals, Count);
   return wrap(ConstantStruct::getAnon(*unwrap(C), ArrayRef(Elements, Count),
                                       Packed != 0));
 }
 

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

switch (Kind) {
         if (Name)
           LLVMStructSetBody(S, Elts.data(), EltCount, LLVMIsPackedStruct(Src));
         else
           S = LLVMStructTypeInContext(Ctx, Elts.data(), EltCount,
                                       LLVMIsPackedStruct(Src));
         return S;
       }
       case LLVMArrayTypeKind:
-        return LLVMArrayType(
+        return LLVMArrayType2(
           Clone(LLVMGetElementType(Src)),
-          LLVMGetArrayLength(Src)
+          LLVMGetArrayLength2(Src)
         );
       case LLVMPointerTypeKind:
         if (LLVMPointerTypeIsOpaque(Src))
           return LLVMPointerTypeInContext(Ctx, LLVMGetPointerAddressSpace(Src));
         else
           return LLVMPointerType(Clone(LLVMGetElementType(Src)),
                                  LLVMGetPointerAddressSpace(Src));
       case LLVMVectorTypeKind:
static LLVMValueRef clone_constant_impl(LLVMValueRef Cst, LLVMModuleRef M) {
   }
 
   // Try constant array or constant data array
   if (LLVMIsAConstantArray(Cst) || LLVMIsAConstantDataArray(Cst)) {
     check_value_kind(Cst, LLVMIsAConstantArray(Cst)
                               ? LLVMConstantArrayValueKind
                               : LLVMConstantDataArrayValueKind);
     LLVMTypeRef Ty = TypeCloner(M).Clone(Cst);
-    unsigned EltCount = LLVMGetArrayLength(Ty);
+    uint64_t EltCount = LLVMGetArrayLength2(Ty);
     SmallVector<LLVMValueRef, 8> Elts;
     for (unsigned i = 0; i < EltCount; i++)
       Elts.push_back(clone_constant(LLVMGetAggregateElement(Cst, i), M));
     return LLVMConstArray(LLVMGetElementType(Ty), Elts.data(), EltCount);
   }
 
   // Try constant struct
   if (LLVMIsAConstantStruct(Cst)) {