asmjit/asmjit
Asmjit
AsmJit is a runtime machine code generator and JIT compiler backend that translates high-level definitions into executable processor instructions. It provides a unified instruction emission API and an executable memory manager to allocate and protect virtual memory pages across multiple CPU architectures.
The library functions as an assembly engine for x86 and ARM, supporting cross-platform assembly generation through a unified backend. It enables the creation of optimized machine code for different CPUs while maintaining a single codebase.
The project covers low-level system abstractions including register allocation, architecture-specific calling conventions, and dynamic binary instrumentation. It manages the translation of intermediate representations into binary code using label-based offset resolution and direct-to-buffer emission.
Features
- Just-In-Time Compilation - Translates high-level logic into optimized x86 and AArch64 machine code during application execution.
- Memory Protection Managers - Provides a cross-platform interface for allocating and protecting virtual memory pages for dynamic code.
- Runtime Assemblers - Implements an assembly engine that produces target-specific binary code and manages CPU register allocation.
- Instruction Emission APIs - Ships a universal interface for generating SIMD and general-purpose instructions with target-specific performance overrides.
- JIT Compiler Backends - Provides a low-latency library for generating x86 and AArch64 machine code at runtime.
- Machine Code Generation - Creates and executes processor instructions during program execution for high performance and low latency.
- Cross-Architecture Code Generators - Produces optimized machine code for multiple CPU architectures from a single unified API.
- Machine Code Generators - Translates high-level function definitions into executable processor instructions for multiple architectures.
- Dual-Mapped Memory Allocation - Implements dual-mapped memory allocation to comply with operating system security restrictions on executable pages.
- Binary Instrumentation - Enables generating and modifying executable code sequences at runtime to insert probes or optimize hot paths.
- Intermediate Representations - Uses a mutable linked-list intermediate representation to allow code reordering and modification before binary emission.
- Direct-to-Binary Emission - Writes machine instructions directly into executable memory regions to minimize latency during runtime generation.
- Calling Conventions - Provides low-level mechanisms for managing stack frames and argument passing for different processor architectures.
- Virtual Register Allocation - Maps abstract virtual registers to physical hardware registers to optimize resource use and execution speed.
- Symbolic Offset Resolution - Calculates final memory addresses for jumps and calls by resolving symbolic labels against the assembled code buffer.
- Cross-Platform Abstractions - Implements a unified interface to translate universal instructions into target-specific machine code for x86 and AArch64.
- Compiler Backends - JIT and remote assembler for C++.
- General Utilities - Low-latency machine code generation library.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
