bjorn3

Progress report on rustc_codegen_cranelift (June 2025)

2025-06-30T00:00:00+00:00

There has been a fair bit of progress since the last progress report! There have been 476 commits since the last progress report.

You can find a precompiled version of cg_clif at https://github.com/rust-lang/rustc_codegen_cranelift/releases/tag/dev or in the rustc-codegen-cranelift-preview rustup component if you want to try it out.

Achievements in the past 7 months

Unwinding

Cranelift has finally implemented support for cleanup during stack unwinding on Linux.

A little bit of history: As part of my bachelor thesis I finished a little under a year ago, I implemented support for unwinding in Cranelift. This was mostly working, however when I revisited the code after finishing writing of my thesis to get it upstreamed, I discovered that there were some cases where the register allocator would insert moves after a call instruction that can unwind and then expect these moves to be executed before jumping to any of the successors of the call instruction. This however can’t happen when unwinding as unwinding directly jumps from the unwinding call to the exception handler block. I tried a bit to fix this, but got stuck on limitations in Cranelift’s register allocator. In addition I got busy with my day job. Fast forward to about two months ago, when Chris Fallin (the main author of major parts of Cranelift) started implementing support for exception handling in Cranelift, fixing the limitations of the register allocator that I got stuck on in the process. The overall design is similar to my proposal, though the details of the Cranelift IR extensions are more elegant than what I previously came up with. I was able to rebase the cg_clif changes from my thesis on top of the newly landed Cranelift changes with minor effort after a couple of small fixes on the Cranelift side. Thanks a lot for working on unwinding support for Cranelift, Chris!

A walkthrough of how unwinding is actually implemented in cg_clif can be found at https://tweedegolf.nl/en/blog/157/exception-handling-in-rustc-codegen-cranelift.

Unwinding support in cg_clif will remain disabled by default for now pending investigation of some build performance issues. In addition it currently doesn’t work on Windows and macOS. On macOS there are some minor differences around the exact encoding of the unwinding tables that haven’t been implemented yet. On Windows adding support will be a fair bit more complicated however. Windows uses the funclets based SEH rather than the landingpads based itanium unwinding (.eh_frame) for unwinding. Cranelift only supports landingpads.

issue wasmtime#1677: Support cleanup during unwinding
bytecodealliance/rfcs#36: Implementing the exception handling proposal in Wasmtime
issue #1567: Support unwinding on panics
wasmtime#10485: Cranelift: remove block params on critical-edge blocks. (thanks @cfallin!)
wasmtime#10502: Cranelift: remove return-value instructions after calls at callsites. (thanks @cfallin!)
wasmtime#10510: Cranelift: initial try_call / try_call_indirect (exception) support. (thanks @cfallin!)
wasmtime#10593: Some fixes for try_call
wasmtime#10609: Cranelift: move exception-handler metadata into callsites. (by me and @cfallin)
wasmtime#10702: Avoid clobbering all float registers in the presence of try_call on arm64
wasmtime#10709: Cranelift: fix invalid regalloc constraints on try-call with empty handler list. (thanks @cfallin!)
ab514c9: Pass UnwindAction to a couple of functions
9495eb5: Pass Module to UnwindContext
#1575: Preparations for exception handling support
#1584: Experimental exception handling support on Linux

ARM

CI now builds and tests on native arm64 Linux systems rather than testing a subset of the tests in QEMU. Inline asm on arm64 can now use vector registers. And the half and bytecount crates are now fixed on arm64.

#1557: Test and dist for arm64 linux on CI
#1564: Fix usage of vector registers in inline asm on arm64
#1566: Fix the half and bytecount crates on arm64

f16/f128 support

@beetrees contributed support for the unstable f16 and f128 types.

wasmtime#8860: Initial f16 and f128 support (thanks @beetrees!)
wasmtime#9045: Add initial f16 and f128 support to the x64 backend (thanks @beetrees!)
wasmtime#9076: Add initial f16 and f128 support to the aarch64 backend (thanks @beetrees!)
wasmtime#10652: Add inital support for f16 without Zfh and f128 to the riscv64 backend (thanks @beetrees!)
wasmtime#10691: Add initial f16 and f128 support to the s390x backend (thanks @beetrees!)
#1574: Add f16/f128 support (thanks @beetrees!)

I’ve made two PR’s to rustc to share more code between codegen backends. This reduces the maintenance burden of both cg_clif and rustc. In the future I would like to migrate the entire inline asm handling of cg_clif to cg_ssa to be used as fallback for codegen backends that don’t natively support inline asm.

rust#132820: Add a default implementation for CodegenBackend::link
rust#134232: Share the naked asm impl between cg_ssa and cg_clif
rust#141769: Move metadata object generation for dylibs to the linker code

SIMD

Some new vendor intrinsics were implemented.

b004312: Implement arm64 vaddlvq_u8 and vld1q_u8_x4 vendor intrinsics
1afce7c: Implement simd_insert_dyn and simd_extract_dyn intrinsics
49bfa1a: Fix simd_insert_dyn and simd_extract_dyn intrinsics with non-pointer sized indices

ABI

ABI handling for 128bit integers libcalls has been improved. In addition the abi-cafe version we test against has been updated to 1.0. Thanks to a bunch of new features it has, we no longer need to patch it’s source code, making it easier to do future updates.

#1546: Fix the ABI for libcalls
#1582: Update to abi-cafe 1.0
b7cfe2f: Use the new –debug flag of abi-cafe

Challenges

SIMD

While core::simd is fully supported through emulation using scalar operations, many platform specific vendor intrinsics in core::arch are not supported. This has been improving though with the most important x86_64 and arm64 vendor intrinsics implemented.

If your program uses any unsupported vendor intrinsics you will get a compile time warning and if it actually gets reached, the program will abort with an error message indicating which intrinsic is unimplemented. Please open an issue if this happens.

issue #171: std::arch SIMD intrinsics

ABI

There are still several remaining ABI compatibility issues with LLVM. On arm64 Linux there is a minor incompatibility with the C ABI, but the Rust ABI works just fine. On arm64 macOS there are several ABI incompatibilities that affect the Rust ABI too, so mixing cg_clif and cg_llvm there isn’t recommended yet. And on x86_64 Windows there is also an incompatibility around return values involving i128. I’m slowly working on fixing these.

issue #1525: Tracking issue for abi-cafe failures

Contributing

Contributions are always appreciated. Feel free to take a look at good first issues and ping me (@bjorn3) for help on either the relevant github issue or preferably on the rust lang zulip if you get stuck.

Progress report on rustc_codegen_cranelift (November 2024)

2024-11-14T00:00:00+00:00

There has been a fair bit of progress since the last progress report! There have been 383 commits since the last progress report.

You can find a precompiled version of cg_clif at https://github.com/bjorn3/rustc_codegen_cranelift/releases/tag/dev or in the rustc-codegen-cranelift-preview rustup component if you want to try it out.

Achievements in the past eight months

ABI

There have been significant improvements in the ABI compatibility between the Cranelift and LLVM backends. Most of these improvements affect the Rust ABI across all targets, but some only affect a single platform. In the latter case I will mention them under the section of the respective target. One of the improvements is a partial fix to the Rust ABI where rustc depended on LLVM inventing a calling convention when more values are returned than fit in the registers reserved for returning values by the native calling convention. It is hard for the Cranelift backend to match whatever calling convention was invented by LLVM. For the GCC backend, it is likely impossible to match the convention.

#1523: Update abi-cafe
issue wasmtime#9250: Cranelift: Incorrect abi for i128, i128 return value on x86_64 sysv
issue wasmtime#9509: Cranelift: Correctly handle abi calculation for multi-part arguments
rust#131211: Return values larger than 2 registers using a return area pointer
rust#132729: Make fn_abi_sanity_check a bit stricter
wasmtime#8875: Various cleanups to the ABI handling code
wasmtime#8903: Various cleanups to the ABI handling code (part 1)
wasmtime#9253: Couple of cleanups to the ABI computation
wasmtime#9258: Remove StructArgument support from the arm64, riscv64 and s390x backends
wasmtime#9267: Couple of improvements to the abi handling code (part 3)
wasmtime#9284: Couple of improvements to the abi handling code (part 4)
wasmtime#9287: Make the Tail call conv follow the system call conv for the return area ptr
issue wasmtime#9510: Cranelift: Remove support for implicitly adding a return area pointer
wasmtime#9511: Gate support for implicit return area pointers behind an option

Windows

raw-dylib support for Windows has been implemented by @dpaoliello and @ChrisDenton. This was the last blocker before distributing cg_clif as rustup component for Windows. Thanks a lot to both for all the work!

issue #1345: Implement raw-dylib for Windows
ar_archive_writer#15: Add the ability to create PE import libraries (thanks @dpaoliello!)
ar_archive_writer#17: Add support for creating archives with members from an import library (thanks @dpaoliello!)
ar_archive_writer#23: Make the null import descriptor name unique to the import library (thanks @ChrisDenton!)
rust#128206: Make create_dll_import_lib easier to implement
rust#129164: Use ar_archive_writer for writing COFF import libs on all backends (thanks @ChrisDenton!)
322c2f6: Sync ar_archive_writer to LLVM 18.1.3
#1524: Add support for raw-dylib (thanks @dpaoliello!)
rust#128939: Distribute rustc_codegen_cranelift for Windows
#1537: Don’t panic about debug info for Arm64 Windows unwind info (thanks @dpaoliello!)

macOS

Support for calling variadic functions has long been a blocker for arm64 macOS support. While Rust doesn’t support defining variadic functions, it does need to be able to call several variadic functions like ioctl. As Cranelift doesn’t have native variadic function support, I have been hacking in support in cg_clif by taking advantage of the fact that in most calling conventions variadic arguments are passed the exact same way as regular arguments, so I could cast the defined function signature of the callee to one which lists all variadic arguments as regular arguments. On arm64 Apple however decided to force all variadic arguments to be passed on the stack¹. As a concequence of this, the hack cg_clif used doesn’t work. A couple months back first contributor @beetrees opened a PR which adds another hack on top of the existing hack to add enough dummy arguments to force the actual variadic arguments to be passed on the stack as they should be. In the future I would like to add native support for variadic functions to Cranelift, but until then this hack unblocked support for arm64 macOS. It is now available as rustup component too.

#1515: enable abi-cafe tests on aarch64-apple-darwin (thanks @lqd!)
#1500: Fix varargs support on aarch64-apple-darwin (thanks @beetrees!)
rust#127177: Distribute rustc_codegen_cranelift for arm64 macOS
object#702: Reverse the order of emitting relocations on MachO
253436c: Better parsing of #[section_name] on Mach-O
f340c81: Statically enable a couple of target features always enabled on arm64 macOS

Performance

I recently ran the rustc-perf benchmark suite on cg_clif first the first time in a very long time. The results were pretty bad with many benchmarks showing significant regressions compared to cg_llvm. After comparing profiler output between cg_clif and cg_llvm, it became quite clear why the regressions happened: When nightly rustc switched to using lld by default on Linux, this was only done when using the LLVM backend. The reason for this was that Cranelift didn’t yet use TLSDESC on arm64 and lld only supports the TLSDESC thread local storage implementation. This was fixed later, but rustc was never changed to allow lld with cg_clif until I opened a PR a couple of days ago. The next nightly showed much better benchmark results with most benchmarks being 10-50% faster. A couple of secondary benchmarks still showed some non-trivial regressions, but all of them are pathological code. Still I did look further into the coercions benchmark. This showed significantly more time spent writing the object file than compiling to clif ir. Turns out I forgot to wrap the File to which the object file is written in a BufWriter, so it did a ton of tiny writes. Adding the BufWriter completely fixed the regressions on this benchmark.

Moral of the story: Benchmark more often.

In any case some work is being done on making it easier to do local benchmarks and in the future getting https://perf.rust-lang.org to routinely benchmark cg_clif and compare it against cg_llvm.

One of the GSoC projects was adding a faster register allocator to Cranelift. This was successfully done and @d-sonuga (who worked on this) has shown quite promising benchmark results on their blog. Cranelift only started to support selecting this new register allocator a couple of days ago, and it hasn’t made it to a stable release of Cranelift yet. Because of this I haven’t benchmarked it myself yet.

Benchmark results. (warning: very long images)

Progress report on rustc_codegen_cranelift (April 2024)

2024-04-06T00:00:00+00:00

There has been a fair bit of progress since the last progress report! There have been 342 commits since the last progress report.

Achievements in the past five months

SIMD

A ton of missing SIMD intrinsics got reported over the past couple of months. Most intrinsics that people have reported missing are now implemented.

#1416: Implement AArch64 intrinsics necessary for simd-json (thanks @afonso360!)
#1417: Implement a lot of SIMD intrinsics
#1425: Implement AES-NI and SHA256 crypto intrinsics using inline asm
#1431: Implement another batch of vendor intrinsics
45d8c12: Return architecturally mandated target features to rustc
#1443: Restructure x86 signed pack instructions (thanks @Noratrieb!)
0dc13d7: Implement _mm_prefetch as nop
24361a1: Fix portable-simd tests
604c8a7: Accept [u8; N] bitmasks in simd_select_bitmask
cdae185: Implement SHA-1 x86 vendor intrinsics
1ace86e: Implement all x86 vendor intrinsics used by glam

Debuginfo

I’ve started implementing debuginfo support beyond the already existing line table support. Most primitive types are now described in the debuginfo tables. And the locations and types of statics are now encoded. For unsupported types [u8; size_of::()] will be used as type instead. While debuginfo for statics may not be all that useful for most use cases, describing types is a prerequisite for debuginfo describing the locations of locals, which is very useful for debugging.

#1470: Various small debuginfo improvements
#1472: Add debuginfo for statics
issue #166: DWARF support

s390x support

A couple of fixes to the s390x support now allows compiling and testing cg_clif on s390x.

#1457: Fix simd_select_bitmask on big-endian systems (thanks @uweigand!)
#1458: Fix download hash check on big-endian systems (thanks @uweigand!)
b03b414: Fix stack alignment problem on s390x

Challenges

SIMD

issue #171: std::arch SIMD intrinsics

Cleanup during stack unwinding on panics

Cranelift currently doesn’t have support for cleanup during stack unwinding. I’m working on implementing this and integrating it with cg_clif.

Until this is fixed panic::catch_unwind() will not work and panicking in a single thread will abort the entire process just like panic=abort would. This also means you will have to use -Zpanic-abort-tests in combination with setting panic = "abort" if you want a test failure to not bring down the entire test harness.

issue wasmtime#1677: Support cleanup during unwinding

Contributing

Progress report on rustc_codegen_cranelift (Oct 2023)

2023-10-31T00:00:00+00:00

Quite some exciting progress since the last progress report! There have been 180 commits since the last progress report.

As of today, rustc_codegen_cranelift is available on nightly! :tada: You can run rustup component add rustc-codegen-cranelift-preview --toolchain nightly to install it and then either CARGO_PROFILE_DEV_CODEGEN_BACKEND=cranelift cargo +nightly build -Zcodegen-backend to use it for the current invocation or add

[unstable]
codegen-backend = true

[profile.dev]
codegen-backend = "cranelift"

to .cargo/config.toml or

# This line needs to come before anything else in Cargo.toml
cargo-features = ["codegen-backend"]

[profile.dev]
codegen-backend = "cranelift"

to Cargo.toml to enable it by default for debug builds. You can also set codegen-backend for individual packages using [profile.dev.package.my_program] codegen-backend = "cranelift". This would for example allow building a game engine using LLVM all optimizations enabled, but your game logic using Cranelift for faster iteration.

The following targets are currently supported:

x86_64-unknown-linux-gnu
x86_64-unknown-linux-musl
x86_64-apple-darwin
aarch64-unknown-linux-gnu
aarch64-unknown-linux-musl

Windows support has been omitted for now. And for macOS currently on supports x86_64 as Apple invented their own calling convention for arm64 for which variadic functions can’t easily be implemented as hack. If you are using an M1 processor, you could try installing the x86_64 version of rustc and then using Rosetta 2. Rosetta 2 will hurt performance though, so you will need to try if it is faster than the LLVM backend with arm64 rustc.

Also be aware that there are currently still some missing features.

Achievements in the past three months

Distributing as rustup component

As I already indicated at the start of this progress report, cg_clif is now available as rustup component.

rust-lang/rust#81746: Distribute cg_clif as rustup component on the nightly channel

Moved to the rust-lang org

Rustc_codegen_cranelift is now part of the rust-lang github organization: https://github.com/rust-lang/rustc_codegen_cranelift/

Risc-V support

While Cranelift has had a riscv64 backend for a couple of months now, only recently some of the features have been implemented as well as some bug fixes have been done by @afonso360 to make cg_clif work on linux riscv64gc. Once that was done I only needed to add inline assembly support for riscv64.

#1398: Add riscv64 linux support

SIMD

A whole bunch more x86_64 and arm64 vendor intrinsics have been implemented. This includes arm64 vendor intrinsics used by newer regex versions and the x86_64 vendor intrinsics used by rav1e and image. In addition a bunch of the new platform independent simd intrinsics used by std::simd have been implemented. The hack to disable detection of target features using is_x86_feature_detected!() has now been removed when inline asm support is enabled. This hack never worked when using a standard library compiled by LLVM anyway and enough vendor intrinsics are now supported to not need it anymore most of the time.

c974bc8: Update regex and implement necessary AArch64 vendor intrinsics
f1ede97: Update portable-simd test and implement new simd_* platform intrinsics
e5ba1e8: Implement llvm intrinsics necessary for rav1e
a558968: Implement all llvm intrinsics necessary for the image crate

Inline assembly

Inline assembly is now supported on arm64 and riscv64 as well as macOS and Windows. Futhermore support for inline assembly is now being tested in cg_clif’s CI. With the exception of sym operands, inline assembly is now declared as stable for usage with cg_clif.

#1396: Support inline asm on AArch64
#1397: Test inline asm support on CI
issue #1204: Full asm!() support
#1403: Support and stabilize inline asm on all platforms

Challenges

SIMD

issue #171: std::arch SIMD intrinsics

Cleanup during stack unwinding on panics

Cranelift currently doesn’t have support for cleanup during stack unwinding. I’m working on implementing this and integrating it with cg_clif.

issue wasmtime#1677: Support cleanup during unwinding

Contributing

Progress report on rustc_codegen_cranelift (July 2023)

2023-07-29T00:00:00+00:00

It has been quite a while since the last progress report. A ton of progress has been made since then, but I simply didn’t get around writing a new progress report. There have been 639 commits since the last progress report. This is significantly more than the last time given how long there has been since the last progress report. As such I skimmed the commit list to see what stood out to me. I may have missed some important things.

You can find a precompiled version of cg_clif at https://github.com/bjorn3/rustc_codegen_cranelift/releases/tag/dev if you want to try it out.

Achievements in the past nine months

Perf improvements

Debug assertions were accidentally enabled for the precompiled dev releases. Disabling them significantly improved performance from a ~13% improvement of cg_clif over cg_llvm to a ~39% improvement on one benchmark. Local builds have not been affected by this issue.

#1347: Build CI dist artifacts without debug assertions

SIMD

A lot of vendor intrinsics have been implemented. The regex crate now works on AVX2 systems without cg_clif’s hack to make is_x86_feature_detected!() hide all features other than SSE and SSE2. This hack doesn’t work when the standard library is compiled using cg_llvm as will be the case when cg_clif gets distributed with rustup.

#1297: Implement some AArch64 SIMD intrinsics
#1309: Implement simd_gather and simd_scatter
#1378: Implement all vendor intrinsics used by regex on AVX2 systems
e4d0811: Implement _mm_srli_epi16 and _mm_slli_epi16
c09ef96: Implement _mm_shuffle_epi8
#1380: Implement a whole bunch more x86 vendor intrinsics

Build system rework

The build system has seen a significant rework to allow using it to test a precompiled cg_clif version and to allow vendoring of everything for offline builds. This was a requirement to testing cg_clif in rust’s CI. A PR is open to run part of cg_clif’s tests in rust’s CI.

#1291: Move downloaded test project to downloads/
#1298: Introduce CargoProject type and use it where possible
#1300: Rename the build/ directory to dist/
#1302: Allow specifying where build artifacts should be written to
#1338: Avoid clobbering build_system/ and ~/.cargo/bin
#1339: Many build system improvements
#1340: Push up a lot of rustc and cargo references
#1341: Refactor sysroot building
#1374: Allow building and testing without rustup
5b3bc29: Allow testing a cranelift backend built into rustc itself
134dc33: Fix testing with unstable features disabled
#1357: Support testing of cg_clif in rust’s CI
rust#112701: Run part of cg_clif’s tests in CI (not yet merged)

Inline assembly

const operands for inline_asm!() and global_asm!() are now supported. sym operands work in some cases, but if rustc decides to make the respective function private to the codegen unit it is contained in, you will get a linker error as inline asm ends up in a separate codegen unit while rustc thinks it ends up in the same codegen unit.

#1350: Implement const and sym operands for inline asm
#1351: Implement const and sym operands for global asm

s390x support tested in CI

@afonso360 contributed CI support for testing s390x.

#1304: Add S390X CI Support

Archive writer

As I already pointed out in a previous progress report I had been working on switching out the archive writer from a fork of rust-ar to a rewrite of LLVM’s archive writer. This work has since been completed. The LLVM backend still uses LLVM’s original version because a couple of regressions were found in the integration with rustc. I plan to fix those issues and switch the LLVM backend to the rust rewrite some time in the future.

#1155: Remove the ar git dependency
rust#97485: Rewrite LLVM’s archive writer in Rust

Benchmark improvements

Release builds of simple-raytracer are now benchmarked too. Release builds are slower but should still be faster than the LLVM backend. At the same time the resulting executables are about 20% faster and for simple-raytracer faster than LLVM in debug mode.

CI runs now also show the benchmark results if you scroll down on the overview page of the workflow run. See for example https://github.com/bjorn3/rustc_codegen_cranelift/actions/runs/5645453142.

#1373: Benchmark clif release builds with ./y.rs bench
448b7a3: Record GHA step summaries for benchmarking

Challenges

SIMD

issue #171: std::arch SIMD intrinsics

Cleanup during stack unwinding on panics

Cranelift currently doesn’t have support for cleanup during stack unwinding. I’m working on implementing this and integrating it with cg_clif.

issue wasmtime#1677: Support cleanup during unwinding

Distributing as rustup component

There is progress towards distributing cg_clif as a rustup component. For example a decent amount of SIMD vendor intrinsics are now implemented and there is an open PR to run part of cg_clif’s test suite on rust’s CI. There are still things to be done though. https://github.com/bjorn3/rustc_codegen_cranelift/milestone/2 lists things I know of that still need to be done.

Contributing

Progress report on rustc_codegen_cranelift (Oct 2022)

2022-10-12T00:00:00+00:00

There has a ton of progress since the last progress report. There have been 303 commits since then. @afonso360 has been contributing a ton to improve Windows and AArch64 support. (Thanks a lot for that!)

Achievements in the past four months

Windows support with the MSVC toolchain

Windows support with the MSVC toolchain has been added by @afonso360. This requires a Cranelift change to add COFF based TLS support, a rewrite of the bash scripts for testing in rust (as windows doesn’t have bash), adding inline stack probing to Cranelift (stack probing is necessary on Windows to grow the stack) and finally a couple of minor changes to tests to make them run on Windows. There are still a couple of issues though. For example the JIT mode just crashes. In addition Bevy gets miscompiled causing it to crash at runtime. An investigation into this is ongoing.

#1252: Move test script to y.rs
#1253: Fix no_sysroot testsuite for MSVC environments
bytecodealliance/wasmtime#4546: cranelift: Add COFF TLS Support
bytecodealliance/wasmtime#4747: cranelift: Add inline stack probing for x64
#1249: Miscompilation of Bevy with MSVC

Abi fixes

Gankra’s abi cafe (previously abi-checker) now gets run on CI. This uncovered a couple of ABI issues between cg_clif and cg_llvm. Some were the fault of cg_clif and others had to be fixed in Cranelift.

#1255: Add abi-checker to y.rs and run it on CI
45b6cd6a8a2a3b364d22d4fabc0d72f9e37e3e50: Fix a crash for 11 single byte fields passed through the C abi
bytecodealliance/wasmtime#4634: Fix sret for AArch64

AArch64 support

Linux on AArch64 now passes the full test suite of cg_clif. It is not tested in CI, so it is possible that support will regress in the future.

Basic s390x support

Basic support for IBM’s s390x architecture has been added by @uweigand. There is no testing on CI and there are still some test failures.

#1260: Ignore ptr_bitops_tagging test on s390x
issue #1258: s390x test failure due to unsupported stack realignment
issue #1259: Enabling s390x on CI

Multi-threading support

The LLVM backend has supported multi-threading during compilation from LLVM IR to object files since 2014. While the frontend is not parallelized, this can still give a non-trivial perf boost. Cg_clif until recently didn’t support this, causing it to take longer to compile especially on machines with many cores. After doing significant refactorings all over cg_clif for about two weeks I was able to implement multi-threading support in cg_clif too. It was a lot of effort, but it was well worth it. There are almost no cases where cg_llvm is faster than cg_clif now.

The perf results (warning: long image)

Progress report on rustc_codegen_cranelift (June 2022)

2022-06-13T00:00:00+00:00

It’s been quite a while since the last progress report. There have been 393 commits since the last progress report.

Achievements in the past ten months

Migrating away from rust-ar

Since the start archive file reading and writing has been done by the rust-ar crate. While is has been very useful, there are a couple of limitations that necessitate moving away from it. First off it doesn’t support writing symbol tables. While I managed to implement support for it with the Gnu and BSD variants of the archive format, it doesn’t work with macOS, thus requiring usage of ranlib on macOS, which is slower than writing the symbol table while creating the archive file. Second my changes to support symbol table writing haven’t been merged into rust-ar, which means that cg_clif has to depend on my own fork. This means that if I accidentally delete my fork, cg_clif would be broken. In addition it doesn’t play nice with vendoring as necessary for building rust offline. And finally rust-ar is not actively maintained.

To migrate away from I first switched archive file reading from rust-ar to the newly introduced archive file support in the object crate. I’m now working on integrating a port of LLVM’s archive writer to rust with rustc so all backends can share the same code.

#1155: Remove the ar git dependency
1da5054: Use the object crate for archive reading during archive building
rust-lang/rust#97485: Rewrite LLVM’s archive writer in Rust

Multi-threading support

Currently cg_clif does everything on a single thread, unlike cg_llvm which does optimizations and emitting object files in parallel. This means that depending on how many codegen units can be compiled in parallel cg_llvm can finish in less time than cg_clif. I have been slowly working on refactorings that will allow Cranelift to compile codegen units on background threads. These refactorings are necessary as currently a function is immediately compiled after it has been translated to cranelift ir.

9089c30: Remove TyCtxt dependency from UnwindContext
5f6c59e: Pass only the Function to write_clif_file
78b6571: Split compile_fn out of codegen_fn

SIMD

There have been a lot of fixes for portable-simd (the unstable core::simd module). Part of these also benefit stdarch (the core::arch module).

a8be7ea: Implement new simd_shuffle signature
d288c69: Implement simd_reduce_{min,max} for floats
dd288d2: Fix vector types containing an array field with mir opts enabled
037aafb: Fix simd type validation
f3d97cc: Fix saturating float casts test
3c030e2: Fix NaN handling of simd float min and max operations
11007c0: Use fma(f) libm function for simd_fma intrinsic

Inline assembly

@nbdd0121 implemented support for register classes in PR #1206. Previously only fixed register constraints were supported.

I also fixed a couple of bugs in an attempt to compile Philipp Oppermann’s blog os. There are still many things missing for that to work though.

#1206: Improve inline asm support
1222192: Use cgu name instead of function name as base for inline asm wrapper name
efdbd88: Ensure inline asm wrapper name never starts with a digit
#1204: Full asm!() support
#1208: Support compiling blog os

Misc bug fixes

f74cf39: Fix crash when struct argument size is not a multiple of the pointer size
97e5045: Fix taking address of truly unsized type field of unsized adt
f3fc94f: Fix #[track_caller] with MIR inlining
f52162f: Fix #[track_caller] location for function chains
74b9232: Fix assert_assignable for array types
7a10059: Fix symbol tables in case of multiple object files with the same name

Usage changes

There have two big changes to the way cg_clif is used. First of the cargo wrapper executable has been renamed to cargo-clif. This is necessary on windows as otherwise the cargo wrapper would invoke itself when running cargo due to windows putting the current working directory in the search path for executables. It also allows invoking the wrapper as cargo clif in case you add the cg_clif build directory to your $PATH. The second change is that cg_clif is now always run using the -Zcodegen-backend rustc argument. This matches what happens when building cg_clif as part of rustc. Previously a wrapper cg_clif executable was used which uses rustc_driver to run rustc with cg_clif as backend. This change is only visible when you are directly using cg_clif/rustc without the cargo-clif wrapper. Usage of cargo-clif is advised.

0dd3d28: Rename cargo executable to cargo-clif
#1225: Use -Zcodegen-backend instead of a custom rustc driver

Perf optimizations

Both build time and runtime performance should be improved by several percent due to a couple of optimizations. A small improvement is the new support of Cranelift for cold blocks. These are placed at the end of the function to enable more efficient usage of the instruction cache and to reduce branch mispredictions, which slightly improves runtime performance. A much bigger improvement is the replacement of a lot of print+trap combinations with just a trap. While the prints have been very useful for debugging miscompilations, they also bloat compiled binaries a lot (up to ~30% improvement from removing them!). Given that miscompilations in cg_clif are quite rare nowadays, I removed most debug prints. The final improvement is caused by Cranelift switching to a new register allocator. This has improved build time by up to 7% and should also have improved runtime performance a bit.

90f8aef: Mark cold blocks
#1220: Replace a lot of print+trap with plain trap
bytecodealliance/wasmtime#3989: Switch Cranelift over to regalloc2

Challenges

Windows support with the MSVC toolchain

Cranelift doesn’t yet support TLS for COFF/PE object files. This means that unlike MinGW which uses pthread keys for implementing TLS, it is not currently possible to compile for MSVC.

issue wasmtime#1885: [Cranelift] Add COFF TLS support
issue #997: Windows support

SIMD

Many vendor intrinsics remain unimplemented. The new portable SIMD project will however likely exclusively use so called “platform intrinsics” of which there are much fewer, compared to the LLVM intrinsics used to implement all vendor intrinsics in core::arch. In addition “platform intrinsics” are the common denominator between platforms supported by rustc, so they only have to be implemented once in cg_clif itself and in fact most have already been implemented. Cranelift does need a definition for each platform when native SIMD is used, but emulating “platform intrinsics” using scalar instructions is pretty easy.

issue #171: std::arch SIMD intrinsics

Cleanup during stack unwinding on panics

Cranelift currently doesn’t have support for cleanup during stack unwinding.

issue wasmtime#1677: Support cleanup during unwinding

Contributing

Progress report on rustc_codegen_cranelift (July 2021)

2021-08-05T00:00:00+00:00

Since the last progress report there have been 242 commits.

Achievements in the past four months

SIMD

Almost all integer tests and float tests of portable-simd (formerly stdsimd) now pass. A couple of operations are not yet implemented, but other than that it now works just fine.

In addition @shamatar implemented the llvm.x86.addcarry.64 and llvm.x86.subborrow.64 instrinsics as their first contribution. They are used by some of the core::arch SIMD intrinsics that the num-bigint crate uses.

#1189: Improve stdsimd support
#1178: Implement llvm.x86.addcarry.64 and llvm.x86.subborrow.64

AArch64 support on Linux

It is now possible to cross-compile to AArch64 Linux. Native compilation should work too, but isn’t tested. At the moment there does seem to be an ABI incompatibility around proc-macros though, so those don’t work when using native compilation.

#1183: AArch64 support on Linux

`-Ctarget-cpu` support

Thanks to @mominul it is now possible to use -Ctarget-cpu with cg_clif. The given value is passed directly to Cranelift, so not every target cpu supported by LLVM is allowed, but -Ctarget-cpu=native works fine as well as the list of target cpus supported by Cranelift.

#1163: Support -Ctarget-cpu

Rust build system

The most important parts of the build system have been rewritten from bash scripts to rust code. This allows it to run on systems that don’t have bash like Windows. It is still necessary for git to be available though.

#1180: Rewrite part of the build system in rust

Multithreading support for the JIT mode

@eggyal implemented multithreading support for the lazy-jit mode. When a function is called that still needs to be lazily compiled, this compilation happens on the main rustc thread. This blocks compilation of other functions, but doesn’t interrupt other threads if they don’t need any function to be compiled.

#1166: Multithreading support for lazy-jit
bytecodealliance/wasmtime#2786: Atomic hotswapping in JIT mode

Challenges

While there are several important things currently missing, I am confident that I will be able to implement the most important ones in 2021.

Windows support with the MSVC toolchain

Cranelift doesn’t yet support TLS for COFF/PE object files. This means that unlike MinGW which uses pthread keys for implementing TLS, it is not currently possible to compile for MSVC.

issue wasmtime#1885: [Cranelift] Add COFF TLS support
issue #997: Windows support

SIMD

issue #171: std::arch SIMD intrinsics

Cleanup during stack unwinding on panics

Cranelift currently doesn’t have support for cleanup during stack unwinding.

issue wasmtime#1677: Support cleanup during unwinding

Contributing

Thanks to @cfallin for giving feedback on this progress report.

Progress report on rustc_codegen_cranelift (April 2021)

2021-04-13T00:00:00+00:00

Since the last progress report there have been 135 commits.

Achievements in the past three months

Removed support for old style Cranelift backends

In the previous progress report I mentioned that I switched to using the new-style Cranelift backends by default. At the time I kept support for the old-style backends just in case I would find a critical bug. There haven’t been any issues with the new backend since, so support for old-style backends has been removed.

commit 92f765f: Remove support for x86 oldBE

Atomics

Atomic operations are now implemented using native atomic instructions instead of being emulated using a global lock. This is much more efficient and also works when pthreads is not available. As only new-style backends implement them, I couldn’t use them until support for the old-style backends was removed.

commit f2f5452: Use real atomic instructions instead of a global lock

Cross-compilation to Windows using MinGW

It is now possible to cross-compile to Windows using MinGW. This required implementing a couple of things, like using the right ABI for calling intrinsics defined in compiler_builtins and adding cross-compilation support to the build system of cg_clif.

#1145: Support cross-compiling to Windows using MinGW

Run the rustc test suite on CI

The rustc test suite is now run on CI by default to prevent regressions. A lot of tests are currently ignored, but most tests are either LLVM specific (eg asm tests) or require unimplemented features like panicking.

#1149: Run the rustc test suite on CI

Challenges

While there are several important things currently missing, I am confident that I will be able to implement the most important ones in 2021.

Windows support with the MSVC toolchain

Cranelift doesn’t yet support TLS for COFF/PE object files. This means that unlike MinGW which uses pthread keys for implementing TLS, it is not currently possible to compile for MSVC.

issue wasmtime#1885: [Cranelift] Add COFF TLS support
issue #997: Windows support

SIMD

Many vendor intrinsics remain unimplemented. The new portable SIMD project will however likely exclusively use so called “platform intrinsics” of which there are much fewer, compared to the LLVM intrinsics used to implement all vendor intrinsics in core::arch. In addition “platform intrinsics” are the common denominator between platforms supported by rustc, so they only have to be implemented once in cg_clif itself. Cranelift does need a definition for each platform when native SIMD is used, but emulating “platform intrinsics” using scalar instructions is pretty easy.

issue #171: std::arch SIMD intrinsics

Cleanup during stack unwinding on panics

Cranelift currently doesn’t have support for cleanup during stack unwinding.

issue wasmtime#1677: Support cleanup during unwinding

Contributing

Thanks to @bnjbvr for giving feedback on this progress report.

Progress report on rustc_codegen_cranelift (Jan 2021)

2021-02-01T00:00:00+00:00

Rustc_codegen_cranelift (cg_clif) is an alternative backend for rustc that I have been working on for the past two years. It uses the Cranelift code generator. Unlike LLVM which is optimized for output quality at the cost of compilation speed even when optimizations are disabled, Cranelift is optimized for compilation speed while producing executables that are almost as fast as LLVM with optimizations disabled. This has the potential to reduce the compilation times of rustc in debug mode.

Since the last progress report there have been 54 commits.

Achievements in the past months

:tada: ABI compatibility :tada:

The biggest achievement this time is ABI compatibility with cg_llvm and C. This fixed several crashes when linking against C code. This also makes it possible to mix and match crates compiled with cg_clif and compiled with cg_llvm. This may be useful for game development by compiling the game engine using cg_llvm with optimizations enabled for runtime performance and then compiling the game logic using cg_clif for incremental compilation time.

There is currently no easy way to mix codegen backends for different crates, but I do have a cargo PR open that would allow it. I do not expect it to land as is, but I hope something like it will be merged.

rust#80594: Various ABI refactorings
issue #10: C abi compatability
#1131: Full abi compatibilty
cargo#9118: Add a profile option to select the codegen backend

Switch to the new backend framework of Cranelift

Cranelift is currently switching to a new backend framework. This framework produces faster code and has support for AArch64. Since the last progress report @cfallin has landed all features and bug fixes necessary to compile using the x64 backend based on the new framework. This allowed me to switch to it by default. So far no new problems have surfaced, but I plan to retain compatibility with the old backend for a little bit longer just in case.

https://cfallin.org/blog/2020/09/18/cranelift-isel-1/
https://cfallin.org/blog/2021/01/22/cranelift-isel-2/
wasmtime#2538: Multi-register value support: framework for Values wider than machine registers.
wasmtime#2539: Support for I128 operations in x64 backend.
wasmtime#2540: Add ELF TLS support in new x64 backend.
wasmtime#2541: x64 and aarch64: allow StructArgument and StructReturn args.
wasmtime#2558: x64: support PC-rel symbol references using the GOT when in PIC mode.
wasmtime#2595: Implement Mach-O TLS access for x64 newBE

Challenges

While there are several important things currently missing, I am confident that I will be able to implement the most important things in 2021.

Atomics

Atomic instructions are currently emulated using a global lock. This is very inefficient and only works when pthreads is available. The new style backends for Cranelift have native support for atomic instructions. I will switch to them once I drop support for the old style x86 backend.

wasmtime#2077: Implement Wasm Atomics for Cranelift/newBE/aarch64.
wasmtime#2149: This patch fills in the missing pieces needed to support wasm atomics…

Windows support

Various issues. See issue #997 for more information.

issue wasmtime#1885: [Cranelift] Add COFF TLS support
issue #997: Windows support
branch wip_windows_support3

SIMD

Many vendor intrinsics remain unimplemented. The new portable SIMD project will however likely exclusively use platform intrinsics of which there are much fewer compared to the LLVM intrinsics used to implement all vendor intrinsics in core::arch. In addition platform intrinsics are architecture independent, so they only have to be implemented once.

issue #171: std::arch SIMD intrinsics

Cleanup during stack unwinding on panics

Cranelift currently doesn’t have support for cleanup during stack unwinding.

issue wasmtime#1677: Support cleanup during unwinding

Maintenance

While there have been several PR’s by other people, I am the only person who has contributed more than a few changes to cg_clif.

https://github.com/bjorn3/rustc_codegen_cranelift/pulls?q=is%3Apr+is%3Aclosed+-author%3Aapp%2Fdependabot-preview

bjorn3

Progress report on rustc_codegen_cranelift (June 2025)

Achievements in the past 7 months

Unwinding

ARM

f16/f128 support

Sharing code between codegen backends

SIMD

ABI

Challenges

SIMD

ABI

Contributing

Progress report on rustc_codegen_cranelift (November 2024)

Achievements in the past eight months

ABI

Windows

macOS

Performance

Progress report on rustc_codegen_cranelift (April 2024)

Achievements in the past five months

SIMD

Debuginfo

s390x support

Challenges

SIMD

Cleanup during stack unwinding on panics

Contributing

Progress report on rustc_codegen_cranelift (Oct 2023)

Achievements in the past three months

Distributing as rustup component

Moved to the rust-lang org

Risc-V support

SIMD

Inline assembly

Challenges

SIMD

Cleanup during stack unwinding on panics

Contributing

Progress report on rustc_codegen_cranelift (July 2023)

Achievements in the past nine months

Perf improvements

SIMD

Build system rework

Inline assembly

s390x support tested in CI

Archive writer

Benchmark improvements

Challenges

SIMD

Cleanup during stack unwinding on panics

Distributing as rustup component

Contributing

Progress report on rustc_codegen_cranelift (Oct 2022)

Achievements in the past four months

Windows support with the MSVC toolchain

Abi fixes

AArch64 support

Basic s390x support

Multi-threading support

Progress report on rustc_codegen_cranelift (June 2022)

Achievements in the past ten months

Migrating away from rust-ar

Multi-threading support

SIMD

Inline assembly

Misc bug fixes

Usage changes

Perf optimizations

Challenges

Windows support with the MSVC toolchain

SIMD

Cleanup during stack unwinding on panics

Contributing

Progress report on rustc_codegen_cranelift (July 2021)

Achievements in the past four months

SIMD

AArch64 support on Linux

-Ctarget-cpu support

Rust build system

`-Ctarget-cpu` support