7 dépôts
Analysis of a compiler's intermediate core representations to optimize execution speed.
Distinguishing note: Candidates focus on AI logic or emulation speed; this is specifically about compiler core analysis for performance.
Explore 7 awesome GitHub repositories matching programming languages & runtimes · Intermediate Representation Analysis. Refine with filters or upvote what's useful.
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
Performs analysis on intermediate representations using value numbering to optimize execution speed.
This project is a comprehensive functional programming curriculum and learning resource for Haskell. It provides sequenced educational paths and technical reference guides designed to take developers from beginner to advanced levels of proficiency. The project distinguishes itself through a deep focus on theoretical and technical foundations, offering detailed studies on type theory, category theory, and runtime internals. It includes a dedicated performance handbook for optimizing execution speed and memory management, as well as an ecosystem guide for managing development tools and editor c
Implements high-performance improvements through the analysis of core intermediate representations.
Paddle-Lite is a deep learning inference engine and edge computing runtime designed to execute trained models on mobile and edge devices. It provides a hardware-accelerated inference framework and a decoupled runtime with a minimal binary footprint to operate in resource-constrained environments without third-party dependencies. The project includes a model quantization tool for reducing precision and size via static and dynamic quantization, as well as a computation graph optimizer. These tools reduce latency and memory usage by fusing operators and pruning the model intermediate representat
Analyzes and prunes the model's intermediate representation to remove redundant nodes and optimize memory allocation.
Static Analyzer for Solidity and Vyper
Transforms Solidity and Vyper source code into a custom intermediate representation for uniform vulnerability detection.
Miasm est un framework de rétro-ingénierie Python conçu pour l'analyse binaire, le désassemblage et la modification. Il fonctionne comme un framework d'analyse binaire qui élève le code machine vers une représentation intermédiaire pour permettre la recherche en sécurité indépendante de la plateforme. Le système opère comme un moteur d'émulation binaire et une boîte à outils de modification, permettant l'exécution de code binaire dans un environnement virtuel pour suivre les changements d'état sans matériel natif. Il fournit des outils de patch binaire pour mettre à jour et modifier des fichiers binaires bruts sur plusieurs architectures CPU et formats d'exécutables. Le framework couvre des capacités de désassemblage, d'élévation vers une représentation intermédiaire et de simplification sémantique pour supprimer l'obfuscation binaire. Il inclut la prise en charge de l'analyse des formats binaires et du mappage mémoire pour suivre les références et la disposition lors de l'analyse de programmes compilés.
Provides a system for analyzing intermediate representations to enable platform-independent security research.
SVF is an open-source static program analysis framework and points-to analysis library that tracks memory references, variable aliases, and data dependencies across whole programs. The platform translates compiled intermediate code formats into unified internal representations, constructing constraint graphs, call graphs, and control-flow graphs to model interprocedural execution behavior and memory state. The framework incorporates specialized engines for flow-sensitive, flow-insensitive, and context-sensitive pointer analysis alongside sparse value-flow graph generation. It features memory
Processes compiled intermediate representation files as input to execute static analysis passes.
Grin is a compiler infrastructure designed for the translation and optimization of high-level functional languages. It functions as a graph-reduction compiler, transforming source code into a standardized intermediate representation that facilitates whole-program analysis and efficient execution across diverse hardware architectures. The project distinguishes itself through a modular backend infrastructure that separates intermediate representation management from target-specific code generation. By utilizing graph-based transformations, the system performs advanced optimizations such as valu
Provides tools for serializing and analyzing program state at various compilation stages to inspect internal logic.