From 10cd187963fe345a9f7d3af7b284230ff6f7fd15 Mon Sep 17 00:00:00 2001 From: Stephen Crane Date: Wed, 27 Sep 2017 17:01:15 -0700 Subject: [PATCH] Propagate LTO type from binary/DSO to object files Propagation of LTO flags from a main binary or library to its static dependencies is necessary so that objects being linked with LTO are built as bitcode rather than native objects. This propagation was broken when thin LTO was added to the build system. This patch propagates the LTO mode (thin or full) down to object and archive dependencies. Test: Build libhwui with full and thin LTO and check that intermediate objects are LLVM bitcode. Change-Id: Ic57a80d75052d86940db076fbc0f5375a79c89a1 --- cc/lto.go | 101 +++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 78 insertions(+), 23 deletions(-) diff --git a/cc/lto.go b/cc/lto.go index fdb768836..b1e7cfa0f 100644 --- a/cc/lto.go +++ b/cc/lto.go @@ -40,10 +40,15 @@ type LTOProperties struct { // Lto must violate capitialization style for acronyms so that it can be // referred to in blueprint files as "lto" Lto struct { - Full *bool `android:"arch_variant"` - Thin *bool `android:"arch_variant"` + Never *bool `android:"arch_variant"` + Full *bool `android:"arch_variant"` + Thin *bool `android:"arch_variant"` } `android:"arch_variant"` - LTODep bool `blueprint:"mutated"` + + // Dep properties indicate that this module needs to be built with LTO + // since it is an object dependency of an LTO module. + FullDep bool `blueprint:"mutated"` + ThinDep bool `blueprint:"mutated"` } type lto struct { @@ -84,7 +89,7 @@ func (lto *lto) flags(ctx BaseModuleContext, flags Flags) Flags { // Can be called with a null receiver func (lto *lto) LTO() bool { - if lto == nil { + if lto == nil || lto.Disabled() { return false } @@ -93,41 +98,91 @@ func (lto *lto) LTO() bool { return full || thin } +// Is lto.never explicitly set to true? +func (lto *lto) Disabled() bool { + return lto.Properties.Lto.Never != nil && *lto.Properties.Lto.Never +} + // Propagate lto requirements down from binaries func ltoDepsMutator(mctx android.TopDownMutatorContext) { - if c, ok := mctx.Module().(*Module); ok && c.lto.LTO() { - full := Bool(c.lto.Properties.Lto.Full) - thin := Bool(c.lto.Properties.Lto.Thin) + if m, ok := mctx.Module().(*Module); ok && m.lto.LTO() { + full := Bool(m.lto.Properties.Lto.Full) + thin := Bool(m.lto.Properties.Lto.Thin) if full && thin { mctx.PropertyErrorf("LTO", "FullLTO and ThinLTO are mutually exclusive") } - mctx.VisitDepsDepthFirst(func(m android.Module) { - tag := mctx.OtherModuleDependencyTag(m) + mctx.WalkDeps(func(dep android.Module, parent android.Module) bool { + tag := mctx.OtherModuleDependencyTag(dep) switch tag { case staticDepTag, staticExportDepTag, lateStaticDepTag, wholeStaticDepTag, objDepTag, reuseObjTag: - if cc, ok := m.(*Module); ok && cc.lto != nil { - cc.lto.Properties.LTODep = true + if dep, ok := dep.(*Module); ok && dep.lto != nil && + !dep.lto.Disabled() { + if full && !Bool(dep.lto.Properties.Lto.Full) { + dep.lto.Properties.FullDep = true + } + if thin && !Bool(dep.lto.Properties.Lto.Thin) { + dep.lto.Properties.ThinDep = true + } } + + // Recursively walk static dependencies + return true } + + // Do not recurse down non-static dependencies + return false }) } } // Create lto variants for modules that need them func ltoMutator(mctx android.BottomUpMutatorContext) { - if c, ok := mctx.Module().(*Module); ok && c.lto != nil { - if c.lto.LTO() { - mctx.SetDependencyVariation("lto") - } else if c.lto.Properties.LTODep { - modules := mctx.CreateVariations("", "lto") - modules[0].(*Module).lto.Properties.Lto.Full = boolPtr(false) - modules[0].(*Module).lto.Properties.Lto.Thin = boolPtr(false) - modules[0].(*Module).lto.Properties.LTODep = false - modules[1].(*Module).lto.Properties.LTODep = false - modules[1].(*Module).Properties.PreventInstall = true - modules[1].(*Module).Properties.HideFromMake = true + if m, ok := mctx.Module().(*Module); ok && m.lto != nil { + // Create variations for LTO types required as static + // dependencies + variationNames := []string{""} + if m.lto.Properties.FullDep && !Bool(m.lto.Properties.Lto.Full) { + variationNames = append(variationNames, "lto-full") + } + if m.lto.Properties.ThinDep && !Bool(m.lto.Properties.Lto.Thin) { + variationNames = append(variationNames, "lto-thin") + } + + // Use correct dependencies if LTO property is explicitly set + // (mutually exclusive) + if Bool(m.lto.Properties.Lto.Full) { + mctx.SetDependencyVariation("lto-full") + } + if Bool(m.lto.Properties.Lto.Thin) { + mctx.SetDependencyVariation("lto-thin") + } + + if len(variationNames) > 1 { + modules := mctx.CreateVariations(variationNames...) + for i, name := range variationNames { + variation := modules[i].(*Module) + // Default module which will be + // installed. Variation set above according to + // explicit LTO properties + if name == "" { + continue + } + + // LTO properties for dependencies + if name == "lto-full" { + variation.lto.Properties.Lto.Full = boolPtr(true) + variation.lto.Properties.Lto.Thin = boolPtr(false) + } + if name == "lto-thin" { + variation.lto.Properties.Lto.Full = boolPtr(false) + variation.lto.Properties.Lto.Thin = boolPtr(true) + } + variation.Properties.PreventInstall = true + variation.Properties.HideFromMake = true + variation.lto.Properties.FullDep = false + variation.lto.Properties.ThinDep = false + } } - c.lto.Properties.LTODep = false } }