Clang

From Wikipedia, the free encyclopedia
This article is about the compiler. For the phenomenon of rhyming word association, see Clanging. For Band-Maid song, see World Domination (Band-Maid album).

Clang
LLVM New Logo.png
Clang 12.0.1 version information screenshot.png
Clang 12.0.1
Original author(s)Chris Lattner
Developer(s)LLVM Developer Group
Initial releaseSeptember 26, 2007; 13 years ago (2007-09-26)[1]
Stable release
12.0.1 / July 8, 2021; 2 months ago (2021-07-08)[2]
Preview release
13.0.0-rc2 / August 27, 2021; 22 days ago (2021-08-27)[3]
Repository
Written inC++
Operating systemUnix-like
PlatformAArch64, ARMv7, IA-32, x86-64, ppc64le[3]
TypeCompiler front end
LicenseApache License 2.0 with LLVM Exceptions[4][5]
Websiteclang.llvm.org

Clang /ˈklæŋ/[6] is a compiler front end for the C, C++, Objective-C, and Objective-C++ programming languages, as well as the OpenMP,[7] OpenCL, RenderScript, CUDA, and HIP[8] frameworks. It acts as a drop-in replacement for the GNU Compiler Collection (GCC), supporting most of its compilation flags and unofficial language extensions.[9][10] It includes a static analyzer, and several code analysis tools.[11]

Clang operates in tandem with the LLVM compiler back end and has been a subproject of LLVM 2.6 and later.[12] As with LLVM, it is free and open-source software under the Apache License 2.0 software license.[4][5] Its contributors include Apple, Microsoft, Google, ARM, Sony, Intel, and AMD.

Clang 12, the latest major version of Clang as of April 2021, has full support for all published C++ standards up to C++17, implements most features of C++20, and adds initial support for the upcoming C++23 standard.[13] Since v6.0.0, Clang compiles C++ using the GNU++14 dialect by default, which includes features from the C++14 standard and conforming GNU extensions.[14]

Background[]

Starting in 2005, Apple Inc. began extensive use of LLVM in several commercial products,[15] including the iOS SDK and Xcode 3.1. One of the first uses of LLVM was an OpenGL code compiler for OS X that converts OpenGL calls into more fundamental calls for graphics processing units (GPU) that do not support certain features. This allowed Apple to support OpenGL on computers using Intel GMA chipsets, increasing performance on those machines.[16]

The LLVM project originally intended to use GCC's front end. The GCC source code, however, is large and somewhat cumbersome; as one long-time GCC developer put it referring to LLVM, "Trying to make the hippo dance is not really a lot of fun".[17] Besides, Apple software use Objective-C, which is a low priority for GCC developers. As such, GCC does not integrate smoothly into Apple's integrated development environment (IDE).[18] Finally, GCC's license agreement, the GNU General Public License (GPL) version 3, requires developers who distribute extensions or modified versions of GCC to make their source code available, but LLVM's permissive software license is devoid of such impediment.[4][5]

In the end, Apple chose to develop Clang, a new compiler front end that supports C, Objective-C and C++.[18] In July 2007, the project received the approval for becoming open-source.[19]

Design[]

Clang works in tandem with LLVM.[20] The combination of Clang and LLVM provides most of the toolchain for replacing the GCC stack. One of Clang's main goals is to provide a library-based architecture,[21] so that the compiler could interoperate with other tools that interact with source code, such as integrated development environments (IDE). In contrast, GCC works in a compile-link-debug workflow; integrating it with other tools is not always easy. For instance, GCC uses a step called fold that is key to the overall compile process, which has the side effect of translating the code tree into a form that looks unlike the original source code. If an error is found during or after the fold step, it can be difficult to translate that back into one location in the original source. Besides, vendors using the GCC stack within IDEs must use separate tools to index the code, to provide features like syntax highlighting and intelligent code completion.

Clang retains more information during the compiling process than GCC, and preserves the overall form of the original code, making it easier to map errors back into the original source. Clang's error reports are more detailed, specific, and machine-readable, so IDEs can index the compiler's output. Modular design of the compiler can offer source code indexing, syntax checking, and other features normally associated with rapid application development systems. The parse tree is also more suitable for supporting automated code refactoring, as it directly represents the original source code.

Clang compiles only C-like languages, such as C, C++, Objective-C, and Objective-C++. In many cases, Clang can replace GCC as needed, with no other effects on the toolchain as a whole.[citation needed] It supports most of the commonly used GCC options. The Flang project by Nvidia and The Portland Group adds Fortran support.[22] However, for other languages, like Ada, LLVM remains dependent on GCC or another compiler front end.

Performance and GCC compatibility[]

Clang is compatible with GCC.[10] Its command-line interface shares many of GCC's flags and options. Clang implements many GNU language extensions and compiler intrinsics, some of which are purely for compatibility. For example, even though Clang implements atomic intrinsics which correspond exactly with C11 atomics, it also implements GCC's __sync_* intrinsics for compatibility with GCC and libstdc++. Clang also maintains ABI compatibility with GCC-generated object code. In practice, Clang is a drop-in replacement for GCC.[23]

Clang's developers aim to reduce memory footprint and increase compilation speed compared to competing compilers, such as GCC. In October 2007, they report that Clang compiled the Carbon libraries more than twice as fast as GCC, while using about one-sixth GCC's memory and disk space.[24] By 2011, Clang seems to retain this advantage in compiler performance.[25][26] As of mid-2014, Clang still consistently compiles faster than GCC in a mixed compile time and program performance benchmark.[27] However, by 2019, Clang is significantly slower at compiling the Linux Kernel than GCC while remaining slightly faster at compiling LLVM.[28]

While Clang has historically been faster than GCC at compiling, the output quality has lagged behind. As of 2014, performance of Clang-compiled programs lagged behind performance of the GCC-compiled program, sometimes by large factors (up to 5.5x),[27] replicating earlier reports of slower performance.[25] Both compilers have evolved to increase their performance since then, with the gap narrowing:

  • Comparisons in November 2016 between GCC 4.8.2 versus clang 3.4, on a large harness of test files shows that GCC outperforms clang by approximately 17% on well-optimized source code. Test results are code-specific, and unoptimized C source code can reverse such differences. The two compilers thus seem broadly comparable.[29][unreliable source]
  • Comparisons in 2019 on Intel Ice Lake has shown that programs generated by Clang 10 has achieved 96% of the performance of GCC 10 over 41 different benchmarks (while winning 22 and losing 19 out of them).[28]

In 2021 there was a benchmark made to compare LLVM 2.7 vs LLVM 11 performance and compile times. The conclusion was LLVM 11 tends to take 2x longer to compile code with optimizations, and as a result produces code that runs 10-20% faster (with occasional outliers in either direction), compared to LLVM 2.7 which is more than 10 years old.[30]

Status history[]

This table presents only significant steps and releases in Clang history.

Date Highlights
11 July 2007 Clang frontend released under open-source licence
25 February 2009 Clang/LLVM can compile a working FreeBSD kernel.[31][32]
16 March 2009 Clang/LLVM can compile a working DragonFly BSD kernel.[33][34]
23 October 2009 Clang 1.0 released, with LLVM 2.6 for the first time.
December 2009 Code generation for C and Objective-C reach production quality. Support for C++ and Objective-C++ still incomplete. Clang C++ can parse GCC 4.2 libstdc++ and generate working code for non-trivial programs,[20] and can compile itself.[35]
2 February 2010 Clang self-hosting.[36]
20 May 2010 Clang latest version built the Boost C++ libraries successfully, and passed nearly all tests.[37]
10 June 2010 Clang/LLVM becomes integral part of FreeBSD, but default compiler is still GCC.[38]
25 October 2010 Clang/LLVM can compile a working modified Linux kernel.[39]
January 2011 Preliminary work completed to support the draft C++0x standard, with a few of the draft's new features supported in Clang development version.[40][13]
10 February 2011 Clang can compile a working HotSpot Java virtual machine.[25]
19 January 2012 Clang becomes an optional component in NetBSD cross-platform build system, but GCC is still default.[41]
29 February 2012 Clang 3.0 can rebuild 91.2% of the Debian archive.[42]
29 February 2012 Clang becomes default compiler in MINIX 3[43]
12 May 2012 Clang/LLVM announced to replace GCC in FreeBSD.[44]
5 November 2012 Clang becomes default compiler in FreeBSD 10.x on amd64/i386.[45]
18 February 2013 Clang/LLVM can compile a working modified Android Linux Kernel for Nexus 7.[46][47]
19 April 2013 Clang is C++11 feature complete.[48]
6 November 2013 Clang is C++14 feature complete.[49]
11 September 2014 Clang 3.5 can rebuild 94.3% of the Debian archive. The percentage of failures has dropped by 1.2% per release since January 2013, mainly due to increased compatibility with GCC flags.[50]
October 2016 Clang becomes default compiler for Android[51] (and later only compiler supported by Android NDK[52]).
13 March 2017 Clang 4.0.0 released
26 July 2017 Clang becomes default compiler in OpenBSD 6.2 on amd64/i386.[53]
7 September 2017 Clang 5.0.0 released
19 January 2018 Clang becomes default compiler in OpenBSD 6.3 on arm.[54]
5 March 2018 Clang is now used to build Google Chrome for Windows.[55]
8 March 2018 Clang 6.0.0 released
5 September 2018 Clang is now used to build Firefox for Windows.[56]
19 September 2018 Clang 7.0.0 released
20 March 2019 Clang 8.0.0 released
1 July 2019 Clang becomes default compiler in OpenBSD 6.6 on mips64.[57]
19 September 2019 Clang 9.0.0 released with official RISC-V target support.[58]
29 February 2020 Clang becomes the only C compiler in the FreeBSD base system, with the removal of GCC.[59]
24 March 2020 Clang 10.0.0 released
2 April 2020 Clang becomes default compiler in OpenBSD 6.7 on powerpc.[60]
12 October 2020 Clang 11.0.0 released
21 December 2020 Clang becomes default compiler in OpenBSD 6.9 on mips64el.[61]
14 April 2021 Clang 12.0.0 released

See also[]

References[]

  1. ^ "LLVM 2.1 Release Notes". llvm.org. LLVM Developer Group. September 27, 2007.
  2. ^ "LLVM Download Page". llvm.org. LLVM Developer Group.
  3. ^ Jump up to: a b "Releases". llvm / llvm-project repo. LLVM Developer Group. August 27, 2021 – via GitHub.com].
  4. ^ Jump up to: a b c "LICENSE.TXT", llvm.org, LLVM Developer Group, retrieved September 24, 2019
  5. ^ Jump up to: a b c "LLVM Developer Policy", llvm.org, LLVM Developer Group, § Copyright, License, and Patents
  6. ^ Christopher, Eric (July 3, 2008). "simply wonder pronunciation of Clang". LLVMdev (Mailing list). Retrieved September 22, 2015.
  7. ^ "OpenMP Support". LLVM Project Blog. Retrieved March 28, 2016.
  8. ^ "C++ Heterogeneous-Compute Interface for Portability". Retrieved February 18, 2020.
  9. ^ "Clang Language Extensions". Retrieved November 8, 2017. In addition to the language extensions listed here, Clang aims to support a broad range of GCC extensions.
  10. ^ Jump up to: a b Clang - Features and Goals: GCC Compatibility, April 15, 2013
  11. ^ "Clang Static Analyzer". LLVM. Retrieved September 3, 2009.
  12. ^ "Getting Involved with the Clang Project", clang.llvm.org, LLVM Developer Group, retrieved September 18, 2012, Clang is a subproject of the LLVM Project, but has its own mailing lists because the communities have people with different interests.
  13. ^ Jump up to: a b "C++ and C++'0x Support in Clang". LLVM.
  14. ^ "Clang 6.0.0 Release Notes". LLVM.
  15. ^ Treat, Adam (February 19, 2005). "mkspecs and patches for LLVM compile of Qt4". Qt4-preview-feedback (Mailing list). Archived from the original on October 4, 2011.
  16. ^ Lattner, Chris (May 25, 2007). LLVM for OpenGL and other stuff (Slides). LLVM Developers' Meeting.
  17. ^ Zadeck, Kenneth (November 19, 2005). "Re: LLVM/GCC Integration Proposal". GCC development (Mailing list).
  18. ^ Jump up to: a b Naroff, Steve (May 25, 2007). New LLVM C Front-end (Slides). LLVM Developers' Meeting.
  19. ^ Lattner, Chris (July 11, 2007). "New LLVM C front-end: "clang"". cfe-dev (Mailing list).
  20. ^ Jump up to: a b Clang team, clang: a C language family frontend for LLVM
  21. ^ Clang: Utility and Applications: Library Based Architecture
  22. ^ FLANG: NVIDIA Brings Fortran To LLVM
  23. ^ Clang can often be used as a drop-in replacement for GCC, May 2020
  24. ^ Clang - Features and Goals: Fast compiles and Low Memory Use, October 2007
  25. ^ Jump up to: a b c Simonis, Volker (February 10, 2011). "Compiling the HotSpot VM with Clang". Archived from the original on February 18, 2011. Retrieved February 13, 2011. While the overall GCC compatibility is excellent and the compile times are impressive, the performance of the generated code is still lacking behind a recent GCC version.
  26. ^ "Benchmarking LLVM & Clang Against GCC 4.5". Phoronix. April 21, 2010. Retrieved February 13, 2011. Binaries from LLVM-GCC and Clang both struggled to compete with GCC 4.5.0 in the timed HMMer benchmark of a Pfam database search. LLVM-GCC and Clang were about 23% slower(...)Though LLVM / Clang isn't the performance champion at this point, both components continue to be under very active development and there will hopefully be more news to report in the coming months
  27. ^ Jump up to: a b "GCC 4.9 VS. LLVM Clang 3.5 Linux Compiler Benchmarks". OpenBenchmarking.org. April 14, 2014. Retrieved June 25, 2014.
  28. ^ Jump up to: a b Michael Larabel (December 23, 2019). "LLVM Clang Achieves ~96% The Performance Of GCC On Intel Ice Lake".
  29. ^ "Clang vs GCC - which produces better binaries?". stackoverflow.com. Retrieved October 1, 2018.[unreliable source]
  30. ^ https://gist.github.com/zeux/3ce4fcc3a43072b4315abde95319ecb6
  31. ^ Divacky, Roman. "[Announce] clang/llvm can compile booting FreeBSD kernel on i386/amd64".
  32. ^ Building FreeBSD with Clang, Wiki.freebsd.org, August 24, 2012, retrieved September 18, 2012
  33. ^ Hornung, Alex. "llvm/clang once more".
  34. ^ Clang, DragonFly BSD, retrieved September 18, 2012
  35. ^ "Clang can compile LLVM and Clang". LLVM Project Blog.
  36. ^ "Clang Successfully Self-Hosts". LLVM Project Blog.
  37. ^ Gregor, Doug. "Clang++ Builds Boost!". LLVM Project Blog.
  38. ^ Davis, Brad. "FreeBSD Status Reports April–June , 2010".
  39. ^ Clang builds a working Linux Kernel (Boots to RL5 with SMP, networking and X, self hosts), Lists.cs.uiuc.edu, archived from the original on September 7, 2015, retrieved September 18, 2012
  40. ^ Gregor, Douglas (January 26, 2011). "New C++0x feature support in Clang" (Mailing list). Archived from the original on January 30, 2011. Retrieved January 29, 2011.
  41. ^ Sonnenberger, Jörg (January 19, 2012). "Status of NetBSD and LLVM". Archived from the original on September 21, 2016. Retrieved February 26, 2014.
  42. ^ Ledru, Sylvestre. "Rebuild of the Debian archive with clang".
  43. ^ "Official Minix 3 website: News".
  44. ^ Gerzo, Daniel (May 12, 2012). "FreeBSD Quarterly Status Report January–March , 2012" (Mailing list). Retrieved May 14, 2012.
  45. ^ Davis, Brooks (November 5, 2012). "Heads Up: Clang now the default on x86" (Mailing list). Retrieved November 7, 2012.
  46. ^ Webster, Behan (February 18, 2013). "LLVMLinux: Compiling Android with LLVM" (PDF). Retrieved May 11, 2013.[permanent dead link]
  47. ^ Tinti, Vinicius (March 17, 2013). "LLVMLinux: Nexus 7". Retrieved May 11, 2013.[permanent dead link]
  48. ^ Du Toit, Stefanus. "Clang is C++11 feature complete as of *just now*!".
  49. ^ "[llvm-project] Revision 194194". Archived from the original on November 18, 2018. Retrieved April 30, 2018.
  50. ^ Ledru, Sylvestre. "Rebuild of Debian using Clang 3.5.0".
  51. ^ "NDK Revision History | Android Developers". developer.android.com. Retrieved March 6, 2018.
  52. ^ "NDK Revision History | Android NDK | Android Developers". Android Developers. Retrieved April 30, 2018.
  53. ^ Nagy, Robert (July 26, 2017). "switch the default compiler on amd64 and i386 to clang" (Mailing list). Retrieved September 30, 2017.
  54. ^ Kettenis, Mark (January 19, 2018). "Switch the default compiler on armv7 to clang" (Mailing list). Retrieved August 27, 2020.
  55. ^ "Clang is now used to build Chrome for Windows". blog.llvm.org. Retrieved April 7, 2018.
  56. ^ "Firefox Beta 63.0beta, See All New Features, Updates and Fixes". www.mozilla.org. Retrieved March 18, 2020.
  57. ^ Hankala, Visa (July 1, 2019). "Switch the default compiler on octeon to clang" (Mailing list). Retrieved August 27, 2020.
  58. ^ "LLVM 9 Releases With Official RISC-V Target Support, Asm Goto, Clang 9, And More". riscv.org. September 26, 2019. Retrieved September 26, 2019.
  59. ^ "FreeBSD svn commit r358454".
  60. ^ Kettenis, Mark (April 2, 2020). "Switch the default compiler on powerpc to clang" (Mailing list). Retrieved August 27, 2020.
  61. ^ Hankala, Visa (December 21, 2020). "Make clang the default compiler on loongson" (Mailing list). Retrieved January 1, 2021.

External links[]

Retrieved from ""