@designliquido/llvm-bindings 2.0.0 → 4.0.0

package/.github/workflows/build.yml

@@ -15,8 +15,8 @@ on:
       - 'LICENSE'
 
 env:
-  LLVM_VERSION: 16.0.6
-  LLVM_VERSION_MAJOR: 16
+  LLVM_VERSION: 17.0.6
+  LLVM_VERSION_MAJOR: 17
 
 jobs:
   build-push:

package/CHANGELOG.md

@@ -1,3 +1,4 @@
+# [2.0.0](https://github.com/DesignLiquido/llvm-bindings/compare/v1.0.0...v2.0.0) (2026-03-08)
 # [1.0.0](https://github.com/DesignLiquido/llvm-bindings/compare/v0.4.2...v1.0.0) (2026-03-08)
 
 

package/CMakeLists.txt

@@ -19,8 +19,8 @@ add_library(${PROJECT_NAME} SHARED ${CMAKE_JS_SRC} ${SOURCE_FILES})
 set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node" LINKER_LANGUAGE CXX)
 
 if (MSVC)
-    # cmake-js forces /MT (MultiThreaded static CRT), but LLVM 15 prebuilt Windows
-    # libraries were compiled with /MD (MultiThreadedDLL dynamic CRT). Override
+    # cmake-js forces /MT (MultiThreaded static CRT), but LLVM prebuilt Windows
+    # libraries are compiled with /MD (MultiThreadedDLL dynamic CRT). Override
     # per-target so the linker can resolve __imp_strdup, __imp_read, etc. from ucrtbase.dll.
     set_property(TARGET ${PROJECT_NAME} PROPERTY MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")
 endif ()

package/README.md

@@ -150,6 +150,7 @@ To opt into opaque pointers, pass an `LLVMContext` to `PointerType.get` / `getUn
 | (original llvm-bindings repo) 0.4.x        | 14.0.x                   |
 | (@designliquido/llvm-bindings) 0.1.x       | 14.0.x                   |
 | (@designliquido/llvm-bindings) 1.0.x       | 15.0.x                   |
+| (@designliquido/llvm-bindings) 2.0.x       | 16.0.x                   |
 
 ## Acknowledgments
 

package/cmake/LLVM.cmake

@@ -7,7 +7,7 @@ if (CMAKE_HOST_APPLE)
     endforeach ()
 endif ()
 
-find_package(LLVM 16 REQUIRED CONFIG)
+find_package(LLVM 17 REQUIRED CONFIG)
 
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@designliquido/llvm-bindings",
-    "version": "2.0.0",
+    "version": "4.0.0",
     "description": "LLVM bindings for Node.js/JavaScript/TypeScript",
     "keywords": [
         "llvm",
@@ -25,14 +25,13 @@
     },
     "scripts": {
         "build": "yarn build:ts",
-        "build:ts": "tsc",
+        "build:ts": "yarn tsc",
         "prepare": "yarn build:ts",
         "postinstall": "cmake-js compile",
         "build:debug": "cmake-js build -D",
         "build:release": "cmake-js build",
-        "clear": "rimraf build dist",
-        "test:legacy": "ts-node test/index.ts",
-        "test": "yarn build:ts && yarn test:legacy && yarn jest --verbose",
+        "clear": "yarn rimraf build dist",
+        "test": "yarn build:ts && yarn jest --verbose",
         "release:patch": "release-it patch",
         "release:minor": "release-it minor",
         "release:major": "release-it major"
@@ -51,7 +50,6 @@
         "release-it": "^19.2.4",
         "rimraf": "^6.1.3",
         "ts-jest": "^28.0.5",
-        "ts-node": "^10.8.1",
         "typescript": "^5.9.3"
     },
     "jest": {

package/src/IR/Intrinsic.cpp

@@ -81,7 +81,6 @@ void Intrinsic::Init(Napi::Env env, Napi::Object &exports) {
     intrinsicNS.Set("ctlz", Napi::Number::New(env, llvm::Intrinsic::ctlz));
     intrinsicNS.Set("ctpop", Napi::Number::New(env, llvm::Intrinsic::ctpop));
     intrinsicNS.Set("cttz", Napi::Number::New(env, llvm::Intrinsic::cttz));
-    intrinsicNS.Set("dbg_addr", Napi::Number::New(env, llvm::Intrinsic::dbg_addr));
     intrinsicNS.Set("dbg_declare", Napi::Number::New(env, llvm::Intrinsic::dbg_declare));
     intrinsicNS.Set("dbg_label", Napi::Number::New(env, llvm::Intrinsic::dbg_label));
     intrinsicNS.Set("dbg_value", Napi::Number::New(env, llvm::Intrinsic::dbg_value));

package/tests/IR/OpaquePointer.spec.ts

@@ -0,0 +1,39 @@
+import llvm from '../..';
+
+describe('Test Opaque Pointer (LLVM 17)', () => {
+    test('PointerType.getUnqual returns a pointer type', () => {
+        const context = new llvm.LLVMContext();
+        const ptr = llvm.PointerType.getUnqual(llvm.Type.getInt8Ty(context));
+        expect(ptr.isPointerTy()).toBe(true);
+    });
+
+    test('PointerType.get(type, addrSpace) returns a pointer type', () => {
+        const context = new llvm.LLVMContext();
+        const ptr = llvm.PointerType.get(llvm.Type.getInt8Ty(context), 0);
+        expect(ptr.isPointerTy()).toBe(true);
+    });
+
+    test('getUnqual, get(AS0), and getInt8PtrTy all resolve to the same type', () => {
+        const context = new llvm.LLVMContext();
+        const a = llvm.PointerType.getUnqual(llvm.Type.getInt8Ty(context));
+        const b = llvm.PointerType.get(llvm.Type.getInt8Ty(context), 0);
+        const c = llvm.Type.getInt8PtrTy(context);
+        expect(llvm.Type.isSameType(a, b)).toBe(true);
+        expect(llvm.Type.isSameType(a, c)).toBe(true);
+    });
+
+    test('pointers in different address spaces are both pointer types', () => {
+        const context = new llvm.LLVMContext();
+        const as0 = llvm.PointerType.get(llvm.Type.getInt8Ty(context), 0);
+        const as1 = llvm.PointerType.get(llvm.Type.getInt8Ty(context), 1);
+        expect(as0.isPointerTy()).toBe(true);
+        expect(as1.isPointerTy()).toBe(true);
+        // Note: isSameType does not currently compare address spaces for opaque
+        // pointers — that is a known limitation of the binding's implementation.
+    });
+
+    // The following require a binary rebuilt against LLVM 17:
+    //   - PointerType.getUnqual(context)   — context overload
+    //   - PointerType.get(context, addrSpace) — context overload
+    //   - ptr.isOpaque()                   — method not yet registered
+});

package/tests/IR/Type.spec.ts

@@ -0,0 +1,24 @@
+import llvm from '../..';
+
+describe('Test Type', () => {
+    test('isSameType correctly compares primitive and pointer types', () => {
+        const context = new llvm.LLVMContext();
+
+        const int32 = llvm.Type.getInt32Ty(context);
+        const int32b = llvm.IntegerType.get(context, 32);
+        const int8Ptr = llvm.Type.getInt8PtrTy(context);
+        const unqualPtr = llvm.PointerType.getUnqual(llvm.Type.getInt8Ty(context));
+        const voidTy = llvm.Type.getVoidTy(context);
+
+        expect(llvm.Type.isSameType(int32, int32b)).toBe(true);
+        expect(llvm.Type.isSameType(int32, int8Ptr)).toBe(false);
+        expect(llvm.Type.isSameType(int32, unqualPtr)).toBe(false);
+        expect(llvm.Type.isSameType(int32, voidTy)).toBe(false);
+        expect(llvm.Type.isSameType(int32b, int8Ptr)).toBe(false);
+        expect(llvm.Type.isSameType(int32b, unqualPtr)).toBe(false);
+        expect(llvm.Type.isSameType(int32b, voidTy)).toBe(false);
+        expect(llvm.Type.isSameType(int8Ptr, unqualPtr)).toBe(true);
+        expect(llvm.Type.isSameType(int8Ptr, voidTy)).toBe(false);
+        expect(llvm.Type.isSameType(unqualPtr, voidTy)).toBe(false);
+    });
+});

package/tests/fixtures/add.spec.ts

@@ -0,0 +1,24 @@
+import llvm from '../..';
+
+describe('Test Add', () => {
+    test('builds and verifies valid IR for an add function', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('add', 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);
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

package/tests/fixtures/attribute.spec.ts

@@ -0,0 +1,27 @@
+import llvm from '../..';
+
+describe('Test Attribute', () => {
+    test('builds and verifies valid IR with function and parameter attributes', () => {
+        const context = new llvm.LLVMContext();
+        const module = new llvm.Module('attribute', 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 result = builder.CreateAdd(func.getArg(0), func.getArg(1));
+        builder.CreateRet(result);
+
+        expect(llvm.verifyFunction(func)).toBe(false);
+        expect(llvm.verifyModule(module)).toBe(false);
+    });
+});

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);
+    });
+});