@designliquido/llvm-bindings 1.0.0 → 4.0.0

package/tests/fixtures/bitcodeWriter.spec.ts

@@ -0,0 +1,42 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import llvm from '../..';
+
+describe('Test Bitcode Writer (IR fixture)', () => {
+    const outputPath = path.join(os.tmpdir(), 'llvm-bindings-writer-test.bc');
+
+    beforeEach(() => {
+        if (fs.existsSync(outputPath)) {
+            fs.unlinkSync(outputPath);
+        }
+    });
+
+    afterEach(() => {
+        if (fs.existsSync(outputPath)) {
+            fs.unlinkSync(outputPath);
+        }
+    });
+
+    test('builds valid IR, writes bitcode, and verifies the output file exists', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('bitcodeWriter', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const returnType = builder.getInt32Ty();
+        const paramTypes = [builder.getInt32Ty(), builder.getInt32Ty()];
+        const functionType = llvm.FunctionType.get(returnType, paramTypes, false);
+        const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'writer', module);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
+        builder.SetInsertPoint(entryBB);
+        const result = builder.CreateAdd(func.getArg(0), func.getArg(1));
+        builder.CreateRet(result);
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+
+        llvm.WriteBitcodeToFile(module, outputPath);
+        expect(fs.existsSync(outputPath)).toBe(true);
+    });
+});

package/tests/fixtures/class.spec.ts

@@ -0,0 +1,30 @@
+import llvm from '../..';
+
+describe('Test Class', () => {
+    test('builds and verifies valid IR for a struct constructor', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('class', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const elementTypes = [builder.getInt32Ty(), builder.getInt32Ty()];
+        const classStructType = llvm.StructType.create(context, elementTypes, 'Person');
+
+        const paramTypes = [llvm.PointerType.getUnqual(classStructType)];
+        const functionType = llvm.FunctionType.get(builder.getVoidTy(), paramTypes, false);
+        const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'class_Person_constructor', module);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
+        builder.SetInsertPoint(entryBB);
+
+        const thisPtr = func.getArg(0);
+        const propertyPtr = builder.CreateGEP(classStructType, thisPtr, [
+            builder.getInt32(0),
+            builder.getInt32(1)
+        ]);
+        builder.CreateStore(builder.getInt32(111), propertyPtr);
+        builder.CreateRetVoid();
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/debugInfo.spec.ts

@@ -0,0 +1,73 @@
+import path from 'path';
+import llvm from '../..';
+
+describe('Test Debug Info', () => {
+    test('builds and verifies valid IR with DWARF debug information', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('debugInfo', context);
+        const builder = new llvm.IRBuilder(context);
+
+        module.addModuleFlag(llvm.Module.ModFlagBehavior.Warning, 'Debug Info Version', llvm.LLVMConstants.DEBUG_METADATA_VERSION);
+        module.addModuleFlag(llvm.Module.ModFlagBehavior.Warning, 'Dwarf Version', llvm.dwarf.LLVMConstants.DWARF_VERSION);
+
+        const diBuilder = new llvm.DIBuilder(module);
+        const diFile = diBuilder.createFile('debugInfo.ts', __dirname);
+        diBuilder.createCompileUnit(llvm.dwarf.SourceLanguage.DW_LANG_C, diFile, 'llvm-bindings', false, '', 0);
+        const diBasicType = diBuilder.createBasicType('int', 32, llvm.dwarf.TypeKind.DW_ATE_float);
+
+        // add function
+        const addFuncType = llvm.FunctionType.get(builder.getInt32Ty(), [builder.getInt32Ty(), builder.getInt32Ty()], false);
+        const addFunc = llvm.Function.Create(addFuncType, llvm.Function.LinkageTypes.ExternalLinkage, 'add', module);
+        const addDIParamTypes = diBuilder.getOrCreateTypeArray([diBasicType, diBasicType, diBasicType]);
+        const addDISubroutineType = diBuilder.createSubroutineType(addDIParamTypes);
+        const addSubprogram = diBuilder.createFunction(diFile, 'add', '', diFile, 1, addDISubroutineType, 1, llvm.DINode.DIFlags.FlagPrototyped, llvm.DISubprogram.DISPFlags.SPFlagDefinition);
+        addFunc.setSubprogram(addSubprogram);
+        builder.SetCurrentDebugLocation(new llvm.DebugLoc());
+
+        const addEntry = llvm.BasicBlock.Create(context, 'entry', addFunc);
+        builder.SetInsertPoint(addEntry);
+        const allocaA = builder.CreateAlloca(builder.getInt32Ty(), null, 'a');
+        builder.CreateStore(addFunc.getArg(0), allocaA);
+        diBuilder.insertDeclare(allocaA, diBuilder.createParameterVariable(addSubprogram, 'a', 1, diFile, 1, diBasicType), diBuilder.createExpression(), llvm.DILocation.get(context, 1, 0, addSubprogram), builder.GetInsertBlock()!);
+        const allocaB = builder.CreateAlloca(builder.getInt32Ty(), null, 'b');
+        builder.CreateStore(addFunc.getArg(1), allocaB);
+        diBuilder.insertDeclare(allocaB, diBuilder.createParameterVariable(addSubprogram, 'b', 2, diFile, 1, diBasicType), diBuilder.createExpression(), llvm.DILocation.get(context, 1, 0, addSubprogram), builder.GetInsertBlock()!);
+        builder.SetCurrentDebugLocation(llvm.DILocation.get(context, 2, 14, addSubprogram));
+        builder.CreateRet(builder.CreateAdd(builder.CreateLoad(builder.getInt32Ty(), allocaA), builder.CreateLoad(builder.getInt32Ty(), allocaB)));
+        diBuilder.finalizeSubprogram(addSubprogram);
+
+        expect(llvm.verifyFunction(addFunc)).toBe(false);
+
+        // main function
+        const mainFuncType = llvm.FunctionType.get(builder.getInt32Ty(), false);
+        const mainFunc = llvm.Function.Create(mainFuncType, llvm.Function.LinkageTypes.ExternalLinkage, 'main', module);
+        const mainDISubroutineType = diBuilder.createSubroutineType(diBuilder.getOrCreateTypeArray([diBasicType]));
+        const mainSubprogram = diBuilder.createFunction(diFile, 'main', '', diFile, 5, mainDISubroutineType, 5, llvm.DINode.DIFlags.FlagPrototyped, llvm.DISubprogram.DISPFlags.SPFlagDefinition);
+        mainFunc.setSubprogram(mainSubprogram);
+        builder.SetCurrentDebugLocation(new llvm.DebugLoc());
+
+        const mainEntry = llvm.BasicBlock.Create(context, 'entry', mainFunc);
+        builder.SetInsertPoint(mainEntry);
+        const allocaC = builder.CreateAlloca(builder.getInt32Ty(), null, 'c');
+        const storeA = builder.CreateAlloca(builder.getInt32Ty(), null, 'a');
+        const storeB = builder.CreateAlloca(builder.getInt32Ty(), null, 'b');
+        diBuilder.insertDeclare(storeA, diBuilder.createAutoVariable(mainSubprogram, 'a', diFile, 6, diBasicType), diBuilder.createExpression(), llvm.DILocation.get(context, 6, 9, mainSubprogram), builder.GetInsertBlock()!);
+        builder.SetCurrentDebugLocation(llvm.DILocation.get(context, 6, 9, mainSubprogram));
+        builder.CreateStore(builder.getInt32(1), storeA);
+        diBuilder.insertDeclare(storeB, diBuilder.createAutoVariable(mainSubprogram, 'b', diFile, 7, diBasicType), diBuilder.createExpression(), llvm.DILocation.get(context, 7, 9, mainSubprogram), builder.GetInsertBlock()!);
+        builder.SetCurrentDebugLocation(llvm.DILocation.get(context, 7, 9, mainSubprogram));
+        builder.CreateStore(builder.getInt32(2), storeB);
+        diBuilder.insertDeclare(allocaC, diBuilder.createAutoVariable(mainSubprogram, 'c', diFile, 8, diBasicType), diBuilder.createExpression(), llvm.DILocation.get(context, 8, 9, mainSubprogram), builder.GetInsertBlock()!);
+        builder.SetCurrentDebugLocation(llvm.DILocation.get(context, 8, 13, mainSubprogram));
+        const callRet = builder.CreateCall(addFunc, [builder.CreateLoad(builder.getInt32Ty(), storeA), builder.CreateLoad(builder.getInt32Ty(), storeB)]);
+        builder.CreateStore(callRet, allocaC);
+        builder.SetCurrentDebugLocation(llvm.DILocation.get(context, 9, 5, mainSubprogram));
+        builder.CreateRet(builder.CreateLoad(builder.getInt32Ty(), allocaC));
+        diBuilder.finalizeSubprogram(mainSubprogram);
+
+        diBuilder.finalize();
+
+        expect(llvm.verifyFunction(mainFunc)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/exception.spec.ts

@@ -0,0 +1,42 @@
+import llvm from '../..';
+
+describe('Test Exception', () => {
+    test('builds and verifies valid IR for a C++ exception throw', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('exception', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const i8PtrType = builder.getInt8PtrTy();
+        const voidType = builder.getVoidTy();
+
+        const functionType = llvm.FunctionType.get(voidType, false);
+        const mainFunc = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'exception', module);
+
+        const allocExceptionFuncType = llvm.FunctionType.get(i8PtrType, [builder.getInt64Ty()], false);
+        const allocExceptionFunc = module.getOrInsertFunction('__cxa_allocate_exception', allocExceptionFuncType);
+        const throwFuncType = llvm.FunctionType.get(voidType, [i8PtrType, i8PtrType, i8PtrType], false);
+        const throwFunc = module.getOrInsertFunction('__cxa_throw', throwFuncType);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', mainFunc);
+        builder.SetInsertPoint(entryBB);
+
+        const errMsgStr = builder.CreateGlobalString('error message');
+        const tmp1 = builder.CreateCall(allocExceptionFunc, [builder.getInt64(8)]);
+        const tmp2 = builder.CreateBitCast(tmp1, llvm.PointerType.getUnqual(builder.getInt8PtrTy()));
+        builder.CreateStore(
+            builder.CreateInBoundsGEP(
+                errMsgStr.getValueType(),
+                errMsgStr,
+                [builder.getInt64(0), builder.getInt64(0)]
+            ),
+            tmp2
+        );
+        const tinfo = new llvm.GlobalVariable(module, builder.getInt8PtrTy(), true, llvm.Function.LinkageTypes.ExternalLinkage, null);
+        const tmp3 = builder.CreateBitCast(tinfo, builder.getInt8PtrTy());
+        builder.CreateCall(throwFunc, [tmp1, tmp3, llvm.ConstantPointerNull.get(builder.getInt8PtrTy())]);
+        builder.CreateUnreachable();
+
+        expect(llvm.verifyFunction(mainFunc)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/fibonacci.spec.ts

@@ -0,0 +1,36 @@
+import llvm from '../..';
+
+describe('Test Fibonacci', () => {
+    test('builds and verifies valid IR for a recursive fibonacci function', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('fibonacci', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const returnType = builder.getInt32Ty();
+        const paramTypes = [builder.getInt32Ty()];
+        const functionType = llvm.FunctionType.get(returnType, paramTypes, false);
+        const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'fibonacci', module);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
+        const thenBB = llvm.BasicBlock.Create(context, 'then', func);
+        const elseBB = llvm.BasicBlock.Create(context, 'else', func);
+
+        builder.SetInsertPoint(entryBB);
+        const cond = builder.CreateICmpULE(func.getArg(0), builder.getInt32(1), 'cond');
+        builder.CreateCondBr(cond, thenBB, elseBB);
+
+        builder.SetInsertPoint(thenBB);
+        builder.CreateRet(func.getArg(0));
+
+        builder.SetInsertPoint(elseBB);
+        const n_1 = builder.CreateSub(func.getArg(0), builder.getInt32(1), 'n_1');
+        const n_2 = builder.CreateSub(func.getArg(0), builder.getInt32(2), 'n_2');
+        const ret1 = builder.CreateCall(func, [n_1], 'ret1');
+        const ret2 = builder.CreateCall(func, [n_2], 'ret2');
+        const result = builder.CreateAdd(ret1, ret2);
+        builder.CreateRet(result);
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/gep.spec.ts

@@ -0,0 +1,27 @@
+import llvm from '../..';
+
+describe('Test GEP', () => {
+    test('builds and verifies valid IR using GetElementPtr', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('gep', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const functionType = llvm.FunctionType.get(builder.getVoidTy(), false);
+        const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'gep', module);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
+        builder.SetInsertPoint(entryBB);
+
+        const strAlloca = builder.CreateAlloca(builder.getInt8PtrTy(), null, 'a');
+        const printConst = builder.CreateGlobalString('string content', '.str', 0, module);
+        const ptr = builder.CreateGEP(printConst.getValueType(), printConst, [
+            builder.getInt64(0),
+            builder.getInt64(0),
+        ]);
+        builder.CreateStore(ptr, strAlloca);
+        builder.CreateRetVoid();
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/intrinsic.spec.ts

@@ -0,0 +1,29 @@
+import llvm from '../..';
+
+describe('Test Intrinsic', () => {
+    test('builds and verifies valid IR using intrinsic declarations', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('intrinsic', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const functionType = llvm.FunctionType.get(builder.getVoidTy(), false);
+        const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'intrinsic', module);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
+        builder.SetInsertPoint(entryBB);
+
+        const debugtrapFn = llvm.Intrinsic.getDeclaration(module, llvm.Intrinsic.debugtrap);
+        builder.CreateCall(debugtrapFn, []);
+
+        llvm.Intrinsic.getDeclaration(module, llvm.Intrinsic.memmove, [
+            builder.getInt8PtrTy(),
+            builder.getInt8PtrTy(),
+            builder.getInt32Ty()
+        ]);
+
+        builder.CreateRetVoid();
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/linker.spec.ts

@@ -0,0 +1,30 @@
+import path from 'path';
+import llvm from '../..';
+
+describe('Test Linker', () => {
+    test('parses a bitcode file, links it, and verifies the resulting module', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('linker', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const bitcodePath = path.join(__dirname, 'bitcode/add.bc');
+        const err = new llvm.SMDiagnostic();
+        const srcModule = llvm.parseIRFile(bitcodePath, err, context);
+        expect(llvm.verifyModule(srcModule)).toBe(false);
+        expect(llvm.Linker.linkModules(module, srcModule)).toBe(false);
+
+        const returnType = builder.getInt32Ty();
+        const functionType = llvm.FunctionType.get(returnType, false);
+        const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'linker', module);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
+        builder.SetInsertPoint(entryBB);
+        const addFunc = module.getFunction('add');
+        expect(addFunc).toBeInstanceOf(llvm.Function);
+        const retVal = builder.CreateCall(addFunc!, [builder.getInt32(1), builder.getInt32(2)]);
+        builder.CreateRet(retVal);
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/str.spec.ts

@@ -0,0 +1,14 @@
+import llvm from '../..';
+
+describe('Test String', () => {
+    test('builds and verifies a module with global strings', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('str', context);
+        const builder = new llvm.IRBuilder(context);
+
+        builder.CreateGlobalString('HelloWorld', 'str', 0, module);
+        builder.CreateGlobalStringPtr('Bye Bye', 'str', 0, module);
+
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/switch.spec.ts

@@ -0,0 +1,45 @@
+import llvm from '../..';
+
+describe('Test Switch', () => {
+    test('builds and verifies valid IR for a switch statement', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('switch', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const returnType = builder.getInt32Ty();
+        const paramTypes = [builder.getInt32Ty()];
+        const functionType = llvm.FunctionType.get(returnType, paramTypes, false);
+        const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'switch', module);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
+        const case1BB = llvm.BasicBlock.Create(context, 'switch.case1', func);
+        const case2BB = llvm.BasicBlock.Create(context, 'switch.case2', func);
+        const defaultCaseBB = llvm.BasicBlock.Create(context, 'switch.default', func);
+        const exitBB = llvm.BasicBlock.Create(context, 'switch.exit', func);
+
+        builder.SetInsertPoint(entryBB);
+        const retPtr = builder.CreateAlloca(builder.getInt32Ty(), null, 'ret');
+        const switchInst = builder.CreateSwitch(func.getArg(0), defaultCaseBB, 2);
+        switchInst.addCase(builder.getInt32(1), case1BB);
+        switchInst.addCase(builder.getInt32(2), case2BB);
+
+        builder.SetInsertPoint(case1BB);
+        builder.CreateStore(builder.getInt32(1), retPtr);
+        builder.CreateBr(exitBB);
+
+        builder.SetInsertPoint(case2BB);
+        builder.CreateStore(builder.getInt32(2), retPtr);
+        builder.CreateBr(exitBB);
+
+        builder.SetInsertPoint(defaultCaseBB);
+        builder.CreateStore(builder.getInt32(3), retPtr);
+        builder.CreateBr(exitBB);
+
+        builder.SetInsertPoint(exitBB);
+        const retVal = builder.CreateLoad(builder.getInt32Ty(), retPtr);
+        builder.CreateRet(retVal);
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/unary.spec.ts

@@ -0,0 +1,44 @@
+import llvm from '../..';
+
+describe('Test Unary', () => {
+    test('builds and verifies valid IR for unary not/neg/fneg', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('unary', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const functionType = llvm.FunctionType.get(builder.getVoidTy(), false);
+        const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'unary', module);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
+        builder.SetInsertPoint(entryBB);
+
+        const boolAlloca = builder.CreateAlloca(builder.getInt1Ty(), null, 'bool_alloca');
+        builder.CreateStore(builder.getFalse(), boolAlloca);
+        const boolValue = builder.CreateLoad(builder.getInt1Ty(), boolAlloca, 'bool_value');
+        const notBoolValue = builder.CreateNot(boolValue, 'not_bool_value');
+        builder.CreateStore(notBoolValue, boolAlloca);
+
+        const flagAlloca = builder.CreateAlloca(builder.getInt64Ty(), null, 'flag_alloca');
+        builder.CreateStore(builder.getInt64(123), flagAlloca);
+        const flagValue = builder.CreateLoad(builder.getInt64Ty(), flagAlloca, 'flag_value');
+        const notFlagValue = builder.CreateNot(flagValue, 'not_flag_value');
+        builder.CreateStore(notFlagValue, flagAlloca);
+
+        const integerAlloca = builder.CreateAlloca(builder.getInt64Ty(), null, 'integer_alloca');
+        builder.CreateStore(builder.getInt64(233), integerAlloca);
+        const integerValue = builder.CreateLoad(builder.getInt64Ty(), integerAlloca, 'integer_value');
+        const negIntegerValue = builder.CreateNeg(integerValue, 'neg_integer_value');
+        builder.CreateStore(negIntegerValue, integerAlloca);
+
+        const floatAlloca = builder.CreateAlloca(builder.getDoubleTy(), null, 'float_alloca');
+        builder.CreateStore(llvm.ConstantFP.get(builder.getDoubleTy(), 11.1), floatAlloca);
+        const floatValue = builder.CreateLoad(builder.getDoubleTy(), floatAlloca, 'float_value');
+        const negFloatValue = builder.CreateFNeg(floatValue, 'neg_float_value');
+        builder.CreateStore(negFloatValue, floatAlloca);
+
+        builder.CreateRetVoid();
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/variable.spec.ts

@@ -0,0 +1,25 @@
+import llvm from '../..';
+
+describe('Test Variable', () => {
+    test('builds and verifies valid IR for alloca/store/load', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('variable', context);
+        const builder = new llvm.IRBuilder(context);
+
+        const returnType = builder.getVoidTy();
+        const functionType = llvm.FunctionType.get(returnType, false);
+        const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'variable', module);
+
+        const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
+        builder.SetInsertPoint(entryBB);
+        const alloca = builder.CreateAlloca(builder.getInt32Ty(), null, 'a');
+        builder.CreateStore(builder.getInt32(11), alloca);
+        const value = builder.CreateLoad(builder.getInt32Ty(), alloca);
+        const cond = builder.CreateICmpSGT(value, builder.getInt32(10), 'cond');
+        builder.CreateSelect(cond, builder.getInt32(10), builder.getInt32(20));
+        builder.CreateRetVoid();
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/test/add.ts

@@ -1,32 +0,0 @@
-import path from 'path';
-import llvm from '..';
-
-export default function testAdd(): void {
-    const filename = path.basename(__filename);
-    const context = new llvm.LLVMContext();
-    const module = new llvm.Module(filename, context);
-    const builder = new llvm.IRBuilder(context);
-
-    const returnType = builder.getInt32Ty();
-    const paramTypes = [builder.getInt32Ty(), builder.getInt32Ty()];
-    const functionType = llvm.FunctionType.get(returnType, paramTypes, false);
-    const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'add', module);
-
-    const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
-    builder.SetInsertPoint(entryBB);
-    const paramA = func.getArg(0);
-    const paramB = func.getArg(1);
-    const result = builder.CreateAdd(paramA, paramB);
-    builder.CreateRet(result);
-
-    console.log(module.print());
-
-    if (llvm.verifyFunction(func)) {
-        console.error(`${filename}: verifying the 'add' function failed`);
-        process.exit(1);
-    }
-    if (llvm.verifyModule(module)) {
-        console.error(`${filename}: verifying the module failed`);
-        process.exit(1);
-    }
-}

package/test/attribute.ts

@@ -1,37 +0,0 @@
-import path from 'path';
-import llvm from '..';
-
-export default function testAttribute(): void {
-    const filename = path.basename(__filename);
-    const context = new llvm.LLVMContext();
-    const module = new llvm.Module(filename, context);
-    const builder = new llvm.IRBuilder(context);
-
-    const returnType = builder.getInt32Ty();
-    const paramTypes = [builder.getInt32Ty(), builder.getInt32Ty()];
-    const functionType = llvm.FunctionType.get(returnType, paramTypes, false);
-    const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'addWithAttributes', module);
-
-    const noInlineAttr = llvm.Attribute.get(context, llvm.Attribute.AttrKind.NoInline);
-    const inRegAttr = llvm.Attribute.get(context, llvm.Attribute.AttrKind.InReg, builder.getInt32Ty());
-    func.addFnAttr(noInlineAttr);
-    func.addParamAttr(0, inRegAttr);
-
-    const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
-    builder.SetInsertPoint(entryBB);
-    const paramA = func.getArg(0);
-    const paramB = func.getArg(1);
-    const result = builder.CreateAdd(paramA, paramB);
-    builder.CreateRet(result);
-
-    console.log(module.print());
-
-    if (llvm.verifyFunction(func)) {
-        console.error(`${filename}: verifying the 'addWithAttributes' function failed`);
-        process.exit(1);
-    }
-    if (llvm.verifyModule(module)) {
-        console.error(`${filename}: verifying the module failed`);
-        process.exit(1);
-    }
-}

package/test/bitcodeWriter.ts

@@ -1,44 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import llvm from '..';
-
-export default function testBitcodeWriter(): void {
-    const filename = path.basename(__filename);
-    const context = new llvm.LLVMContext();
-    const module = new llvm.Module(filename, context);
-    const builder = new llvm.IRBuilder(context);
-
-    const returnType = builder.getInt32Ty();
-    const paramTypes = [builder.getInt32Ty(), builder.getInt32Ty()];
-    const functionType = llvm.FunctionType.get(returnType, paramTypes, false);
-    const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'writer', module);
-
-    const entryBB = llvm.BasicBlock.Create(context, 'entry');
-    builder.SetInsertPoint(entryBB);
-    const paramA = func.getArg(0);
-    const paramB = func.getArg(1);
-    const result = builder.CreateAdd(paramA, paramB);
-    builder.CreateRet(result);
-
-    console.log(module.print());
-
-    if (llvm.verifyFunction(func)) {
-        console.error(`${filename}: verifying the 'writer' function failed`);
-        process.exit(1);
-    }
-    if (llvm.verifyModule(module)) {
-        console.error(`${filename}: verifying the module failed`);
-        process.exit(1);
-    }
-
-    const outputDir = path.join(__dirname, 'temp');
-    const outputBitcodePath = path.join(outputDir, 'add.out.bc');
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir);
-    }
-    if (fs.existsSync(outputBitcodePath)) {
-        fs.unlinkSync(outputBitcodePath);
-    }
-    llvm.WriteBitcodeToFile(module, outputBitcodePath);
-    console.log(`${filename}: bitcode was successfully written to the ${outputBitcodePath}`);
-}

package/test/class.ts

@@ -1,39 +0,0 @@
-import path from 'path';
-import llvm from '..';
-
-export default function testClass(): void {
-    const filename = path.basename(__filename);
-    const context = new llvm.LLVMContext();
-    const module = new llvm.Module(filename, context);
-    const builder = new llvm.IRBuilder(context);
-
-    const elementTypes = [builder.getInt32Ty(), builder.getInt32Ty()];
-    const classStructType = llvm.StructType.create(context, elementTypes, 'Person');
-
-    const returnType = builder.getVoidTy();
-    const paramTypes = [llvm.PointerType.getUnqual(classStructType)];
-    const functionType = llvm.FunctionType.get(returnType, paramTypes, false);
-    const func = llvm.Function.Create(functionType, llvm.Function.LinkageTypes.ExternalLinkage, 'class_Person_constructor', module);
-
-    const entryBB = llvm.BasicBlock.Create(context, 'entry', func);
-    builder.SetInsertPoint(entryBB);
-
-    const thisPtr = func.getArg(0);
-    const propertyPtr = builder.CreateGEP(classStructType, thisPtr, [
-        builder.getInt32(0),
-        builder.getInt32(1)
-    ]);
-    builder.CreateStore(builder.getInt32(111), propertyPtr);
-    builder.CreateRetVoid();
-
-    console.log(module.print());
-
-    if (llvm.verifyFunction(func)) {
-        console.error(`${filename}: verifying the 'class_Person_constructor' function failed`);
-        process.exit(1);
-    }
-    if (llvm.verifyModule(module)) {
-        console.error(`${filename}: verifying the module failed`);
-        process.exit(1);
-    }
-};