Array ( [0] => {{Short description|Compiler backend for multiple programming languages}} [1] => {{Infobox software [2] => | name = LLVM [3] => | logo = LLVM logo.png [4] => | logo caption = The LLVM logo, a stylized [[wyvern]]{{Cite web |url=https://llvm.org/Logo.html |title=LLVM Logo |website=The LLVM Compiler Infrastructure Project}} [5] => | author = [[Chris Lattner]], [[Vikram Adve]] [6] => | developer = LLVM Developer Group [7] => | released = {{start date and age|2003}} [8] => | latest release version = {{wikidata|property|preferred|references|edit|Q223490|P348|P548=Q2804309}} [9] => | latest release date = {{wikidata|qualifier|preferred|single|Q223490|P348|P548=Q2804309|P577}} [10] => | latest preview version = {{wikidata|property|preferred|references|edit|Q223490|P348|P548=Q51930650}} [11] => | latest preview date = {{wikidata|qualifier|preferred|single|Q223490|P348|P548=Q51930650|P577}} [12] => | programming language = [[C++]] [13] => | operating system = [[Cross-platform software|Cross-platform]] [14] => | genre = [[Compiler]] [15] => | license = [[University of Illinois/NCSA Open Source License|UIUC]] ([[BSD licenses|BSD-style]])
[[Apache License 2.0]] with LLVM Exceptions (v9.0.0 or later){{cite web|url=https://releases.llvm.org/9.0.0/LICENSE.TXT|title=LICENSE.TXT|publisher=llvm.org|access-date=2019-09-24}} [16] => | website = {{URL|https://www.llvm.org}} [17] => }} [18] => [19] => '''LLVM''' is a set of [[compiler]] and [[toolchain]] technologies{{Cite web| title = The LLVM Compiler Infrastructure Project| access-date = March 11, 2016| url = http://llvm.org/}} that can be used to develop a [[Compiler#Front end|frontend]] for any [[programming language]] and a [[Compiler#Backend|backend]] for any [[instruction set architecture]]. LLVM is designed around a [[language-independent specification|language-independent]] [[intermediate representation]] (IR) that serves as a [[Software portability|portable]], high-level [[assembly language]] that can be [[optimizing compiler|optimized]] with a variety of transformations over multiple passes.{{cite web|url=http://llvm.org/docs/LangRef.html|title=LLVM Language Reference Manual|access-date=June 9, 2019}} The name ''LLVM'' originally stood for ''Low Level Virtual Machine,'' though the project has expanded and the name is [[orphan initialism|no longer officially an initialism]]. [20] => [21] => LLVM is written in [[C++]] and is designed for [[compile-time]], [[Linker (computing)|link-time]], [[runtime (program lifecycle phase)|runtime]], and "idle-time" optimization. Originally implemented for [[C (programming language)|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 (programming language)|Ada]], [[C Sharp (programming language)|C#]] for [[.NET]],{{Cite web |title=Announcing LLILC - A new LLVM-based Compiler for .NET |url=https://dotnetfoundation.org/blog/2015/04/14/announcing-llilc-llvm-for-dotnet|access-date=2020-09-12 |website=dotnetfoundation.org|archive-date=December 12, 2021 |archive-url=https://web.archive.org/web/20211212184833/https://dotnetfoundation.org/blog/2015/04/14/announcing-llilc-llvm-for-dotnet |url-status=dead}}{{cite web |url= http://www.mono-project.com/Mono_LLVM |title=Mono LLVM |access-date=March 10, 2013}}{{cite book |last=Lattner |first=Chris |author-link=Chris Lattner |editor1-last=Brown |editor1-first=Amy |editor2-last=Wilson |editor2-first=Greg |year=2011 |title=The Architecture of Open Source Applications |url=http://www.aosabook.org/ |chapter=LLVM |chapter-url=http://www.aosabook.org/en/llvm.html}} [[Common Lisp]], [[PicoLisp]], [[Crystal (programming language)|Crystal]], [[CUDA]], [[D (programming language)|D]], [[Delphi (software)|Delphi]], [[Dylan (programming language)|Dylan]], [[Forth (programming language)|Forth]],{{Cite web |url=https://github.com/reschivon/movForth |title=MovForth |website=[[GitHub]] |date=November 28, 2021}} [[Fortran]], [[FreeBASIC]], [[Free Pascal]], [[Halide (programming language)|Halide]], [[Haskell]], [[Java bytecode]], [[Julia (programming language)|Julia]], [[Kotlin (programming language)|Kotlin]], [[LabVIEW]]'s G language,{{cite web|url=http://www.electronicdesign.com/test-measurement/what-s-difference-between-labview-2017-and-labview-nxg|title=What's the Difference Between LabVIEW 2017 and LabVIEW NXG?|author=William Wong|date=May 23, 2017|website=[[Electronic Design (magazine)|Electronic Design]]}}{{cite web | url=https://www.ni.com/en/support/documentation/supplemental/10/ni-labview-compiler--under-the-hood.html | title=NI LabVIEW Compiler: Under the Hood }} [[Lua (programming language)|Lua]], [[Objective-C]], [[OpenCL]],{{cite news [22] => |last = Larabel |first = Michael [23] => |date = 11 April 2018 [24] => |url = https://www.phoronix.com/scan.php?page=news_item&px=SPIRV-LLVM-Translator [25] => |title = Khronos Officially Announces Its LLVM/SPIR-V Translator [26] => |work = Phoronix.com [27] => }} [[PostgreSQL]]'s SQL and PLpgSQL,{{Cite web|date=2020-11-12|title=32.1. What is JIT compilation?|url=https://www.postgresql.org/docs/11/jit-reason.html|access-date=2021-01-25 |website=PostgreSQL Documentation|language=en}} [[Ruby (programming language)|Ruby]],{{cite web|title=Features|url=http://www.rubymotion.com/tour/features/|website=RubyMotion|publisher=Scratchwork Development LLC|access-date=June 17, 2017|quote=[[RubyMotion]] transforms the Ruby source code of your project into ... machine code using a[n] ... ahead-of-time (AOT) compiler, based on LLVM.}} [[Rust (programming language)|Rust]],{{Cite web|url=https://rustc-dev-guide.rust-lang.org/backend/codegen.html|title=Code Generation - Guide to Rustc Development|website=rust-lang.org|access-date=2023-01-04}} [[Scala (programming language)|Scala]],{{Cite web|last=Reedy |first=Geoff |date=September 24, 2012 |title=Compiling Scala to LLVM |location=St. Louis, Missouri, United States |access-date=February 19, 2013 |url=http://www.infoq.com/presentations/Scala-LLVM}}{{cite web |title=Scala Native |url=https://scala-native.org/ |access-date=26 November 2023}} [[Swift (programming language)|Swift]], [[Xojo]], and [[Zig (programming language)|Zig]]. [28] => [29] => ==History== [30] => 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 language|dynamic]] programming languages. LLVM was released under the [[University of Illinois/NCSA Open Source License]], a [[permissive free software licence]]. In 2005, [[Apple Inc.]] hired Lattner and formed a team to work on the LLVM system for various uses within Apple's development systems.{{citation|url=http://lists.trolltech.com/qt4-preview-feedback/2005-02/msg00691.html |title=mkspecs and patches for LLVM compile of Qt4 |author=Adam Treat |date=February 19, 2005 |access-date=January 27, 2012 |url-status=dead |archive-url=https://web.archive.org/web/20111004073001/http://lists.trolltech.com/qt4-preview-feedback/2005-02/msg00691.html |archive-date= October 4, 2011}} LLVM has been an integral part of Apple's [[Xcode]] development tools for [[macOS]] and [[iOS]] since Xcode 4 in 2011.{{cite web |url=https://developer.apple.com/technologies/tools/ |title=Developer Tools Overview |website=Apple Developer |publisher=Apple |archive-url=https://web.archive.org/web/20110423095129/https://developer.apple.com/technologies/tools/ |archive-date=April 23, 2011}} [31] => [32] => 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. [33] => [34] => 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",{{cite mailing list |title=The name of LLVM |url=http://lists.llvm.org/pipermail/llvm-dev/2011-December/046445.html |last=Lattner |first=Chris |author-link=Chris Lattner |mailing-list=llvm-dev |date=December 21, 2011 |quote='LLVM' is officially no longer an acronym. The acronym it once expanded too was confusing, and inappropriate almost from day 1. :) As LLVM has grown to encompass other subprojects, it became even less useful and meaningless. |access-date=March 2, 2016}} but a brand that applies to the LLVM umbrella project.{{cite book |last1=Lattner |first1=Chris |editor1-last=Brown |editor1-first=Amy |editor2-last=Wilson |editor2-first=Greg |title=The architecture of open source applications |date=1 June 2011 |isbn=978-1257638017 |chapter-url=https://www.aosabook.org/en/llvm.html |chapter=LLVM|publisher=Lulu.com |quote=The name 'LLVM' was once an acronym, but is now just a brand for the 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]]{{cite web|url=http://libcxx.llvm.org/|title="libc++" C++ Standard Library}}), etc. LLVM is administered by the LLVM Foundation. Compiler engineer Tanya Lattner became its president in 2014{{cite web |url=http://blog.llvm.org/2014/04/the-llvm-foundation.html |title=The LLVM Foundation |last=Lattner |first=Chris |author-link=Chris Lattner |date=April 3, 2014 |work=LLVM Project Blog}} and was in post {{As of|2024|March|lc=y}}.{{cite web |title=Board of Directors |url=https://foundation.llvm.org/docs/board/ |access-date=19 March 2024 |website=LLVM Foundation}} [35] => [36] => ''"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]].{{cite web |url=https://awards.acm.org/software-system/award-winners?year=2012&award=149®ion=&submit=Submit&isSpecialCategory= |title=ACM Software System Award |publisher=ACM}} [37] => [38] => The project was originally available under the [[UIUC license]]. After v9.0.0 released in 2019,{{cite web |last1=Wennborg |first1=Hans |title=[llvm-announce] LLVM 9.0.0 Release |url=https://lists.llvm.org/pipermail/llvm-announce/2019-September/000085.html |date=19 September 2019}} LLVM relicensed to the [[Apache License 2.0]] with LLVM Exceptions. {{As of|2022|11|}} about 400 contributions had not been relicensed.{{cite web |title=Relicensing Long Tail |url=https://foundation.llvm.org/docs/relicensing_long_tail/ |website=foundation.llvm.org|date=11 November 2022}}{{Cite web |title=LLVM relicensing - long tail |publisher=LLVM Project |via=Google Docs |date= |access-date=27 November 2022 |url= https://docs.google.com/spreadsheets/d/18_0Hog_eSwES8lKwf7WJal3yBwwcYfvPu1yCfZnTcek/edit#gid=975215793}} [39] => [40] => ==Features== [41] => 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.{{Cite web |title=⚙ D156286 [docs] Bump minimum GCC version to 7.5 |url=https://reviews.llvm.org/D156286 |access-date=2023-07-28 |website=reviews.llvm.org}} [42] => [43] => LLVM can also generate [[Relocation (computing)|relocatable machine code]] at compile-time or link-time or even binary machine code at runtime. [44] => [45] => LLVM supports a language-independent [[instruction set]] and [[type system]]. Each instruction is in [[static single assignment form]] (SSA), meaning that each [[variable (programming)|variable]] (called a typed register) is assigned once and then frozen. This helps simplify the analysis of dependencies among variables. LLVM allows code to be compiled statically, as it is under the traditional GCC system, or left for late-compiling from the IR to machine code via [[just-in-time compilation]] (JIT), similar to [[Java (programming language)|Java]]. The type system consists of basic types such as [[integer (computer science)|integer]] or [[floating-point arithmetic|floating-point]] numbers and five [[Composite data type|derived types]]: [[pointer (computer programming)|pointers]], [[array data structure|arrays]], [[array data type|vectors]], [[record (computer science)|structures]], and [[function (programming)|functions]]. A type construct in a concrete language can be represented by combining these basic types in LLVM. For example, a class in C++ can be represented by a mix of structures, functions and arrays of [[function pointer]]s. [46] => [47] => The LLVM JIT compiler can optimize unneeded static branches out of a program at runtime, and thus is useful for [[partial evaluation]] in cases where a program has many options, most of which can easily be determined unneeded in a specific environment. This feature is used in the [[OpenGL]] pipeline of [[Mac OS X Leopard]] (v10.5) to provide support for missing hardware features.{{cite mailing list [48] => | last = Lattner |first = Chris |author-link=Chris Lattner [49] => | date = August 15, 2006 [50] => | url = http://lists.llvm.org/pipermail/llvm-dev/2006-August/006497.html [51] => | title = A cool use of LLVM at Apple: the OpenGL stack [52] => | mailing-list = llvm-dev [53] => | access-date = March 1, 2016}} [54] => [55] => 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 unit]]s (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.Michael Larabel, [https://www.phoronix.com/scan.php?page=news_item&px=MTAxMjI "GNOME Shell Works Without GPU Driver Support"], ''phoronix'', November 6, 2011 [56] => [57] => In 2011, programs compiled by GCC outperformed those from LLVM by 10%, on average.{{cite web [58] => | last = Makarov |first = V. [59] => | url = http://vmakarov.fedorapeople.org/spec/2011/llvmgcc32.html [60] => | title = SPEC2000: Comparison of LLVM-2.9 and GCC4.6.1 on x86 [61] => | access-date = October 3, 2011}}{{cite web [62] => | last = Makarov |first = V. [63] => | url = http://vmakarov.fedorapeople.org/spec/2011/llvmgcc64.html [64] => | title = SPEC2000: Comparison of LLVM-2.9 and GCC4.6.1 on x86_64 [65] => | access-date = October 3, 2011}} [66] => In 2013, [[Phoronix Test Suite#Phoronix website|phoronix]] reported that LLVM had caught up with GCC, compiling binaries of approximately equal performance.{{cite web [67] => | last = Larabel |first = Michael [68] => | date = December 27, 2012 [69] => | url = https://www.phoronix.com/scan.php?page=article&item=llvm_clang32_final [70] => | title = LLVM/Clang 3.2 Compiler Competing With GCC [71] => | access-date = March 31, 2013}} [72] => [73] => ==Components== [74] => LLVM has become an umbrella project containing multiple components. [75] => [76] => ===Frontends=== [77] => LLVM was originally written to be a replacement for the extant [[Code generation (compiler)|code generator]] in the GCC stack,{{cite conference |last1=Lattner |first1=Chris |author1-link=Chris Lattner |last2=Adve |first2=Vikram |author2-link=Vikram Adve |title=Architecture For a Next-Generation GCC |url=http://llvm.org/pubs/2003-05-01-GCCSummit2003.html |conference=First Annual GCC Developers' Summit |date=May 2003 |access-date=September 6, 2009}} 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).{{cite web |title=LLVM Compiler Overview |url=https://developer.apple.com/library/archive/documentation/CompilerTools/Conceptual/LLVMCompilerOverview/index.html |website=developer.apple.com}}{{cite web|url=https://developer.apple.com/library/archive/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc5_release_notes.html|title=Xcode 5 Release Notes|work=Apple Inc.}} 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. [78] => [79] => LLVM currently{{as of?|date=March 2023}} supports compiling of [[Ada (programming language)|Ada]], [[C (programming language)|C]], [[C++]], [[D (programming language)|D]], [[Delphi (software)|Delphi]], [[Fortran]], [[Haskell]], [[Julia (programming language)|Julia]], [[Objective-C]], [[Rust (programming language)|Rust]], and [[Swift (programming language)|Swift]] using various [[Semantic analysis (compilers)|frontends]]. [80] => [81] => 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 environment]]s (IDEs) and has wider support for [[Thread (computing)|multithreading]]. Support for [[OpenMP]] directives has been included in [[Clang]] since release 3.8.{{cite web [82] => | url = http://llvm.org/releases/3.8.0/tools/clang/docs/ReleaseNotes.html#openmp-support-in-clan [83] => | title = Clang 3.8 Release Notes [84] => | access-date = August 24, 2016}} [85] => [86] => The [[Utrecht University|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.{{cite web [87] => | url = http://www.cs.uu.nl/wiki/bin/view/Stc/CompilingHaskellToLLVM [88] => | title = Compiling Haskell To LLVM [89] => | access-date = February 22, 2009}} 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.{{cite web [90] => | url = http://blog.llvm.org/2010/05/glasgow-haskell-compiler-and-llvm.html [91] => | title = LLVM Project Blog: The Glasgow Haskell Compiler and LLVM [92] => | date = May 17, 2010 [93] => | access-date = August 13, 2010}} [94] => [95] => Many other components are in various stages of development, including, but not limited to, the [[Rust (programming language)|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.{{citation needed|date=June 2012}} [96] => [97] => ===Intermediate representation=== [98] => [[File:Mesa layers of crap 2016.svg|thumb|LLVM IR is used e.g., by radeonsi and by llvmpipe. Both are part of [[Mesa 3D]].]] [99] => [100] => The core of LLVM is the [[intermediate representation]] (IR), a low-level programming language similar to assembly. IR is a strongly typed [[reduced instruction set computer]] (RISC) instruction set which abstracts away most details of the target. For example, the calling convention is abstracted through call and ret instructions with explicit arguments. Also, instead of a fixed set of registers, IR uses an infinite set of temporaries of the form %0, %1, etc. LLVM supports three equivalent forms of IR: a human-readable assembly format,{{cite web |url=https://llvm.org/docs/LangRef.html |title=LLVM Language Reference Manual |author= |date=10 January 2023 |website=LLVM.org}} an in-memory format suitable for frontends, and a dense bitcode format for serializing. A simple [["Hello, world!" program]] in the IR format: [101] => [102] => [103] => @.str = internal constant [14 x i8] c"Hello, world\0A\00" [104] => [105] => declare i32 @printf(ptr, ...) [106] => [107] => define i32 @main(i32 %argc, ptr %argv) nounwind { [108] => entry: [109] => %tmp1 = getelementptr [14 x i8], ptr @.str, i32 0, i32 0 [110] => %tmp2 = call i32 (ptr, ...) @printf( ptr %tmp1 ) nounwind [111] => ret i32 0 [112] => } [113] => [114] => [115] => The many different conventions used and features provided by different targets mean that LLVM cannot truly produce a target-independent IR and retarget it without breaking some established rules. Examples of target dependence beyond what is explicitly mentioned in the documentation can be found in a 2011 proposal for "wordcode", a fully target-independent variant of LLVM IR intended for online distribution.{{cite web |last1=Kang |first1=Jin-Gu |title=Wordcode: more target independent LLVM bitcode |url=https://llvm.org/devmtg/2011-09-16/EuroLLVM2011-MoreTargetIndependentLLVMBitcode.pdf |access-date=1 December 2019}} A more practical example is [[PNaCl]].{{cite web|url=http://nativeclient.googlecode.com/svn/data/site/pnacl.pdf |title=PNaCl: Portable Native Client Executables |access-date=25 April 2012 |url-status=dead |archive-url=https://web.archive.org/web/20120502135033/http://nativeclient.googlecode.com/svn/data/site/pnacl.pdf |archive-date=2 May 2012 |df=dmy-all}} [116] => [117] => The LLVM project also introduces another type of intermediate representation named [[MLIR (software)|MLIR]]{{Cite web |title=MLIR |url=https://mlir.llvm.org/ |access-date=2022-06-07 |website=mlir.llvm.org}} which helps build reusable and extensible compiler infrastructure by employing a plugin architecture named Dialect.{{Cite web |title=Dialects - MLIR |url=https://mlir.llvm.org/docs/Dialects/ |access-date=2022-06-07 |website=mlir.llvm.org}} It enables the use of higher-level information on the program structure in the process of optimization including [[Polytope model|polyhedral compilation]]. [118] => [119] => ===Backends=== [120] => At version 16, LLVM supports many [[instruction set]]s, including [[IA-32]], [[x86-64]], [[ARM architecture|ARM]], [[Qualcomm Hexagon]], [[Loongson#LoongArch|LoongArch]], [[Motorola 68000|M68K]], [[MIPS architecture|MIPS]], [[Nvidia|NVIDIA]] [[Parallel Thread Execution]] (PTX, also named ''NVPTX'' in LLVM documentation), [[PowerPC]], [[TeraScale (microarchitecture)|AMD TeraScale]],{{cite mailing list |url=http://lists.llvm.org/pipermail/llvm-dev/2012-March/048409.html |title=[LLVMdev] RFC: R600, a new backend for AMD GPUs |mailing-list=llvm-dev |first=Tom |last=Stellard |date=March 26, 2012}} most [[Advanced Micro Devices|AMD]] GPU recent ones (also named ''AMDGPU'' in LLVM documentation),{{cite web |url=https://llvm.org/docs/AMDGPUUsage.html |title=User Guide for AMDGPU Backend — LLVM 15.0.0git documentation}} [[SPARC]], [[z/Architecture]] (also named ''SystemZ'' in LLVM documentation), and [[XCore]]. [121] => [122] => Some features are not available on some platforms. Most features are present for IA-32, x86-64, z/Architecture, ARM, and PowerPC.[http://llvm.org/docs/CodeGenerator.html#target-feature-matrix Target-specific Implementation Notes: Target Feature Matrix] // The LLVM Target-Independent Code Generator, LLVM site. [[RISC-V]] is supported as of version 7. [123] => [124] => In the past, LLVM also supported other backends, fully or partially, including C backend, [[Cell (microprocessor)|Cell SPU]], [[MicroBlaze|mblaze (MicroBlaze)]],{{cite web |title=Remove the mblaze backend from llvm |website=GitHub |date=July 25, 2013 |url=https://github.com/llvm/llvm-project/commit/729866670b05108c399221ca3908400d94ef9783 |access-date=January 26, 2020}} AMD R600, DEC/Compaq [[DEC Alpha|Alpha]] ([[Alpha AXP]]){{cite web |title=Remove the Alpha backend. |website=GitHub |date=October 27, 2011 |url=https://github.com/llvm/llvm-project/commit/4c9fca99c9a6734bb33c34aeaf40b71c4002757e |access-date=January 26, 2020}} and [[Nios II|Nios2]],{{cite web |title=[Nios2] Remove Nios2 backend |website=GitHub |date=January 15, 2019 |url=https://github.com/llvm/llvm-project/commit/99fcbf67d04d488d819bffb8fda3bb9d5504b63b |access-date=January 26, 2020}} but that hardware is mostly obsolete, and LLVM developers decided the support and maintenance costs were no longer justified.{{citation needed|date=December 2021}} [125] => [126] => LLVM also supports [[WebAssembly]] as a target, enabling compiled programs to execute in WebAssembly-enabled environments such as [[Google Chrome]] / [[Chromium (web browser)|Chromium]], [[Firefox]], [[Microsoft Edge]], [[Apple Safari]] or [[WAVM (virtual machine)|WAVM]]. LLVM-compliant WebAssembly compilers typically support mostly unmodified source code written in C, C++, D, Rust, Nim, Kotlin and several other languages. [127] => [128] => 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.{{citation needed|date=December 2021}} [129] => [130] => ===Linker=== [131] => The lld subproject is an attempt to develop a built-in, platform-independent [[linker (computing)|linker]] for LLVM.{{cite web|title=lld - The LLVM Linker|url=http://lld.llvm.org/|publisher=The LLVM Project|access-date=May 10, 2017}} lld aims to remove dependence on a third-party linker. {{As of|2017|05}}, lld supports [[Executable and Linkable Format|ELF]], [[PE/COFF]], [[Mach-O]], and [[WebAssembly]]{{cite web|url=https://lld.llvm.org/WebAssembly.html|title=WebAssembly lld port}} in descending order of completeness. lld is faster than both flavors of [[GNU ld]].{{citation needed|date=December 2021}} [132] => [133] => 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.{{cite web |title=42446 – lld can't handle gcc LTO files |url=https://bugs.llvm.org/show_bug.cgi?id=42446 |website=bugs.llvm.org}} [134] => [135] => ===C++ Standard Library=== [136] => The LLVM project includes an implementation of the [[C++ Standard Library]] named libc++, dual-licensed under the [[MIT License]] and the [[UIUC license]].{{cite web|url=http://libcxx.llvm.org|title="libc++" C++ Standard Library}} [137] => [138] => Since v9.0.0, it was relicensed to the [[Apache License 2.0]] with LLVM Exceptions. [139] => [140] => ===Polly=== [141] => This implements a suite of cache-locality optimizations as well as auto-parallelism and [[Automatic vectorization|vectorization]] using a [[Polytope model|polyhedral model]].{{cite web|url=https://polly.llvm.org|title=Polly - Polyhedral optimizations for LLVM}} [142] => [143] => ===Debugger=== [144] => {{Main article|LLDB (debugger)}} [145] => [146] => ===C Standard Library=== [147] => llvm-libc is an incomplete, upcoming, ABI independent [[C standard library]] designed by and for the LLVM project.{{Cite web |title=llvm-libc: An ISO C-conformant Standard Library — libc 15.0.0git documentation |url=https://libc.llvm.org/ |access-date=2022-07-18 |website=libc.llvm.org}} [148] => [149] => == Derivatives == [150] => Due to its permissive license, many vendors release their own tuned forks of LLVM. This is officially recognized by LLVM's documentation, which suggests against using version numbers in feature checks for this reason.{{cite web |title=Clang Language Extensions |url=https://clang.llvm.org/docs/LanguageExtensions.html#feature-checking-macros |website=Clang 12 documentation |quote=Note that marketing version numbers should not be used to check for language features, as different vendors use different numbering schemes. Instead, use the Feature Checking Macros.}} Some of the vendors include: [151] => * AMD's [[AMD Optimizing C/C++ Compiler]] is based on LLVM, Clang, and Flang. [152] => * Apple maintains an open-source fork for [[Xcode]].{{cite web |title=apple/llvm-project |url=https://github.com/apple/llvm-project |publisher=Apple |date=5 September 2020}} [153] => * [[ARM architecture|Arm]] provides a number of LLVM based toolchains, including Arm Compiler for Embedded targeting bare-metal development and Arm Compiler for Linux targeting the High Performance Computing market [154] => * [[Flang]], Fortran project in development {{As of|2022|lc=y}} [155] => * [[IBM]] is adopting LLVM in its [[IBM XL C/C++ Compilers|C/C++]] and [[IBM XL Fortran|Fortran]] compilers.{{cite web |url=https://developer.ibm.com/blogs/c-and-fortran-adopt-llvm-open-source/ |title=IBM C/C++ and Fortran compilers to adopt LLVM open source infrastructure}} [156] => * [[Intel]] has adopted LLVM for their next generation [[Intel C++ Compiler]].{{Cite web |title=Intel C/C++ compilers complete adoption of LLVM |url=https://www.intel.com/content/www/us/en/develop/blogs/adoption-of-llvm-complete-icx.html |access-date=2021-08-17 |website=Intel |language=en}} [157] => * The [[Los Alamos National Laboratory]] has a parallel-computing fork of LLVM 8 named "Kitsune".{{cite web |title=lanl/kitsune |url=https://github.com/lanl/kitsune |publisher=Los Alamos National Laboratory |date=27 February 2020}} [158] => * [[Nvidia]] uses LLVM in the implementation of its NVVM [[CUDA]] Compiler.{{cite web|title=NVVM IR Specification 1.5|url=https://docs.nvidia.com/cuda/nvvm-ir-spec/index.html|quote=The current NVVM IR is based on LLVM 5.0}} The NVVM compiler is distinct from the "NVPTX" backend mentioned in the [[#Backends|Backends section]], although both generate PTX code for Nvidia GPUs. [159] => * Since 2013, Sony has been using LLVM's primary front-end Clang compiler in the [[software development kit]] (SDK) of its [[PlayStation 4]] console.{{citation |url=http://llvm.org/devmtg/2013-11/slides/Robinson-PS4Toolchain.pdf |title=Developer Toolchain for ps4 |access-date=February 24, 2015}} [160] => [161] => ==See also== [162] => {{Portal|Free and open-source software}} [163] => * [[Common Intermediate Language]] [164] => * [[HHVM]] [165] => * [[C--]] [166] => * [[Amsterdam Compiler Kit]] (ACK) [167] => * [[Optimizing compiler]] [168] => * [[LLDB (debugger)]] [169] => * [[GNU lightning]] [170] => * [[GNU Compiler Collection]] (GCC) [171] => * [[Pure (programming language)|Pure]] [172] => * [[OpenCL]] [173] => * [[ROCm]] [174] => * [[Emscripten]] [175] => * [[TenDRA Distribution Format]] [176] => * [[Architecture Neutral Distribution Format]] (ANDF) [177] => * [[Comparison of application virtualization software]] [178] => * [[SPIR-V]] [179] => * [[University of Illinois at Urbana Champaign#Discoveries and innovation|University of Illinois at Urbana Champaign discoveries & innovations]] [180] => [181] => ==Literature== [182] => * [[Chris Lattner]] - ''[http://www.aosabook.org/en/llvm.html The Architecture of Open Source Applications - Chapter 11 LLVM]'', {{ISBN|978-1257638017}}, released 2012 under [[CC BY]] 3.0 ([[Open Access]]).{{cite book [183] => | last = Lattner |first = Chris |author-link=Chris Lattner [184] => | date = March 15, 2012 [185] => | title = The Architecture of Open Source Applications [186] => | publisher = Amy Brown, Greg Wilson [187] => | chapter = Chapter 11 [188] => | isbn = 978-1257638017 [189] => | chapter-url = http://www.aosabook.org/en/llvm.html [190] => }} [191] => * [http://llvm.org/pubs/2004-01-30-CGO-LLVM.pdf LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation], a published paper by Chris Lattner, Vikram Adve [192] => [193] => ==References== [194] => {{Reflist|30em}} [195] => [196] => ==External links== [197] => * {{Official website}} [198] => [199] => {{Use mdy dates|date=October 2018}} [200] => [201] => [[Category:Compilers]] [202] => [[Category:Free compilers and interpreters]] [203] => [[Category:Register-based virtual machines]] [204] => [[Category:Software using the NCSA license]] [205] => [[Category:Software using the Apache license]] [] => )
good wiki

LLVM

LLVM is a collection of modular and reusable compiler and toolchain technologies designed to optimize and enhance the performance of programming languages. It stands for Low-Level Virtual Machine, but it has evolved beyond its original virtual machine roots and is now used as a general framework for building compilers.

More about us

About

It stands for Low-Level Virtual Machine, but it has evolved beyond its original virtual machine roots and is now used as a general framework for building compilers. The LLVM project was initiated at the University of Illinois at Urbana-Champaign and has since grown into a widely adopted open-source project with contributions from various organizations and individuals. Its primary goal is to provide a set of tools and libraries that enable developers to create efficient, portable, and well-optimized code. One of the notable features of LLVM is its intermediate representation (IR), a low-level, platform-independent representation of the code that serves as a common language between different stages of the compilation process. This IR enables various optimization and analysis techniques to be applied before generating the final machine code, leading to improved performance and code quality. LLVM also provides a wide range of tools, including a state-of-the-art compiler front-end for C and C++, a just-in-time compiler (JIT) for dynamic languages, a debugger, and a suite of libraries for building custom tools. Because of its modular architecture, these tools can be easily integrated into existing software development workflows, making LLVM a popular choice for compiler researchers, language designers, and toolchain developers. Apart from its technical merits, LLVM has also had a significant impact on the software industry. Many popular compilers and programming languages, such as Clang (a C/C++ compiler), Rust, and Swift, are based on LLVM. Its flexible and extensible nature has made it a cornerstone for innovative research and development in the compiler field. Overall, LLVM is an essential technology in the domain of compiler construction, providing a powerful and flexible framework for optimizing and generating high-quality code. Its open-source nature and extensive community support ensure its ongoing development and widespread adoption in various software projects.

Expert Team

Vivamus eget neque lacus. Pellentesque egauris ex.

Award winning agency

Lorem ipsum, dolor sit amet consectetur elitorceat .

10 Year Exp.

Pellen tesque eget, mauris lorem iupsum neque lacus.

You might be interested in

C++

C++ is a general-purpose programming language that was developed in 1979 by Bjarne Stroustrup.

GitHub

GitHub is a web-based platform used for version control and collaboration in software development projects.

PostgreSQL

PostgreSQL is a popular open-source relational database management system (RDBMS) that is widely used for storing and analyzing structured data.

RISC-V

RISC-V is an open-source instruction set architecture (ISA) that is designed to be simple, modular, and extensible.