maintenancerustc Deep Dive: Flags, Targets, and Advanced Compilation (The Controls Most Developers Don't Know Exist Unti

For most Rust developers, the compiler is Cargo. You type cargo build, things compile, and you move on with your life. The fact that Cargo is calling rustc with a dozen flags behind the scenes is an implementation detail you never think about—right up until you need to cross-compile for an ARM server, emit assembly to understand a performance bottleneck, or toggle features based on deployment environment. Then suddenly, knowing rustc's flags isn't academic trivia. It's the difference between solving your problem in five minutes and spending an afternoon on Stack Overflow.

Think of Cargo as the automatic transmission and rustc flags as the manual gearbox underneath. You don't need the manual gearbox for your daily commute. But when you're towing heavy cargo up a steep hill, or racing on a track, or navigating icy roads, having manual control over gear selection is exactly what you need.

At RantAI, where we cross-compile for ARM-based edge devices, analyze assembly output for performance-critical code paths, and use conditional compilation to toggle features between development and production environments, rustc flags are daily tools. This article, drawn from Chapter 7, Section 7.1 of our guide "The Rust Programming Language," covers the flags that matter for real-world development—not the obscure ones that only compiler developers care about, but the practical ones that every serious Rust developer should know.

Optimization Levels: Trading Compile Time for Performance#

poptimization: even smaller than 's'

# List all available targets
rustc --print target-list

# Compile for ARM64 Linux (e.g., AWS Graviton, Raspberry Pi 4)
rustc --target=aarch64-unknown-linux-gnu main.rs

# Compile for WebAssembly
rustc --target=wasm32-unknown-unknown main.rs

# Compile for Windows from a Linux machine
rustc --target=x86_64-pc-windows-msvc main.rs

The --target flag tells rustc to generate code for a platform different from the one you're developing on. This is cross-compilation: building on your macOS laptop for a Linux ARM server, or from any platform to WebAssembly for browser deployment. You'll need the target's standard library (rustup target add aarch64-unknown-linux-gnu) and possibly a cross-linker, but the compilation itself is straightforward.

At RantAI, we develop on macOS and Linux workstations and deploy to Linux x86_64 servers and ARM-based edge devices. Cross-compilation via --target means our CI pipeline builds for all targets from a single Linux build machine. No need to maintain separate build environments for each target platform.

Output Control: See What the Compiler Produces#

rustc --emit=llvm-ir main.rs     # LLVM Intermediate Representation — the optimizer's input
rustc --emit=asm main.rs         # Assembly code — what the CPU actually executes
rustc --emit=obj main.rs         # Object file — for manual linking
rustc --emit=mir main.rs         # Mid-level IR — Rust's internal representation post-analysis

These flags are invaluable for performance engineering. --emit=asm lets you verify that the compiler is generating the code you expect—that a function is being inlined, that a bounds check is being eliminated, that a SIMD instruction is being used. --emit=llvm-ir shows you the optimizer's input, which helps you understand why certain optimizations are or aren't happening.

The mir output is Rust-specific and shows the code after borrow checking and before LLVM optimization. It's useful for understanding how ownership and borrowing are compiled, and for diagnosing why certain code patterns lead to unexpected runtime behavior.

Conditional Compilation: Code That Adapts#

rustc --cfg feature="json_support" main.rs
rustc --cfg target_os="linux" main.rs

#[cfg(feature = "json_support")]
fn parse_json(input: &str) -> Result<Value, Error> {
    serde_json::from_str(input)
}

#[cfg(not(feature = "json_support"))]
fn parse_json(_input: &str) -> Result<Value, Error> {
    Err(Error::new("JSON support not enabled"))
}

#[cfg(target_os = "linux")]
fn get_memory_usage() -> usize {
    // Linux-specific /proc/self/statm reading
}

#[cfg(target_os = "macos")]
fn get_memory_usage() -> usize {
    // macOS-specific mach_task_info reading
}

Conditional compilation lets you include or exclude code based on compile-time flags. This is how Cargo features work under the hood—each feature in Cargo.toml becomes a --cfg flag passed to rustc. Platform-specific code, optional dependencies, and feature flags all use this mechanism.

The Complex Real-World Command#

When Cargo calls rustc for a real project, the command looks something like this:

rustc --crate-type=lib \
      --edition=2021 \
      --out-dir target/release/deps \
      --target x86_64-unknown-linux-gnu \
      --opt-level=3 \
      -C lto=thin \
      -C codegen-units=1 \
      --cfg 'feature="full"' \
      --extern serde=/path/to/libserde.rlib \
      --extern tokio=/path/to/libtokio.rlib \
      src/lib.rs

Edition, crate type, output directory, target, optimization, link-time optimization, codegen units, features, external dependencies—all passed as flags. Cargo manages this complexity for you, but knowing it exists helps you understand Cargo.toml settings like [profile.release] and why they affect compilation the way they do.

Broader Implications: Control When You Need It#

At RantAI, we use Cargo for 99% of builds. But the 1% where we need direct rustc control—cross-compilation scripts, assembly analysis for hot paths, conditional compilation for deployment environments—is where knowing these flags saves hours of confusion. The abstractions are great for daily work; the underlying controls are essential for specialized needs.

Practical Applications & Strategic Takeaways#

For newcomers: You'll interact with these flags through Cargo.toml's [profile] sections, not directly. But understanding that opt-level, lto, and codegen-units are rustc flags helps you configure your build profiles intelligently.

For embedded developers: --target + --opt-level=s + --emit=asm is your core toolkit: cross-compile for your target, optimize for size, and verify the generated assembly meets your constraints.

For performance engineers: --emit=asm and --emit=llvm-ir are how you verify compiler behavior. When you suspect the compiler isn't optimizing a hot path, look at the assembly. The answer is always there.

Our Commitment to Open Knowledge#

RantAI is committed to open education. Advanced rustc flags are covered in Chapter 7, Section 7.1 of our guide, "The Rust Programming Language," freely available online.

Explore these concepts further: https://trpl.rantai.dev

Support Our Mission & Get Your Handbook#

• Get the Handbook on Amazon KDP: https://www.amazon.com/dp/B0DHCMD3F2

• Get the Handbook on Google Play Books: https://play.google.com/store/books/details?id=INwfEQAAQBAJ

What's the most useful rustc flag you've discovered? Or the most surprising thing you found in --emit=asm output? Share your compilation tricks below!

#RustLang #Rustc #CrossCompilation #LLVM #RantAI #LearnRust #Optimization #Assembly #CompilerFlags #SystemsProgramming