Add more types to the LLVM dialect C API

[apaszke]

Summary

This includes:

• void type
• array types
• function types
• literal (unnamed) struct types

[apaszke]

Swapped the argument order to be more consistent with other APIs

[ftynse]

mlir/test/CAPI/llvm.c

57

Nit: did you forget the trailing 1 for the equality check?

63

Ditto.

[apaszke]

Add missing CHECK suffixes

mlir/include/mlir-c/Dialect/LLVM.h

 #endif
 
 MLIR_DECLARE_CAPI_DIALECT_REGISTRATION(LLVM, llvm);
 
 /// Creates an llvm.ptr type.
 MLIR_CAPI_EXPORTED MlirType mlirLLVMPointerTypeGet(MlirType pointee,
                                                    unsigned addressSpace);
 
+/// Creates an llmv.void type.
+MLIR_CAPI_EXPORTED MlirType mlirLLVMVoidTypeGet(MlirContext ctx);
+
+/// Creates an llvm.array type.
+MLIR_CAPI_EXPORTED MlirType mlirLLVMArrayTypeGet(MlirType elementType,
+                                                 unsigned numElements);
+
+/// Creates an llvm.func type.
+MLIR_CAPI_EXPORTED MlirType mlirLLVMFunctionTypeGet(MlirType resultType,
+                                                    MlirType *argumentTypes,
+                                                    intptr_t nArgumentTypes,
+                                                    bool isVarArg);
+
+/// Creates an LLVM literal (unnamed) struct type.
+MLIR_CAPI_EXPORTED MlirType mlirLLVMStructTypeLiteralGet(MlirContext ctx,
+                                                         MlirType *fieldTypes,
+                                                         intptr_t nFieldTypes,
+                                                         bool isPacked);
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // MLIR_C_DIALECT_LLVM_H

mlir/lib/CAPI/Dialect/LLVM.cpp

 using namespace mlir;
 using namespace mlir::LLVM;
 
 MLIR_DEFINE_CAPI_DIALECT_REGISTRATION(LLVM, llvm, LLVMDialect)
 
 MlirType mlirLLVMPointerTypeGet(MlirType pointee, unsigned addressSpace) {
   return wrap(LLVMPointerType::get(unwrap(pointee), addressSpace));
 }
+
+MlirType mlirLLVMVoidTypeGet(MlirContext ctx) {
+  return wrap(LLVMVoidType::get(unwrap(ctx)));
+}
+
+MlirType mlirLLVMArrayTypeGet(MlirType elementType, unsigned numElements) {
+  return wrap(LLVMArrayType::get(unwrap(elementType), numElements));
+}
+
+MlirType mlirLLVMFunctionTypeGet(MlirType resultType, MlirType *argumentTypes,
+                                 intptr_t nArgumentTypes, bool isVarArg) {
+  SmallVector<Type, 2> argumentStorage;
+  return wrap(LLVMFunctionType::get(
+      unwrap(resultType),
+      unwrapList(nArgumentTypes, argumentTypes, argumentStorage), isVarArg));
+}
+
+MlirType mlirLLVMStructTypeLiteralGet(MlirContext ctx, MlirType *fieldTypes,
+                                      intptr_t nFieldTypes, bool isPacked) {
+  SmallVector<Type, 2> fieldStorage;
+  return wrap(LLVMStructType::getLiteral(
+      unwrap(ctx), unwrapList(nFieldTypes, fieldTypes, fieldStorage),
+      isPacked));
+}

mlir/test/CAPI/llvm.c

 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 // CHECK-LABEL: testTypeCreation()
 static void testTypeCreation(MlirContext ctx) {
   fprintf(stderr, "testTypeCreation()\n");
+  MlirType i8 = mlirIntegerTypeGet(ctx, 8);
   MlirType i32 = mlirIntegerTypeGet(ctx, 32);
+  MlirType i64 = mlirIntegerTypeGet(ctx, 64);
 
   const char *i32p_text = "!llvm.ptr<i32>";
   MlirType i32p = mlirLLVMPointerTypeGet(i32, 0);
   MlirType i32p_ref = mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i32p_text));
   // CHECK: !llvm.ptr<i32>: 1
   fprintf(stderr, "%s: %d\n", i32p_text, mlirTypeEqual(i32p, i32p_ref));
 
   const char *i32p4_text = "!llvm.ptr<i32, 4>";
   MlirType i32p4 = mlirLLVMPointerTypeGet(i32, 4);
   MlirType i32p4_ref = mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i32p4_text));
   // CHECK: !llvm.ptr<i32, 4>: 1
   fprintf(stderr, "%s: %d\n", i32p4_text, mlirTypeEqual(i32p4, i32p4_ref));
+
+  const char *voidt_text = "!llvm.void";
+  MlirType voidt = mlirLLVMVoidTypeGet(ctx);
+  MlirType voidt_ref = mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(voidt_text));
+  // CHECK: !llvm.void: 1
+  fprintf(stderr, "%s: %d\n", voidt_text, mlirTypeEqual(voidt, voidt_ref));
+
+  const char *i32_4_text = "!llvm.array<4xi32>";
+  MlirType i32_4 = mlirLLVMArrayTypeGet(i32, 4);
+  MlirType i32_4_ref = mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i32_4_text));
+  // CHECK: !llvm.array<4xi32>: 1
+  fprintf(stderr, "%s: %d\n", i32_4_text, mlirTypeEqual(i32_4, i32_4_ref));
+
+  const char *i8_i32_i64_text = "!llvm.func<i8 (i32, i64)>";
+  MlirType i32_i64_arr[] = {i32, i64};
+  MlirType i8_i32_i64 = mlirLLVMFunctionTypeGet(i8, i32_i64_arr, 2, false);
+  MlirType i8_i32_i64_ref = mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i8_i32_i64_text));
+  // CHECK: !llvm.func<i8 (i32, i64)>
+  fprintf(stderr, "%s: %d\n", i8_i32_i64_text, mlirTypeEqual(i8_i32_i64, i8_i32_i64_ref));
+
+  const char *i32_i64_s_text = "!llvm.struct<(i32, i64)>";
+  MlirType i32_i64_s = mlirLLVMStructTypeLiteralGet(ctx, i32_i64_arr, 2, false);
+  MlirType i32_i64_s_ref = mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i32_i64_s_text));
+  // CHECK: !llvm.struct<(i32, i64)>
+  fprintf(stderr, "%s: %d\n", i32_i64_s_text, mlirTypeEqual(i32_i64_s, i32_i64_s_ref));
 }
 
 int main() {
   MlirContext ctx = mlirContextCreate();
   mlirDialectHandleRegisterDialect(mlirGetDialectHandle__llvm__(), ctx);
   mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("llvm"));
   testTypeCreation(ctx);
   mlirContextDestroy(ctx);
   return 0;
 }