tree e27ae86da5d144cacfd2c95ad8576ac320183346
parent 04540f1549a6fea5227ac9538edb8b2643c4d719
author Jacob Garber <jgarber1@ualberta.ca> 1570064123 -0600
committer Stefan Reinauer <stefan.reinauer@coreboot.org> 1604355023 +0000

coreinfo: Add support for link time optimization

This introduces a Kconfig option for compiling coreinfo with LTO.
This option can be used independently of LTO in libpayload, though will
benefit most if that is enabled as well. If both are enabled, the
final size of coreinfo.elf is reduced from 95 KiB to 92 KiB.

Tested in QEMU and on Thinkpad T500.

Change-Id: I6feacdb911b52b946869bff369e03dcf72897c9f
Signed-off-by: Jacob Garber <jgarber1@ualberta.ca>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/38293
Reviewed-by: Michael Niewöhner <foss@mniewoehner.de>
Reviewed-by: Martin Roth <martinroth@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
