Format README.md

Author: johnthagen

README.md

@@ -55,7 +55,7 @@ $ strip target/release/min-sized-rust
 
 [Cargo defaults its optimization level to `3` for release builds][cargo-profile],
 which optimizes the binary for **speed**. To instruct Cargo to optimize for minimal binary
-**size**, use the `z` optimization level in 
+**size**, use the `z` optimization level in
 [`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html):
 
 [cargo-profile]: https://doc.rust-lang.org/cargo/reference/profiles.html#default-profiles
@@ -70,15 +70,15 @@ the
 [`opt-level` documentation](https://doc.rust-lang.org/cargo/reference/profiles.html#opt-level):
 
 > It is recommended to experiment with different levels to find the right balance for your project.
-There may be surprising results, such as ... the `"s"` and `"z"` levels not being necessarily
-smaller. 
+> There may be surprising results, such as ... the `"s"` and `"z"` levels not being necessarily
+> smaller.
 
 # Enable Link Time Optimization (LTO)
 
 ![Minimum Rust: 1.0](https://img.shields.io/badge/Minimum%20Rust%20Version-1.0-brightgreen.svg)
 
-By default, 
-[Cargo instructs compilation units to be compiled and optimized in isolation][cargo-profile]. 
+By default,
+[Cargo instructs compilation units to be compiled and optimized in isolation][cargo-profile].
 [LTO](https://llvm.org/docs/LinkTimeOptimization.html) instructs the linker to optimize at the
 link stage. This can, for example, remove dead code and often times reduces binary size.
 
@@ -94,14 +94,14 @@ lto = true
 ![Minimum Rust: 1.28](https://img.shields.io/badge/Minimum%20Rust%20Version-1.28-brightgreen.svg)
 ![Maximum Rust: 1.31](https://img.shields.io/badge/Maximum%20Rust%20Version-1.31-brightgreen.svg)
 
-As of Rust 1.32, 
-[`jemalloc` is removed by default](https://blog.rust-lang.org/2019/01/17/Rust-1.32.0.html). 
-**If using Rust 1.32 or newer, no action is needed to reduce binary size regarding this 
+As of Rust 1.32,
+[`jemalloc` is removed by default](https://blog.rust-lang.org/2019/01/17/Rust-1.32.0.html).
+**If using Rust 1.32 or newer, no action is needed to reduce binary size regarding this
 feature**.
 
 **Prior to Rust 1.32**, to improve performance on some platforms Rust bundled
-[jemalloc](https://github.com/jemalloc/jemalloc), an allocator that often 
-outperforms the default system allocator. Bundling jemalloc added around 200KB 
+[jemalloc](https://github.com/jemalloc/jemalloc), an allocator that often
+outperforms the default system allocator. Bundling jemalloc added around 200KB
 to the resulting binary, however.
 
 To remove `jemalloc` on Rust 1.28 - Rust 1.31, add this code to the top of `main.rs`:
@@ -116,7 +116,7 @@ static A: System = System;
 # Reduce Parallel Code Generation Units to Increase Optimization
 
 [By default][cargo-profile], Cargo specifies 16 parallel codegen units for release builds.
-This improves compile times, but prevents some optimizations. 
+This improves compile times, but prevents some optimizations.
 
 Set this to `1` in `Cargo.toml` to allow for maximum size reduction optimizations:
 
@@ -130,12 +130,12 @@ codegen-units = 1
 ![Minimum Rust: 1.10](https://img.shields.io/badge/Minimum%20Rust%20Version-1.10-brightgreen.svg)
 
 > **Note**: Up to this point, the features discussed to reduce binary size did not have an
-impact on the behaviour of the program (only its execution speed). This feature does
-have an impact on behavior.
+> impact on the behaviour of the program (only its execution speed). This feature does
+> have an impact on behavior.
 
-[By default][cargo-profile], when Rust code encounters a situation when it must call `panic!()`, 
-it unwinds the stack and produces a helpful backtrace. The unwinding code, however, does require 
-extra binary size. `rustc` can be instructed to abort immediately rather than unwind, which 
+[By default][cargo-profile], when Rust code encounters a situation when it must call `panic!()`,
+it unwinds the stack and produces a helpful backtrace. The unwinding code, however, does require
+extra binary size. `rustc` can be instructed to abort immediately rather than unwind, which
 removes the need for this extra unwinding code.
 
 Enable this in `Cargo.toml`:
@@ -166,7 +166,7 @@ $ RUSTFLAGS="-Zlocation-detail=none" cargo +nightly build --release
 ![Minimum Rust: Nightly](https://img.shields.io/badge/Minimum%20Rust%20Version-nightly-orange.svg)
 
 > **Note**: See also [Xargo](https://github.com/japaric/xargo), the predecessor to `build-std`.
-  [Xargo is currently in maintenance status](https://github.com/japaric/xargo/issues/193).
+[Xargo is currently in maintenance status](https://github.com/japaric/xargo/issues/193).
 
 > Example project is located in the [`build_std`](build_std) folder.
 
@@ -179,10 +179,10 @@ aggressively optimize for size.
 
 1. The prebuilt `libstd` is optimized for speed, not size.
 
-2. It's not possible to remove portions of `libstd` that are not used in a particular application 
+2. It's not possible to remove portions of `libstd` that are not used in a particular application
    (e.g. LTO and panic behaviour).
 
-This is where [`build-std`](https://doc.rust-lang.org/cargo/reference/unstable.html#build-std) 
+This is where [`build-std`](https://doc.rust-lang.org/cargo/reference/unstable.html#build-std)
 comes in. The `build-std` feature is able to compile `libstd` with your application from the
 source. It does this with the `rust-src` component that `rustup` conveniently provides.
 
@@ -214,7 +214,7 @@ On macOS, the final stripped binary size is reduced to 51KB.
 ![Minimum Rust: Nightly](https://img.shields.io/badge/Minimum%20Rust%20Version-nightly-orange.svg)
 
 Even if `panic = "abort"` is specified in `Cargo.toml`, `rustc` will still include panic strings
-and formatting code in final binary by default. 
+and formatting code in final binary by default.
 [An unstable `panic_immediate_abort` feature](https://github.com/rust-lang/rust/pull/55011)
 has been merged into the `nightly` `rustc` compiler to address this.
 
@@ -235,29 +235,27 @@ On macOS, the final stripped binary size is reduced to 30KB.
 
 > Example project is located in the [`no_main`](no_main) folder.
 
-> This section was contributed in part by [@vi](https://github.com/vi)
- 
 Up until this point, we haven't restricted what utilities we used from `libstd`. In this section
 we will restrict our usage of `libstd` in order to reduce binary size further.
 
-If you want an executable smaller than 20 kilobytes, Rust's string formatting code, 
-[`core::fmt`](https://doc.rust-lang.org/core/fmt/index.html) must 
-be removed. `panic_immediate_abort` only removes some usages of this code. There is a lot of other 
+If you want an executable smaller than 20 kilobytes, Rust's string formatting code,
+[`core::fmt`](https://doc.rust-lang.org/core/fmt/index.html) must
+be removed. `panic_immediate_abort` only removes some usages of this code. There is a lot of other
 code that uses formatting in some cases. That includes Rust's "pre-main" code in `libstd`.
 
-By using a C entry point (by adding the `#![no_main]` attribute) , managing stdio manually, and 
-carefully analyzing which chunks of code you or your dependencies include, you can sometimes 
+By using a C entry point (by adding the `#![no_main]` attribute) , managing stdio manually, and
+carefully analyzing which chunks of code you or your dependencies include, you can sometimes
 make use of `libstd` while avoiding bloated `core::fmt`.
 
-Expect the code to be hacky and unportable, with more `unsafe{}`s than usual. It feels like 
+Expect the code to be hacky and unportable, with more `unsafe{}`s than usual. It feels like
 `no_std`, but with `libstd`.
 
-Start with an empty executable, ensure 
-[`xargo bloat --release --target=...`](https://github.com/RazrFalcon/cargo-bloat) contains no 
-`core::fmt` or something about padding. Add (uncomment) a little bit. See that `xargo bloat` now 
-reports drastically more. Review source code that you've just added. Probably some external crate or 
+Start with an empty executable, ensure
+[`xargo bloat --release --target=...`](https://github.com/RazrFalcon/cargo-bloat) contains no
+`core::fmt` or something about padding. Add (uncomment) a little bit. See that `xargo bloat` now
+reports drastically more. Review source code that you've just added. Probably some external crate or
 a new `libstd` function is used. Recurse into that with your review process
-(it requires `[replace]` Cargo dependencies and maybe digging in `libstd`), find out why it 
+(it requires `[replace]` Cargo dependencies and maybe digging in `libstd`), find out why it
 weighs more than it should. Choose alternative way or patch dependencies to avoid unnecessary
 features. Uncomment a bit more of your code, debug exploded size with `xargo bloat` and so on.
 
@@ -306,8 +304,8 @@ fn my_panic(_info: &core::panic::PanicInfo) -> ! {
 Up until this point, all size-reducing techniques were Rust-specific. This section describes
 a language-agnostic binary packing tool that is an option to reduce binary size further.
 
-[UPX](https://github.com/upx/upx) is a powerful tool for creating a self contained, compressed
-binary with no addition runtime requirements.  It claims to typically reduce binary size by 50-70%,
+[UPX](https://github.com/upx/upx) is a powerful tool for creating a self-contained, compressed
+binary with no addition runtime requirements. It claims to typically reduce binary size by 50-70%,
 but the actual result depends on your executable.
 
 ```bash
@@ -319,7 +317,7 @@ heuristic-based anti-virus software because malware often uses UPX.
 
 # Tools
 
-- [`cargo-bloat`](https://github.com/RazrFalcon/cargo-bloat) - Find out what takes most of the 
+- [`cargo-bloat`](https://github.com/RazrFalcon/cargo-bloat) - Find out what takes most of the
   space in your executable.
 - [`cargo-unused-features`](https://github.com/TimonPost/cargo-unused-features) - Find and prune
   enabled but potentially unused feature flags from your project.
@@ -329,8 +327,8 @@ heuristic-based anti-virus software because malware often uses UPX.
 
 # Containers
 
-Sometimes it's advantageous to deploy Rust into containers 
-(e.g. [Docker](https://www.docker.com/)). There are several great existing resources to help 
+Sometimes it's advantageous to deploy Rust into containers
+(e.g. [Docker](https://www.docker.com/)). There are several great existing resources to help
 create minimum sized container images that run Rust binaries.
 
 - [Official `rust:alpine` image](https://hub.docker.com/_/rust)
@@ -359,20 +357,35 @@ create minimum sized container images that run Rust binaries.
 - [Shrinking `.wasm` Code Size][shrinking-wasm-code-size]
 
 [151-byte-static-linux-binary]: https://mainisusuallyafunction.blogspot.com/2015/01/151-byte-static-linux-binary-in-rust.html
+
 [why-rust-binary-large]: https://lifthrasiir.github.io/rustlog/why-is-a-rust-executable-large.html
+
 [fmt-unreasonably-expensive]: https://jamesmunns.com/blog/fmt-unreasonably-expensive/
+
 [tiny-windows-exe]: https://www.codeslow.com/2019/12/tiny-windows-executable-in-rust.html
+
 [tiny-webassembly-graphics]: https://cliffle.com/blog/bare-metal-wasm/
+
 [gstreamer-plugin]: https://www.collabora.com/news-and-blog/blog/2020/04/28/reducing-size-rust-gstreamer-plugin/
+
 [optimizing-rust-binary-size]: https://arusahni.net/blog/2020/03/optimizing-rust-binary-size.html
+
 [minimizing-mender-rust]: https://mender.io/blog/building-mender-rust-in-yocto-and-minimizing-the-binary-size
+
 [optimize-with-cargo-and-semver]: https://oknozor.github.io/blog/optimize-rust-binary-size/
+
 [tighten-rusts-belt]: https://dl.acm.org/doi/abs/10.1145/3519941.3535075
+
 [avoiding-allocations-shrink-wasm]: https://nickb.dev/blog/avoiding-allocations-in-rust-to-shrink-wasm-modules/
+
 [a-very-small-rust-binary]: https://darkcoding.net/software/a-very-small-rust-binary-indeed/
+
 [dark-side-of-inlining]: https://nickb.dev/blog/the-dark-side-of-inlining-and-monomorphization/
+
 [making-rust-binaries-smaller-by-default]: https://kobzol.github.io/rust/cargo/2024/01/23/making-rust-binaries-smaller-by-default.html
+
 [min-sized-rust-windows]: https://github.com/mcountryman/min-sized-rust-windows
+
 [shrinking-wasm-code-size]: https://rustwasm.github.io/docs/book/reference/code-size.html
 
 # Organizations