awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
asmjit avatar

asmjit/asmjit

0
View on GitHub↗
asmjit.com↗

Asmjit

AsmJit ist ein Laufzeit-Maschinencode-Generator und JIT-Compiler-Backend, das High-Level-Definitionen in ausführbare Prozessorinstruktionen übersetzt. Es bietet eine einheitliche Instruction-Emission-API und einen Manager für ausführbaren Speicher, um virtuelle Speicherseiten über mehrere CPU-Architekturen hinweg zuzuweisen und zu schützen.

Die Bibliothek fungiert als Assembler-Engine für x86 und ARM und unterstützt die plattformübergreifende Assembler-Generierung durch ein einheitliches Backend. Sie ermöglicht die Erstellung optimierter Maschinencodes für verschiedene CPUs bei gleichzeitiger Beibehaltung einer einzigen Codebasis.

Das Projekt deckt Low-Level-Systemabstraktionen ab, einschließlich Registerallokation, architekturspezifischer Calling-Conventions und dynamischer binärer Instrumentierung. Es verwaltet die Übersetzung von Zwischenrepräsentationen in Binärcode unter Verwendung von Label-basierter Offset-Auflösung und Direct-to-Buffer-Emission.

KI-Suche

Entdecke weitere awesome Repositories

Beschreibe in einfachen Worten, was du brauchst — die KI bewertet tausende kuratierte Open-Source-Projekte nach Relevanz.

Start searching with AI

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.
4,527 Stars·581 Forks·C++·Zlib·5 Aufrufe

Star-Verlauf

Star-Verlauf für asmjit/asmjitStar-Verlauf für asmjit/asmjit

Häufig gestellte Fragen

Was macht asmjit/asmjit?

AsmJit ist ein Laufzeit-Maschinencode-Generator und JIT-Compiler-Backend, das High-Level-Definitionen in ausführbare Prozessorinstruktionen übersetzt. Es bietet eine einheitliche Instruction-Emission-API und einen Manager für ausführbaren Speicher, um virtuelle Speicherseiten über mehrere CPU-Architekturen hinweg zuzuweisen und zu schützen.

Was sind die Hauptfunktionen von asmjit/asmjit?

Die Hauptfunktionen von asmjit/asmjit sind: Just-In-Time Compilation, Memory Protection Managers, Runtime Assemblers, Instruction Emission APIs, JIT Compiler Backends, Machine Code Generation, Cross-Architecture Code Generators, Machine Code Generators.

Welche Open-Source-Alternativen gibt es zu asmjit/asmjit?

Open-Source-Alternativen zu asmjit/asmjit sind unter anderem: gcc-mirror/gcc — This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from… luajit/luajit — LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded… chakra-core/chakracore — ChakraCore is an embeddable JavaScript engine and high-performance scripting runtime. It provides a just-in-time… bytecodealliance/wasmtime — Wasmtime is a WebAssembly runtime and sandboxed bytecode executor designed to run WebAssembly bytecode on a host… bytecodealliance/lucet — Lucet is a WebAssembly runtime and sandboxing compiler that translates WebAssembly bytecode into native machine code.… jmpews/dobby — Dobby is a dynamic function hooking framework and binary instrumentation tool designed to intercept and redirect…

Open-Source-Alternativen zu Asmjit

Ähnliche Open-Source-Projekte, sortiert nach der Anzahl der gemeinsamen Funktionen mit Asmjit.
  • gcc-mirror/gccAvatar von gcc-mirror

    gcc-mirror/gcc

    11,019Auf GitHub ansehen↗

    This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from various programming languages into optimized machine code for different hardware architectures. It provides a suite of tools including an optimizing compiler backend, a machine code generator, and a comprehensive runtime library suite that implements necessary execution environments and support functions. The system utilizes a multi-pass compilation pipeline and pluggable language front-ends to process source code into intermediate representations. It distinguishes itself throu

    C++
    Auf GitHub ansehen↗11,019
  • luajit/luajitAvatar von LuaJIT

    LuaJIT/LuaJIT

    5,592Auf GitHub ansehen↗

    LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded scripting engine and dynamic binary translator that converts portable bytecode into native machine code during execution. The project focuses on high-performance scripting by translating bytecode into architecture-specific instructions to achieve execution speeds close to compiled C code. It utilizes a lightweight runtime environment designed for minimal memory overhead. The system supports binary data processing via bitwise operations and enables asynchronous task management throu

    C
    Auf GitHub ansehen↗5,592
  • bytecodealliance/wasmtimeAvatar von bytecodealliance

    bytecodealliance/wasmtime

    18,241Auf GitHub ansehen↗

    Wasmtime is a WebAssembly runtime and sandboxed bytecode executor designed to run WebAssembly bytecode on a host system. It functions as an embeddable engine that integrates into applications through native APIs and language-specific bindings, as well as a standalone execution environment accessible via a command line interface. It is a WASI compatible runtime, implementing the WebAssembly System Interface to provide portable access to system resources. The engine utilizes a JIT compilation model to translate intermediate representation into optimized machine code for various CPU architecture

    Rustaotcraneliftjit
    Auf GitHub ansehen↗18,241
  • chakra-core/chakracoreAvatar von chakra-core

    chakra-core/ChakraCore

    9,242Auf GitHub ansehen↗

    ChakraCore is an embeddable JavaScript engine and high-performance scripting runtime. It provides a just-in-time compiler that converts JavaScript source code into optimized machine code during runtime to increase execution speed and throughput. The engine utilizes a multi-tiered compilation pipeline and tiered machine code generation to balance startup time with execution speed. Memory is managed via a concurrent garbage collector that reclaims unreachable objects on background threads to minimize application pauses. The project provides capabilities for embedded JavaScript execution and au

    JavaScriptchakrachakracorecplusplus
    Auf GitHub ansehen↗9,242
    • Alle 30 Alternativen zu Asmjit anzeigen→