Exploring the Rust Compiler: GCC vs LLVM

The Rust compiler uses a borrow checker to optimize code performance and memory management. Rust code is compiled using the official compiler rustc.

rustc uses LLVM optimizations on the backend to convert high-level Rust code into low-level machine code. However, a new GCC frontend called gccrs has recently emerged as an alternative to the rustc compiler.

In this article, we will explore the future prospects of the Rust compiler, focusing on two native compiler projects: LLVM and GCC.

What is LLVM?

LLVM is a collection of reusable compiler and toolchain components. Technically, LLVM stands for Low Level Virtual Machine, but over time, the acronym itself has become the brand for the project. LLVM is known for its ability to optimize code and generate high-performance machine code across various programming languages.

A standard compiler infrastructure can be divided into frontend, middle-end, and backend. The frontend acts as a conversion layer between high-level programming languages, which is similar across different compilers (including LLVM and GCC).

The middle-end applies various optimizations to the code, such as loop unrolling and function inlining. LLVM IR is the intermediate representation of LLVM, which can be optimized for different backends based on the target architecture.

From the beginning, LLVM has been the default backend for the Rust compiler, with rustc essentially being an LLVM frontend. The collaboration between Rust and LLVM has proven successful, as LLVM’s advanced optimization techniques enhance the performance of Rust programs and allow them to run on multiple platforms.

What is GCC?

GCC stands for the GNU Compiler Collection, an open-source compiler suite that supports various programming languages such as C, C++, Fortran, and more. It is known for its stability, reliability, and extensive support for different architectures and operating systems.

In addition to the languages listed above, GCC has evolved to support many other languages, including Ada, Java, Go, and recently (still under development) Rust.

There are multiple frontends that support various languages, with each frontend converting the programming language into an abstract syntax tree (AST). The AST serves as an intermediary between the frontend and the middle-end.

LLVM has IR as its intermediate representation, while GCC has GIMPLE and RTL. GIMPLE is the high-level intermediate representation handled by GCC’s middle-end. GIMPLE provides a simplified representation of the program, preserving high-level semantics and simplifying optimization tasks.

After the GIMPLE representation, the code is further transformed into RTL. This low-level representation is very similar to assembly language instructions and undergoes further optimization before generating machine code.

A GCC frontend named gccrs is currently being developed for Rust. This project is still unstable and has not yet been officially integrated into GCC.

Differences in Architecture Between GCC and LLVM

As a compiler collection, GCC employs a different compilation approach compared to LLVM. GCC takes a more traditional approach, using a frontend to parse the source code and generate an AST.

This AST is then converted into a high-level intermediate representation called GIMPLE, which retains the high-level semantics of the program. Unlike LLVM, GCC adds an intermediate representation: RTL.

The optimization goals of both are different. GIMPLE focuses on high-level optimizations, while RTL focuses on low-level optimizations and conversion to assembly-like instructions.

LLVM goes directly from the frontend to its intermediate representation LLVM IR, which is language-agnostic and architecture-agnostic. This allows LLVM to perform various optimizations that can benefit different programming languages and target architectures:

However, the most striking difference between GCC and LLVM lies in how they build source code. LLVM is modular and was designed from the start to be extensible, being used by multiple languages targeting a wide range of backend machines.

On the other hand, GCC was designed as a monolithic compiler with tightly coupled components. Extensions can be created for GCC, but most of its code is tightly integrated, requiring the entire GCC codebase to be downloaded for changes or additions.

Installing gccrs

The Rust programming language primarily uses LLVM as its default compiler infrastructure. As mentioned, rustc is a frontend that uses LLVM, meaning Rust code defaults to using LLVM’s optimizations and transformations to generate machine code.

To use GCC with Rust, you need to use gccrs. gccrs is another frontend for the Rust compiler that uses native GCC as its backend.

To install and use gccrs, please refer to https://github.com/Rust-GCC/gccrs for installation instructions based on different operating systems.

gccrs is still in the early stages of development, so it cannot support most Rust syntax, especially compared to Rust with LLVM. For example, gccrs currently does not support Rust macros, making it difficult to compare Rust between GCC and LLVM carefully.

Future Prospects: Ongoing Projects and Development

Compiling Rust code with GCC and LLVM may yield different results in terms of performance and optimization, with both approaches having their unique advantages. For instance, GCC can compile for various architectures and has existed for a long time, making it more mature and stable in certain areas. It has a mature codebase optimized over decades.

There are two projects working to make Rust compatible with GCC. The first is gccrs, and the second is rustc_codegen_gcc.

The difference between the two is that rustc_codegen_gcc uses the rustc frontend to generate intermediate representation for the GCC backend. It is more stable compared to gccrs and provides a better compilation experience for Rust code using the GCC backend.

Why gccrs is Important for the Rust Community

First, it is still in the early stages led by the community, with rustc remaining the primary Rust compiler. However, having a community-driven compiler adds more diversity to the Rust ecosystem, helping Rust become more versatile across multiple ecosystems.

Having gccrs also helps promote more community innovation. Rust is already a high-performance language on most target platforms, but optimizing for architectures using GCC may be more effective in some niche platforms.

GCC is relatively old and stable, targeting legacy systems that are incompatible with LLVM—such as the Motorola 68000 (m68k), a legacy microprocessor widely used in the 80s and 90s. GCC provides easy access to many such legacy microprocessors. Given the obsolescence of the technology, it is impractical for LLVM to support them.

Conclusion

Today, we explored the future prospects of Rust compilation, focusing on two projects: LLVM and GCC. Both projects have unique advantages, design philosophies, and goals in the Rust compilation approach. However, it should be noted that the gccrs project is still in the early stages of development and does not fully support all features of the Rust language.