Some that crave the absolute best possible performance sometimes build their software with the "-Ofast" optimization level that is a step above "-O3" but comes with the risk of potentially unsafe math. LLVM developers are now weighing whether to deprecate -Ofast to either remove it or have it just be an alias for the -O3 optimizations.
LLVM News Archives
741 LLVM open-source and Linux related news articles on Phoronix since 2009.
LLVM's BOLT is an amazing tool for optimizing the layout of binaries and in turn can lead to some mighty useful performance improvements. But now an Arm compiler engineer has taken to leveraging BOLT for creating a binary analysis tool to vet the correctness of security hardening options.
Out today is the big LLVM/Clang 18.1 release. Due to shifting to a new versioning scheme like GCC, today's LLVM 18.1 release is the first major stable release in the new series for what previously would have been called LLVM 18.0.
Merged to the LLVM compiler stack two years ago was the BOLT tool for optimizing the layout of generated binaries for offering even greater performance than the likes of Profile Guided Optimizations (PGO) alone. BOLT had been in development for years by Facebook/Meta engineers and has continued to be improved upon for enhancing the code layout of binaries to yield enhanced performance. Recently there's been renewed work on using BOLT to optimize Linux kernel images.
While the performance of LLVM/Clang is on-par with GCC these days on both x86_64 and AArch64 and the C/C++ support is very robust compared to many years ago, most Linux distributions continue using the GCC compiler and GNU toolchain by default. OpenMandriva is a well known Linux distribution that for several years has been a Clang-built Linux distribution while for three years now the Chimera Linux distribution has also been relying exclusively on an LLVM toolchain.
Following the recent branching of LLVM 18, LLVM 18.1-rc1 was released today as the first test candidate for this half-year update of this widely-used open-source compiler stack.
Being developed the past several years by the SYRMIA embedded software firm is Autocheck, an LLVM/Clang-based project to check C and C++ code to evaluate if it's suitable for running inside automobiles and other safety critical environments. Autocheck is now free and open-source for those wanting to help evaluate the safety of your C/C++ code.
Tom Stellard announced plans this past week for releasing the LLVM 18 compiler stack in early March.
Following discussions with upstream developers, LLVM is changing its versioning as part of the branch creation process to better distinguish mainline development builds of LLVM against those from stable (or soon to be stable) release branches.
As part of Intel's ongoing quest for maximizing the compute performance of their GPUs/accelerators, their compiler engineers have proposed introducing a XeGPU dialect for LLVM's MLIR.
Intel compiler engineers remain quite busy working not only on AVX10 family support but also plumbing in the Advanced Performance Extensions (APX) to be found with future Intel processors.
The LLVM project is now employing profile-guided optimizations (PGO) when building their x86_64 Microsoft Windows release packages. Making use of PGO is able to make their Clang build a stunning 22% faster.
As noted a few weeks back, NVIDIA is working to add OpenACC support to the upstream LLVM Clang compiler for this parallel computing standard. Today that work began landing in LLVM/Clang's development codebase.
A NVIDIA compiler engineer last week laid out the company's plans for implementing OpenACC 3.3 offloading support within the LLVM Clang compiler.
While most hardware vendors are relying on LLVM when it comes to offloading compute work to GPUs, AI accelerators, FPGAs, and similar heterogeneous compute environments, right now each vendor is basically creating their own LLVM offloading run-time among a lot of other duplicated -- and often downstream only -- code. The new "llvm/offload" project hopes to lead to better collaboration in this area.
Intel engineers are proposing that full support for the SYCL programming model be added to upstream LLVM. This is part of their broader oneAPI effort and embracing Khronos' SYCL standard for single-source C++ heterogeneous programming from CPUs to GPUs, FPGAs, and other accelerators.
Merged to LLVM 18 Git yesterday was the initial support for the OpenMP kernel language, an effort around having performance portable GPU codes as an alternative to the likes of the proprietary CUDA.
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.
741 LLVM news articles published on Phoronix.