@designliquido/llvm-bindings 0.1.0 → 2.0.0

package/.github/workflows/build.yml

@@ -15,8 +15,8 @@ on:
       - 'LICENSE'
 
 env:
-  LLVM_VERSION: 14.0.6
-  LLVM_VERSION_MAJOR: 14
+  LLVM_VERSION: 16.0.6
+  LLVM_VERSION_MAJOR: 16
 
 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: |
@@ -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: |

package/CHANGELOG.md

@@ -1,2 +1,33 @@
-## [0.0.1](https://github.com/DesignLiquido/llvm-bindings/compare/v0.4.2...v0.0.1) (2026-03-06)
+# [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
+
+- **Opaque pointer support (LLVM 15):** `PointerType.get` and `PointerType.getUnqual` now accept either a `Type` (typed pointer, existing behaviour) or an `LLVMContext` (opaque pointer, new in LLVM 15). No method renames — the overloads are resolved at runtime by inspecting the first argument.
+- `PointerType.isOpaque()` — returns `true` when the pointer type carries no element type.
+- `Type.isOpaquePointerTy()` — lets user code branch between typed- and opaque-pointer paths.
+- `IRBuilder.getPtrTy(addrSpace?)` — returns the opaque `ptr` type; canonical replacement for `getInt8PtrTy()` in opaque-pointer IR.
+
+### Fixed
+
+- `isSameType` (internal helper in `src/IR/Type.cpp`) no longer aborts when either pointer is opaque; it now guards the `getPointerElementType()` call and compares opaqueness directly.
+
+### Notes
+
+- Typed-pointer APIs are unchanged. The LLVM 15 compatibility shim (`context->setOpaquePointers(false)`) remains active by default, so existing code continues to work without modification.
+
+---
+
+## [0.1.0]
+
+Initial release.

package/CMakeLists.txt

@@ -19,7 +19,7 @@ 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 14 prebuilt Windows
+    # cmake-js forces /MT (MultiThreaded static CRT), but LLVM 15 prebuilt Windows
     # libraries were 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")

package/README.md

@@ -2,7 +2,7 @@
 
 LLVM bindings for Node.js/JavaScript/TypeScript. This project is a hard fork of https://github.com/ApsarasX/llvm-bindings, which it does not seem to be maintained anymore.
 
-[![github-action](https://img.shields.io/github/workflow/status/DesignLiquido/llvm-bindings/Build?style=flat-square)](https://github.com/DesignLiquido/llvm-bindings/actions)
+[![github-action](https://img.shields.io/github/actions/workflow/status/DesignLiquido/llvm-bindings/build.yml?style=flat-square)](https://github.com/DesignLiquido/llvm-bindings/actions)
 [![npm](https://img.shields.io/npm/v/@designliquido/llvm-bindings?style=flat-square)](https://www.npmjs.com/package/@designliquido/llvm-bindings)
 [![github-license](https://img.shields.io/github/license/DesignLiquido/llvm-bindings?style=flat-square)](https://github.com/DesignLiquido/llvm-bindings/blob/master/LICENSE)
 
@@ -28,7 +28,7 @@ listed in the [TypeScript definition file](./llvm-bindings.d.ts).
 
 ```shell
 # install cmake and llvm by homebrew
-brew install cmake llvm@14
+brew install cmake llvm@15
 
 # install llvm-bindings by yarn
 yarn add llvm-bindings
@@ -40,7 +40,7 @@ yarn add llvm-bindings
 #install llvm by installation script
 wget https://apt.llvm.org/llvm.sh
 sudo chmod +x llvm.sh
-sudo ./llvm.sh 14
+sudo ./llvm.sh 15
 
 # install cmake and zlib by apt-get
 sudo apt-get install cmake zlib1g-dev
@@ -53,14 +53,14 @@ yarn add llvm-bindings
 
 First, please refer to [Build LLVM from sources on Windows 10](https://github.com/ApsarasX/llvm-bindings/wiki/Build-LLVM-from-source-code-on-Windows-10) to build LLVM. An alternative is to download [prebuilt LLVM binary](https://github.com/ApsarasX/llvm-windows/releases).
 
-Then, find the `llvm-config` command in your LLVM build directory and execute `llvm-config --cmakedir` to get LLVM cmake directory, assuming `C:\Users\dev\llvm-13.0.1.src\build\lib\cmake\llvm`.
+Then, find the `llvm-config` command in your LLVM build directory and execute `llvm-config --cmakedir` to get LLVM cmake directory, assuming `C:\Users\dev\llvm-15.0.7.src\build\lib\cmake\llvm`.
 
 Finally, execute the following commands.
 
 ```shell
 # specify the LLVM cmake directory for cmake-js
 # note: cmake-js reads npm-style config keys
-npm config set cmake_LLVM_DIR C:\Users\dev\llvm-13.0.1.src\build\lib\cmake\llvm
+npm config set cmake_LLVM_DIR C:\Users\dev\llvm-15.0.7.src\build\lib\cmake\llvm
 
 # install llvm-bindings by yarn
 yarn add llvm-bindings
@@ -120,14 +120,36 @@ main();
 ## Note
 Due to the limitation of `node-addon-api`, this project has not implemented inheritance yet, so calling the method of superclass from subclass object will report an error. Please see [#1](https://github.com/ApsarasX/llvm-bindings/issues/1) for details.
 
+## Opaque Pointers (LLVM 15 / v1.0.0)
+
+LLVM 15 makes opaque pointers the default. Starting from v1.0.0 this library exposes the necessary APIs to opt into opaque-pointer IR while keeping all existing typed-pointer APIs intact.
+
+**New APIs**
+
+| API | Description |
+|-----|-------------|
+| `PointerType.get(context, addrSpace)` | Creates an opaque pointer type (pass `LLVMContext` instead of `Type`) |
+| `PointerType.getUnqual(context)` | Shorthand for address space 0 opaque pointer |
+| `PointerType.isOpaque()` | Returns `true` if the pointer type carries no element type |
+| `Type.isOpaquePointerTy()` | Returns `true` if the type is an opaque pointer |
+| `IRBuilder.getPtrTy(addrSpace?)` | Returns the opaque `ptr` type; replaces `getInt8PtrTy()` in opaque-pointer IR |
+
+**Compatibility shim**
+
+Typed-pointer code continues to work without changes. The compatibility flag `context->setOpaquePointers(false)` is set automatically in `LLVMContext`'s constructor, so existing code is unaffected.
+
+To opt into opaque pointers, pass an `LLVMContext` to `PointerType.get` / `getUnqual` and use `getPtrTy()` for generic pointer values.
+
 ## Compatibility
 
-| llvm-bindings versions | compatible LLVM versions |
-|------------------------|--------------------------|
-| 0.0.x, 0.1.x           | 11.0.x, 11.1.x           |
-| 0.2.x                  | 12.0.x                   |
-| 0.3.x                  | 13.0.x                   |
-| 0.4.x                  | 14.0.x                   |
+| llvm-bindings versions                     | compatible LLVM versions |
+|--------------------------------------------|--------------------------|
+| (original llvm-bindings repo) 0.0.x, 0.1.x | 11.0.x, 11.1.x           |
+| (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       | 14.0.x                   |
+| (@designliquido/llvm-bindings) 1.0.x       | 15.0.x                   |
 
 ## Acknowledgments
 

package/cmake/LLVM.cmake

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

package/include/IR/DerivedTypes.h

@@ -228,5 +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/IRBuilder.h

@@ -179,6 +179,8 @@ private:
 
     Napi::Value getInt8PtrTy(const Napi::CallbackInfo &info);
 
+    Napi::Value getPtrTy(const Napi::CallbackInfo &info);
+
     Napi::Value getIntPtrTy(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/Util/ErrMsg.h

@@ -74,8 +74,8 @@ namespace ErrMsg {
         }
         namespace PointerType {
             constexpr const char *constructor = "PointerType.constructor needs to be called with new (external: Napi::External<llvm::PointerType>)";
-            constexpr const char *get = "PointerType.get needs to be called with: (elementType: Type, addrSpace: number)";
-            constexpr const char *getUnqual = "PointerType.getUnqual needs to be called with: (elementType: Type)";
+            constexpr const char *get = "PointerType.get needs to be called with: (elementType: Type | context: LLVMContext, addrSpace: number)";
+            constexpr const char *getUnqual = "PointerType.getUnqual needs to be called with: (elementType: Type | context: LLVMContext)";
         }
         namespace Value {
             constexpr const char *constructor = "Value.constructor needs to be called with new (external: Napi::External<llvm::Value>)";
@@ -406,6 +406,7 @@ namespace ErrMsg {
 
             constexpr const char *getIntNTy = "IRBuilder.getIntNTy needs to be called with (numBits: number)";
             constexpr const char *getInt8PtrTy = "IRBuilder.getInt8PtrTy needs to be called with (addrSpace?: number)";
+            constexpr const char *getPtrTy = "IRBuilder.getPtrTy needs to be called with (addrSpace?: number)";
             constexpr const char *getIntPtrTy = "IRBuilder.getIntPtrTy needs to be called with (dataLayout: DataLayout, addrSpace?: number)";
 
             constexpr const char *CreateRet = "IRBuilder.CreateRet needs to be called with: (value: Value)";

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

@@ -247,7 +247,6 @@ declare namespace llvm {
             VoidTyID: number;
             LabelTyID: number;
             MetadataTyID: number;
-            X86_MMXTyID: number;
             TokenTyID: number;
             IntegerTyID: number;
             FunctionTyID: number;
@@ -278,8 +277,6 @@ declare namespace llvm {
 
         public static getPPC_FP128Ty(context: LLVMContext): Type;
 
-        public static getX86_MMXTy(context: LLVMContext): Type;
-
         public static getTokenTy(context: LLVMContext): Type;
 
         public static getIntNTy(context: LLVMContext, numBits: number): IntegerType;
@@ -310,8 +307,6 @@ declare namespace llvm {
 
         public static getPPC_FP128PtrTy(context: LLVMContext, addrSpace?: number): PointerType;
 
-        public static getX86_MMXPtrTy(context: LLVMContext, addrSpace?: number): PointerType;
-
         public static getInt1PtrTy(context: LLVMContext, addrSpace?: number): PointerType;
 
         public static getInt8PtrTy(context: LLVMContext, addrSpace?: number): PointerType;
@@ -342,8 +337,6 @@ declare namespace llvm {
 
         public isFloatingPointTy(): boolean;
 
-        public isX86_MMXTy(): boolean;
-
         public isLabelTy(): boolean;
 
         public isMetadataTy(): boolean;
@@ -360,6 +353,8 @@ declare namespace llvm {
 
         public isPointerTy(): boolean;
 
+        public isOpaquePointerTy(): boolean;
+
         public isVectorTy(): boolean;
 
         public isEmptyTy(): boolean;
@@ -374,7 +369,7 @@ declare namespace llvm {
 
         public getPrimitiveSizeInBits(): number;
 
-        public getPointerElementType(): Type;
+        public getNonOpaquePointerElementType(): Type;
 
         // extra
         public static isSameType(type1: Type, type2: Type): boolean;
@@ -498,8 +493,10 @@ declare namespace llvm {
 
     class PointerType extends Type {
         public static get(elementType: Type, addrSpace: number): PointerType;
+        public static get(context: LLVMContext, addrSpace: number): PointerType;
 
         public static getUnqual(elementType: Type): PointerType;
+        public static getUnqual(context: LLVMContext): PointerType;
 
         // duplicated
         public isPointerTy(): boolean;
@@ -516,8 +513,12 @@ 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;
 
         protected constructor();
     }
@@ -1427,6 +1428,8 @@ declare namespace llvm {
 
         public getInt8PtrTy(addrSpace?: number): PointerType;
 
+        public getPtrTy(addrSpace?: number): PointerType;
+
         public getIntPtrTy(dataLayout: DataLayout, addrSpace?: number): IntegerType;
 
         //===--------------------------------------------------------------------===//
@@ -1942,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": "0.1.0",
+    "version": "2.0.0",
     "description": "LLVM bindings for Node.js/JavaScript/TypeScript",
     "keywords": [
         "llvm",
@@ -66,7 +66,7 @@
             "publish": true
         },
         "hooks": {
-            "before:git:release": "conventional-changelog -p angular -i CHANGELOG.md -s && git add CHANGELOG.md"
+            "before:git:release": "yarn conventional-changelog -p angular -i CHANGELOG.md -s && git add CHANGELOG.md"
         }
     }
 }

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,8 @@ 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);
     constructor.SuppressDestruct();
@@ -599,22 +600,38 @@ PointerType::PointerType(const Napi::CallbackInfo &info) : ObjectWrap(info) {
 
 Napi::Value PointerType::get(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-    if (info.Length() < 2 || !Type::IsClassOf(info[0]) || !info[1].IsNumber()) {
+    if (info.Length() < 2 || !info[1].IsNumber()) {
         throw Napi::TypeError::New(env, ErrMsg::Class::PointerType::get);
     }
-    llvm::Type *type = Type::Extract(info[0]);
     uint32_t addrSpace = info[1].As<Napi::Number>();
-    llvm::PointerType *pointerType = llvm::PointerType::get(type, addrSpace);
+    llvm::PointerType *pointerType;
+    if (LLVMContext::IsClassOf(info[0])) {
+        llvm::LLVMContext &context = LLVMContext::Extract(info[0]);
+        pointerType = llvm::PointerType::get(context, addrSpace);
+    } else if (Type::IsClassOf(info[0])) {
+        llvm::Type *type = Type::Extract(info[0]);
+        pointerType = llvm::PointerType::get(type, addrSpace);
+    } else {
+        throw Napi::TypeError::New(env, ErrMsg::Class::PointerType::get);
+    }
     return PointerType::New(env, pointerType);
 }
 
 Napi::Value PointerType::getUnqual(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
-    if (info.Length() == 0 || !Type::IsClassOf(info[0])) {
+    if (info.Length() == 0) {
+        throw Napi::TypeError::New(env, ErrMsg::Class::PointerType::getUnqual);
+    }
+    llvm::PointerType *pointerType;
+    if (LLVMContext::IsClassOf(info[0])) {
+        llvm::LLVMContext &context = LLVMContext::Extract(info[0]);
+        pointerType = llvm::PointerType::getUnqual(context);
+    } else if (Type::IsClassOf(info[0])) {
+        llvm::Type *type = Type::Extract(info[0]);
+        pointerType = llvm::PointerType::getUnqual(type);
+    } else {
         throw Napi::TypeError::New(env, ErrMsg::Class::PointerType::getUnqual);
     }
-    llvm::Type *type = Type::Extract(info[0]);
-    llvm::PointerType *pointerType = llvm::PointerType::getUnqual(type);
     return PointerType::New(env, pointerType);
 }
 
@@ -647,6 +664,10 @@ 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) {
+    return Napi::Boolean::New(info.Env(), pointerType->isOpaque());
 }

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

@@ -53,6 +53,7 @@ void IRBuilder::Init(Napi::Env env, Napi::Object &exports) {
             InstanceMethod("getDoubleTy", &IRBuilder::getTypeFactory<&LLVMIRBuilder::getDoubleTy>),
             InstanceMethod("getVoidTy", &IRBuilder::getTypeFactory<&LLVMIRBuilder::getVoidTy>),
             InstanceMethod("getInt8PtrTy", &IRBuilder::getInt8PtrTy),
+            InstanceMethod("getPtrTy", &IRBuilder::getPtrTy),
             InstanceMethod("getIntPtrTy", &IRBuilder::getIntPtrTy),
 
             //===--------------------------------------------------------------------===//
@@ -395,6 +396,17 @@ Napi::Value IRBuilder::getInt8PtrTy(const Napi::CallbackInfo &info) {
     throw Napi::TypeError::New(env, ErrMsg::Class::IRBuilder::getInt8PtrTy);
 }
 
+Napi::Value IRBuilder::getPtrTy(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    unsigned argsLen = info.Length();
+    if (argsLen == 0 || argsLen == 1 && info[0].IsNumber()) {
+        unsigned addrSpace = argsLen == 1 ? info[0].As<Napi::Number>() : 0;
+        llvm::PointerType *type = builder->getPtrTy(addrSpace);
+        return PointerType::New(env, type);
+    }
+    throw Napi::TypeError::New(env, ErrMsg::Class::IRBuilder::getPtrTy);
+}
+
 Napi::Value IRBuilder::getIntPtrTy(const Napi::CallbackInfo &info) {
     Napi::Env env = info.Env();
     unsigned argsLen = info.Length();
@@ -486,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)) {
@@ -502,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)) {
@@ -521,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]) &&
@@ -699,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)) {
@@ -711,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)) {
@@ -724,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

@@ -107,7 +107,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/Type.cpp

@@ -59,7 +59,6 @@ void Type::Init(Napi::Env env, Napi::Object &exports) {
     typeID.Set("VoidTyID", Napi::Number::New(env, llvm::Type::TypeID::VoidTyID));
     typeID.Set("LabelTyID", Napi::Number::New(env, llvm::Type::TypeID::LabelTyID));
     typeID.Set("MetadataTyID", Napi::Number::New(env, llvm::Type::TypeID::MetadataTyID));
-    typeID.Set("X86_MMXTyID", Napi::Number::New(env, llvm::Type::TypeID::X86_MMXTyID));
     typeID.Set("TokenTyID", Napi::Number::New(env, llvm::Type::TypeID::TokenTyID));
     typeID.Set("IntegerTyID", Napi::Number::New(env, llvm::Type::TypeID::IntegerTyID));
     typeID.Set("FunctionTyID", Napi::Number::New(env, llvm::Type::TypeID::FunctionTyID));
@@ -81,7 +80,6 @@ void Type::Init(Napi::Env env, Napi::Object &exports) {
             StaticMethod("getX86_FP80Ty", &getTypeFactory<&llvm::Type::getX86_FP80Ty>),
             StaticMethod("getFP128Ty", &getTypeFactory<&llvm::Type::getFP128Ty>),
             StaticMethod("getPPC_FP128Ty", &getTypeFactory<&llvm::Type::getPPC_FP128Ty>),
-            StaticMethod("getX86_MMXTy", &getTypeFactory<&llvm::Type::getX86_MMXTy>),
             StaticMethod("getTokenTy", &getTypeFactory<&llvm::Type::getTokenTy>),
             StaticMethod("getIntNTy", &Type::getIntNTy),
             StaticMethod("getInt1Ty", &getIntTypeFactory<&llvm::Type::getInt1Ty>),
@@ -97,7 +95,6 @@ void Type::Init(Napi::Env env, Napi::Object &exports) {
             StaticMethod("getX86_FP80PtrTy", &getPointerTypeFactory<&llvm::Type::getX86_FP80PtrTy>),
             StaticMethod("getFP128PtrTy", &getPointerTypeFactory<&llvm::Type::getFP128PtrTy>),
             StaticMethod("getPPC_FP128PtrTy", &getPointerTypeFactory<&llvm::Type::getPPC_FP128PtrTy>),
-            StaticMethod("getX86_MMXPtrTy", &getPointerTypeFactory<&llvm::Type::getX86_MMXPtrTy>),
             StaticMethod("getInt1PtrTy", &getPointerTypeFactory<&llvm::Type::getInt1PtrTy>),
             StaticMethod("getInt8PtrTy", &getPointerTypeFactory<&llvm::Type::getInt8PtrTy>),
             StaticMethod("getInt16PtrTy", &getPointerTypeFactory<&llvm::Type::getInt16PtrTy>),
@@ -113,7 +110,6 @@ void Type::Init(Napi::Env env, Napi::Object &exports) {
             InstanceMethod("isFP128Ty", &Type::isTypeFactory<&llvm::Type::isFP128Ty>),
             InstanceMethod("isPPC_FP128Ty", &Type::isTypeFactory<&llvm::Type::isPPC_FP128Ty>),
             InstanceMethod("isFloatingPointTy", &Type::isTypeFactory<&llvm::Type::isFloatingPointTy>),
-            InstanceMethod("isX86_MMXTy", &Type::isTypeFactory<&llvm::Type::isX86_MMXTy>),
             InstanceMethod("isLabelTy", &Type::isTypeFactory<&llvm::Type::isLabelTy>),
             InstanceMethod("isMetadataTy", &Type::isTypeFactory<&llvm::Type::isMetadataTy>),
             InstanceMethod("isTokenTy", &Type::isTypeFactory<&llvm::Type::isTokenTy>),
@@ -122,6 +118,7 @@ void Type::Init(Napi::Env env, Napi::Object &exports) {
             InstanceMethod("isStructTy", &Type::isTypeFactory<&llvm::Type::isStructTy>),
             InstanceMethod("isArrayTy", &Type::isTypeFactory<&llvm::Type::isArrayTy>),
             InstanceMethod("isPointerTy", &Type::isTypeFactory<&llvm::Type::isPointerTy>),
+            InstanceMethod("isOpaquePointerTy", &Type::isTypeFactory<&llvm::Type::isOpaquePointerTy>),
             InstanceMethod("isVectorTy", &Type::isTypeFactory<&llvm::Type::isVectorTy>),
             InstanceMethod("isEmptyTy", &Type::isTypeFactory<&llvm::Type::isEmptyTy>),
             InstanceMethod("isFirstClassType", &Type::isTypeFactory<&llvm::Type::isFirstClassType>),
@@ -129,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);
@@ -219,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 +245,10 @@ static bool isSameType(llvm::Type *type1, llvm::Type *type2) {
             }
         }
     } else if (type1->isPointerTy()) {
-        return isSameType(type1->getPointerElementType(), type2->getPointerElementType());
+        if (type1->isOpaquePointerTy() || type2->isOpaquePointerTy()) {
+            return type1->isOpaquePointerTy() && type2->isOpaquePointerTy();
+        }
+        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/test/exception.ts

@@ -27,7 +27,7 @@ export default function testException() {
     const tmp2 = builder.CreateBitCast(tmp1, llvm.PointerType.getUnqual(builder.getInt8PtrTy()));
     builder.CreateStore(
         builder.CreateInBoundsGEP(
-            errMsgStr.getType().getPointerElementType(),
+            errMsgStr.getValueType(),
             errMsgStr,
             [builder.getInt64(0), builder.getInt64(0)]
         ),