388 lines · c
1//===- llvm.c - Test of llvm APIs -----------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM4// Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10// RUN: mlir-capi-llvm-test 2>&1 | FileCheck %s11 12#include "mlir-c/Dialect/LLVM.h"13#include "mlir-c/BuiltinAttributes.h"14#include "mlir-c/BuiltinTypes.h"15#include "mlir-c/IR.h"16#include "mlir-c/Support.h"17#include "llvm-c/Core.h"18#include "llvm-c/DebugInfo.h"19 20#include <assert.h>21#include <inttypes.h>22#include <math.h>23#include <stdio.h>24#include <stdlib.h>25#include <string.h>26 27// CHECK-LABEL: testTypeCreation()28static void testTypeCreation(MlirContext ctx) {29 fprintf(stderr, "testTypeCreation()\n");30 MlirType i8 = mlirIntegerTypeGet(ctx, 8);31 MlirType i32 = mlirIntegerTypeGet(ctx, 32);32 MlirType i64 = mlirIntegerTypeGet(ctx, 64);33 34 const char *ptr_text = "!llvm.ptr";35 MlirType ptr = mlirLLVMPointerTypeGet(ctx, 0);36 MlirType ptr_ref =37 mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(ptr_text));38 // CHECK: !llvm.ptr: 139 fprintf(stderr, "%s: %d\n", ptr_text, mlirTypeEqual(ptr, ptr_ref));40 41 const char *ptr_addr_text = "!llvm.ptr<42>";42 MlirType ptr_addr = mlirLLVMPointerTypeGet(ctx, 42);43 MlirType ptr_addr_ref =44 mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(ptr_addr_text));45 // CHECK: !llvm.ptr<42>: 146 fprintf(stderr, "%s: %d\n", ptr_addr_text,47 mlirTypeEqual(ptr_addr, ptr_addr_ref));48 49 const char *voidt_text = "!llvm.void";50 MlirType voidt = mlirLLVMVoidTypeGet(ctx);51 MlirType voidt_ref =52 mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(voidt_text));53 // CHECK: !llvm.void: 154 fprintf(stderr, "%s: %d\n", voidt_text, mlirTypeEqual(voidt, voidt_ref));55 56 const char *i32_4_text = "!llvm.array<4 x i32>";57 MlirType i32_4 = mlirLLVMArrayTypeGet(i32, 4);58 MlirType i32_4_ref =59 mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i32_4_text));60 // CHECK: !llvm.array<4 x i32>: 161 fprintf(stderr, "%s: %d\n", i32_4_text, mlirTypeEqual(i32_4, i32_4_ref));62 63 const char *i8_i32_i64_text = "!llvm.func<i8 (i32, i64)>";64 const MlirType i32_i64_arr[] = {i32, i64};65 MlirType i8_i32_i64 = mlirLLVMFunctionTypeGet(i8, 2, i32_i64_arr, false);66 MlirType i8_i32_i64_ref =67 mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i8_i32_i64_text));68 // CHECK: !llvm.func<i8 (i32, i64)>: 169 fprintf(stderr, "%s: %d\n", i8_i32_i64_text,70 mlirTypeEqual(i8_i32_i64, i8_i32_i64_ref));71 72 const char *i32_i64_s_text = "!llvm.struct<(i32, i64)>";73 MlirType i32_i64_s = mlirLLVMStructTypeLiteralGet(ctx, 2, i32_i64_arr, false);74 MlirType i32_i64_s_ref =75 mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(i32_i64_s_text));76 // CHECK: !llvm.struct<(i32, i64)>: 177 fprintf(stderr, "%s: %d\n", i32_i64_s_text,78 mlirTypeEqual(i32_i64_s, i32_i64_s_ref));79}80 81// CHECK-LABEL: testStructTypeCreation82static int testStructTypeCreation(MlirContext ctx) {83 fprintf(stderr, "testStructTypeCreation\n");84 85 // CHECK: !llvm.struct<()>86 mlirTypeDump(mlirLLVMStructTypeLiteralGet(ctx, /*nFieldTypes=*/0,87 /*fieldTypes=*/NULL,88 /*isPacked=*/false));89 90 MlirType i8 = mlirIntegerTypeGet(ctx, 8);91 MlirType i32 = mlirIntegerTypeGet(ctx, 32);92 MlirType i64 = mlirIntegerTypeGet(ctx, 64);93 MlirType i8_i32_i64[] = {i8, i32, i64};94 // CHECK: !llvm.struct<(i8, i32, i64)>95 mlirTypeDump(96 mlirLLVMStructTypeLiteralGet(ctx, sizeof(i8_i32_i64) / sizeof(MlirType),97 i8_i32_i64, /*isPacked=*/false));98 // CHECK: !llvm.struct<(i32)>99 mlirTypeDump(mlirLLVMStructTypeLiteralGet(ctx, 1, &i32, /*isPacked=*/false));100 MlirType i32_i32[] = {i32, i32};101 // CHECK: !llvm.struct<packed (i32, i32)>102 mlirTypeDump(mlirLLVMStructTypeLiteralGet(103 ctx, sizeof(i32_i32) / sizeof(MlirType), i32_i32, /*isPacked=*/true));104 105 MlirType literal =106 mlirLLVMStructTypeLiteralGet(ctx, sizeof(i8_i32_i64) / sizeof(MlirType),107 i8_i32_i64, /*isPacked=*/false);108 // CHECK: num elements: 3109 // CHECK: i8110 // CHECK: i32111 // CHECK: i64112 fprintf(stderr, "num elements: %" PRIdPTR "\n",113 mlirLLVMStructTypeGetNumElementTypes(literal));114 for (intptr_t i = 0; i < 3; ++i) {115 mlirTypeDump(mlirLLVMStructTypeGetElementType(literal, i));116 }117 118 if (!mlirTypeEqual(119 mlirLLVMStructTypeLiteralGet(ctx, 1, &i32, /*isPacked=*/false),120 mlirLLVMStructTypeLiteralGet(ctx, 1, &i32, /*isPacked=*/false))) {121 return 1;122 }123 if (mlirTypeEqual(124 mlirLLVMStructTypeLiteralGet(ctx, 1, &i32, /*isPacked=*/false),125 mlirLLVMStructTypeLiteralGet(ctx, 1, &i64, /*isPacked=*/false))) {126 return 2;127 }128 129 // CHECK: !llvm.struct<"foo", opaque>130 // CHECK: !llvm.struct<"bar", opaque>131 mlirTypeDump(mlirLLVMStructTypeIdentifiedGet(132 ctx, mlirStringRefCreateFromCString("foo")));133 mlirTypeDump(mlirLLVMStructTypeIdentifiedGet(134 ctx, mlirStringRefCreateFromCString("bar")));135 136 if (!mlirTypeEqual(mlirLLVMStructTypeIdentifiedGet(137 ctx, mlirStringRefCreateFromCString("foo")),138 mlirLLVMStructTypeIdentifiedGet(139 ctx, mlirStringRefCreateFromCString("foo")))) {140 return 3;141 }142 if (mlirTypeEqual(mlirLLVMStructTypeIdentifiedGet(143 ctx, mlirStringRefCreateFromCString("foo")),144 mlirLLVMStructTypeIdentifiedGet(145 ctx, mlirStringRefCreateFromCString("bar")))) {146 return 4;147 }148 149 MlirType fooStruct = mlirLLVMStructTypeIdentifiedGet(150 ctx, mlirStringRefCreateFromCString("foo"));151 MlirStringRef name = mlirLLVMStructTypeGetIdentifier(fooStruct);152 if (memcmp(name.data, "foo", name.length))153 return 5;154 if (!mlirLLVMStructTypeIsOpaque(fooStruct))155 return 6;156 157 MlirType i32_i64[] = {i32, i64};158 MlirLogicalResult result =159 mlirLLVMStructTypeSetBody(fooStruct, sizeof(i32_i64) / sizeof(MlirType),160 i32_i64, /*isPacked=*/false);161 if (!mlirLogicalResultIsSuccess(result))162 return 7;163 164 // CHECK: !llvm.struct<"foo", (i32, i64)>165 mlirTypeDump(fooStruct);166 if (mlirLLVMStructTypeIsOpaque(fooStruct))167 return 8;168 if (mlirLLVMStructTypeIsPacked(fooStruct))169 return 9;170 if (!mlirTypeEqual(mlirLLVMStructTypeIdentifiedGet(171 ctx, mlirStringRefCreateFromCString("foo")),172 fooStruct)) {173 return 10;174 }175 176 MlirType barStruct = mlirLLVMStructTypeIdentifiedGet(177 ctx, mlirStringRefCreateFromCString("bar"));178 result = mlirLLVMStructTypeSetBody(barStruct, 1, &i32, /*isPacked=*/true);179 if (!mlirLogicalResultIsSuccess(result))180 return 11;181 182 // CHECK: !llvm.struct<"bar", packed (i32)>183 mlirTypeDump(barStruct);184 if (!mlirLLVMStructTypeIsPacked(barStruct))185 return 12;186 187 // Same body, should succeed.188 result =189 mlirLLVMStructTypeSetBody(fooStruct, sizeof(i32_i64) / sizeof(MlirType),190 i32_i64, /*isPacked=*/false);191 if (!mlirLogicalResultIsSuccess(result))192 return 13;193 194 // Different body, should fail.195 result = mlirLLVMStructTypeSetBody(fooStruct, 1, &i32, /*isPacked=*/false);196 if (mlirLogicalResultIsSuccess(result))197 return 14;198 199 // Packed flag differs, should fail.200 result = mlirLLVMStructTypeSetBody(barStruct, 1, &i32, /*isPacked=*/false);201 if (mlirLogicalResultIsSuccess(result))202 return 15;203 204 // Should have a different name.205 // CHECK: !llvm.struct<"foo{{[^"]+}}206 mlirTypeDump(mlirLLVMStructTypeIdentifiedNewGet(207 ctx, mlirStringRefCreateFromCString("foo"), /*nFieldTypes=*/0,208 /*fieldTypes=*/NULL, /*isPacked=*/false));209 210 // Two freshly created "new" types must differ.211 if (mlirTypeEqual(212 mlirLLVMStructTypeIdentifiedNewGet(213 ctx, mlirStringRefCreateFromCString("foo"), /*nFieldTypes=*/0,214 /*fieldTypes=*/NULL, /*isPacked=*/false),215 mlirLLVMStructTypeIdentifiedNewGet(216 ctx, mlirStringRefCreateFromCString("foo"), /*nFieldTypes=*/0,217 /*fieldTypes=*/NULL, /*isPacked=*/false))) {218 return 16;219 }220 221 MlirType opaque = mlirLLVMStructTypeOpaqueGet(222 ctx, mlirStringRefCreateFromCString("opaque"));223 // CHECK: !llvm.struct<"opaque", opaque>224 mlirTypeDump(opaque);225 if (!mlirLLVMStructTypeIsOpaque(opaque))226 return 17;227 228 return 0;229}230 231// CHECK-LABEL: testLLVMAttributes232static void testLLVMAttributes(MlirContext ctx) {233 fprintf(stderr, "testLLVMAttributes\n");234 235 // CHECK: #llvm.linkage<internal>236 mlirAttributeDump(mlirLLVMLinkageAttrGet(ctx, MlirLLVMLinkageInternal));237 // CHECK: #llvm.cconv<ccc>238 mlirAttributeDump(mlirLLVMCConvAttrGet(ctx, MlirLLVMCConvC));239 // CHECK: #llvm<comdat any>240 mlirAttributeDump(mlirLLVMComdatAttrGet(ctx, MlirLLVMComdatAny));241}242 243// CHECK-LABEL: testDebugInfoAttributes244static void testDebugInfoAttributes(MlirContext ctx) {245 fprintf(stderr, "testDebugInfoAttributes\n");246 247 MlirAttribute foo =248 mlirStringAttrGet(ctx, mlirStringRefCreateFromCString("foo"));249 MlirAttribute bar =250 mlirStringAttrGet(ctx, mlirStringRefCreateFromCString("bar"));251 252 MlirAttribute none = mlirUnitAttrGet(ctx);253 MlirAttribute id = mlirDisctinctAttrCreate(none);254 MlirAttribute recId0 = mlirDisctinctAttrCreate(none);255 MlirAttribute recId1 = mlirDisctinctAttrCreate(none);256 257 // CHECK: #llvm.di_null_type258 mlirAttributeDump(mlirLLVMDINullTypeAttrGet(ctx));259 260 // CHECK: #llvm.di_basic_type<name = "foo", sizeInBits =261 // CHECK-SAME: 64, encoding = DW_ATE_signed>262 MlirAttribute di_type =263 mlirLLVMDIBasicTypeAttrGet(ctx, 0, foo, 64, MlirLLVMTypeEncodingSigned);264 mlirAttributeDump(di_type);265 266 MlirAttribute file = mlirLLVMDIFileAttrGet(ctx, foo, bar);267 268 // CHECK: #llvm.di_file<"foo" in "bar">269 mlirAttributeDump(file);270 271 MlirAttribute compile_unit = mlirLLVMDICompileUnitAttrGet(272 ctx, id, LLVMDWARFSourceLanguageC99, file, foo, false,273 MlirLLVMDIEmissionKindFull, MlirLLVMDINameTableKindDefault, bar);274 275 // CHECK: #llvm.di_compile_unit<{{.*}}>276 mlirAttributeDump(compile_unit);277 278 MlirAttribute di_module = mlirLLVMDIModuleAttrGet(279 ctx, file, compile_unit, foo,280 mlirStringAttrGet(ctx, mlirStringRefCreateFromCString("")), bar, foo, 1,281 0);282 // CHECK: #llvm.di_module<{{.*}}>283 mlirAttributeDump(di_module);284 285 // CHECK: #llvm.di_compile_unit<{{.*}}>286 mlirAttributeDump(mlirLLVMDIModuleAttrGetScope(di_module));287 288 // CHECK: 1 : i32289 mlirAttributeDump(mlirLLVMDIFlagsAttrGet(ctx, 0x1));290 291 // CHECK: #llvm.di_lexical_block<{{.*}}>292 mlirAttributeDump(293 mlirLLVMDILexicalBlockAttrGet(ctx, compile_unit, file, 1, 2));294 295 // CHECK: #llvm.di_lexical_block_file<{{.*}}>296 mlirAttributeDump(297 mlirLLVMDILexicalBlockFileAttrGet(ctx, compile_unit, file, 3));298 299 // CHECK: #llvm.di_local_variable<{{.*}}>300 MlirAttribute local_var = mlirLLVMDILocalVariableAttrGet(301 ctx, compile_unit, foo, file, 1, 0, 8, di_type, 0);302 mlirAttributeDump(local_var);303 // CHECK: #llvm.di_derived_type<{{.*}}>304 // CHECK-NOT: dwarfAddressSpace305 mlirAttributeDump(mlirLLVMDIDerivedTypeAttrGet(306 ctx, 0, bar, di_type, 64, 8, 0, MLIR_CAPI_DWARF_ADDRESS_SPACE_NULL,307 di_type));308 309 // CHECK: #llvm.di_derived_type<{{.*}} dwarfAddressSpace = 3{{.*}}>310 mlirAttributeDump(311 mlirLLVMDIDerivedTypeAttrGet(ctx, 0, bar, di_type, 64, 8, 0, 3, di_type));312 313 MlirAttribute subroutine_type =314 mlirLLVMDISubroutineTypeAttrGet(ctx, 0x0, 1, &di_type);315 316 // CHECK: #llvm.di_subroutine_type<{{.*}}>317 mlirAttributeDump(subroutine_type);318 319 MlirAttribute di_subprogram_self_rec =320 mlirLLVMDISubprogramAttrGetRecSelf(recId0);321 MlirAttribute di_imported_entity = mlirLLVMDIImportedEntityAttrGet(322 ctx, 0, di_subprogram_self_rec, di_module, file, 1, foo, 1, &local_var);323 324 mlirAttributeDump(di_imported_entity);325 // CHECK: #llvm.di_imported_entity<{{.*}}>326 327 MlirAttribute di_annotation = mlirLLVMDIAnnotationAttrGet(328 ctx, mlirStringAttrGet(ctx, mlirStringRefCreateFromCString("foo")),329 mlirStringAttrGet(ctx, mlirStringRefCreateFromCString("bar")));330 331 mlirAttributeDump(di_annotation);332 // CHECK: #llvm.di_annotation<{{.*}}>333 334 MlirAttribute di_subprogram = mlirLLVMDISubprogramAttrGet(335 ctx, recId0, false, id, compile_unit, compile_unit, foo, bar, file, 1, 2,336 0, subroutine_type, 1, &di_imported_entity, 1, &di_annotation);337 // CHECK: #llvm.di_subprogram<{{.*}}>338 mlirAttributeDump(di_subprogram);339 340 // CHECK: #llvm.di_compile_unit<{{.*}}>341 mlirAttributeDump(mlirLLVMDISubprogramAttrGetScope(di_subprogram));342 343 // CHECK: #llvm.di_file<{{.*}}>344 mlirAttributeDump(mlirLLVMDISubprogramAttrGetFile(di_subprogram));345 346 // CHECK: #llvm.di_subroutine_type<{{.*}}>347 mlirAttributeDump(mlirLLVMDISubprogramAttrGetType(di_subprogram));348 349 MlirAttribute expression_elem =350 mlirLLVMDIExpressionElemAttrGet(ctx, 1, 1, &(uint64_t){1});351 352 // CHECK: #llvm<di_expression_elem(1)>353 mlirAttributeDump(expression_elem);354 355 MlirAttribute expression =356 mlirLLVMDIExpressionAttrGet(ctx, 1, &expression_elem);357 // CHECK: #llvm.di_expression<[(1)]>358 mlirAttributeDump(expression);359 360 MlirAttribute string_type =361 mlirLLVMDIStringTypeAttrGet(ctx, 0x0, foo, 16, 0, local_var, expression,362 expression, MlirLLVMTypeEncodingSigned);363 // CHECK: #llvm.di_string_type<{{.*}}>364 mlirAttributeDump(string_type);365 366 // CHECK: #llvm.di_composite_type<recId = {{.*}}, isRecSelf = true>367 mlirAttributeDump(mlirLLVMDICompositeTypeAttrGetRecSelf(recId1));368 369 // CHECK: #llvm.di_composite_type<{{.*}}>370 mlirAttributeDump(mlirLLVMDICompositeTypeAttrGet(371 ctx, recId1, false, 0, foo, file, 1, compile_unit, di_type, 0, 64, 8, 1,372 &di_type, expression, expression, expression, expression));373}374 375int main(void) {376 MlirContext ctx = mlirContextCreate();377 mlirDialectHandleRegisterDialect(mlirGetDialectHandle__llvm__(), ctx);378 mlirContextGetOrLoadDialect(ctx, mlirStringRefCreateFromCString("llvm"));379 testTypeCreation(ctx);380 int result = testStructTypeCreation(ctx);381 testLLVMAttributes(ctx);382 testDebugInfoAttributes(ctx);383 mlirContextDestroy(ctx);384 if (result)385 fprintf(stderr, "FAILED: code %d", result);386 return result;387}388