Porting ApsarasX/llvm-bindings#33 to this repo.

Author: leonelsanchesdasilva

CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [9.1.0](https://github.com/DesignLiquido/llvm-bindings/compare/v9.0.0...v9.1.0) (2026-03-12)
+
+### At a glance
+
+- Adds basic code generation: compile a module directly to an object file or an in-memory buffer.
+- Adds `ModulePassManager` and `FunctionPassManager` wrappers over LLVM's new PassBuilder infrastructure.
+- Adds `CallingConv`, `Reloc`, `CodeModel`, `CodeGenOpt`, `CodeGenFileType`, `OptimizationLevel`, and `ThinOrFullLTOPhase` enum namespaces.
+- Extends `Function`, `StructType.create`, `APInt`, and `Target.createTargetMachine` with new parameters.
+
+### Added
+
+- `TargetMachine.emitToFile(module, filePath, fileType)` — compiles a module to an object or assembly file on disk.
+- `TargetMachine.emitToBuffer(module, fileType)` — compiles a module to an in-memory `Buffer`.
+- `ModulePassManager` class — wraps LLVM's new `PassBuilder` pipeline. Constructor accepts an optional `OptimizationLevel` value (default: `O0`). Methods: `run(module)`, `addVerifierPass()`, `addFunctionPasses(fpm)`, `createFunctionPassManager(ltoPhase?)`, `isEmpty()`.
+- `FunctionPassManager` class — function-level pass pipeline obtained via `ModulePassManager.createFunctionPassManager`. Methods: `addSROAPass()`, `addEarlyCSEPass(useSSA?)`, `addInstCombinePass()`, `isEmpty()`.
+- `CallingConv` namespace — all `llvm::CallingConv` IDs (C, Fast, Cold, GHC, X86_StdCall, ARM_AAPCS, AMDGPU_KERNEL, …).
+- `Reloc` namespace — `Static`, `PIC_`, `DynamicNoPIC`, `ROPI`, `RWPI`, `ROPI_RWPI`.
+- `CodeModel` namespace — `Tiny`, `Small`, `Kernel`, `Medium`, `Large`.
+- `CodeGenOpt` namespace — `None`, `Less`, `Default`, `Aggressive`.
+- `CodeGenFileType` namespace — `Assembly`, `Object`, `Null`.
+- `OptimizationLevel` namespace — `O0`, `O1`, `O2`, `O3`, `Os`, `Oz`.
+- `ThinOrFullLTOPhase` namespace — `None`, `ThinLTOPreLink`, `ThinLTOPostLink`, `FullLTOPreLink`, `FullLTOPostLink`.
+- `Function.getCallingConv(): number` — returns the function's current calling convention.
+- `Function.setCallingConv(cc: number): void` — sets the function's calling convention.
+- `StructType.create(context, elementTypes, name, isPacked?)` — new optional `isPacked` boolean parameter.
+- `APInt` constructor now also accepts a `bigint` value (in addition to `number`), enabling representation of values larger than `Number.MAX_SAFE_INTEGER`.
+- `Target.createTargetMachine` overloads with optional `reloc`, `codeModel`, `optLevel` (`CodeGenOpt`), and `jit` parameters.
+
 ## [9.0.0](https://github.com/DesignLiquido/llvm-bindings/compare/v8.0.0...v9.0.0) (2026-03-11)
 
 ### At a glance

README.md

@@ -258,6 +258,94 @@ LLVM 22 introduces a source-language naming API change in debug info and bumps t
 - `DIBuilder.cpp`: removed the `#if LLVM_VERSION_MAJOR >= 22` conditional; the LLVM 22+ API is now the only code path.
 - `cmake/LLVM.cmake`: the version discovery loop and the minimum-version guard now enforce LLVM >= 22.
 
+## v9.1.0 — Basic code generation
+
+v9.1.0 adds a substantial set of new APIs for compiling LLVM IR to native code.
+
+**At a glance**
+
+- Adds basic code generation: compile a module to an object file or an in-memory buffer.
+- Adds `ModulePassManager` and `FunctionPassManager` wrappers over LLVM's new PassBuilder infrastructure.
+- Adds `CallingConv` namespace with all calling convention IDs.
+- Adds `Reloc`, `CodeModel`, `CodeGenOpt`, and `CodeGenFileType` enum namespaces.
+- Adds `OptimizationLevel` and `ThinOrFullLTOPhase` enum namespaces.
+- Extends `Function` with `getCallingConv()` and `setCallingConv(cc)`.
+- Extends `StructType.create` with an optional `isPacked` boolean parameter.
+- Extends `APInt` constructor to accept a `bigint` value in addition to `number`.
+- Extends `Target.createTargetMachine` with optional `reloc`, `codeModel`, `optLevel`, and `jit` parameters.
+
+**Code generation**
+
+Initialize target backends first, then use `TargetMachine.emitToFile` or `TargetMachine.emitToBuffer`:
+
+```typescript
+import llvm from 'llvm-bindings';
+
+llvm.InitializeAllTargetInfos();
+llvm.InitializeAllTargets();
+llvm.InitializeAllTargetMCs();
+llvm.InitializeAllAsmPrinters();
+
+const target = llvm.TargetRegistry.lookupTarget('x86_64')!;
+const machine = target.createTargetMachine(
+    'x86_64-unknown-unknown',
+    'generic',
+    '',
+    llvm.Reloc.PIC_,
+    llvm.CodeModel.Small,
+    llvm.CodeGenOpt.Default,
+);
+
+// ... build your module ...
+const myModule: llvm.Module = /* ... */;
+myModule.setDataLayout(machine.createDataLayout());
+
+// Emit to an object file on disk
+machine.emitToFile(myModule, '/tmp/out.o', llvm.CodeGenFileType.Object);
+
+// Or emit to an in-memory Buffer
+const buf: Buffer = machine.emitToBuffer(myModule, llvm.CodeGenFileType.Object);
+```
+
+**Pass manager**
+
+`ModulePassManager` wraps LLVM's new PassBuilder pipeline. Pass the desired `OptimizationLevel` to its constructor:
+
+```typescript
+const mpm = new llvm.ModulePassManager(llvm.OptimizationLevel.O2);
+mpm.run(myModule);
+```
+
+`FunctionPassManager` is obtained via `ModulePassManager.createFunctionPassManager` and can be composed back into the module pipeline:
+
+```typescript
+const fpm = mpm.createFunctionPassManager(llvm.ThinOrFullLTOPhase.None);
+// fpm.addSROAPass();
+// fpm.addEarlyCSEPass();
+// fpm.addInstCombinePass();
+mpm.addFunctionPasses(fpm);
+```
+
+**Calling conventions**
+
+```typescript
+func.setCallingConv(llvm.CallingConv.Fast);
+console.log(func.getCallingConv()); // 8
+```
+
+**Packed structs**
+
+```typescript
+const packed = llvm.StructType.create(context, [i8, i32], 'PackedPoint', true);
+console.log(packed.isPacked()); // true
+```
+
+**BigInt support for APInt**
+
+```typescript
+const big = new llvm.APInt(64, 9007199254740993n); // value > Number.MAX_SAFE_INTEGER
+```
+
 ## Compatibility
 
 | llvm-bindings versions                     | compatible LLVM versions |
@@ -275,6 +363,7 @@ LLVM 22 introduces a source-language naming API change in debug info and bumps t
 | (@designliquido/llvm-bindings) 7.0.x       | 20.1.x                   |
 | (@designliquido/llvm-bindings) 8.0.x       | 21.1.x                   |
 | (@designliquido/llvm-bindings) 9.0.x       | 22.1.x                   |
+| (@designliquido/llvm-bindings) 9.1.x       | 22.1.x                   |
 
 ## Acknowledgments
 

cmake/LLVM.cmake

@@ -36,4 +36,4 @@ include_directories(${LLVM_INCLUDE_DIRS})
 
 add_definitions(${LLVM_DEFINITIONS})
 
-llvm_map_components_to_libnames(LLVM_LIBS core codegen irreader linker support target ${LLVM_TARGETS_TO_BUILD})
+llvm_map_components_to_libnames(LLVM_LIBS core codegen irreader linker passes support target ${LLVM_TARGETS_TO_BUILD})

include/IR/CallingConv.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <napi.h>
+
+namespace CallingConv {
+    void Init(Napi::Env env, Napi::Object &exports);
+}

include/IR/Function.h

@@ -64,6 +64,10 @@ class Function : public Napi::ObjectWrap<Function> {
 
     Napi::Value getType(const Napi::CallbackInfo &info);
 
+    Napi::Value getCallingConv(const Napi::CallbackInfo &info);
+
+    void setCallingConv(const Napi::CallbackInfo &info);
+
     void addFnAttr(const Napi::CallbackInfo &info);
 
     void addParamAttr(const Napi::CallbackInfo &info);

include/IR/PassManager.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <napi.h>
+#include <llvm/IR/PassManager.h>
+#include <llvm/Passes/PassBuilder.h>
+#include <llvm/Analysis/LoopAnalysisManager.h>
+#include <llvm/Analysis/CGSCCPassManager.h>
+
+class FunctionPassManager : public Napi::ObjectWrap<FunctionPassManager> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    static Napi::Object New(Napi::Env env, llvm::FunctionPassManager fpm);
+
+    static bool IsClassOf(const Napi::Value &value);
+
+    explicit FunctionPassManager(const Napi::CallbackInfo &info);
+
+    llvm::FunctionPassManager &getLLVMPrimitive();
+
+private:
+    llvm::FunctionPassManager fpm;
+
+    void addSROAPass(const Napi::CallbackInfo &info);
+    void addEarlyCSEPass(const Napi::CallbackInfo &info);
+    void addInstCombinePass(const Napi::CallbackInfo &info);
+    Napi::Value isEmpty(const Napi::CallbackInfo &info);
+};
+
+class ModulePassManager : public Napi::ObjectWrap<ModulePassManager> {
+public:
+    static inline Napi::FunctionReference constructor; // NOLINT
+
+    static void Init(Napi::Env env, Napi::Object &exports);
+
+    explicit ModulePassManager(const Napi::CallbackInfo &info);
+
+private:
+    llvm::LoopAnalysisManager LAM;
+    llvm::FunctionAnalysisManager FAM;
+    llvm::CGSCCAnalysisManager CGAM;
+    llvm::ModuleAnalysisManager MAM;
+    llvm::PassBuilder PB;
+    llvm::ModulePassManager MPM;
+    llvm::OptimizationLevel optLevel;
+
+    Napi::Value createFunctionPassManager(const Napi::CallbackInfo &info);
+    void addFunctionPasses(const Napi::CallbackInfo &info);
+    void addVerifierPass(const Napi::CallbackInfo &info);
+    Napi::Value isEmpty(const Napi::CallbackInfo &info);
+    void run(const Napi::CallbackInfo &info);
+};

include/IR/index.h

@@ -26,5 +26,7 @@
 #include "IR/DataLayout.h"
 #include "IR/Verifier.h"
 #include "IR/Intrinsic.h"
+#include "IR/CallingConv.h"
+#include "IR/PassManager.h"
 
 void InitIR(Napi::Env env, Napi::Object &exports);

include/Passes/OptimizationLevel.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <napi.h>
+
+namespace OptimizationLevel {
+    void Init(Napi::Env env, Napi::Object &exports);
+}

include/Passes/ThinOrFullLTOPhase.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <napi.h>
+
+namespace ThinOrFullLTOPhase {
+    void Init(Napi::Env env, Napi::Object &exports);
+}

include/Passes/index.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <napi.h>
+#include "Passes/OptimizationLevel.h"
+#include "Passes/ThinOrFullLTOPhase.h"
+
+void InitPasses(Napi::Env env, Napi::Object &exports);