0 views collected around this technical thread.
ByteDance's STE team dissected the severe compile‑time delays and oversized binary artifacts in their data‑center C++ applications, presenting root‑cause analyses, LLVM bug fixes, and a suite of optimization techniques that together cut build times by up to 50% and reduced binary size by over 80%.
This article explains the importance of instruction scheduling for modern CPU pipelines, describes dependency types, distinguishes dynamic and static scheduling, outlines LLVM's multiple scheduling phases and algorithms, and introduces the underlying topological‑sort technique used to improve compiler performance.
A compiler transforms source code into executable machine instructions by first tokenizing the text into keywords, identifiers and literals, then parsing these tokens into an abstract syntax tree, generating and optimizing intermediate code, and finally assembling and linking the output for the target architecture or LLVM IR.
This article explains how a programmer's source code is transformed into CPU‑executable machine instructions through lexical analysis, parsing into an abstract syntax tree, optimization, target‑specific code generation, and linking, highlighting the role of compilers and tools like LLVM.
The article explains how Python 3.13 introduces a copy‑and‑patch Just‑In‑Time (JIT) compiler that compiles bytecode to machine code on first execution, reuses it to boost performance, and leverages LLVM tools for efficient runtime code generation.
The article explains how database expression evaluation—especially in WHERE and SELECT clauses—can be dramatically accelerated by replacing interpreted AST traversal with Just‑In‑Time compilation using Apache Gandiva, which leverages LLVM to generate SIMD‑optimized machine code for Arrow columnar data, and discusses extensions such as timestamp, array, higher‑order functions, and UDF support.
This article explains how Just‑In‑Time (JIT) compilation, particularly via the Gandiva expression compiler built on LLVM and Apache Arrow, can dramatically accelerate database expression evaluation by transforming abstract syntax trees into native vectorized code, addressing traditional interpretation bottlenecks and improving CPU‑bound query performance.
Android’s Shadow Call Stack (SCS), silently enabled since Android R on AArch64 devices, stores return addresses in a protected register‑based stack separate from the regular stack, complementing stack canaries and requiring hardware support, while developers can activate it via -fsanitize=shadow-call-stack and avoid using X18 elsewhere.
This article explains the Strict Aliasing Rule, how compilers use Type‑Based Alias Analysis (TBAA) for optimization, demonstrates LLVM’s metadata‑based implementation, introduces the TypeSanitizer tool for detecting aliasing violations, and offers practical guidance to avoid common pitfalls in C/C++ code.
Swift inserts the high‑level SIL intermediate representation between source code and LLVM, exposing type declarations, method blocks, and virtual tables, while supporting three dispatch strategies—direct for value types and final methods, VTable for regular class methods, and Objective‑C message dispatch for @objc dynamic methods—crucial for debugging mixed Swift/Objective‑C and protocol‑extension behavior.
This article introduces WebAssembly’s efficient, safe, open standards and LLVM‑based compilation pipeline, then guides Rust developers through installing tools, writing and binding simple functions, optimizing performance and bundle size, and explores tooling, runtimes, real‑world use cases, current limitations, and future extensions such as WASI, SIMD, and threads.
The article presents a technique for static function hooking in Objective‑C by writing a custom LLVM Pass that modifies the intermediate representation during compilation to inject stub calls at chosen points inside a function, and details the required LLVM setup, Pass implementation, Clang integration, and Xcode configuration.
This article explores how to reduce Go's heavy runtime by replacing its entry point, demonstrates building a minimal Go runtime, implements a simple Python JIT compiler in Go, and shows how to create a self‑hosted Go compiler using LLVM IR, complete with code examples and optimizations.
The article demonstrates three advanced Go techniques—eliminating the standard runtime by custom entry points, building a simple Python JIT compiler that translates bytecode to optimized machine code, and bootstrapping the Go compiler itself via AST‑to‑LLVM translation—offering practical code examples that reveal compiler internals.
The tutorial walks through building a complete LLVM‑based Kaleidoscope compiler—from a tokenizing lexer and recursive‑descent parser, through AST construction, LLVM IR generation with SSA and phi nodes, optimization passes, JIT execution, and mutable variable handling via stack allocation—providing full C++ source examples.
The article describes how enabling the aggressive size‑optimisation flag -Oz in Clang caused a video component to create numerous GLFramebuffer and CVPixelBuffer objects, leading to OOM crashes, and explains the underlying ARC and Machine Outliner interactions that exposed a compiler bug which was later fixed in LLVM.
This article explains how to use LLVM and SanitizerCoverage to insert BasicBlock‑level instrumentation into iOS binaries such as the WeChat SDK, covering the theory of code‑coverage metrics, compilation steps, bitcode extraction, and a practical demo that visualizes runtime execution paths.
This article explains how large-scale recommendation systems rely on efficient feature engineering, describes the three-layer architecture (offline, stream, online), and details how Spark SQL and the LLVM‑optimized FESQL engine improve performance and ensure offline‑online feature consistency.
The article explains how to instrument code for coverage using LLVM’s modular compiler infrastructure—adding compile‑time probes that generate .gcno files, runtime counters that produce .gcda files, and then parsing these with GCOV, while detailing LLVM IR, basic blocks, flow graphs, and extensions for custom plugins.
This article explains how Swift leverages LLVM's three‑stage compiler architecture and the Swift Intermediate Language (SIL) to implement protocol extensions, detailing the generation and analysis of SIL code, VTables, Witness Tables, and function calls to reveal the language's underlying compilation process.