LLVM: Компиляторный бэкенд для множества языков программирования

Compiler backend for multiple programming languages

LLVM is a set of compiler and toolchain technologies that can be used to develop a frontend for any programming language and a backend for any instruction set architecture. LLVM is designed around a language independent intermediate representation (IR) that serves as a portable, high level assembly language that can be optimized with a variety of transformations over multiple passes. The name LLVM originally stood for Low Level Virtual Machine, though the project has expanded and the name is no longer officially an initialism. LLVM is written in C++ and is designed for compile time, link time, runtime, and "idle time" optimization. Originally implemented for C and C++, the language agnostic design of LLVM has since spawned a wide variety of frontends: languages with compilers that use LLVM (or which do not directly use LLVM but can generate compiled programs as LLVM IR) include ActionScript, Ada, C# for NET, Common Lisp, PicoLisp, Crystal, CUDA, D, Delphi, Dylan, Forth, Fortran, FreeBASIC, Free Pascal, Halide, Haskell, Java bytecode, Julia, Kotlin, LabVIEW's G language, Lua, Objective C, OpenCL, PostgreSQL's SQL and PLpgSQL, Ruby, Rust, Scala, Swift, Xojo, and Zig.

The LLVM project started in 2000 at the University of Illinois at Urbana–Champaign, under the direction of Vikram Adve and Chris Lattner. LLVM was originally developed as a research infrastructure to investigate dynamic compilation techniques for static and dynamic programming languages. LLVM was released under the University of Illinois/NCSA Open Source License, LLVM has been an integral part of Apple's Xcode development tools for macOS and iOS since Xcode 4 in 2011. In 2006, Lattner started working on a new project named Clang. The combination of Clang frontend and LLVM backend is named Clang/LLVM or simply Clang. The name LLVM was originally an initialism for Low Level Virtual Machine. However, the LLVM project evolved into an umbrella project that has little relationship to what most current developers think of as a virtual machine. This made the initialism "confusing" and "inappropriate", and since 2011 LLVM is "officially no longer an acronym", but a brand that applies to the LLVM umbrella project. The project encompasses the LLVM intermediate representation (IR), the LLVM debugger, the LLVM implementation of the C++ Standard Library (with full support of C++11 and C++14), etc. LLVM is administered by the LLVM Foundation. Compiler engineer Tanya Lattner became its president in 2014 and was in post as of 2024. "For designing and implementing LLVM", the Association for Computing Machinery presented Vikram Adve, Chris Lattner, and Evan Cheng with the 2012 ACM Software System Award. The project was originally available under the UIUC license. After v9.0.0 released in 2019, LLVM relicensed to the Apache License 2.0 with LLVM Exceptions.

LLVM can provide the middle layers of a complete compiler system, taking intermediate representation (IR) code from a compiler and emitting an optimized IR. This new IR can then be converted and linked into machine dependent assembly language code for a target platform. LLVM can accept the IR from the GNU Compiler Collection (GCC) toolchain, allowing it to be used with a wide array of extant compiler front ends written for that project. LLVM can also be built with gcc after version 7.5. LLVM can also generate relocatable machine code at compile time or link time or even binary machine code at runtime. LLVM supports a language independent instruction set and type system. Graphics code within the OpenGL stack can be left in intermediate representation and then compiled when run on the target machine. On systems with high end graphics processing units (GPUs), the resulting code remains quite thin, passing the instructions on to the GPU with minimal changes. On systems with low end GPUs, LLVM will compile optional procedures that run on the local central processing unit (CPU) that emulate instructions that the GPU cannot run internally. LLVM improved performance on low end machines using Intel GMA chipsets. A similar system was developed under the Gallium3D LLVMpipe, and incorporated into the GNOME shell to allow it to run without a proper 3D hardware driver loaded. In 2011, programs compiled by GCC outperformed those from LLVM by 10%, on average. In 2013, phoronix reported that LLVM had caught up with GCC, compiling binaries of approximately equal performance.

LLVM has become an umbrella project containing multiple components.

LLVM was originally written to be a replacement for the extant code generator in the GCC stack, and many of the GCC frontends have been modified to work with it, resulting in the now defunct LLVM GCC suite. The modifications generally involve a GIMPLE to LLVM IR step so that LLVM optimizers and codegen can be used instead of GCC's GIMPLE system. Apple was a significant user of LLVM GCC through Xcode 4. x (2013). This use of the GCC frontend was considered mostly a temporary measure, but with the advent of Clang and advantages of LLVM and Clang's modern and modular codebase (as well as compilation speed), is mostly obsolete. LLVM currently supports compiling of Ada, C, C++, D, Delphi, Fortran, Haskell, Julia, Objective C, Rust, and Swift using various frontends. Widespread interest in LLVM has led to several efforts to develop new frontends for many languages. The one that has received the most attention is Clang, a newer compiler supporting C, C++, and Objective C. Primarily supported by Apple, Clang is aimed at replacing the C/Objective C compiler in the GCC system with a system that is more easily integrated with integrated development environments (IDEs) and has wider support for multithreading. Support for OpenMP directives has been included in Clang since release 3.8. The Utrecht Haskell compiler can generate code for LLVM. While the generator was in early stages of development, in many cases it was more efficient than the C code generator. The Glasgow Haskell Compiler (GHC) backend uses LLVM and achieves a 30% speed up of compiled code relative to native code compiling via GHC or C code generation followed by compiling, missing only one of the many optimizing techniques implemented by the GHC. Many other components are in various stages of development, including, but not limited to, the Rust compiler, a Java bytecode frontend, a Common Intermediate Language (CIL) frontend, the MacRuby implementation of Ruby 1.9, various frontends for Standard ML, and a new graph coloring register allocator.

At version 16, LLVM supports many instruction sets, including IA 32, x86 64, ARM, Qualcomm Hexagon, LoongArch, M68K, MIPS, NVIDIA Parallel Thread Execution (PTX, also named NVPTX in LLVM documentation), PowerPC, AMD TeraScale, most AMD GPU recent ones (also named AMDGPU in LLVM documentation), SPARC, z/Architecture (also named SystemZ in LLVM documentation), and XCore. Some features are not available on some platforms. Most features are present for IA 32, x86 64, z/Architecture, ARM, and PowerPC. RISC V is supported as of version 7. In the past, LLVM also supported other backends, fully or partially, including C backend, Cell SPU, mblaze (MicroBlaze), AMD R600, DEC/Compaq Alpha (Alpha AXP) and Nios2, but that hardware is mostly obsolete, and LLVM developers decided the support and maintenance costs were no longer justified. LLVM also supports WebAssembly as a target, enabling compiled programs to execute in WebAssembly enabled environments such as Google Chrome / Chromium, Firefox, Microsoft Edge, Apple Safari or WAVM. LLVM compliant WebAssembly compilers typically support mostly unmodified source code written in C, C++, D, Rust, Nim, Kotlin and several other languages. The LLVM machine code (MC) subproject is LLVM's framework for translating machine instructions between textual forms and machine code. Formerly, LLVM relied on the system assembler, or one provided by a toolchain, to translate assembly into machine code. LLVM MC's integrated assembler supports most LLVM targets, including IA 32, x86 64, ARM, and ARM64. For some targets, including the various MIPS instruction sets, integrated assembly support is usable but still in the beta stage.

The lld subproject is an attempt to develop a built in, platform independent linker for LLVM. lld aims to remove dependence on a third party linker. as of 2017, lld supports ELF, PE/COFF, Mach O, and WebAssembly in descending order of completeness. lld is faster than both flavors of GNU ld. Unlike the GNU linkers, lld has built in support for link time optimization (LTO). This allows for faster code generation as it bypasses the use of a linker plugin, but on the other hand prohibits interoperability with other flavors of LTO.

The LLVM project includes an implementation of the C++ Standard Library named libc++, dual licensed under the MIT License and the UIUC license. Since v9.0.0, it was relicensed to the Apache License 2.0 with LLVM Exceptions.

llvm libc is an incomplete, upcoming, ABI independent C standard library designed by and for the LLVM project.