Multifile IPO obtains potential optimization information from individual program modules of a multifile program. Using the information, the compiler performs optimizations across modules.
Building a program is divided into two phases: compilation and linkage. Multifile IPO performs different work depending on whether the compilation, linkage or both are performed.
Compilation Phase--As each source file is compiled, multifile IPO stores an intermediate representation (IR) of the source code in the object file, which includes summary information used for optimization.
By default, the compiler produces "mock" object files during the compilation phase of multifile IPO. Generating mock files instead of real object files reduces the time spent in the multifile IPO compilation phase. Each mock object file contains the IR for its corresponding source file, but no real code or data. These mock objects must be linked using the -ipo option and ifc, or using the xild tool. (See Creating a Multifile IPO Executable Using a Project Makefile. )
Note
Failure to link "mock" objects with ifc
-ipo or xild will result
in linkage errors. There are situations where mock object files cannot
be used. See Compilation with Real Object Files
for more information.
Linkage Phase--When you specify -ipo, the compiler is invoked a final time before the linker. The compiler performs multifile IPO across all object files that have an IR.
Note
The compiler does not support multifile IPO for static libraries (.a files). See Compilation with Real Object Files for
more information.
-ipo enables the driver and compiler to attempt detecting a whole program automatically. If a whole program is detected, the interprocedural constant propagation, stack frame alignment, data layout and padding of common blocks perform more efficiently, while more dead functions get deleted. This option is safe.
-wp_ipo is a whole program assertion flag that tells the compiler the whole program is present. It enables multi-file optimization with the whole program assumption that all user variables and user functions seen in the compiled sources are referenced only within those sources. This is an unsafe option. The user must guarantee that this assumption is safe.