Rust.CodeCompared.To/Assembly

Everything println! does is visible here as the thing it is missing. The macro locks stdout, formats into a buffer, writes, and flushes on exit; it also appends the newline that the assembly version has to spell out as the byte 10. The four movs are the entire write, and the two after it are the only reason the process stops rather than running off the end of the section.

There is no way to "fall off the end" of an assembly program safely. Without that final exit syscall the processor keeps executing whatever bytes follow in the .text section and the process dies on an illegal instruction. Rust returning from main is a function return into runtime code that then calls exit for you.

Sixteen instructions, one division per digit, and a buffer sized by hand. println!("{}", value) is a macro that expands into a formatting machine doing exactly this, plus width and padding and locale-independent handling of every integer width and sign. Notice also that nothing here reports failure — a buffer too small would simply write past it.

Three named bindings became three registers, and the names are gone. Rust's let also does not allocate anything by itself — an optimized build of this program keeps all three in registers exactly like the assembly does. The difference is that Rust will tell you when you use a binding that no longer holds what you think; nothing here will.

A truncating as cast in Rust is usually free for the same reason: the bits were already there and the narrower type just stops looking at the rest. The direction that costs something is widening a signed value, where the sign bit has to be smeared across the new high bits — that is the movsx instruction, and it exists precisely because reading al into rax would otherwise leave the top 56 bits stale.

Using point after the call is a compile error in Rust and is physically impossible to detect here — rdi and rsi still hold 40 and 2 after consume returns, and nothing marks them as spent. That is the clearest statement of what ownership is: a rule the compiler enforces on the source and then discards. The binary is not protected by it; the binary never needed to be, because the program that could violate it was rejected.

A &mut i64 and a &i64 compile to the identical thing: one address in one register. The distinction between them, the lifetime attached to them, and the rule that only one &mut may exist at a time are all compile-time fictions with no representation in the instruction stream. Two &muts to the same address here would work exactly as badly as you would expect, and nothing would say so.

Rust makes you write & to take an address and * to follow one, and then quietly inserts most of the *s for you through auto-deref. Down here neither is implicit: a bare label is a number, brackets are a memory access, and forgetting the brackets gives you an address where you wanted a value with no type error to stop you.

This is the clearest demonstration that a Rust pointer is an address plus a type. The type is what supplies the 8. Change the array to [i32; 3] and the Rust line does not change at all while the assembly must become [rbx + 4] — the knowledge moved from the code into the type system, which is where Rust keeps it.

A plain + in a Rust debug build would panic here, and that panic is not free: it is a conditional jump on the carry flag plus a call into the panic machinery, emitted after every arithmetic operation. A release build removes the check and the program behaves exactly like this assembly. That is the one place where "zero-cost" is a choice made by a build flag rather than a property of the language.

checked_sub returning an Option is this carry flag, lifted into a value the type system can see and force you to handle. The flag itself is invisible, unnamed, and overwritten by the very next arithmetic instruction — which is why the jump has to come immediately after the sub and why interleaving an unrelated add between them silently breaks the test.

The condition is inverted, which is the single most common source of confusion when reading compiler output: source code says "if this is true, do the block", and the machine says "if this is false, skip the block". Note also that the two arms had to be arranged so control can rejoin — Rust's if is an expression with one value and one exit, and here you build that yourself out of a jump.

The range 0..5 is an iterator in Rust — a struct with a start and an end and a next method — and in a release build it compiles to precisely this: a counter, an increment, a compare, a jump. Nothing of the Iterator trait survives. The choice of rbx over rcx is the kind of thing the register allocator does for you thousands of times per program without mentioning it.

A function is a label plus an agreement. Nothing checks that double takes one argument, that it takes it in rdi, or that it returns anything at all — ret with garbage in rax assembles and links happily. Rust's signature is a machine-checked statement of an agreement that at this level is pure convention.

A parameter list is a promise about registers, and it is a promise nobody enforces. Calling combine having set only rdi is not an error — the function reads whatever rsi and rdx happened to contain. In Rust the same mistake cannot be spelled; the compiler will not emit a call whose arity is wrong.

Returning a &i64 to [rbp - 8] from this function would "work" almost every time, because mov rsp, rbp does not erase anything — it moves a number, and the bytes sit there until the next call overwrites them. That is the entire hazard Rust's lifetimes exist to prevent, and it is why the borrow checker has to be a compile-time analysis: at runtime there is nothing left to check.

This is why &[T] is called a fat pointer and why size_of::<&[i64]>() is 16 rather than 8. Passing the length alongside the address is the same discipline a C programmer follows by hand and forgets; Rust made the pair a single type so the two halves cannot drift apart.

Two instructions per index is the honest price of Rust's memory safety, and it is the one part of the story that is not literally zero. It is also the part the optimizer works hardest to remove: iterating with for value in slice rather than by index lets the compiler prove the bound once instead of testing it every time, which is why the idiomatic form is usually the faster one. The black_box above is the proof of how hard it works — without it, rustc const-evaluates the index, sees a guaranteed panic, and rejects the program under the deny-by-default unconditional_panic lint rather than emitting any check at all.

This is the niche optimization, and it is why size_of::<Option<&i64>>() is 8 — exactly the size of the reference it wraps. Because a &i64 is guaranteed never to be null, the null pattern is a spare value the layout can spend on None. Wrapping a pointer in Option costs nothing at all, which is the reason returning Option<&T> is idiomatic rather than a performance compromise.

The two rows print the same word and cost different amounts. Option<i64> is 16 bytes, not 9, because the payload must stay 8-byte aligned and the tag gets padded out to preserve that. This is the whole of what people mean by a niche: Option is free exactly when the wrapped type has an unused bit pattern to donate, and costs a word when it does not.

With three arms a compare chain is cheapest; with a dozen dense arms the compiler switches to a jump table — an array of addresses indexed by the discriminant, reached with one indirect jump instead of twelve compares. Either way, exhaustiveness is gone: the final jmp arm_blue is reached by anything that is not 0 or 1, including a 7 that should never have existed. Rust's guarantee that a match covers every variant is what makes that fallthrough safe to write.

There is no Filter, no Map, no intermediate collection, and no closure call — the three adapters became one test, one imul, and one add inside a single pass. This is the claim "zero-cost abstraction" makes, stated in the only terms that can settle it. The optimized build of the Rust column produces the same shape as the column beside it, which is why the idiomatic version is not the slow version.

Note that the two copies are not identical: the signed comparison uses jg and the unsigned one uses ja, because "greater" means different things for i64 and u8. A single shared implementation could not do that without being told the type at runtime, which is exactly the cost dyn Trait pays and generics do not. The trade is binary size — every instantiation is another copy on disk.

Field access is free — it is part of the addressing mode, not an extra instruction. What is not free is assuming you know the offsets: Rust reorders struct fields by default to minimize padding, so writing the 8 by hand against a plain struct is undefined behavior waiting to happen. Adding #[repr(C)] is the promise that the fields stay in declaration order, and it is what makes hand-written offsets like these legitimate.

Slicing a &str is this: the same address with a smaller length, and no copying. It is also why .len() on a Rust string is instant while strlen in C is a loop — the count was carried along rather than rediscovered. The one thing Rust adds on top is a check that the slice boundaries land on character boundaries, since a &str promises valid UTF-8 and these raw bytes promise nothing.

A Box is an address in a register plus a promise about who frees it. The promise is the part that does not survive to this level: nothing here will ever give the page back, and nothing would complain if the address were used after it had been. Rust's Drop is a call the compiler inserts at the exact point ownership ends — it is ordinary code, generated from a rule, and there is no garbage collector anywhere in this picture.

The message had to be a fixed string because formatting the length and the index into it would mean writing the number conversion again. That is the honest shape of the trade: a panic is expensive in binary size — every call site carries its message, its location, and its unwinding tables — which is exactly why embedded Rust reaches for panic = "abort" and #![no_std] to get back to something like this column.

Alignment is the clearest example of a rule that is real, load-bearing, and completely invisible in the source of every language above this one. Rust tracks the alignment of every type, pads every struct to satisfy it, and maintains the stack invariant on every call without ever mentioning it — and align_of is the only place the concept surfaces at all.

unsafe does not switch off a runtime guard, because at this level there was never a guard to switch off. It switches off the compiler's refusal to emit code it cannot prove correct, handing you the same latitude this column has always had. The keyword marks the places where the proof is yours to carry — which is why an unsafe block is a claim, not an escape.