LLVM News Archives

The LLVM 17 compiler stack has been released as stable as LLVM 17.0.1 -- a slight mistake leaving the 17.0.0-rc tag meant the original v17.0.0 tag was skipped. This LLVM 17.0.1 stable release along with sub-projects like the Clang 17 C/C++ compiler bring many new features and improvements.

LLVM/Clang developers have been working on C23 language support for some time already but to this point it's only been exposed when using the -std=c2x target or -std=gnu2x for the GNU dialect. However, with C2x having been finalized this summer as C23, the LLVM Clang 18 compiler will now honor the -std=c23 option.

The first release candidate of LLVM 17 is now available for testing as what will be the next half-year update to this innovative open-source compiler stack.

Going along with LLVM's recent additions around supporting new Intel instructions coming with future generation Core CPUs, the LLVM 18 Git development code has now landed support for actually honoring -march=arrowlake, -march=arrowlake-s, and -march=lunarlake targets.

Thanks to work carried out by Sony engineers and then offered for upstream, over the past few weeks support for a unified LTO bitcode front-end has materialized within the LLVM codebase.

Following GCC recently adding new x86 instructions for Intel Arrow Lake and Lunar Lake, the LLVM 17 open-source compiler has now received similar treatment.

In a move similar to GCC's implementation, LLVM Git landed this week initial support for fat LTO objects. This "-ffat-lto-objects" support will be found with the LLVM/Clang 17 release this autumn.

While the upstream LLVM/Clang compiler has been building the AArch64 and x86_64 mainline Linux kernel builds for quite some time, for those interested in China's LoongArch CPU architecture it's the latest target seeing work to enable compiling the Linux kernel under Clang.

The LLVM Clang 17 C/C++ compiler when shipping later this year will now use OpenMP 5.1 as the default version of this multi-processing programming API.

The LLVM Fortran compiler "Flang" has begun seeing NVIDIA CUDA support land in the upstream code-base.

Being merged into LLVM's libc library recently are an optimized memory copy function "memcpy" implementation for the RISC-V architecture.

With LLVM Clang's C++23 support coming together and the -std=c++23 option now exposed, LLVM Clang 17 Git has already added its initial options for specifying what will be C++26 / C++2C support.

Merged today to LLVM 17 Git is now recognizing -std=c++23 rather than just -std=c++2b for the Clang compiler now that C++23 has been deemed technically complete.

It's been two weeks already since the release of LLVM 16.0 as the latest shiny feature update to this widely-used, open-source compiler stack. LLVM release manager Tom Stellard today issued LLVM 16.0.1 as the first point release with a wide collection of fixes and other maintenance work to LLVM and its contained sub-projects.

Merged this weekend to the LLVM 17 development code-base is initial support for RISC-V's vector crypto extension ISA.

AMD has upstreamed a basic RPC (remote procedure call) mechanism for GPU use to LLVM's libc and wired it up for AMDGPU use.

LLVM 16 was released on Friday night as the latest half-year feature release to this open-source compiler stack. From initial AMD Zen 4 support to bringing up new Intel CPU instruction sets and processor targets for their new processors being introduced through 2024, there is a lot of exciting hardware additions in LLVM 16.0. LLVM 16.0 is also notable for faster LLD linking, Zstd compressed debug sections, stabilizing of its LoongArch target, defaulting to C++17 for Clang, and much more. Here's a look at all the exciting changes of LLVM 16.

An updated scheduler model for Intel Alder Lake P processors has been merged into the LLVM compiler after finding some differences compared to Intel's documentation/guidance.

Being worked on actively by a number of stakeholders in recent years has been Flang as a Fortran language front-end to the LLVM compiler stack. While not yet ready for general use, Flang has been making strides as well as showing some promising performance results.

Following the LLVM 16.0 feature freeze and code branching earlier this week, LLVM 16.0.0-rc1 is now available as the first of at least three planned release candidates.

Google engineer Ilya Tocar has introduced the notion of "light" AVX support within the LLVM compiler infrastructure for utilizing some benefits of Advanced Vector Extensions (AVX) but trying to avoid the power/frequency impact that AVX-512 use has on older generations of Intel processors.

LLVM 16 feature development is now officially over with the code having been branched, LLVM 17.0 development now happening with the mainline code, and LLVM 16.0 stable hoping to officially release in early March.

Over the past few years it's become possible to compile the mainline Linux kernel with LLVM/Clang compared to the long-standing dependence on using the GCC compiler. While it's been possible for 3+ years to use the mainline Linux kernel and mainline Clang for building a working x86_64 and AArch64 kernel, the process and support continues to mature.

The newest CPU back-end added to the LLVM compiler stack is for Xtensa processor cores.

LLVM's GPU/device offloading support continues to advance and this open-source compiler stack has now added basic JIT (Just In Time) compilation support to its OpenMP offloading capabilities.

Flang as LLVM's Fortran language front-end has landed support for the -Ofast and -ffast-math compiler flags.

BOLT as the Facebook/Meta-developed tech for optimizing binaries in the name of greater performance by optimizing the code layout was merged to mainline LLVM at the start of the year. Now as we approach the end of the year BOLT is getting a bit of a promotion with being flipped on by default for Linux x86_64 and AArch64 test releases.

Released last month was LLVM/Clang 15 and since then a number of Phoronix readers have been inquiring about Clang 15 compiler benchmarks or there the lack of on Phoronix. I've been testing various Intel and AMD systems with Clang 15, but it hasn't been particularly exciting -- but that's not a bad thing, just that it doesn't make for particularly compelling benchmark articles.

Upstream LLVM has added the compiler CPU targets for the Apple M2, A15, and A16 SoCs.

It's been two weeks since the release of LLVM 15.0 and its sub-projects like Clang 15.0 so per their rapid release rhythm, out today is LLVM 15.0.1 with the initial batch of fixes.

Following the news from this summer of Zstd compression being eyed for use within LLVM, the code has begun being merged to allow for Zstd-compressed ELF debug sections as an alternative to the long-used Zlib.

While LLVM 15.0 was just released this week with many new compiler features, a big change just merged for next spring's LLVM/Clang 16.0 release: C++17 with GNU extensions is now the default C++ and ObjectiveC++ version.

LLVM 15 is now ready to roll as a big half-year update to this open-source compiler stack. LLVM 15.0, Clang 15.0, and other sub-projects have a lot to show for their summer 2022 accomplishments.

The first release candidate of LLVM 15.0 is now available for testing of this growing open-source compiler stack.

With LLVM 15 branched and main now open for LLVM 16, one of the early changes for this next compiler release cycle is enabling scalable vectorization by default for RISC-V with supported targets for RISC-V vector instructions.

LLVM 15.0 and its sub-projects like the Clang compiler are now under a feature freeze and branched from the main code-base ahead of the stable 15.0 release in September.

Merged prior to the weekend into LLVM 15 was a basic web server implementation.

LLVM release manager Tom Stellard of Red Hat has laid out the planned LLVM/Clang 15.0 release schedule for this next major version of this open-source compiler stack.

LLVM developers are eyeing Zstandard "Zstd" use within this compiler stack as a secondary compression method to Zlib. Zstd could be used for compressing ELF debug sections, AST data structures, and other purposes within this open-source compiler stack.

Meta (Facebook) engineers on Monday announced CIR, a proposed new intermediate representation (IR) for LLVM's Clang C/C++ compiler front-end that is based on the MLIR representation.

LLVM 14.0.1 released just earlier this month while already LLVM 14.0.2 is out today. LLVM normally sees just a single point release and traditionally happened mid-to-late in the development cycle ahead of LLVM's next major release. But now LLVM is moving to shipping point releases every two weeks.

The long in-development work by Intel, The Khronos Group, and other organizations on a proper SPIR-V back-end for LLVM is finally seeing code in mainline. As of last night the initial pieces have landed for the LLVM SPIR-V back-end for this Khronos open standard IR used most notably by Vulkan but for OpenCL and OpenGL as well.

Back in 2020 the University of Illinois released HPVM as a heterogeneous parallel systems compiler. This compiler for CPUs / GPUs / FPGAs / other accelerators reached version 1.0 and this week HPVM 2.0 has been announced by the university research crew.

Similar to Sony contributing PlayStation 4 compiler support in LLVM with Clang being their preferred code compiler, Sony has now begun upstreaming PlayStation 5 (PS5) support in the open-source LLVM/Clang compiler stack.

In matching behavior already provided by the GCC compiler, LLVM/Clang has landed "RandStruct" functionality to allow optionally randomizing the structure layout for C code.

LLVM 14.0 was just released last month while shipping today is already the LLVM 14.0.1 release with this point milestone coming much sooner than usual.

After LLVM moved from C++11 to allowing C++14 code within the LLVM code-base itself in 2019, LLVM developers are now preparing the transition to C++17.

Building the Linux kernel with LLVM/Clang rather than GCC has continued maturing nicely since the support was mainlined two years ago and additional LLVM/Clang functionality continues to be optionally supported by the Linux kernel. With Linux 5.18 there is an improvement around the handling of the LLVM environment variable for dealing with versioned compiler binaries or compiler installations outside of the PATH.

Earlier this month I wrote about Microsoft engineers wanting to add DirectX and HLSL support into the upstream LLVM/Clang compiler. As of this week the very early bits of code are beginning to land in LLVM 15.0 for this Microsoft graphics effort.

A subtle but notable change worth mentioning last week for LLVM Clang 15.0 is "-march=native" now working for this compiler when running on Apple M1 SoCs.