fix(avr): archive framework objects with gcc-ar (fixes #304)

avr_linker::link() previously iterated the `archives` parameter and
passed each path as a raw positional argument to avr-gcc, regardless of
whether it was .a or .o. Callers (pipeline::sequential::run_sequential
_build_with_libs) pass raw .o files. As a result, framework Tone.cpp.o
was always linked into AVR binaries that never called tone(), pulling
in __vector_1 (90 B), __vector_3 (206 B) and noTone() (50 B) via
weak-symbol override of __vector_default - inflating attiny85 Blink by
342 bytes (+10.1%) vs the equivalent PlatformIO build.

Fix: partition the `archives` parameter into actual .a files (pass
through) and raw .o files (archive into libframework.a using
avr-gcc-ar). gcc-ar writes the LTO bytecode plugin index, preserving
compatibility with the default -flto -fuse-linker-plugin profile from
avr.json. Plumb gcc_ar_path through AvrLinker::new() from the
toolchain's existing get_gcc_ar_path() - already used by pick_archiver
in the orchestrator.

Regression tests assert the partition helper splits a mixed .o/.a
input correctly. The end-to-end size check landed against FastLED is
intentionally deferred to FastLED's CI (re-enable --backend fbuild for
binary-size checks once this fix ships, verify attiny85_binary_size
stays under 9500).

Closes #304.

Author: zackees

crates/fbuild-build/src/avr/avr_linker.rs

@@ -15,6 +15,7 @@ use crate::linker::{LinkExtraArgs, Linker};
 pub struct AvrLinker {
     gcc_path: PathBuf,
     ar_path: PathBuf,
+    gcc_ar_path: PathBuf,
     objcopy_path: PathBuf,
     size_path: PathBuf,
     mcu: String,
@@ -30,6 +31,7 @@ impl AvrLinker {
     pub fn new(
         gcc_path: PathBuf,
         ar_path: PathBuf,
+        gcc_ar_path: PathBuf,
         objcopy_path: PathBuf,
         size_path: PathBuf,
         mcu: &str,
@@ -42,6 +44,7 @@ impl AvrLinker {
         Self {
             gcc_path,
             ar_path,
+            gcc_ar_path,
             objcopy_path,
             size_path,
             mcu: mcu.to_string(),
@@ -54,6 +57,24 @@ impl AvrLinker {
     }
 }
 
+/// Partition a mixed list of link inputs into (existing archives, raw objects).
+///
+/// Inputs ending in `.a` (case-sensitive — matches the toolchain convention) are
+/// real static archives and should be passed straight to the linker. Everything
+/// else (typically `.o` files coming from the framework compile step) is treated
+/// as a raw object that needs to be wrapped in an archive so the linker pulls in
+/// only members whose strong symbols are referenced.
+///
+/// Lives at module scope so unit tests can exercise the partition logic without
+/// invoking `avr-gcc-ar`.
+pub(crate) fn partition_link_inputs(inputs: &[PathBuf]) -> (Vec<PathBuf>, Vec<PathBuf>) {
+    let (existing_archives, raw_objects): (Vec<PathBuf>, Vec<PathBuf>) = inputs
+        .iter()
+        .cloned()
+        .partition(|p| p.extension().and_then(|e| e.to_str()) == Some("a"));
+    (existing_archives, raw_objects)
+}
+
 impl Linker for AvrLinker {
     fn archive(&self, objects: &[PathBuf], output: &Path) -> Result<()> {
         crate::linker::LinkerBase::archive(&self.ar_path, objects, output, "avr-ar")
@@ -90,9 +111,31 @@ impl Linker for AvrLinker {
             args.push(obj.to_string_lossy().to_string());
         }
 
-        // Core objects passed directly (not archived) for LTO compatibility
-        // Python fbuild does the same: archive breaks LTO symbol visibility
-        for archive in archives {
+        // Partition: actual .a archives are pass-through; raw .o files get
+        // archived into libframework.a so the linker only pulls in members
+        // whose strong symbols are referenced. Without this, unused-but-not-
+        // eliminable ISRs (e.g. Tone.cpp __vector_1/__vector_3 in the AVR
+        // framework) are dragged in via weak-symbol override of
+        // __vector_default, inflating the binary by ~10% on attiny85.
+        // See FastLED/fbuild#304.
+        //
+        // Use gcc-ar (not plain ar) so the LTO bytecode plugin index is
+        // written — preserves -fuse-linker-plugin compatibility, which the
+        // default avr.json profile enables via `-flto -fuse-linker-plugin`.
+        let (existing_archives, raw_objects) = partition_link_inputs(archives);
+
+        if !raw_objects.is_empty() {
+            let framework_archive = output_dir.join("libframework.a");
+            crate::linker::LinkerBase::archive(
+                &self.gcc_ar_path,
+                &raw_objects,
+                &framework_archive,
+                "avr-gcc-ar",
+            )?;
+            args.push(framework_archive.to_string_lossy().to_string());
+        }
+
+        for archive in existing_archives {
             args.push(archive.to_string_lossy().to_string());
         }
 
@@ -155,6 +198,7 @@ mod tests {
         let linker = AvrLinker::new(
             PathBuf::from("/bin/avr-gcc"),
             PathBuf::from("/bin/avr-ar"),
+            PathBuf::from("/bin/avr-gcc-ar"),
             PathBuf::from("/bin/avr-objcopy"),
             PathBuf::from("/bin/avr-size"),
             "atmega328p",
@@ -167,5 +211,65 @@ mod tests {
         assert_eq!(linker.mcu, "atmega328p");
         assert_eq!(linker.max_flash, Some(32256));
         assert_eq!(linker.max_ram, Some(2048));
+        assert_eq!(linker.gcc_ar_path, PathBuf::from("/bin/avr-gcc-ar"));
+    }
+
+    #[test]
+    fn link_partitions_archives_and_objects() {
+        // Regression test for FastLED/fbuild#304: link() must split mixed
+        // .a/.o inputs so .o files are archived (and thus subject to
+        // unreferenced-member elimination by the linker) while real .a
+        // files pass through unchanged.
+        let inputs = vec![
+            PathBuf::from("/tmp/Tone.cpp.o"),
+            PathBuf::from("/tmp/libfoo.a"),
+            PathBuf::from("/tmp/main.cpp.o"),
+        ];
+        let (archives, objects) = partition_link_inputs(&inputs);
+        assert_eq!(archives, vec![PathBuf::from("/tmp/libfoo.a")]);
+        assert_eq!(
+            objects,
+            vec![
+                PathBuf::from("/tmp/Tone.cpp.o"),
+                PathBuf::from("/tmp/main.cpp.o"),
+            ]
+        );
+    }
+
+    #[test]
+    fn partition_handles_all_archives() {
+        let inputs = vec![PathBuf::from("/tmp/a.a"), PathBuf::from("/tmp/b.a")];
+        let (archives, objects) = partition_link_inputs(&inputs);
+        assert_eq!(archives.len(), 2);
+        assert!(objects.is_empty());
+    }
+
+    #[test]
+    fn partition_handles_all_objects() {
+        let inputs = vec![PathBuf::from("/tmp/x.o"), PathBuf::from("/tmp/y.o")];
+        let (archives, objects) = partition_link_inputs(&inputs);
+        assert!(archives.is_empty());
+        assert_eq!(objects.len(), 2);
+    }
+
+    #[test]
+    fn partition_handles_empty() {
+        let (archives, objects) = partition_link_inputs(&[]);
+        assert!(archives.is_empty());
+        assert!(objects.is_empty());
+    }
+
+    #[test]
+    fn partition_treats_unknown_extensions_as_objects() {
+        // Defensive: anything that isn't .a (e.g. .lo, .obj, no extension)
+        // is treated as an object and archived. This is safer than letting
+        // an unknown extension fall through to a raw avr-gcc positional arg.
+        let inputs = vec![
+            PathBuf::from("/tmp/weird.lo"),
+            PathBuf::from("/tmp/no_ext"),
+        ];
+        let (archives, objects) = partition_link_inputs(&inputs);
+        assert!(archives.is_empty());
+        assert_eq!(objects.len(), 2);
     }
 }

crates/fbuild-build/src/avr/orchestrator.rs

@@ -237,10 +237,13 @@ impl BuildOrchestrator for AvrOrchestrator {
         .with_build_unflags(ctx.build_unflags.clone())
         .with_eh_frame_policy(eh_frame_policy);
 
-        // 7. Create linker
+        // 7. Create linker — pass gcc-ar so framework .o inputs can be
+        // archived into libframework.a with the LTO bytecode plugin index
+        // intact (preserves `-fuse-linker-plugin`). See FastLED/fbuild#304.
         let linker = AvrLinker::new(
             toolchain.get_gcc_path(),
             toolchain.get_ar_path(),
+            toolchain.get_gcc_ar_path(),
             toolchain.get_objcopy_path(),
             toolchain.get_size_path(),
             &ctx.board.mcu,