Merge #1788

1788: ci: Add commit format checker r=CohenArthur a=CohenArthur

Bring over the commit checker from `gcc-patch-dev` with the `gccrs` prefix checker enabled only for `gcc-patch-dev` PRs. I'll open up an issue to make sure that in the future it's easier to keep that folder in sync between the two branches

Co-authored-by: Arthur Cohen <>
tree: d1b0c5ec3de65a7d3ca2d7746eac7f68cba7ce99
  1. .github/
  2. c++tools/
  3. config/
  4. contrib/
  5. fixincludes/
  6. gcc/
  7. gnattools/
  8. gotools/
  9. include/
  10. INSTALL/
  11. intl/
  12. libada/
  13. libatomic/
  14. libbacktrace/
  15. libcc1/
  16. libcody/
  17. libcpp/
  18. libdecnumber/
  19. libffi/
  20. libgcc/
  21. libgfortran/
  22. libgm2/
  23. libgo/
  24. libgomp/
  25. libiberty/
  26. libitm/
  27. libobjc/
  28. libphobos/
  29. libquadmath/
  30. libsanitizer/
  31. libssp/
  32. libstdc++-v3/
  33. libvtv/
  34. lto-plugin/
  35. maintainer-scripts/
  36. zlib/
  37. .dir-locals.el
  38. .gitattributes
  39. .gitignore
  40. .remarkrc
  42. ar-lib
  43. ChangeLog
  44. ChangeLog.jit
  45. ChangeLog.tree-ssa
  47. compile
  49. config.guess
  50. config.rpath
  51. config.sub
  52. configure
  58. COPYING3
  60. depcomp
  61. Dockerfile
  62. install-sh
  63. libtool-ldflags
  64. libtool.m4
  65. logo.png
  66. ltgcc.m4
  68. ltoptions.m4
  69. ltsugar.m4
  70. ltversion.m4
  71. lt~obsolete.m4
  73. Makefile.def
  75. Makefile.tpl
  76. missing
  77. mkdep
  78. mkinstalldirs
  79. move-if-change
  81. README
  83. symlink-tree
  84. test-driver
  85. ylwrap

C/C++ CI GCC Bootstrap Build Build Docker image Docker Pulls project chat Bors enabled badge

GCC Rust

GCC Rust

Please note, the compiler is in a very early stage and not usable yet for compiling real Rust programs.

gccrs is a full alternative implementation of the Rust language ontop of GCC with the goal to become fully upstream with the GNU toolchain.

The origin of this project was a community effort several years ago where Rust was still at version 0.9; the language was subject to so much change that it became difficult for a community effort to play catch up. Now that the language is stable, it is an excellent time to create alternative compilers. The developers of the project are keen “Rustaceans” with a desire to give back to the Rust community and to learn what GCC is capable of when it comes to a modern language.

Build Farm Status


Please find the answers to frequently asked questions over on:

Development Environment


Fetch dependencies for Ubuntu:

$ apt install build-essential libgmp3-dev libmpfr-dev libmpc-dev flex bison autogen gcc-multilib dejagnu

Clone the repository

$ git clone


It is important to remember that GNU toolchain projects are designed to be built outside of their source directory which is why a build directory is created.

$ mkdir gccrs-build
$ cd gccrs-build
$ ../gccrs/configure --prefix=$HOME/gccrs-install --disable-bootstrap --enable-multilib --enable-languages=rust
$ make


The path of header dir and sysroot should be specified when you configure the project.

$ mkdir mac-build
$ cd mac-build
$ ../gccrs/configure --prefix=$HOME/gccrs-install --disable-bootstrap --enable-multilib --enable-languages=rust --with-native-system-header-dir=/usr/include --with-sysroot=/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk
$ make

Running GCC Rust

Running the compiler itself without make install we can simply invoke the compiler proper:

$ ./gcc/rust1 -frust-debug -frust-dump-parse -Warray-bounds -dumpbase -mtune=generic -march=x86-64 -O0 -version -fdump-tree-gimple -o test.s -L/lib/x86_64-linux-gnu -L/lib/../lib64 -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib64 -frust-incomplete-and-experimental-compiler-do-not-use

To invoke the compiler driver (gccrs) we need to:

$ make install

Then invoke the compiler from the installation directory:

$ $HOME/gccrs-install/bin/gccrs -g -O2 -c -o test.o -frust-incomplete-and-experimental-compiler-do-not-use
$ $HOME/gccrs-install/bin/gccrs -o test test.o

You can also setup your shell to automatically find the installed compiler. For example for bash, add the following in your $HOME/.bashrc:

export PATH=$HOME/gccrs-install/bin:$PATH


Invoke the full testsuite from the build directory (gccrs-build in the previous commands):

$ make check-rust

Invoke a subset of the testsuite. For example, to only run tests that are currently known/expected to fail:

$ make check-rust RUNTESTFLAGS="xfail.exp"

There are the following sets of tests:

  • compile.exp : compilation tests
  • execute.exp : execution tests
  • xfail.exp : tests that are currently known/expected to fail

Invoke only a specific test :

$ make check-rust RUNTESTFLAGS="--all"

Logs (with corresponding commands) can be found in : gccrs-build/gcc/testsuite/rust/rust.log.

See GCC Testing documentation for more details.

Test cases are located within gcc/testsuite/rust/. Please contribute your specific test cases referencing any issues on Github.


Enabling internal checks

GCC has several internal checks that can be enabled during configuration. In the case of gccrs, you can enable the following:

$ ../gccrs/configure --prefix=$HOME/gccrs-install --disable-bootstrap --enable-multilib --enable-languages=rust --enable-checking=gimple,tree,types


You can directly invoke gdb on the rust1 compiler process (you can find the exact command adding --verbose to your gccrs invocation):

$ gccrs -O0 -S -o arithmetic_expressions1.s --verbose
 /some/path/../../rust1 -quiet -dumpbase -dumpbase-ext .rs
 -mtune=generic -march=x86-64 -O0 -w -version -fdiagnostics-color=never -fno-diagnostics-show-caret -fno-diagnostics-show-line-numbers -fdiagnostics-urls=never -fdiagnostics-path-format=separate-events -o test.s -L/lib/x86_64-linux-gnu -L/lib/../lib64 -L/usr/lib/x86_64-linux-gnu
$ gdb --args  /some/path/../../rust1 -quiet -dumpbase -dumpbase-ext .rs
 -mtune=generic -march=x86-64 -O0 -w -version -fdiagnostics-color=never -fno-diagnostics-show-caret -fno-diagnostics-show-line-numbers -fdiagnostics-urls=never -fdiagnostics-path-format=separate-events -o test.s -L/lib/x86_64-linux-gnu -L/lib/../lib64 -L/usr/lib/x86_64-linux-gnu

Or simply add the -wrapper gdb,--args option. This will call each subcommand in gdb and you simply have to break/debug in rust1:

$ gccrs -O0 -S -o arithmetic_expressions1.s -wrapper gdb,--args

Docker image

There is a docker image hosted over on:

$ docker pull philberty/gccrs

Or you can build your own image:

$ docker build . -t gccrs-dev

If you want to build an object file:

$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp \
    gccrs-dev:latest gccrs -g -O2 -c \
    gcc/testsuite/rust/compile/torture/ -o type_infer1.o

If you want to build an executable file:

$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp \
    gccrs-dev:latest gccrs -g -O2 \
    gcc/testsuite/rust/compile/torture/ -o type_infer1

To emit assembly :

$ docker run --rm -v "$PWD":/usr/src/myapp -w /usr/src/myapp \
    gccrs-dev:latest gccrs -g -O2 \
    gcc/testsuite/rust/compile/torture/ -S -o type_infer1.s

To emit Rust front end debug output, you may add options like -frust-debug, -frust-dump-all.


If you want to contribute to GCC Rust, you can find more information in

Please be aware this project is designed to be pushed upstream to GCC when we reach some milestones, and this means we require copyright assignment or the Developer's Certificate of Origin sign-off. Please see the Contributing to GCC guide or Developer's Certificate of Origin (DCO) Sign-off guide.

Not all contributions must be code; we would love to see new test cases or bugs and issues to be reported. Feel free to add any comments on open PRs

Continuous Integration

When submitting (or updating) a GitHub Pull Request, several automated checks are run. Generally, a “green status” is necessary before merge.

Compiler Diagnostics

That is, here, diagnostics emitted by the “initial” compiler used to build GCC/Rust.

If building a native toolchain, GCC by default does a 3-stage bootstrap build ( In addition to making sure that GCC is able to reproduce itself bit-by-bit, this also means that stages 2+ are built with -Werror (turning most warning into error diagnostics; see --enable-werror, possibly enabled by default). This helps to catch a good number of bugs, because it enforces that GCC compiles without compiler diagnostics; it's a requirement for upstream patch submission (

GCC generally is only expected to be “warning-clean” without --disable-bootstrap (that is, default --enable-bootstrap for a native build), and not for the initial stage where it‘s using the “initial” compiler -- otherwise we’re at the mercy of whatever “initial” compiler we‘re using. Doing a --disable-bootstrap build is much faster, of course, so we’re often doing that: for example, per the instructions above, or in the standard CI. With that, we're missing out on the aspect that enforces that GCC compiles without compiler diagnostics.

To encounter that, the default CI has a check for new warnings step that verifies in the CI --disable-bootstrap build configuration that no new warnings are introduced. If that step fails, it usually points out a new warning you‘ve introduced erroneously, and should address. Occasionally it means that simply the .github/bors_log_expected_warnings file needs to be updated, for example if due to any kind of “environmental changes” (for example, CI “initial” compiler changes). Unless diligently reproducing the CI configuration (in particular “initial” compiler, GCC version), it’s not really feasible to reproduce this check locally. If in doubt, do a local --enable-bootstrap build, or submit your changes, and wait for the CI system's results.


We can be found on all usual Rust channels such as Zulip, but we also have our own channels: