К основному содержанию
скилл CX Codex

jit-compilation — скилл для Claude Code: что делает и как установить

Скилл jit-compilation для Claude Code учит агента строить JIT-компиляцию с LLVM ORC/LLJIT, Cranelift, инлайн-кэшами, трамплинами и dynasm в Rust. Генерирует код на лету.

MIT 382 установок ★ 298 обновлён 2026-06-27

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add mohitmishra786/low-level-dev-skills --skill jit-compilation -a claude-code
Открыть на GitHub

Что делает jit-compilation

Скилл ведёт агента через JIT-компиляцию. Он начинает с LLJIT, самого короткого способа запустить LLVM IR из памяти, и переходит к слоям ORC JIT v2 (ExecutionSession, IRLayer, ObjectLayer). Cranelift JIT и ленивая компиляция через трамплины с LazyCallThroughManager вынесены в отдельные разделы. Инлайн-кэши для динамической диспетчеризации и политика W^X тоже разобраны.

Внутри примеры кода: C++ с LLJIT и функцией add, настройка Cranelift на Rust, фрагмент с mmap и mprotect, подпрограмма dynasm для x86_64. Есть дерево выбора бэкенда и таблица поломок: символ не находится при lookup, сегфолт из-за несовпадения ABI, устаревший код после перекомпиляции.

Пример LLJIT собирается через clang++ и llvm-config, поэтому LLVM с компонентами core, orcjit и native должен стоять заранее. Пример dynasm рассчитан на x86_64.

Какие задачи решает

  • собрать минимальный JIT на LLJIT и вызвать сгенерированную add из C++
  • компилировать функцию лениво, при первом вызове, через трамплин
  • сделать инлайн-кэш для полиморфного вызова в интерпретаторе
  • записать машинный код в память и перевести страницу в RX по правилу W^X
  • найти, почему JIT-код падает с сегфолтом или символ не находится

Примеры запросов агенту

  • Помоги собрать JIT на LLJIT: функция add из LLVM IR и её вызов из C++
  • Добавь в мой ORC JIT ленивую компиляцию функций через трамплины
  • Напиши на Rust с dynasm подпрограмму сложения для x86_64

Как установить jit-compilation

1Через Skills CLI (Vercel)

npx skills add mohitmishra786/low-level-dev-skills --skill jit-compilation -a claude-code

2Вручную: положить файлы

~/.claude/skills/jit-compilation/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/jit-compilation/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о jit-compilation

Как установить jit-compilation в Claude Code?

Выполните npx skills add mohitmishra786/low-level-dev-skills --skill jit-compilation -a claude-code. Файл скилла окажется в ~/.claude/skills/jit-compilation/SKILL.md.

Что делает jit-compilation?

Объясняет агенту, как строить JIT: LLJIT и слои ORC JIT v2, Cranelift, ленивая компиляция через трамплины, инлайн-кэши, W^X и dynasm для x86_64.

Какой JIT-бэкенд советует скилл?

Нужны оптимизации LLVM: ORC JIT или LLJIT. Важны быстрая компиляция и встраиваемость: Cranelift. Для крошечных фрагментов на ассемблере: dynasm.

Исходный текст

SKILL.md · MIT
---
name: jit-compilation
description: JIT compilation skill for runtime code generation. Use when building LLVM ORC JIT, LLJIT, Cranelift JIT, inline caches, trampolines, or Rust dynasm codegen. Activates on queries about ORC JIT, LLJIT, Cranelift, ExecutionSession, inline cache, W^X, or dynasm.
---

# JIT Compilation

## Purpose

Guide agents through just-in-time compilation: LLVM ORC JIT v2 (`ExecutionSession`, `IRLayer`, `ObjectLayer`), LLJIT for simpler use cases, Cranelift JIT, inline caches for dynamic dispatch, trampolines for lazy compilation, security considerations (W^X, code signing), and Rust `dynasm` for x86 codegen.

## When to Use

- Building an interpreter with a JIT hot-path
- Implementing lazy function compilation on first call
- Embedding dynamic code generation in a REPL or game engine
- Prototyping codegen without writing a full linker
- Creating inline caches for polymorphic call sites
- Generating x86 machine code from Rust with `dynasm`

## Workflow

### 1. JIT architecture overview

```
Source/AST/Bytecode
    → IR (LLVM IR or Cranelift CLIF)
    → Object file (in memory)
    → Runtime linker (RTDyldObjectLinkingLayer)
    → Executable code in R+X memory
    → Function pointer call
```

### 2. LLJIT — simplest LLVM JIT

```cpp
#include "llvm/ExecutionEngine/Orc/LLJIT.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/IRBuilder.h"

using namespace llvm;
using namespace llvm::orc;

int main() {
    auto JIT = cantFail(LLJITBuilder().create());

    LLVMContext Context;
    auto M = std::make_unique<Module>("jit", Context);
    IRBuilder<> Builder(Context);

    // int add(int a, int b) { return a + b; }
    Function *AddFn = Function::Create(
        FunctionType::get(Builder.getInt32Ty(),
                          {Builder.getInt32Ty(), Builder.getInt32Ty()}, false),
        Function::ExternalLinkage, "add", M.get());

    BasicBlock *BB = BasicBlock::Create(Context, "entry", AddFn);
    Builder.SetInsertPoint(BB);
    auto Args = AddFn->arg_begin();
    Value *Sum = Builder.CreateAdd(Args, Args + 1);
    Builder.CreateRet(Sum);

    cantFail(JIT->addIRModule(ThreadSafeModule(std::move(M), std::make_unique<LLVMContext>())));

    auto AddSym = JIT->lookup("add");
    auto *AddPtr = (int (*)(int, int))AddSym->getValue();
    int result = AddPtr(3, 4);  // 7
    return 0;
}
```

```bash
clang++ -std=c++17 jit.cpp $(llvm-config --cxxflags --ldflags --libs core orcjit native) -o jit
```

### 3. ORC JIT v2 layers

```cpp
ExecutionSession ES;
auto &MainJD = ES.createBareJITDylib("main");

RTDyldObjectLinkingLayer ObjectLayer(
    ES, []() { return std::make_unique<SectionMemoryManager>(); });

IRCompileLayer CompileLayer(
    ES, ObjectLayer, std::make_unique<TargetMachineBuilder>());

// Add IR module to JITDylib
ThreadSafeModule TSM = ...;
CompileLayer.add(MainJD, std::move(TSM));

// Resolve symbol
auto Sym = ES.lookup({&MainJD}, "my_func");
```

Layers:
- **IRLayer** — compiles LLVM IR to object
- **ObjectLayer** — links relocatable objects
- **ExecutionSession** — symbol lookup and JITDylib management

### 4. Lazy compilation with trampolines

```
First call → trampoline → compile function → patch trampoline → direct call
```

```cpp
// Simplified lazy compile on first invocation
void *LazyCompile(const std::string &Name) {
    if (!Compiled.count(Name)) {
        auto Fn = CompileFromAST(Name);
        Compiled[Name] = Fn;
        // Patch call site or update function pointer table
    }
    return Compiled[Name];
}
```

ORC supports lazy reexports and lazy compilation via `LazyCallThroughManager`.

### 5. Inline caches

```javascript
// Concept: monomorphic call site caches resolved target
// Pseudocode for dynamic language
function call_site(obj, method, args) {
    if (obj.class_id === cache.class_id) {
        return cache.fn_ptr(args);  // fast path
    }
    cache.class_id = obj.class_id;
    cache.fn_ptr = resolve_method(obj, method);
    return cache.fn_ptr(args);
}
```

JIT generates specialized code per cached type; deoptimize on cache miss.

### 6. Cranelift JIT

```rust
use cranelift::prelude::*;
use cranelift_jit::{JITBuilder, JITModule};
use cranelift_module::{Linkage, Module};

let isa = cranelift_native::builder().finish(settings::Flags::new(settings::builder()))?;
let jit_builder = JITBuilder::with_isa(isa, cranelift_module::default_libcall_names());
let mut module = JITModule::new(jit_builder);

let mut ctx = module.make_context();
ctx.func = Function::with_name_signature(
    module.declare_function("add", Linkage::Export, &sig)?,
    sig,
);
// ... build IR in ctx.func ...
module.define_function(func_id, &mut ctx)?;
module.finalize_definitions()?;
let code = module.get_finalized_function(func_id);
let add_fn: fn(i32, i32) -> i32 = unsafe { std::mem::transmute(code) };
```

Cranelift: faster compile times than LLVM, good for embeddable JITs.

### 7. Security — W^X policy

```
W^X (Write XOR Execute)
├── Memory page is writable OR executable, never both
├── JIT: allocate RW → write code → mprotect(RX)
└── macOS hardened runtime requires signed JIT pages
```

```c
#include <sys/mman.h>

void *mem = mmap(NULL, size, PROT_READ | PROT_WRITE,
                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
// write machine code to mem
mprotect(mem, size, PROT_READ | PROT_EXEC);
```

Linux: `MAP_JIT` on Apple platforms; `sealed` memfd on hardened systems.

### 8. Rust dynasm (x86)

```rust
use dynasm::dynasm;
use dynasmrt::{Assembler, ExecutableBuffer};

let mut asm = Assembler::new().unwrap();
dynasm!(asm
    ; .arch x86_64
    ; add:
    ; add eax, ecx
    ; ret
);
let buf = asm.finalize().unwrap();
let add_fn: fn(i32, i32) -> i32 = unsafe { std::mem::transmute(buf.ptr(0)) };
```

Use for lightweight asm snippets without LLVM dependency.

### 9. Decision tree

```
JIT backend choice?
├── Need LLVM optimizations → ORC JIT / LLJIT
├── Fast compile, embeddable → Cranelift
├── Tiny asm snippets → dynasm
└── ML workloads → MLIR → ORC pipeline
```

## Common Problems

| Symptom | Cause | Fix |
|---------|-------|-----|
| Symbol not found on lookup | Name mangling or not exported | Use C linkage; `LLVMExternalLinkage` |
| Segfault calling JIT code | ABI mismatch | Match calling convention and types |
| W^X mmap failed | SELinux/grsecurity | Use `MAP_JIT`; check `dmesg` |
| Stale code after recompile | Old function pointer | Invalidate caches; use trampolines |
| LLVM JIT slow compile | `-O2` in JIT | Use `-O0` for JIT; optimize hot paths only |
| Cranelift verify error | Invalid CLIF | Enable `cranelift_codegen::verify_function` |

## Related Skills

- `skills/compiler-internals/llvm-passes` — optimize before JIT
- `skills/compiler-internals/compiler-frontend` — AST to IR for JIT input
- `skills/compiler-internals/mlir` — MLIR lowering to LLVM for JIT
- `skills/compilers/llvm` — LLVM IR fundamentals
- `skills/low-level-programming/interpreters` — bytecode interpreters using JIT
- `skills/low-level-programming/assembly-x86` — hand-written asm context

© mohitmishra786 · MIT · mohitmishra786/low-level-dev-skills

Похожие скиллы

Все скиллы по теме «Языки программирования» →
xcode-compilation-analyzer AvdLee Скилл xcode-compilation-analyzer разбирает, почему Xcode долго собирает Swift-проект: читает тайминги сборки и диагностику фронтенда, находит тяжёлые места в коде и выдаёт план правок. CX Codex +1 3 500установок jax-best-practices Mindrally Скилл jax-best-practices для Claude Code задаёт агенту правила работы с JAX: чистые функции, jit, vmap, grad и профилирование. Помогает писать численный код и обучать модели на JAX. CX Codex +1 744установок dwarf-expert trailofbits Скилл dwarf-expert для Claude Code, Codex, Cursor и других агентов, который разбирает DWARF-отладочную информацию в скомпилированных бинарях. CX Codex +1 5 800установок libfuzzer trailofbits Помогает настраивать и запускать libFuzzer на C/C++ коде под Clang. CX Codex +1 5 800установок numba sanjeed5 Задаёт практики написания Numba-кода на Python: CPU-ускорение, CUDA-ядра и работа с массивами для численных задач в .py. CX Codex +1 ★ 3 589звёзд репо paper-compilation lingzhi227 Скилл paper-compilation для Claude Code собирает LaTeX-статью в PDF, ловит ошибки компиляции и проверяет ссылки с цитатами. Читает лог и устраняет ошибки без ручного разбора. CX Codex +1 1 700установок

Из того же набора140

Весь набор →
protocol-analysis Скилл protocol-analysis для Claude Code разбирает дампы шин I2C, SPI и UART, помогает настроить sigrok и PulseView и сверить данные с драйвером. Помогает разобраться, почему датчик молчит. CX Codex +1 383установок gpio-baremetal Скилл gpio-baremetal помогает настраивать регистры GPIO, альтернативные функции и прерывания EXTI на микроконтроллерах без библиотек HAL. CX Codex +1 383установок apple-silicon Скилл помогает разработчикам работать с Apple Silicon: настраивать код под единую память, использовать Metal Performance Shaders и Instruments, понимать поведение Rosetta 2 и особенности 16KB страниц. CX Codex +1 383установок code-generation-and-backends Скилл code-generation-and-backends объясняет этапы LLVM-бэкенда: от легализации IR до выдачи ассемблера. Пригодится, чтобы разобраться с llc, TableGen или переносом компилятора на новую архитектуру. CX Codex +1 382установок kernel-testing Скилл kernel-testing для Claude Code и Codex: тестирование Linux ядра через KUnit для unit-тестов, kselftest для регрессионных проверок, syzkaller для фаззинга и LTP для проверки совместимости syscall. CX Codex +1 382установок branch-prediction-and-speculation Скилл branch-prediction-and-speculation для Claude Code объясняет предсказание ветвлений и спекулятивное выполнение процессоров, помогая оптимизировать горячие циклы и защищать код от утечек. CX Codex +1 382установок os-dev-scratch Скилл os-dev-scratch для Claude Code помогает собрать минимальную ОС для x86-64: от загрузчика и таблиц страниц до драйверов и переключения контекста. Активируется на вопросах о загрузке ядра, прерываниях и QEMU. CX Codex +1 381установок kernel-security Скилл kernel-security для работы с SELinux, AppArmor, seccomp-bpf, KASLR и аппаратной защитой (CET, PAC). Помогает писать политики безопасности ядра, триировать CVE и настраивать хардение. CX Codex +1 381установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой