LLVM

Modern compiler infrastructures such as LLVM uniformly translate high-level language code into machine code for various architectures through an intermediate representation (IR) layer.

LLVM is a modular compiler infrastructure project, originally initiated by Chris Lattner at the University of Illinois, and has been adopted by Apple's Swift, the Rust compiler, and others.

Xcode背后使用的是LLVM编译器基础设施，代码在运行前必须通过严格的静态类型检查和编译

Residual optimization opportunities refer to the performance improvement space that still remains in a program after the compiler performs aggressive optimization (such as LLVM's -O3 level) and that is not automatically handled by the compiler.

Modern optimizing compilers (such as LLVM and GCC) already have built in a large number of transformations such as constant propagation, dead code elimination, and loop unrolling.

The heuristic rules used by traditional GPU compilers (such as NVCC and LLVM) are friendly to general-purpose code but often cannot achieve the optimum for a specific kernel.

Modern compilers such as GCC's -O2/-O3 and LLVM's auto-vectorization will automatically perform partial loop unrolling when optimization flags are enabled.

The RISC-V ecosystem rapidly accumulated a usable software library in its early days by porting GCC and LLVM.

MLIR is a modern compiler infrastructure led by Google and maintained by the LLVM community, which progressively lowers high-level algorithm descriptions to hardware instructions through multi-level intermediate representations.

The current version of Zig retains both the LLVM backend (used for release builds) and the self-developed backend (used for development builds).

Starting from version 0.10, Zig launched a self-hosting project, rewriting the compiler frontend in Zig and progressively building self-developed backends (such as x86 and WebAssembly) that do not depend on LLVM.

The early Zig compiler was written in C++ and relied almost entirely on LLVM for code generation, resulting in slower compilation speeds and larger binary sizes.

The LLVM project has evolved over more than twenty years to form a modular, industrial-grade compiler framework.

Codegen units split a crate into multiple independent LLVM modules for parallel compilation, trading a slight runtime performance cost (which hinders cross-unit inlining) for faster compilation speed.

The intrinsic reasons for slow Rust compilation include the powerful type system, the borrow checker, code bloat caused by monomorphization, and the optimization overhead of the LLVM backend.

The open-source C++ compiler landscape has long been dominated primarily by two camps: GCC and Clang/LLVM

Clang is a front end built on the LLVM architecture, known for its modular design, friendly diagnostics, and embeddability, and is the preferred choice of companies such as Apple and Google

TileLang can be understood as a domain-specific language (DSL) or compiler intermediate layer for AI computation, playing a role similar to that of LLVM in the general-purpose compiler domain.

Compiler backends such as GCC and LLVM use the mathematical identities summarized in Hacker's Delight when performing constant propagation and strength reduction.

The -funroll-loops option in LLVM and GCC heuristically selects the unroll factor, whereas using #pragma unroll N on performance-sensitive paths often yields more predictable results.