rustc_codegen_gcc VS mrustc

It's true that if this project succeeds, that would be an outcome, but it's probably worth noting that you'd really only have to add support for the GCC backend to do that, and not reimplement the frontend as well (parsing, type checking, lifetime checking, etc.). There's an unrelated project working to do that: https://github.com/antoyo/rustc_codegen_gcc that would likely yield those same benefits for less effort.

platform support (may improve soon)

Here's the gcc backend for rustc here https://github.com/antoyo/rustc_codegen_gcc Since this just swaps the optimizer/codegen module and reuses all the other stuff from rustc it needs less work and can already compile many valid rust programs.

I'd like to use the rustc_codegen_gcc backend to compile some Rust programs, but I'm confused about how to install and use the patched libgccjit dependency. I've downloaded the fork provided but don't know where to go from there.

I was being a little sloppy and mixing together "actual embedded hardware" with "extensions for applications written in other languages" in my head. I think your point about LLVM is still accurate, though I hear peeps about different projects working on GCC support from time to time.

This doesn't have anything to do with using GCC to compile rust, but instead using rustc to compile Rust using the GCC backend. You can do that today by using the linked project, rustc_codegen_gcc, which is intended to be integrated into rustc at some point in the (hopefully near) future.

Rather than mrustc you should probably look at rustc_codegen_gcc which uses gcc as a backend to rustc (WIP) or GCC Rust which tries to implement a rust frontend for gcc (also WIP). I think rustc_codegen_gcc looks the most promising at the moment

Libgccjit AOT Codegen for Rustc\ (2 comments)

No, you don't. Existential proof: mrustc ignores lifetimes. Just flat out simply ignores. It changes some corner-cases related to HRBT, yet rustc compiled by mrustc works (that's BTW mrustc exist: to bootsrap the rustc compiler).

Incidentally C++ is the only way to bootstrap rust without rust today.

https://github.com/thepowersgang/mrustc

Well, there is mrustc[0], a Rust compiler that doesn't include a borrow-checker, so it's possible to compile (at least some versions of) Rust without a borrow checker, though it might not result in the most optimized code.

AFAIK there are some optimization like the infamous `noalias` optimization (which took several tries to get turned on[1]) that uses information established during borrow checking.

I'm also not sure what the relation with NLL (non-lexical lifetimes) is, where I would assume you would need at least a primitive borrow-checker to establish some information that the backend might be interested in. Then again, mrustc compiles Rust versions that have NLL features without a borrow-checker, so it's again probably more on the optimization side than being essential.

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

[1]: https://stackoverflow.com/a/57259339

> Maybe another memory safe language, but Rust has severe bootstrapping issues which is a hard sell for distros that care about source to binary transparency.

It is possible to bootstrap rustc from just GCC relatively easily, although it's a little bit time consuming.

You can use mrustc to bootstrap Rust 1.54: https://github.com/thepowersgang/mrustc

And from then you can go through each version all the way to the current 1.72. (Each new Rust version officially needs the previous one to compile.)

Have you tried this route : https://github.com/thepowersgang/mrustc ?

Mrustc supports Rust 1.54.0 today

There are three. The official one, mrustc (no borrow checker, but can essentially compile the official rustc) and GCC (can't really compile anything substantial yet). Only rustc is production-ready though.

That probably depends on what you mean by problematic. Having an ever increasing chain of dependencies isn’t the most desirable situation so there has been some work to trim the bootstrap chain. In 2018, when the blogpost I linked above was written, mrustc was used to bootstrap rust 1.19.0; now mrustc can bootstrap rust 1.54.0 so the chain to recent versions is much shorter than if all those intervening versions back through 1.19.0 needed to be built. https://github.com/thepowersgang/mrustc