LTO default behavior in GCC 12 for shared libraries versus static libraries

Answer

According to the GCC 12 release notes and documentation, when the -fuse-linker-plugin option is present, link‑time optimization (LTO) is enabled by default for shared objects (.so files). This default does **not** extend to static archives (.a files); static libraries still require an explicit -flto (or -flto=thin) flag to participate in LTO.

Why the distinction exists

• The linker plugin extracts GCC’s internal GIMPLE representation (the LTO intermediate format) from object files that are actually linked into the output. For a shared object the linker sees all constituent object files as part of the same output, so the plugin can pull the GIMPLE from each and feed it to the LTO pass.
• A static archive is merely a collection of object files; the linker only extracts those members needed to satisfy undefined symbols. Without -flto the archive’s members are treated as ordinary object files, and the plugin does not attempt to scan the whole archive for GIMPLE because doing so would change link semantics (ordering, weak symbols, linker‑script expectations).
• Therefore GCC 12 conservatively retains the pre‑existing rule: static libraries need an explicit -flto flag to indicate that their object files were compiled with LTO‑compatible GIMPLE.

Impact if the default were changed to include static archives

• Build time: Enabling LTO for every .a would force the compiler to generate GIMPLE for all translation units and the linker to run a whole‑program LTO step, increasing both compile‑ and link‑time, especially for large third‑party static libraries.
• Binary size: With LTO you usually get smaller executables because dead‑code elimination and cross‑module inlining can remove unused functions. The size reduction would be similar to manually adding -flto, but the gain would only appear for libraries that actually benefit from whole‑program analysis.
• Compatibility: Many build systems rely on the deterministic ordering of .o files inside an archive or on linker scripts that expect regular object sections. Switching to LTO by default could break those assumptions, leading to missing‑section errors or changes in symbol resolution.

Circumstances that could cause link‑time failures if LTO were enabled by default for static archives

• Archives containing symbols with hidden or protected visibility that are only resolved via linker scripts; LTO may discard them as unused.
• Weak definitions that rely on the linker’s “first‑definition wins” rule; LTO’s whole‑program view can treat them differently, causing duplicate‑definition errors.
• Member objects compiled without -flto (or with -fno-lto-objects). If the linker plugin tried to pull GIMPLE from them, it would find none and emit warnings like "no GIMPLE found in member", which could become errors under -Werror.
• Use of --whole-archive or custom linker scripts that expect specific section names (.init, .fini) that LTO may rename or discard.

Recommendation

Keep the current behavior: add -flto (or -flto=thin) explicitly when you want static libraries to participate in LTO. Only consider changing the default if you can verify that all static dependencies are built with LTO‑compatible GIMPLE and that your linker scripts and build rules do not depend on ordinary object ordering.