Hacker News Reader

Comment by pjerem | Hacker News Reader

Would someone kindly ELI5 what is GCC Rust ?

A third implementation of the rust compiler.

The official compiler has an LLVM backend. GNU also wants to provide rust, and is adding a rust front to their gcc compiler.

These monthly reports document the progress until the gcc compiler reaches feature parity with the LLVM-based compiler

I always thought Rust and other PLs generate LLVM IR and leave the optimizations to LLVM while GCC has something more complex to deal with, doesnt it make things much complicated ?

This has largely been true for Rust, however, there are some optimizations that the compiler does before generating LLVM IR.

* Compiler docs: https://rustc-dev-guide.rust-lang.org/mir/optimizations.html

* Working Group: https://rust-lang.github.io/compiler-team/working-groups/mir...

* Example of one such optimization, "constant propagation" https://blog.rust-lang.org/inside-rust/2019/12/02/const-prop...

It is complicated, but GCC has more target platforms.

And generates faster code depending on which benchmarks matter to you

GCC and LLVM have very similar structures, as do all compilers. LLVM IR is only special because it has a defined serialization.

GCC has an IR called GIMPLE that’s fine.

> A third implementation of the rust compiler.

What is the second rust compiler?

I am assuming they're talking about https://github.com/thepowersgang/mrustc

mrustc[0] I think.

[0](https://github.com/thepowersgang/mrustc/)

Others claim mrustc is the second, but has anyone actually tried to use it? the readme does not inspire too much confidence, and looks to (currently) be a C transpiler:

"mrustc's primary goal is bootstrapping rustc, and as such it tends to assume that the code it's compiling is valid (and any errors in the generated code are mrustc bugs). Code generation is done by emitting a high-level assembly (currently very ugly C, but LLVM/cretone/GIMPLE/... could work) and getting an external tool (i.e. gcc) to do the heavy-lifting of optimising and machine code generation."

At least it can be used to bootstrap the actual rust compiler. It's a bit crazy to me how popular this language appears to be, but doesn't have a proper second compiler yet.

Using GCC for Rust backend compilation instead of LLVM.

No, this is writing a new frontend for compiling Rust which uses GCC as a backend.

Was it actually done tabulā rasā?, why?

Certainly quite a bit of rustc could be cannibalized? Surely the parsing, type, and borrow checking stage or perhaps all the way to the m.i.r. could have been shared.

Part of the point is that you won’t need a Rust compiler to compile this. If you did that, you would.

There is another project pursuing that approach. Both are valid strategies with different pros and cons.

Didn't that recent critique of this project say that they've already imported some Rust code, so that wouldn't be true.

I don’t know what you’re referring to, exactly. I’m pretty sure you’re talking about the post linked above but I don’t remember reading that in it. It’s possible I missed it!

I believe gcc-rs has a dependency on Polonius, the new(ish) experimental Rust borrow checker.

Gotcha, thanks. I wonder about the details here; you could imagine that as either a temporary step until things are further along, or possibly a thing only introduced later in the bootstrap process after you’ve built a stage1 compiler, which you could use to build this without an external rustc.

Polonius is an awesome name for a borrow checker! Just hope there’s a —no-verbose flag.

Philosophically, I think the view is that two independent implementations will give the language more long term stability by helping it avoid the trap of a single implementation, with its bugs, being the definitive version of the language.

On the practical level, rustc is written in rust and self-hosting, so reusing code from it in gcc would mean that you needed a rust compiler as well as a c compiler to compile gcc.

Also, rustc and gcc have incompatible licenses.

I am not a licensing lawyer, but the license for rustc (and its standard library, and a great many infrastructural crates in the ecosystem) is dual MIT + Apache 2, which was explicitly chosen so that it would be compatible with both GPL v2 and GPL v3.

I think that the biggest barrier to having GCC use the rustc frontend isn't technical, it's the requirement of copyright assignment to the FSF.

That wasn't a problem when GCC was a requirement to keep free beer UNIX alive, how quickly people forget.

It is a problem when trying to bring code from an existing codebase that has no such copyright assignment clauses. Bringing the rustc frontend code into gcc would be unlikely because getting a copyright release to GNU from everyone that contributed to rustc would be unlikely.

Do you know whether the GCC Ada, Fortran, Go, D and Java frontends also assign full copyright to the FSF? Are the copyright of all dependencies likewise assigned to them?

There is no such requirement to develop one's own frontend for the GCC, but there sometimes is to be part of the GNU project.

You can always take GNU licensed code and build what you want as long as you comply with the license, but to be part of the GCC release that copyright assignment requirement exists.

> On the practical level, rustc is written in rust and self-hosting, so reusing code from it in gcc would mean that you needed a rust compiler as well as a c compiler to compile gcc.

I see, they want a full Rust implementation written in C++ rather than in Rust?

There is a different project that grafts the existing rustc frontend to the gcc backend: rustc_codegen_gcc. The existence of both projects is currently very contentious, as there are concerns about duplicated effort and possible fragmentation of the community. Some of the goals, like the ability to target more architectures, are equally supported by both projects, but for other goals (mostly more organizational and less technical, to my ears) they're pretty different.

Reply on news.ycombinator.com