From 3f736c9661b0a3a739e6050decf705f0a1cfab37 Mon Sep 17 00:00:00 2001 From: Jiyong Park Date: Thu, 24 May 2018 13:36:56 +0900 Subject: [PATCH 1/3] Add recovery_available to cc_genrule recovery_available property is required in cc_genrule. Specifically, we will mark libminijail as recovery_available:true as part of building adbd and other stuffs for recovery. Some source code of libminijail is created via cc_genrule, so we need recovery_available in the module type. Bug: 79146551 Test: m -j Change-Id: I0cf0d9b1004dda055373573e5c5a7debd112685f --- cc/cc.go | 29 ++++++++++++++++++++++++----- cc/genrule.go | 7 ++++++- 2 files changed, 30 insertions(+), 6 deletions(-) diff --git a/cc/cc.go b/cc/cc.go index a885c91b2..e261d40e3 100644 --- a/cc/cc.go +++ b/cc/cc.go @@ -1554,16 +1554,35 @@ func imageMutator(mctx android.BottomUpMutatorContext) { } if genrule, ok := mctx.Module().(*genrule.Module); ok { - if props, ok := genrule.Extra.(*VendorProperties); ok { + if props, ok := genrule.Extra.(*GenruleExtraProperties); ok { + var coreVariantNeeded bool = false + var vendorVariantNeeded bool = false + var recoveryVariantNeeded bool = false if mctx.DeviceConfig().VndkVersion() == "" { - mctx.CreateVariations(coreMode) + coreVariantNeeded = true } else if Bool(props.Vendor_available) { - mctx.CreateVariations(coreMode, vendorMode) + coreVariantNeeded = true + vendorVariantNeeded = true } else if mctx.SocSpecific() || mctx.DeviceSpecific() { - mctx.CreateVariations(vendorMode) + vendorVariantNeeded = true } else { - mctx.CreateVariations(coreMode) + coreVariantNeeded = true } + if Bool(props.Recovery_available) { + recoveryVariantNeeded = true + } + + var variants []string + if coreVariantNeeded { + variants = append(variants, coreMode) + } + if vendorVariantNeeded { + variants = append(variants, vendorMode) + } + if recoveryVariantNeeded { + variants = append(variants, recoveryMode) + } + mctx.CreateVariations(variants...) } } diff --git a/cc/genrule.go b/cc/genrule.go index 51c0d1628..a67299271 100644 --- a/cc/genrule.go +++ b/cc/genrule.go @@ -23,13 +23,18 @@ func init() { android.RegisterModuleType("cc_genrule", genRuleFactory) } +type GenruleExtraProperties struct { + Vendor_available *bool + Recovery_available *bool +} + // cc_genrule is a genrule that can depend on other cc_* objects. // The cmd may be run multiple times, once for each of the different arch/etc // variations. func genRuleFactory() android.Module { module := genrule.NewGenRule() - module.Extra = &VendorProperties{} + module.Extra = &GenruleExtraProperties{} module.AddProperties(module.Extra) android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibBoth) From 6caa21aa820dfa29a3e51eb7b4c1d1f877c93438 Mon Sep 17 00:00:00 2001 From: Jiyong Park Date: Thu, 24 May 2018 14:14:08 +0900 Subject: [PATCH 2/3] Mark as recovery_available:true Libraries that are direct or indirect dependencies of modules installed to recovery partition (e.g. adbd) are marked as recovery_available: true. This allows a recovery variant of the lib is created when it is depended by other recovery or recovery_available modules. Bug: 79146551 Test: m -j Change-Id: I1181fa0646d840c0194e4af2043ec228ec9eff16 --- cc/libbuildversion/Android.bp | 1 + 1 file changed, 1 insertion(+) diff --git a/cc/libbuildversion/Android.bp b/cc/libbuildversion/Android.bp index fd563e6d5..825b920a0 100644 --- a/cc/libbuildversion/Android.bp +++ b/cc/libbuildversion/Android.bp @@ -1,6 +1,7 @@ cc_library_static { name: "libbuildversion", host_supported: true, + recovery_available: true, srcs: ["libbuildversion.cpp"], export_include_dirs: ["include"], cflags: ["-fvisibility=hidden"], From 4a2dcb5c4bbf3d01533bc6643ad30954d3b8bd09 Mon Sep 17 00:00:00 2001 From: Jiyong Park Date: Thu, 24 May 2018 16:44:14 +0900 Subject: [PATCH 3/3] fix: recovery.cflags now works There was a bug that recovery.cflags is ignored. Respect the property when building for recovery. Bug: 79146551 Test: m -j Change-Id: I24c1c1b593c83eb1992721571c6d5c42483a41a0 --- cc/compiler.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/cc/compiler.go b/cc/compiler.go index b410115f8..8f119cf3c 100644 --- a/cc/compiler.go +++ b/cc/compiler.go @@ -258,6 +258,8 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps CheckBadCompilerFlags(ctx, "cppflags", compiler.Properties.Cppflags) CheckBadCompilerFlags(ctx, "conlyflags", compiler.Properties.Conlyflags) CheckBadCompilerFlags(ctx, "asflags", compiler.Properties.Asflags) + CheckBadCompilerFlags(ctx, "vendor.cflags", compiler.Properties.Target.Vendor.Cflags) + CheckBadCompilerFlags(ctx, "recovery.cflags", compiler.Properties.Target.Recovery.Cflags) esc := proptools.NinjaAndShellEscape @@ -454,6 +456,10 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps flags.CFlags = append(flags.CFlags, esc(compiler.Properties.Target.Vendor.Cflags)...) } + if ctx.inRecovery() { + flags.CFlags = append(flags.CFlags, esc(compiler.Properties.Target.Recovery.Cflags)...) + } + // We can enforce some rules more strictly in the code we own. strict // indicates if this is code that we can be stricter with. If we have // rules that we want to apply to *our* code (but maybe can't for