Add command to compare the binary size of two arbitrary binaries

Author: Kobzol

collector/README.md

@@ -516,23 +516,28 @@ Codegen diff is currently only implemented for runtime benchmarks.
 
 ## Binary size statistics
 You can use the `binary_stats` command to display size statistics (section and symbol sizes) of
-binary artifacts (executables, libraries) of selected compile benchmarks.
-
-```bash
-./target/release/collector binary_stats compile `<rustc>` --include <benchmark name> \
-    [--profile <Debug|Opt>] \
-    [--backend <Llvm|Cranelift>]
-```
-
-You can also compare (diff) the size statistics between two compilers:
-```bash
-./target/release/collector binary_stats compile `<rustc>` --include <benchmark name> --rustc2 <rustc2>
-```
-or between two codegen backends:
-```bash
-./target/release/collector binary_stats compile `<rustc>` --include <benchmark name> --rustc2 <rustc>
-    --backend <Llvm|Cranelift> --backend2 <Llvm|Cranelift>
-```
+binary artifacts (executables, libraries). You can compare the binary statistics of:
+
+- Selected compile benchmarks:
+  ```bash
+  ./target/release/collector binary_stats compile `<rustc>` --include <benchmark name> \
+      [--profile <Debug|Opt>] \
+      [--backend <Llvm|Cranelift>]
+  ```
+  
+  You can also compare (diff) the size statistics between two compilers:
+  ```bash
+  ./target/release/collector binary_stats compile `<rustc>` --include <benchmark name> --rustc2 <rustc2>
+  ```
+  or between two codegen backends:
+  ```bash
+  ./target/release/collector binary_stats compile `<rustc>` --include <benchmark name> --rustc2 <rustc>
+      --backend <Llvm|Cranelift> --backend2 <Llvm|Cranelift>
+  ```
+- Arbitrary binary artifacts on disk:
+  ```bash
+  ./target/release/collector binary_stats local `<artifact-path>` [<artifact-to-compare-to>]
+  ```
 
 ## How `rustc` wrapping works
 When a crate is benchmarked or profiled, the real `rustc` is replaced with the `rustc-fake` binary,

collector/src/artifact_stats.rs

@@ -2,6 +2,7 @@
 //! names and sizes.
 
 use std::collections::{HashMap, VecDeque};
+use std::ffi::OsStr;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::sync::OnceLock;
@@ -23,6 +24,17 @@ pub struct ArtifactStats {
 }
 
 impl ArtifactStats {
+    /// Try to auto-detect the artifact type from the given path.
+    /// If auto-detection fails, tries to load the artifact as a dynamic object.
+    pub fn from_path(path: &Path) -> anyhow::Result<Self> {
+        if path.extension() == Some(OsStr::new("a")) || path.extension() == Some(OsStr::new("rlib"))
+        {
+            Self::from_rlib(path)
+        } else {
+            Self::from_dynamic_object(path)
+        }
+    }
+
     /// Loads size statistics from an ELF file (either an executable or a shared library).
     pub fn from_dynamic_object(path: &Path) -> anyhow::Result<Self> {
         let data = std::fs::read(path)

collector/src/bin/collector.rs

@@ -26,7 +26,9 @@ use tabled::settings::{Alignment, Border, Color, Modify};
 use tokio::runtime::Runtime;
 
 use collector::api::next_artifact::NextArtifact;
-use collector::artifact_stats::{compile_and_get_stats, ArtifactWithStats, CargoProfile};
+use collector::artifact_stats::{
+    compile_and_get_stats, ArtifactStats, ArtifactWithStats, CargoProfile,
+};
 use collector::codegen::{codegen_diff, CodegenType};
 use collector::compile::benchmark::category::Category;
 use collector::compile::benchmark::codegen_backend::CodegenBackend;
@@ -431,12 +433,25 @@ struct BinaryStatsCompile {
     codegen_backend2: Option<CodegenBackend>,
 }
 
+#[derive(Debug, clap::Args)]
+#[command(rename_all = "snake_case")]
+struct BinaryStatsLocal {
+    /// Binary artifact to examine.
+    artifact: PathBuf,
+
+    /// Optional second artifact to compare with the first one.
+    artifact2: Option<PathBuf>,
+}
+
 #[derive(Debug, clap::Subcommand)]
 #[command(rename_all = "snake_case")]
 enum BinaryStatsMode {
     /// Show size statistics for the selected compile benchmark(s).
     /// Optionally compares sizes between two compiler toolchains, if `--rustc2` is provided.
     Compile(BinaryStatsCompile),
+    /// Show size statistics for the selected binary artifact on disk.
+    /// Optionally compares sizes with a second provided artifact, if `--artifact2` is provided.
+    Local(BinaryStatsLocal),
 }
 
 // For each subcommand we list the mandatory arguments in the required
@@ -667,6 +682,9 @@ fn main_result() -> anyhow::Result<i32> {
                 BinaryStatsMode::Compile(args) => {
                     binary_stats_compile(args, symbols, &target_triple)?;
                 }
+                BinaryStatsMode::Local(args) => {
+                    binary_stats_local(args, symbols)?;
+                }
             }
 
             Ok(0)
@@ -1168,6 +1186,29 @@ Make sure to modify `{dir}/perf-config.json` if the category/artifact don't matc
     }
 }
 
+fn binary_stats_local(args: BinaryStatsLocal, symbols: bool) -> anyhow::Result<()> {
+    let stats = ArtifactStats::from_path(&args.artifact)
+        .with_context(|| format!("Cannot load artifact from {}", args.artifact.display()))?;
+    let stats2 = args
+        .artifact2
+        .as_ref()
+        .map(|path| {
+            ArtifactStats::from_path(&path)
+                .with_context(|| format!("Cannot load artifact from {}", path.display()))
+        })
+        .transpose()?;
+    print_binary_stats(
+        "Sections",
+        stats.sections,
+        stats2.as_ref().map(|s| s.sections.clone()),
+    );
+    if symbols {
+        print_binary_stats("Symbols", stats.symbols, stats2.map(|s| s.symbols));
+    }
+
+    Ok(())
+}
+
 fn binary_stats_compile(
     args: BinaryStatsCompile,
     symbols: bool,