rustc_codegen_gcc

Gccrs is valuable for various reasons (bootstrapping, refining the spec, etc), but for the main purpose of "compiling to targets supported by gcc but not llvm", it's definitely not as promising as https://github.com/rust-lang/rustc_codegen_gcc. It's a rustc backend, at the same level as llvm or cranelift, it's much further along than gccrs (already available as a rustup component and can compile any rust code) and will not suffer from lagging behind rustc. But OP has wider ambitions: the real niche targets are supported by neither gcc nor llvm. A rust-to-c transpiler that can adapt to weird C compilers should have a very wide reach.

> There are many architectures that NetBSD supports where Rust is not available Are there many architectures that NetBSD supports where GCC is not available? The rustc_codegen_gcc project allows using the rustc compiler to target any architecture that GCC supports. I think it is pretty far along. https://github.com/rust-lang/rustc_codegen_gcc > getting a Rust compiler running in the first place is hard > bootstrap relies on a binary package > the compiler would also have to be part of the base system The gccrs project aims to make Rust a fully supported language in GCC. It is fully self-hosting and can be built from source. Once accepted, it will be one of the languages you get when you build GCC. https://github.com/Rust-GCC/gccrs When gccrs is ready, it will address all the above objections. Linux faces the same issues. Today, Rust is op

Also there is a rustc codegen backend that uses GCC, so you can just skip the C part: https://github.com/rust-lang/rustc_codegen_gcc

Shouldn't the codegen_gcc project[1] theoretically allow Rust to target backends that only GCC supports? [1] https://github.com/rust-lang/rustc_codegen_gcc

Here’s the set of platforms Rust supports [1] and indeed it has broad support due to LLMV. It obviously still needs to port it’s platform-specific parts of the stdlib to the platforms that aren’t nostd. There’s also [2] which broadens to the set of platforms that GCC supports although I think it might be more bleeding edge than even tier 3 platforms at the moment. I think the only place C really beats Rust is in vendors with toolchains they’ve stopped investing in. More broadly there’s clearly pressure for the industry to abandon C/C++ in favor of Rust given the inability of the language to be modernized into a safe version. [1] https://doc.rust-lang.org/nightly/rustc/platform-support.htm... [2] https://github.com/rust-lang/rustc_codegen_gcc

Then use the GCC backend. https://github.com/rust-lang/rustc_codegen_gcc

That doesn't require a whole new frontend, just a GCC backend will be enough. This is in fact already being worked on with rustc_codegen_gcc https://github.com/rust-lang/rustc_codegen_gcc

>> Is it possible that rust also uses MLIR as backend and thus benefits from a modern backend? Compiler backends require corresponding compiler frontends to do lexical analysis and parsing of the programming language into the intermediate representation (IR) that the backend accepts. The Rust compiler frontend currently lexes and compiles Rust source code into LLVM IR. It is possible to create a Rust frontend that lexes and compiles into other intermediate representations and there are several related projects: 1) gccrs (https://github.com/Rust-GCC/gccrs) is creating a GCC frontend for Rust that can be used with the GCC backend. 2) Cranelift (https://cranelift.dev/) is creating an alternate LLVM IR-based backend for Rust written in Rust since the current LLVM backend is written in C++. 3) rustc_codegen_gcc (https://github.com/rust-lan

gcc-rs is one of two projects for bringing Rust to gcc. gcc-rs is the more ambitious of the two, with an entirely new frontend. There is also rustc_codegen_gcc (https://github.com/rust-lang/rustc_codegen_gcc) that keeps the rustc frontend, and only swaps out LLVM for GCC at the codegen stage.

You can also use rustc as a frontend to GCC through rustc_codegen_gcc. https://github.com/rust-lang/rustc_codegen_gcc

Why not use this instead? https://github.com/rust-lang/rustc_codegen_gcc

That's rather rustc_codegen_gcc. gcc-rs is more for people who don't like LLVM and/or Rust. https://github.com/rust-lang/rustc_codegen_gcc

There is also a project for rustc to use GCC instead of LLVM for codegen. https://github.com/rust-lang/rustc_codegen_gcc

> Has the Rust-portability situation been addressed? The rust portability story is in the process of being addressed, by two different projects: gcc-rs[0] adds a Rust frontend to GCC. rustc-codegen-gcc[1] adds a GCC backend to rustc. Both are progressing pretty well, but it will likely still take a while until they reach maturity. > Or will this change restrict the number of platforms the Linux kernel will be usable on? There won't be any Rust inside the Linux core, only for drivers. So no, the linux kernel will always be usable on all platforms. However, the drivers written in Rust won't be usable on platforms not supported by LLVM until a GCC alternative becomes mature. > what will the advantages be? There are multiple: Safety, improved stability, and developer productivity. Compile time will likely take a hit (Rust is famously slow t