@designliquido/llvm-bindings 1.0.0 → 4.0.0

package/.github/workflows/build.yml

@@ -15,8 +15,8 @@ on:
       - 'LICENSE'
 
 env:
-  LLVM_VERSION: 15.0.7
-  LLVM_VERSION_MAJOR: 15
+  LLVM_VERSION: 17.0.6
+  LLVM_VERSION_MAJOR: 17
 
 jobs:
   build-push:
@@ -39,7 +39,7 @@ jobs:
         if: startsWith(matrix.os, 'macos')
         run: |
           brew update
-          brew install llvm@${{ env.LLVM_VERSION_MAJOR }} ninja
+          brew install llvm@${{ env.LLVM_VERSION_MAJOR }} ninja || brew link --overwrite python@3.12
       - name: Install LLVM and Ninja on Ubuntu (via llvm.sh)
         if: startsWith(matrix.os, 'ubuntu') && matrix.os != 'ubuntu-24.04'
         run: |
@@ -56,7 +56,7 @@ jobs:
         if: startsWith(matrix.os, 'windows')
         run: |
           $LLVM_VERSION = "${{ env.LLVM_VERSION }}"
-          $LLVM_PREBUILT_FILE = "llvm-$LLVM_VERSION-windows-latest.zip"
+          $LLVM_PREBUILT_FILE = "llvm-$LLVM_VERSION-windows-2022.zip"
           curl -sLO "https://github.com/DesignLiquido/llvm-windows/releases/download/llvmorg-$LLVM_VERSION/$LLVM_PREBUILT_FILE"
           Expand-Archive -Path $LLVM_PREBUILT_FILE -DestinationPath .
           $LLVM_CMAKE_DIR = "$pwd/LLVM-$LLVM_VERSION-win64/lib/cmake/llvm"
@@ -107,7 +107,7 @@ jobs:
         if: startsWith(matrix.os, 'macos')
         run: |
           brew update
-          brew install llvm@${{ env.LLVM_VERSION_MAJOR }} ninja
+          brew install llvm@${{ env.LLVM_VERSION_MAJOR }} ninja || brew link --overwrite python@3.12
       - name: Install LLVM and Ninja on Ubuntu (via llvm.sh)
         if: startsWith(matrix.os, 'ubuntu') && matrix.os != 'ubuntu-24.04'
         run: |
@@ -124,7 +124,7 @@ jobs:
         if: startsWith(matrix.os, 'windows')
         run: |
           $LLVM_VERSION = "${{ env.LLVM_VERSION }}"
-          $LLVM_PREBUILT_FILE = "llvm-$LLVM_VERSION-windows-latest.zip"
+          $LLVM_PREBUILT_FILE = "llvm-$LLVM_VERSION-windows-2022.zip"
           curl -sLO "https://github.com/DesignLiquido/llvm-windows/releases/download/llvmorg-$LLVM_VERSION/$LLVM_PREBUILT_FILE"
           Expand-Archive -Path $LLVM_PREBUILT_FILE -DestinationPath .
           $LLVM_CMAKE_DIR = "$pwd/LLVM-$LLVM_VERSION-win64/lib/cmake/llvm"

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [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)
+
+
+### Bug Fixes
+
+* uncomment test entry ([69c93f7](https://github.com/DesignLiquido/llvm-bindings/commit/69c93f7aae697c3cb3e75d01e447554b0565e3d5))
+
+
+### Features
+
+* **Attribute:** add basic support for enum attributes ([#32](https://github.com/DesignLiquido/llvm-bindings/issues/32)) ([db45aa5](https://github.com/DesignLiquido/llvm-bindings/commit/db45aa583729956dfefa01772ab69f019e56b05a))
 ## [1.0.0] - 2026-03-07
 
 ### Added

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

@@ -148,8 +148,9 @@ To opt into opaque pointers, pass an `LLVMContext` to `PointerType.get` / `getUn
 | (original llvm-bindings repo) 0.2.x        | 12.0.x                   |
 | (original llvm-bindings repo) 0.3.x        | 13.0.x                   |
 | (original llvm-bindings repo) 0.4.x        | 14.0.x                   |
-| (@designliquido/llvm-bindings) 0.1.x       | 15.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 15 REQUIRED CONFIG)
+find_package(LLVM 17 REQUIRED CONFIG)
 
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 

package/include/IR/DerivedTypes.h

@@ -228,7 +228,7 @@ private:
 
     Napi::Value getTypeID(const Napi::CallbackInfo &info);
 
-    Napi::Value getPointerElementType(const Napi::CallbackInfo &info);
+    Napi::Value getNonOpaquePointerElementType(const Napi::CallbackInfo &info);
 
     Napi::Value isOpaque(const Napi::CallbackInfo &info);
 };

package/include/IR/Type.h

@@ -39,7 +39,7 @@ private:
         return Napi::Boolean::New(info.Env(), (type->*method)());
     }
 
-    Napi::Value getPointerElementType(const Napi::CallbackInfo &info);
+    Napi::Value getNonOpaquePointerElementType(const Napi::CallbackInfo &info);
 
     static Napi::Value isSameType(const Napi::CallbackInfo &info);
 };

package/include/assert.h

@@ -0,0 +1,13 @@
+#ifndef LLVM_BINDINGS_NODEJS_ASSERT_H
+#define LLVM_BINDINGS_NODEJS_ASSERT_H
+
+#ifdef __cplusplus
+void llvm_bindings_assert(const char* expr, const char* file, int line);
+
+#define LLVM_BINDINGS_ASSERT_IMPL(e, file, line) ((void)llvm_bindings_assert ((e), (file), (line)))
+
+#define assert(e) ((void) ((e) ? ((void)0) : LLVM_BINDINGS_ASSERT_IMPL (#e, __FILE__, __LINE__)))
+
+#endif
+
+#endif

package/llvm-bindings.d.ts

@@ -369,7 +369,7 @@ declare namespace llvm {
 
         public getPrimitiveSizeInBits(): number;
 
-        public getPointerElementType(): Type;
+        public getNonOpaquePointerElementType(): Type;
 
         // extra
         public static isSameType(type1: Type, type2: Type): boolean;
@@ -513,8 +513,10 @@ declare namespace llvm {
         // duplicated
         public getTypeID(): number;
 
-        // duplicated
-        public getPointerElementType(): Type;
+        /**
+         * @deprecated In LLVM 15/16 this is deprecated. LLVM 17 removes it.
+         */
+        public getNonOpaquePointerElementType(): Type;
 
         public isOpaque(): boolean;
 
@@ -1943,7 +1945,6 @@ declare namespace llvm {
         const expect_with_probability: number;
         const fabs: number;
         const floor: number;
-        const flt_rounds: number;
         const fma: number;
         const fmuladd: number;
         const fptosi_sat: number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@designliquido/llvm-bindings",
-    "version": "1.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/Attributes.cpp

@@ -5,88 +5,12 @@ void Attribute::Init(Napi::Env env, Napi::Object &exports) {
     Napi::HandleScope scope(env);
 
     Napi::Object attributeKinds = Napi::Object::New(env);
-    attributeKinds.Set("AlwaysInline", Napi::Number::New(env, llvm::Attribute::AttrKind::AlwaysInline));
-    attributeKinds.Set("ArgMemOnly", Napi::Number::New(env, llvm::Attribute::AttrKind::ArgMemOnly));
-    attributeKinds.Set("Builtin", Napi::Number::New(env, llvm::Attribute::AttrKind::Builtin));
-    attributeKinds.Set("Cold", Napi::Number::New(env, llvm::Attribute::AttrKind::Cold));
-    attributeKinds.Set("Convergent", Napi::Number::New(env, llvm::Attribute::AttrKind::Convergent));
-    attributeKinds.Set("DisableSanitizerInstrumentation",
-                       Napi::Number::New(env, llvm::Attribute::AttrKind::DisableSanitizerInstrumentation));
-    attributeKinds.Set("Hot", Napi::Number::New(env, llvm::Attribute::AttrKind::Hot));
-    attributeKinds.Set("ImmArg", Napi::Number::New(env, llvm::Attribute::AttrKind::ImmArg));
-    attributeKinds.Set("InReg", Napi::Number::New(env, llvm::Attribute::AttrKind::InReg));
-    attributeKinds.Set("InaccessibleMemOnly", Napi::Number::New(env, llvm::Attribute::AttrKind::InaccessibleMemOnly));
-    attributeKinds.Set("InaccessibleMemOrArgMemOnly",
-                       Napi::Number::New(env, llvm::Attribute::AttrKind::InaccessibleMemOrArgMemOnly));
-    attributeKinds.Set("InlineHint", Napi::Number::New(env, llvm::Attribute::AttrKind::InlineHint));
-    attributeKinds.Set("JumpTable", Napi::Number::New(env, llvm::Attribute::AttrKind::JumpTable));
-    attributeKinds.Set("MinSize", Napi::Number::New(env, llvm::Attribute::AttrKind::MinSize));
-    attributeKinds.Set("MustProgress", Napi::Number::New(env, llvm::Attribute::AttrKind::MustProgress));
-    attributeKinds.Set("Naked", Napi::Number::New(env, llvm::Attribute::AttrKind::Naked));
-    attributeKinds.Set("Nest", Napi::Number::New(env, llvm::Attribute::AttrKind::Nest));
-    attributeKinds.Set("NoAlias", Napi::Number::New(env, llvm::Attribute::AttrKind::NoAlias));
-    attributeKinds.Set("NoBuiltin", Napi::Number::New(env, llvm::Attribute::AttrKind::NoBuiltin));
-    attributeKinds.Set("NoCallback", Napi::Number::New(env, llvm::Attribute::AttrKind::NoCallback));
-    attributeKinds.Set("NoCapture", Napi::Number::New(env, llvm::Attribute::AttrKind::NoCapture));
-    attributeKinds.Set("NoCfCheck", Napi::Number::New(env, llvm::Attribute::AttrKind::NoCfCheck));
-    attributeKinds.Set("NoDuplicate", Napi::Number::New(env, llvm::Attribute::AttrKind::NoDuplicate));
-    attributeKinds.Set("NoFree", Napi::Number::New(env, llvm::Attribute::AttrKind::NoFree));
-    attributeKinds.Set("NoImplicitFloat", Napi::Number::New(env, llvm::Attribute::AttrKind::NoImplicitFloat));
-    attributeKinds.Set("NoInline", Napi::Number::New(env, llvm::Attribute::AttrKind::NoInline));
-    attributeKinds.Set("NoMerge", Napi::Number::New(env, llvm::Attribute::AttrKind::NoMerge));
-    attributeKinds.Set("NoProfile", Napi::Number::New(env, llvm::Attribute::AttrKind::NoProfile));
-    attributeKinds.Set("NoRecurse", Napi::Number::New(env, llvm::Attribute::AttrKind::NoRecurse));
-    attributeKinds.Set("NoRedZone", Napi::Number::New(env, llvm::Attribute::AttrKind::NoRedZone));
-    attributeKinds.Set("NoReturn", Napi::Number::New(env, llvm::Attribute::AttrKind::NoReturn));
-    attributeKinds.Set("NoSanitizeCoverage", Napi::Number::New(env, llvm::Attribute::AttrKind::NoSanitizeCoverage));
-    attributeKinds.Set("NoSync", Napi::Number::New(env, llvm::Attribute::AttrKind::NoSync));
-    attributeKinds.Set("NoUndef", Napi::Number::New(env, llvm::Attribute::AttrKind::NoUndef));
-    attributeKinds.Set("NoUnwind", Napi::Number::New(env, llvm::Attribute::AttrKind::NoUnwind));
-    attributeKinds.Set("NonLazyBind", Napi::Number::New(env, llvm::Attribute::AttrKind::NonLazyBind));
-    attributeKinds.Set("NonNull", Napi::Number::New(env, llvm::Attribute::AttrKind::NonNull));
-    attributeKinds.Set("NullPointerIsValid", Napi::Number::New(env, llvm::Attribute::AttrKind::NullPointerIsValid));
-    attributeKinds.Set("OptForFuzzing", Napi::Number::New(env, llvm::Attribute::AttrKind::OptForFuzzing));
-    attributeKinds.Set("OptimizeForSize", Napi::Number::New(env, llvm::Attribute::AttrKind::OptimizeForSize));
-    attributeKinds.Set("OptimizeNone", Napi::Number::New(env, llvm::Attribute::AttrKind::OptimizeNone));
-    attributeKinds.Set("ReadNone", Napi::Number::New(env, llvm::Attribute::AttrKind::ReadNone));
-    attributeKinds.Set("ReadOnly", Napi::Number::New(env, llvm::Attribute::AttrKind::ReadOnly));
-    attributeKinds.Set("Returned", Napi::Number::New(env, llvm::Attribute::AttrKind::Returned));
-    attributeKinds.Set("ReturnsTwice", Napi::Number::New(env, llvm::Attribute::AttrKind::ReturnsTwice));
-    attributeKinds.Set("SExt", Napi::Number::New(env, llvm::Attribute::AttrKind::SExt));
-    attributeKinds.Set("SafeStack", Napi::Number::New(env, llvm::Attribute::AttrKind::SafeStack));
-    attributeKinds.Set("SanitizeAddress", Napi::Number::New(env, llvm::Attribute::AttrKind::SanitizeAddress));
-    attributeKinds.Set("SanitizeHWAddress", Napi::Number::New(env, llvm::Attribute::AttrKind::SanitizeHWAddress));
-    attributeKinds.Set("SanitizeMemTag", Napi::Number::New(env, llvm::Attribute::AttrKind::SanitizeMemTag));
-    attributeKinds.Set("SanitizeMemory", Napi::Number::New(env, llvm::Attribute::AttrKind::SanitizeMemory));
-    attributeKinds.Set("SanitizeThread", Napi::Number::New(env, llvm::Attribute::AttrKind::SanitizeThread));
-    attributeKinds.Set("ShadowCallStack", Napi::Number::New(env, llvm::Attribute::AttrKind::ShadowCallStack));
-    attributeKinds.Set("Speculatable", Napi::Number::New(env, llvm::Attribute::AttrKind::Speculatable));
-    attributeKinds.Set("SpeculativeLoadHardening",
-                       Napi::Number::New(env, llvm::Attribute::AttrKind::SpeculativeLoadHardening));
-    attributeKinds.Set("StackProtect", Napi::Number::New(env, llvm::Attribute::AttrKind::StackProtect));
-    attributeKinds.Set("StackProtectReq", Napi::Number::New(env, llvm::Attribute::AttrKind::StackProtectReq));
-    attributeKinds.Set("StackProtectStrong", Napi::Number::New(env, llvm::Attribute::AttrKind::StackProtectStrong));
-    attributeKinds.Set("StrictFP", Napi::Number::New(env, llvm::Attribute::AttrKind::StrictFP));
-    attributeKinds.Set("SwiftAsync", Napi::Number::New(env, llvm::Attribute::AttrKind::SwiftAsync));
-    attributeKinds.Set("SwiftError", Napi::Number::New(env, llvm::Attribute::AttrKind::SwiftError));
-    attributeKinds.Set("SwiftSelf", Napi::Number::New(env, llvm::Attribute::AttrKind::SwiftSelf));
-    attributeKinds.Set("UWTable", Napi::Number::New(env, llvm::Attribute::AttrKind::UWTable));
-    attributeKinds.Set("WillReturn", Napi::Number::New(env, llvm::Attribute::AttrKind::WillReturn));
-    attributeKinds.Set("WriteOnly", Napi::Number::New(env, llvm::Attribute::AttrKind::WriteOnly));
-    attributeKinds.Set("LastEnumAttr", Napi::Number::New(env, llvm::Attribute::AttrKind::LastEnumAttr));
-    attributeKinds.Set("ByRef", Napi::Number::New(env, llvm::Attribute::AttrKind::ByRef));
-    attributeKinds.Set("ByVal", Napi::Number::New(env, llvm::Attribute::AttrKind::ByVal));
-    attributeKinds.Set("ElementType", Napi::Number::New(env, llvm::Attribute::AttrKind::ElementType));
-    attributeKinds.Set("InAlloca", Napi::Number::New(env, llvm::Attribute::AttrKind::InAlloca));
-    attributeKinds.Set("Preallocated", Napi::Number::New(env, llvm::Attribute::AttrKind::Preallocated));
-    attributeKinds.Set("LastTypeAttr", Napi::Number::New(env, llvm::Attribute::AttrKind::LastTypeAttr));
-    attributeKinds.Set("Alignment", Napi::Number::New(env, llvm::Attribute::AttrKind::Alignment));
-    attributeKinds.Set("AllocSize", Napi::Number::New(env, llvm::Attribute::AttrKind::AllocSize));
-    attributeKinds.Set("Dereferenceable", Napi::Number::New(env, llvm::Attribute::AttrKind::Dereferenceable));
-    attributeKinds.Set("DereferenceableOrNull",
-                       Napi::Number::New(env, llvm::Attribute::AttrKind::DereferenceableOrNull));
-    attributeKinds.Set("StackAlignment", Napi::Number::New(env, llvm::Attribute::AttrKind::StackAlignment));
-    attributeKinds.Set("VScaleRange", Napi::Number::New(env, llvm::Attribute::AttrKind::VScaleRange));
+
+#define GET_ATTR_NAMES
+#define ATTRIBUTE_ENUM(EnumName, lower) attributeKinds.Set(#EnumName, Napi::Number::New(env, llvm::Attribute::AttrKind::EnumName));
+#include "llvm/IR/Attributes.inc"
+#undef GET_ATTR_NAMES
+#undef ATTRIBUTE_ENUM
 
     Napi::Function func = DefineClass(env, "Attribute", {
             StaticValue("AttrKind", attributeKinds),

package/src/IR/DataLayout.cpp

@@ -53,7 +53,7 @@ Napi::Value DataLayout::getTypeAllocSize(const Napi::CallbackInfo &info) {
     if (info.Length() == 1 && Type::IsClassOf(info[0])) {
         llvm::Type *type = Type::Extract(info[0]);
         auto allocSize = dataLayout->getTypeAllocSize(type);
-        return Napi::Number::New(env, double(allocSize.getFixedSize()));
+        return Napi::Number::New(env, static_cast<double>(allocSize.getFixedValue()));
     }
     throw Napi::TypeError::New(env, ErrMsg::Class::DataLayout::getTypeAllocSize);
 }

package/src/IR/DerivedTypes.cpp

@@ -565,7 +565,7 @@ void PointerType::Init(Napi::Env env, Napi::Object &exports) {
             InstanceMethod("isIntegerTy", &PointerType::isIntegerTy),
             InstanceMethod("isVoidTy", &PointerType::isVoidTy),
             InstanceMethod("getTypeID", &PointerType::getTypeID),
-            InstanceMethod("getPointerElementType", &PointerType::getPointerElementType),
+            InstanceMethod("getNonOpaquePointerElementType", &PointerType::getNonOpaquePointerElementType),
             InstanceMethod("isOpaque", &PointerType::isOpaque)
     });
     constructor = Napi::Persistent(func);
@@ -664,8 +664,8 @@ Napi::Value PointerType::getTypeID(const Napi::CallbackInfo &info) {
     return Napi::Number::New(info.Env(), pointerType->getTypeID());
 }
 
-Napi::Value PointerType::getPointerElementType(const Napi::CallbackInfo &info) {
-    return Type::New(info.Env(), pointerType->getPointerElementType());
+Napi::Value PointerType::getNonOpaquePointerElementType(const Napi::CallbackInfo &info) {
+    return Type::New(info.Env(), pointerType->getNonOpaquePointerElementType());
 }
 
 Napi::Value PointerType::isOpaque(const Napi::CallbackInfo &info) {

package/src/IR/Function.cpp

@@ -111,7 +111,7 @@ void Function::addBasicBlock(const Napi::CallbackInfo &info) {
         throw Napi::TypeError::New(env, ErrMsg::Class::Function::addBasicBlock);
     }
     llvm::BasicBlock *basicBlock = BasicBlock::Extract(info[0]);
-    function->getBasicBlockList().push_back(basicBlock);
+    function->insert(function->end(), basicBlock);
 }
 
 Napi::Value Function::getEntryBlock(const Napi::CallbackInfo &info) {
@@ -129,7 +129,9 @@ void Function::insertAfter(const Napi::CallbackInfo &info) {
     }
     llvm::BasicBlock *where = BasicBlock::Extract(info[0]);
     llvm::BasicBlock *bb = BasicBlock::Extract(info[1]);
-    function->getBasicBlockList().insertAfter(where->getIterator(), bb);
+    auto it = where->getIterator();
+    ++it;
+    function->insert(it, bb);
 }
 
 void Function::deleteBody(const Napi::CallbackInfo &info) {

package/src/IR/IRBuilder.cpp

@@ -498,7 +498,7 @@ Napi::Value IRBuilder::CreateInvoke(const Napi::CallbackInfo &info) {
         llvm::BasicBlock *normalDest = BasicBlock::Extract(info[1]);
         llvm::BasicBlock *unwindDest = BasicBlock::Extract(info[2]);
         std::string name = argsLen == 4 ? std::string(info[3].As<Napi::String>()) : "";
-        invokeInst = builder->CreateInvoke(callee, normalDest, unwindDest, llvm::None, name);
+        invokeInst = builder->CreateInvoke(callee, normalDest, unwindDest, {}, name);
     } else if (argsLen == 4 && Function::IsClassOf(info[0]) && BasicBlock::IsClassOf(info[1]) && BasicBlock::IsClassOf(info[2]) && info[3].IsArray() ||
                argsLen == 5 && Function::IsClassOf(info[0]) && BasicBlock::IsClassOf(info[1]) && BasicBlock::IsClassOf(info[2]) && info[3].IsArray() && info[4].IsString()) {
         if (assembleArray<WrappedValue>(info[3].As<Napi::Array>(), calleeArgs)) {
@@ -514,7 +514,7 @@ Napi::Value IRBuilder::CreateInvoke(const Napi::CallbackInfo &info) {
         llvm::BasicBlock *normalDest = BasicBlock::Extract(info[1]);
         llvm::BasicBlock *unwindDest = BasicBlock::Extract(info[2]);
         std::string name = argsLen == 4 ? std::string(info[3].As<Napi::String>()) : "";
-        invokeInst = builder->CreateInvoke(callee, normalDest, unwindDest, llvm::None, name);
+        invokeInst = builder->CreateInvoke(callee, normalDest, unwindDest, {}, name);
     } else if (argsLen == 4 && FunctionCallee::IsClassOf(info[0]) && BasicBlock::IsClassOf(info[1]) && BasicBlock::IsClassOf(info[2]) && info[3].IsArray() ||
                argsLen == 5 && FunctionCallee::IsClassOf(info[0]) && BasicBlock::IsClassOf(info[1]) && BasicBlock::IsClassOf(info[2]) && info[3].IsArray() && info[4].IsString()) {
         if (assembleArray<WrappedValue>(info[3].As<Napi::Array>(), calleeArgs)) {
@@ -533,7 +533,7 @@ Napi::Value IRBuilder::CreateInvoke(const Napi::CallbackInfo &info) {
         llvm::BasicBlock *normalDest = BasicBlock::Extract(info[2]);
         llvm::BasicBlock *unwindDest = BasicBlock::Extract(info[3]);
         std::string name = argsLen == 5 ? std::string(info[4].As<Napi::String>()) : "";
-        invokeInst = builder->CreateInvoke(funcType, callee, normalDest, unwindDest, llvm::None, name);
+        invokeInst = builder->CreateInvoke(funcType, callee, normalDest, unwindDest, {}, name);
     } else if (argsLen == 5 && FunctionType::IsClassOf(info[0]) && Function::IsClassOf(info[1]) && BasicBlock::IsClassOf(info[2]) &&
                BasicBlock::IsClassOf(info[3]) && info[4].IsArray() ||
                argsLen == 6 && FunctionType::IsClassOf(info[0]) && Function::IsClassOf(info[1]) && BasicBlock::IsClassOf(info[2]) &&
@@ -711,7 +711,7 @@ Napi::Value IRBuilder::CreateCall(const Napi::CallbackInfo &info) {
         argsLen == 2 && Function::IsClassOf(info[0]) && info[1].IsString()) {
         llvm::Function *callee = Function::Extract(info[0]);
         std::string name = argsLen == 2 ? std::string(info[1].As<Napi::String>()) : "";
-        callInst = builder->CreateCall(callee, llvm::None, name);
+        callInst = builder->CreateCall(callee, {}, name);
     } else if (argsLen == 2 && Function::IsClassOf(info[0]) && info[1].IsArray() ||
                argsLen == 3 && Function::IsClassOf(info[0]) && info[1].IsArray() && info[2].IsString()) {
         if (assembleArray<WrappedValue>(info[1].As<Napi::Array>(), calleeArgs)) {
@@ -723,7 +723,7 @@ Napi::Value IRBuilder::CreateCall(const Napi::CallbackInfo &info) {
                argsLen == 2 && FunctionCallee::IsClassOf(info[0]) && info[1].IsString()) {
         llvm::FunctionCallee callee = FunctionCallee::Extract(info[0]);
         std::string name = argsLen == 2 ? std::string(info[1].As<Napi::String>()) : "";
-        callInst = builder->CreateCall(callee, llvm::None, name);
+        callInst = builder->CreateCall(callee, {}, name);
     } else if (argsLen == 2 && FunctionCallee::IsClassOf(info[0]) && info[1].IsArray() ||
                argsLen == 3 && FunctionCallee::IsClassOf(info[0]) && info[1].IsArray() && info[2].IsString()) {
         if (assembleArray<WrappedValue>(info[1].As<Napi::Array>(), calleeArgs)) {
@@ -736,7 +736,7 @@ Napi::Value IRBuilder::CreateCall(const Napi::CallbackInfo &info) {
         llvm::FunctionType *funcType = FunctionType::Extract(info[0]);
         llvm::Value *callee = Value::Extract(info[1]);
         std::string name = argsLen == 3 ? std::string(info[2].As<Napi::String>()) : "";
-        callInst = builder->CreateCall(funcType, callee, llvm::None, name);
+        callInst = builder->CreateCall(funcType, callee, {}, name);
     } else if (argsLen == 3 && FunctionType::IsClassOf(info[0]) && Value::IsClassOf(info[1]) && info[2].IsArray() ||
                argsLen == 4 && FunctionType::IsClassOf(info[0]) && Value::IsClassOf(info[1]) && info[2].IsArray() && info[3].IsString()) {
         if (assembleArray<WrappedValue>(info[2].As<Napi::Array>(), calleeArgs)) {

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));
@@ -107,7 +106,6 @@ void Intrinsic::Init(Napi::Env env, Napi::Object &exports) {
     intrinsicNS.Set("expect_with_probability", Napi::Number::New(env, llvm::Intrinsic::expect_with_probability));
     intrinsicNS.Set("fabs", Napi::Number::New(env, llvm::Intrinsic::fabs));
     intrinsicNS.Set("floor", Napi::Number::New(env, llvm::Intrinsic::floor));
-    intrinsicNS.Set("flt_rounds", Napi::Number::New(env, llvm::Intrinsic::flt_rounds));
     intrinsicNS.Set("fma", Napi::Number::New(env, llvm::Intrinsic::fma));
     intrinsicNS.Set("fmuladd", Napi::Number::New(env, llvm::Intrinsic::fmuladd));
     intrinsicNS.Set("fptosi_sat", Napi::Number::New(env, llvm::Intrinsic::fptosi_sat));

package/src/IR/LLVMContext.cpp

@@ -23,7 +23,6 @@ LLVMContext::LLVMContext(const Napi::CallbackInfo &info) : ObjectWrap(info) {
         throw Napi::TypeError::New(env, ErrMsg::Class::LLVMContext::constructor);
     }
     context = new llvm::LLVMContext();
-    context->setOpaquePointers(false);
 }
 
 llvm::LLVMContext &LLVMContext::getLLVMPrimitive() {

package/src/IR/Type.cpp

@@ -126,7 +126,7 @@ void Type::Init(Napi::Env env, Napi::Object &exports) {
             InstanceMethod("isAggregateType", &Type::isTypeFactory<&llvm::Type::isAggregateType>),
             InstanceMethod("getPointerTo", &Type::getPointerTo),
             InstanceMethod("getPrimitiveSizeInBits", &Type::getPrimitiveSizeInBits),
-            InstanceMethod("getPointerElementType", &Type::getPointerElementType),
+            InstanceMethod("getNonOpaquePointerElementType", &Type::getNonOpaquePointerElementType),
             StaticMethod("isSameType", &Type::isSameType)
     });
     constructor = Napi::Persistent(func);
@@ -216,8 +216,8 @@ Napi::Value Type::isIntegerTy(const Napi::CallbackInfo &info) {
     return Napi::Boolean::New(env, result);
 }
 
-Napi::Value Type::getPointerElementType(const Napi::CallbackInfo &info) {
-    return Type::New(info.Env(), type->getPointerElementType());
+Napi::Value Type::getNonOpaquePointerElementType(const Napi::CallbackInfo &info) {
+    return Type::New(info.Env(), type->getNonOpaquePointerElementType());
 }
 
 static bool isSameType(llvm::Type *type1, llvm::Type *type2) {
@@ -248,7 +248,7 @@ static bool isSameType(llvm::Type *type1, llvm::Type *type2) {
         if (type1->isOpaquePointerTy() || type2->isOpaquePointerTy()) {
             return type1->isOpaquePointerTy() && type2->isOpaquePointerTy();
         }
-        return isSameType(type1->getPointerElementType(), type2->getPointerElementType());
+        return isSameType(type1->getNonOpaquePointerElementType(), type2->getNonOpaquePointerElementType());
     } else if (type1->isStructTy()) {
         unsigned numElements = type1->getStructNumElements();
         if (numElements != type2->getStructNumElements()) {

package/src/MC/TargetRegistry.cpp

@@ -45,7 +45,8 @@ Napi::Value Target::createTargetMachine(const Napi::CallbackInfo &info) {
         features = info[2].As<Napi::String>();
     }
     llvm::TargetOptions options{};
-    llvm::TargetMachine *targetMachinePtr = target->createTargetMachine(targetTriple, cpu, features, options, llvm::Optional<llvm::Reloc::Model>{});
+    llvm::TargetMachine *targetMachinePtr = target->createTargetMachine(
+        targetTriple, cpu, features, options, std::optional<llvm::Reloc::Model>{});
     return TargetMachine::New(env, targetMachinePtr);
 }
 

package/src/llvm-bindings.cpp

@@ -1,3 +1,8 @@
+#include <cstdio>
+#include <memory>
+#include <stdexcept>
+#include <string>
+
 #include "ADT/index.h"
 #include "BinaryFormat/index.h"
 #include "Bitcode/index.h"
@@ -9,7 +14,27 @@
 #include "Support/index.h"
 #include "Target/index.h"
 
+template<typename ... Args>
+std::string string_format( const std::string& format, Args ... args )
+{
+    int size_s = std::snprintf( nullptr, 0, format.c_str(), args ... ) + 1; // Extra space for '\0'
+    if( size_s <= 0 ){ throw std::runtime_error( "Error during formatting." ); }
+    auto size = static_cast<size_t>( size_s );
+    std::unique_ptr<char[]> buf( new char[ size ] );
+    std::snprintf( buf.get(), size, format.c_str(), args ... );
+    return std::string( buf.get(), buf.get() + size - 1 ); // We don't want the '\0' inside
+}
+
+static std::unique_ptr<Napi::Env> node_env;
+
+void llvm_bindings_assert(const char* e, const char* file, int line)
+{
+    throw Napi::Error::New(
+        *node_env, string_format("%s:%d: failed assertion `%s'\n", file, line, e));
+}
+
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    node_env = std::make_unique<Napi::Env>(env);
     InitADT(env, exports);
     InitBinaryFormat(env, exports);
     InitBitCode(env, exports);

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