GCC 15 dropping IA64 support is final nail in the coffin for Itanium architecture

Linux kernel cut it loose, now leading FOSS compiler lands depth-charge on Itanic

Updated GNU Compiler Collection (GCC) 14 should appear any month now, and its documentation reveals that the upcoming iteration, GCC 15, will no longer build binaries for IA64 – or Itanic, as The Reg dubs it.

Development work on version 14 of GCC is still under way but there's an interesting paragraph in the Caveats section of the latest change notes:

Support for the ia64*-*- target ports which have been unmaintained for quite a while has been declared obsolete in GCC 14. The next release of GCC will have their sources permanently removed.

IA64 is the official sobriquet of Intel's ill-fated Itanium architecture, which is why The Reg FOSS desk prefers it to "x64". x86-64, as invented by AMD and thus sometimes called AMD64, was not the first 64-bit architecture in the greater Intel-compatible family, and as for "x" – well, X could mean anything.

This should not be a big surprise. As we reported while it was still in development, Linux kernel 6.7 accepted a patch to remove IA64 support. There were, predictably, howls of dismay about this but it happened anyway.

As we reported then, celebrated industry diplomat Linus Torvalds – who marked the code orphaned in 2021 – offered a modest proposal for those who wanted to keep the Itanic afloat: Maintain it out-of-tree for a year and we'll consider merging it back in again. Though some tried to keep it maintained, this wasn't enough for the kernel community, and now the code definitely won't be merged back in if the default compiler used to compile the kernel no longer supports generating IA64 binaries.

As we discussed when examining Rust support in the kernel, an important angle of Linux kernel development is which compiler you use. The kernel is the largest single FOSS software project in the world, and you can't just throw it at any old compiler and expect a working result.

These days, there are two supported compilers: GCC, on multiple architectures, and Clang, which is based on LLVM, which primarily supports building kernels for x86-64 and Arm. About 20 years ago, you could build the kernel with Intel C [PDF] – but as of 2021, Intel itself switched to LLVM as the basis of its C/C++ compiler.

It's no surprise. Red Hat let its Itanic version sink some 15 years ago. It has been on its way out of the compiler suite for ages as well: it was deprecated in 2019, and the Linux specialist site Phoronix predicted it would be gone by GCC 11. It took a little longer, but finally, it is disappearing into the inky abyss.

We thank a Reg reader, who'd prefer to remain anonymous, for the tip. He commented:

I spent much of 1999-2004 porting software to it, which was a prime waste of time and money. I had realised by mid-2001 that it was a turkey.

It looks like this particular EPIC [PDF] is finally over. ®

Corrected on April 23

The original version of this article incorrectly stated GCC 14 was dropping IA64 support; this was due to a snafu in our reading of the documentation. The article has been updated to now say, correctly, support is due to be removed in version 15. We are happy to clarify this point.

More about


Send us news

Other stories you might like