gcc LTO优化范围限制：大共享库LTO构建提速方案问询

Absolutely! GCC’s LTO has exactly the tools you need to trim down the analysis scope and cut those 10+ minute build times—especially useful for your template-heavy shared library where you don’t want to split the final binary. Let’s break down the approaches you’re asking about, plus some extra tips tailored to your scenario:

If you know certain object files have zero cross-file optimization opportunities (no calls that need inlining between them and other parts of the library), you can exclude them from LTO entirely:

• Per-file compilation flags: Compile these files with -fno-lto instead of -flto. This skips generating LTO bitcode for them, so they won’t be part of the global interprocedural analysis. This is perfect for standalone utility files or code paths that are completely independent of the rest of the library.
• Linker-level exclusion for static libs: If your project uses nested static libraries within the final shared library, use the linker flag --exclude-libs=libfoo.a (replace libfoo.a with your target) to exclude all object files in that static lib from LTO. Use --exclude-libs=ALL to exclude all static libraries, but be careful—only do this if none of their code benefits from cross-file optimizations.

Instead of blacklisting, you can group related files into partitions that GCC analyzes independently, reducing the overall computational load:

• Partitioned LTO (PLTO): This lets you split your code into smaller groups (partitions) that are processed separately, rather than doing one massive global analysis. To use it:
  1. Compile all files with -flto=partitioned
  2. Control partition grouping via linker flags or scripts. For example, --lto-partition=4 splits code into 4 equal partitions, or you can write a linker script to explicitly group closely related template instantiations together (e.g., all container template files in one partition, all math utility templates in another).
• Thin LTO (TLTO): While not explicit grouping, Thin LTO is optimized for speed by running most analysis in parallel per-object-file, with only minimal global coordination. Compile with -flto=thin instead of the default full LTO—it’s often 2-5x faster for large codebases, while still capturing most critical optimizations. This is a great first step if you don’t want to manually curate blacklists or partitions.

Your library’s large number of template instantiations is likely a big contributor to LTO slowdowns—here’s how to mitigate that:

• Explicit template instantiation: Move template instantiations into dedicated translation units (e.g., templates_instantiate.cpp) instead of letting them be implicitly instantiated across multiple files. This reduces redundant work during LTO, as GCC only has to process each instantiation once.
• Mark non-critical templates as noinline: Add __attribute__((noinline)) to template functions/methods that don’t benefit from cross-file inlining. This tells GCC to skip considering them for interprocedural inlining, narrowing the analysis scope.
• Combine with PGO: If you can run a profiling pass first, use -flto -fprofile-use to guide LTO to focus optimizations on hot code paths. This avoids wasting time analyzing cold, rarely executed template instantiations that don’t need LTO optimizations.

内容的提问来源于stack exchange，提问作者Martin Richtarsky