Rust 1.97.1: Critical Miscompilation Fix, Upgrade Now?

TL;DR: Upgrade Immediately

Rust 1.97.1 addresses a critical miscompilation bug present in 1.97.0. This codegen-llvm defect affects specific async/await patterns and complex generic monomorphization. It can manifest as incorrect calculations, unexpected control flow, or memory corruption at runtime. The compiler will not report an error for these cases, making the bug difficult to diagnose and potentially leading to silent data issues in production. All users on 1.97.0 are affected, especially those with significant async codebases or intricate generic designs that push the compiler’s optimization passes.

The release also fixes a regression in cargo build that caused hangs or obscure errors in workspaces with certain dependency cycles. This affected developers managing large multi-crate projects, where cargo could enter an infinite loop or report spurious dependency resolution failures. The fix restores expected cargo behavior for complex workspace setups, improving build reliability.

A performance regression in std::collections::HashMap is also resolved. In 1.97.0, HashMap operations (insertions, lookups) could be significantly slower – up to 2-3x – for specific key types due to an inefficient default hasher seed generation. Applications relying on HashMap performance, particularly with custom Hash implementations or high-throughput scenarios, will see restored performance comparable to 1.96.0.

Given the severity of the miscompilation bug, an immediate upgrade to Rust 1.97.1 is required. This ensures your binaries behave as expected and prevents hard-to-debug runtime issues.

To upgrade, run:

rustup update stable

If you are currently on Rust 1.97.0, ensure all production and development environments are updated. This is a maintenance release focused on stability and correctness.

Rustc: LLVM Miscompilation Fixed

Rust 1.97.1 addresses a critical miscompilation bug originating in LLVM’s instcombine pass. This bug could lead to incorrect program behavior when specific integer comparisons and bitwise operations were optimized. The issue affected code paths where LLVM generated select instructions from conditional logic.

The miscompilation occurred within LLVM’s instcombine pass, a crucial optimization stage that simplifies sequences of instructions into more efficient forms. Specifically, when rustc translated certain conditional logic involving integer comparisons (icmp) and bitwise and operations into LLVM’s select instruction, instcombine could incorrectly simplify the resulting instruction DAG. This led to an output value that diverged from the source code’s intended computation.

This could manifest in code patterns where a conditional branch modifies a value based on a bitmask. For example:

fn process_data(input: u32, flag_mask: u32) -> u32 {
    let mut output = input;
    if (input & flag_mask) != 0 {
        output = input ^ flag_mask; // Conditional bitwise operation
    }
    output
}

If input was 0b1010 and flag_mask was 0b0010, the condition (input & flag_mask) != 0 would be true. The output should become 0b1000. The bug could cause output to incorrectly retain 0b1010 or become another unexpected value after optimization.

The bug primarily affected targets where LLVM’s instcombine pass aggressively optimized such patterns, including x86-64 and ARM. Its intermittent nature and dependence on specific input data made diagnosis challenging, often leading developers to suspect application logic errors rather than a compiler fault.

Rust 1.97.1 integrates an updated LLVM backend that includes a targeted patch for this instcombine issue. This patch specifically corrects the logic for combining icmp and and operations within select instructions, ensuring the generated machine code correctly implements the source-level semantics. The fix is transparent; no user code modifications are needed.

This resolution eliminates a class of subtle, hard-to-trace data integrity issues. Any project dealing with critical numerical processing or bit manipulation should prioritize upgrading to 1.97.1 to mitigate potential runtime errors.

Who Is Affected by This Bug?

Rust 1.97.0 contains an LLVM miscompilation that can generate incorrect machine code under specific optimization levels. This bug primarily affects release builds, specifically those compiled with -C opt-level=2 or -C opt-level=3. Debug builds (-C opt-level=0) are not impacted.

The miscompilation occurs when LLVM incorrectly reorders or optimizes memory accesses. It can lead to a program reading a stale or incorrect value from memory, even after a more recent write to the same location. This is often triggered when LLVM’s alias analysis makes an incorrect assumption about pointer non-aliasing.

Any Rust project compiled with optimization levels 2 or 3 is potentially affected. This includes the majority of applications built for production deployment. Code that performs multiple writes and reads to the same memory location, especially within performance-critical loops or concurrent contexts, is particularly vulnerable. For example, a sequence of operations like assigning to *ptr twice might be optimized such that a subsequent read of *ptr retrieves the first assigned value instead of the second.

The consequences range from subtle data corruption and incorrect program logic to non-deterministic crashes. These issues are challenging to debug because the source Rust code appears correct, and the bug only manifests in the optimized machine code.

Projects that rely on precise memory ordering for correctness are at higher risk. This includes applications implementing custom synchronization primitives, memory allocators, or interacting directly with hardware registers. Developers working with FFI or low-level system interfaces, where specific memory semantics are expected, should be particularly vigilant. While not strictly limited to unsafe code, diagnosing issues from such miscompilations can be significantly harder within unsafe blocks due to fewer compiler guarantees.

No Breaking Changes or Migration Steps

Rust 1.97.1 introduces no breaking changes to the language, standard library, or core tooling. This release adheres to Rust’s commitment to stability, particularly for patch versions which focus on critical fixes rather than introducing new features or altering existing APIs. Existing Rust 1.x codebases will compile and execute as before, maintaining full forward compatibility.

You will not encounter new compiler warnings, altered type inference rules, or changes in how existing standard library functions behave. The stability guarantees of Rust ensure that upgrades within a major version, especially patch releases, are designed to be non-disruptive. This means no manual code modifications or complex migration scripts are necessary for your projects.

The upgrade process is straightforward. If you manage your Rust toolchains with rustup, simply execute the update command:

rustup update stable

This command will fetch and install the latest stable version, replacing any older stable toolchain. After the update completes, you can verify your active Rust version:

rustc --version

The output should confirm the successful installation of the new version:

rustc 1.97.1 (abcdef123 2024-03-15)
binary: rustc
commit-hash: abcdef123
commit-date: 2024-03-15
host: x86_64-unknown-linux-gnu
release: 1.97.1
LLVM version: 18.0.0

While the core language and library APIs remain stable, the primary change in 1.97.1 is a critical miscompilation fix. For programs previously affected by this bug, the upgrade will correct incorrect runtime behavior to produce the expected, accurate results. This correction of behavior is not a breaking change in the sense of API modification or requiring code rewrite; instead, it ensures the compiler generates correct machine code. Projects unaffected by the specific miscompilation issue will experience a transparent upgrade.

Action: Upgrade Now

Rust 1.97.1 addresses a critical miscompilation bug present in 1.97.0. This bug can lead to undefined behavior, crashes, or silent data corruption in release builds. The issue specifically affects certain optimization passes within the compiler, causing incorrect code generation under specific circumstances.

The miscompilation is not hypothetical; it has been observed in projects compiling with a release profile, which is the default for production deployments. Affected users might experience intermittent failures that are difficult to debug, as the root cause lies in the compiler’s output rather than the source code logic. There is no known workaround for the bug in 1.97.0 other than using a different compiler version.

All users currently on Rust 1.97.0, or planning to upgrade to it, should instead upgrade directly to 1.97.1. This patch release contains no other breaking changes or new features; its sole purpose is to fix this critical defect. Deferring this upgrade risks deploying software with unpredictable runtime behavior.

To upgrade your toolchain, run the following command:

rustup update stable

This command will fetch and install Rust 1.97.1. After upgrading, it is prudent to re-run your project’s test suite, particularly integration and end-to-end tests that exercise release builds. This ensures your binaries are now correctly compiled and free from the miscompilation defect. Prioritize updating your CI/CD pipelines to use 1.97.1 immediately.