Merge "Update VndkMustUseVendorVariantList"
diff --git a/OWNERS b/OWNERS
index bbfd011..f15bd32 100644
--- a/OWNERS
+++ b/OWNERS
@@ -1,17 +1,22 @@
# This file is included by several other projects as the list of people
# approving build related projects.
+# AMER
ahumesky@google.com
asmundak@google.com
ccross@android.com
cparsons@google.com
dwillemsen@google.com
eakammer@google.com
-jingwen@google.com
joeo@google.com
-lberki@google.com
+spandandas@google.com
+yuntaoxu@google.com
+
+# APAC
+jingwen@google.com
ruperts@google.com
-# To expedite LON reviews
+# EMEA
hansson@google.com
+lberki@google.com
paulduffin@google.com
diff --git a/android/arch.go b/android/arch.go
index 340f136..583793e 100644
--- a/android/arch.go
+++ b/android/arch.go
@@ -15,13 +15,14 @@
package android
import (
- "android/soong/bazel"
"encoding"
"fmt"
"reflect"
"runtime"
"strings"
+ "android/soong/bazel"
+
"github.com/google/blueprint"
"github.com/google/blueprint/bootstrap"
"github.com/google/blueprint/proptools"
@@ -290,28 +291,6 @@
return NoOsType
}
-// BuildOs returns the OsType for the OS that the build is running on.
-var BuildOs = func() OsType {
- switch runtime.GOOS {
- case "linux":
- return Linux
- case "darwin":
- return Darwin
- default:
- panic(fmt.Sprintf("unsupported OS: %s", runtime.GOOS))
- }
-}()
-
-// BuildArch returns the ArchType for the CPU that the build is running on.
-var BuildArch = func() ArchType {
- switch runtime.GOARCH {
- case "amd64":
- return X86_64
- default:
- panic(fmt.Sprintf("unsupported Arch: %s", runtime.GOARCH))
- }
-}()
-
var (
// osTypeList contains a list of all the supported OsTypes, including ones not supported
// by the current build host or the target device.
@@ -336,8 +315,6 @@
// Android is the OS for target devices that run all of Android, including the Linux kernel
// and the Bionic libc runtime.
Android = newOsType("android", Device, false, Arm, Arm64, X86, X86_64)
- // Fuchsia is the OS for target devices that run Fuchsia.
- Fuchsia = newOsType("fuchsia", Device, false, Arm64, X86_64)
// CommonOS is a pseudo OSType for a common OS variant, which is OsType agnostic and which
// has dependencies on all the OS variants.
@@ -1397,6 +1374,31 @@
}
}
+// determineBuildOS stores the OS and architecture used for host targets used during the build into
+// config based on the runtime OS and architecture determined by Go.
+func determineBuildOS(config *config) {
+ config.BuildOS = func() OsType {
+ switch runtime.GOOS {
+ case "linux":
+ return Linux
+ case "darwin":
+ return Darwin
+ default:
+ panic(fmt.Sprintf("unsupported OS: %s", runtime.GOOS))
+ }
+ }()
+
+ config.BuildArch = func() ArchType {
+ switch runtime.GOARCH {
+ case "amd64":
+ return X86_64
+ default:
+ panic(fmt.Sprintf("unsupported Arch: %s", runtime.GOARCH))
+ }
+ }()
+
+}
+
// Convert the arch product variables into a list of targets for each OsType.
func decodeTargetProductVariables(config *config) (map[OsType][]Target, error) {
variables := config.productVariables
@@ -1430,9 +1432,9 @@
hostCross := false
if os.Class == Host {
var osSupported bool
- if os == BuildOs {
+ if os == config.BuildOS {
osSupported = true
- } else if BuildOs.Linux() && os.Linux() {
+ } else if config.BuildOS.Linux() && os.Linux() {
// LinuxBionic and Linux are compatible
osSupported = true
} else {
@@ -1470,11 +1472,11 @@
}
// The primary host target, which must always exist.
- addTarget(BuildOs, *variables.HostArch, nil, nil, nil, NativeBridgeDisabled, nil, nil)
+ addTarget(config.BuildOS, *variables.HostArch, nil, nil, nil, NativeBridgeDisabled, nil, nil)
// An optional secondary host target.
if variables.HostSecondaryArch != nil && *variables.HostSecondaryArch != "" {
- addTarget(BuildOs, *variables.HostSecondaryArch, nil, nil, nil, NativeBridgeDisabled, nil, nil)
+ addTarget(config.BuildOS, *variables.HostSecondaryArch, nil, nil, nil, NativeBridgeDisabled, nil, nil)
}
// Optional cross-compiled host targets, generally Windows.
@@ -1499,13 +1501,8 @@
// Optional device targets
if variables.DeviceArch != nil && *variables.DeviceArch != "" {
- var target = Android
- if Bool(variables.Fuchsia) {
- target = Fuchsia
- }
-
// The primary device target.
- addTarget(target, *variables.DeviceArch, variables.DeviceArchVariant,
+ addTarget(Android, *variables.DeviceArch, variables.DeviceArchVariant,
variables.DeviceCpuVariant, variables.DeviceAbi, NativeBridgeDisabled, nil, nil)
// An optional secondary device target.
@@ -1987,6 +1984,10 @@
axisToProps[bazel.OsConfigurationAxis] = osToProp
axisToProps[bazel.OsArchConfigurationAxis] = archOsToProp
+ axisToProps[bazel.BionicConfigurationAxis] = map[string]interface{}{
+ "bionic": getTargetStruct(ctx, propertySet, archProperties, "Bionic"),
+ }
+
return axisToProps
}
diff --git a/android/arch_test.go b/android/arch_test.go
index 3aa4779..2a2fd45 100644
--- a/android/arch_test.go
+++ b/android/arch_test.go
@@ -473,3 +473,164 @@
})
}
}
+
+type testArchPropertiesModule struct {
+ ModuleBase
+ properties struct {
+ A []string `android:"arch_variant"`
+ }
+}
+
+func (testArchPropertiesModule) GenerateAndroidBuildActions(ctx ModuleContext) {}
+
+func TestArchProperties(t *testing.T) {
+ bp := `
+ module {
+ name: "foo",
+ a: ["root"],
+ arch: {
+ arm: {
+ a: ["arm"],
+ armv7_a_neon: { a: ["armv7_a_neon"] },
+ },
+ arm64: {
+ a: ["arm64"],
+ armv8_a: { a: ["armv8_a"] },
+ },
+ x86: { a: ["x86"] },
+ x86_64: { a: ["x86_64"] },
+ },
+ multilib: {
+ lib32: { a: ["lib32"] },
+ lib64: { a: ["lib64"] },
+ },
+ target: {
+ bionic: { a: ["bionic"] },
+ host: { a: ["host"] },
+ android: { a: ["android"] },
+ linux_bionic: { a: ["linux_bionic"] },
+ linux: { a: ["linux"] },
+ linux_glibc: { a: ["linux_glibc"] },
+ windows: { a: ["windows"], enabled: true },
+ darwin: { a: ["darwin"] },
+ not_windows: { a: ["not_windows"] },
+ android32: { a: ["android32"] },
+ android64: { a: ["android64"] },
+ android_arm: { a: ["android_arm"] },
+ android_arm64: { a: ["android_arm64"] },
+ linux_x86: { a: ["linux_x86"] },
+ linux_x86_64: { a: ["linux_x86_64"] },
+ linux_glibc_x86: { a: ["linux_glibc_x86"] },
+ linux_glibc_x86_64: { a: ["linux_glibc_x86_64"] },
+ darwin_x86_64: { a: ["darwin_x86_64"] },
+ windows_x86: { a: ["windows_x86"] },
+ windows_x86_64: { a: ["windows_x86_64"] },
+ },
+ }
+ `
+
+ type result struct {
+ module string
+ variant string
+ property []string
+ }
+
+ testCases := []struct {
+ name string
+ goOS string
+ preparer FixturePreparer
+ results []result
+ }{
+ {
+ name: "default",
+ results: []result{
+ {
+ module: "foo",
+ variant: "android_arm64_armv8-a",
+ property: []string{"root", "linux", "bionic", "android", "android64", "arm64", "armv8_a", "lib64", "android_arm64"},
+ },
+ {
+ module: "foo",
+ variant: "android_arm_armv7-a-neon",
+ property: []string{"root", "linux", "bionic", "android", "android64", "arm", "armv7_a_neon", "lib32", "android_arm"},
+ },
+ },
+ },
+ {
+ name: "linux",
+ goOS: "linux",
+ results: []result{
+ {
+ module: "foo",
+ variant: "linux_glibc_x86_64",
+ property: []string{"root", "host", "linux", "linux_glibc", "not_windows", "x86_64", "lib64", "linux_x86_64", "linux_glibc_x86_64"},
+ },
+ {
+ module: "foo",
+ variant: "linux_glibc_x86",
+ property: []string{"root", "host", "linux", "linux_glibc", "not_windows", "x86", "lib32", "linux_x86", "linux_glibc_x86"},
+ },
+ },
+ },
+ {
+ name: "windows",
+ goOS: "linux",
+ preparer: FixtureModifyConfig(func(config Config) {
+ config.Targets[Windows] = []Target{
+ {Windows, Arch{ArchType: X86_64}, NativeBridgeDisabled, "", "", true},
+ {Windows, Arch{ArchType: X86}, NativeBridgeDisabled, "", "", true},
+ }
+ }),
+ results: []result{
+ {
+ module: "foo",
+ variant: "windows_x86_64",
+ property: []string{"root", "host", "windows", "x86_64", "lib64", "windows_x86_64"},
+ },
+ {
+ module: "foo",
+ variant: "windows_x86",
+ property: []string{"root", "host", "windows", "x86", "lib32", "windows_x86"},
+ },
+ },
+ },
+ {
+ name: "darwin",
+ goOS: "darwin",
+ results: []result{
+ {
+ module: "foo",
+ variant: "darwin_x86_64",
+ property: []string{"root", "host", "darwin", "not_windows", "x86_64", "lib64", "darwin_x86_64"},
+ },
+ },
+ },
+ }
+
+ for _, tt := range testCases {
+ t.Run(tt.name, func(t *testing.T) {
+ if tt.goOS != "" && tt.goOS != runtime.GOOS {
+ t.Skipf("test requires runtime.GOOS==%s, got %s", tt.goOS, runtime.GOOS)
+ }
+ result := GroupFixturePreparers(
+ PrepareForTestWithArchMutator,
+ OptionalFixturePreparer(tt.preparer),
+ FixtureRegisterWithContext(func(ctx RegistrationContext) {
+ ctx.RegisterModuleType("module", func() Module {
+ module := &testArchPropertiesModule{}
+ module.AddProperties(&module.properties)
+ InitAndroidArchModule(module, HostAndDeviceDefault, MultilibBoth)
+ return module
+ })
+ }),
+ ).RunTestWithBp(t, bp)
+
+ for _, want := range tt.results {
+ t.Run(want.module+"_"+want.variant, func(t *testing.T) {
+ got := result.ModuleForTests(want.module, want.variant).Module().(*testArchPropertiesModule).properties.A
+ AssertArrayString(t, "arch mutator property", want.property, got)
+ })
+ }
+ })
+ }
+}
diff --git a/android/bazel.go b/android/bazel.go
index 8d13762..d40e650 100644
--- a/android/bazel.go
+++ b/android/bazel.go
@@ -129,7 +129,7 @@
// Keep any existing BUILD files (and do not generate new BUILD files) for these directories
bp2buildKeepExistingBuildFile = map[string]bool{
// This is actually build/bazel/build.BAZEL symlinked to ./BUILD
- ".":/*recrusive = */ false,
+ ".":/*recursive = */ false,
"build/bazel":/* recursive = */ true,
"build/pesto":/* recursive = */ true,
@@ -140,13 +140,15 @@
"prebuilts/sdk":/* recursive = */ false,
"prebuilts/sdk/tools":/* recursive = */ false,
+ "packages/apps/Music":/* recursive = */ false,
}
// Configure modules in these directories to enable bp2build_available: true or false by default.
bp2buildDefaultConfig = Bp2BuildConfig{
- "bionic": Bp2BuildDefaultTrueRecursively,
- "external/gwp_asan": Bp2BuildDefaultTrueRecursively,
- "system/core/libcutils": Bp2BuildDefaultTrueRecursively,
+ "bionic": Bp2BuildDefaultTrueRecursively,
+ "build/bazel/examples/apex/minimal": Bp2BuildDefaultTrueRecursively,
+ "external/gwp_asan": Bp2BuildDefaultTrueRecursively,
+ "system/core/libcutils": Bp2BuildDefaultTrueRecursively,
"system/core/property_service/libpropertyinfoparser": Bp2BuildDefaultTrueRecursively,
"system/libbase": Bp2BuildDefaultTrueRecursively,
"system/logging/liblog": Bp2BuildDefaultTrueRecursively,
diff --git a/android/bazel_paths.go b/android/bazel_paths.go
index f74fed1..26cacdb 100644
--- a/android/bazel_paths.go
+++ b/android/bazel_paths.go
@@ -73,6 +73,7 @@
EarlyModulePathContext
GetDirectDep(name string) (blueprint.Module, blueprint.DependencyTag)
+ ModuleFromName(name string) (blueprint.Module, bool)
Module() Module
ModuleType() string
OtherModuleName(m blueprint.Module) string
@@ -331,11 +332,9 @@
// module. The label will be relative to the current directory if appropriate. The dependency must
// already be resolved by either deps mutator or path deps mutator.
func getOtherModuleLabel(ctx BazelConversionPathContext, dep, tag string, isWholeLibs bool) bazel.Label {
- m, _ := ctx.GetDirectDep(dep)
+ m, _ := ctx.ModuleFromName(dep)
if m == nil {
- panic(fmt.Errorf(`Cannot get direct dep %q of %q.
- This is likely because it was not added via AddDependency().
- This may be due a mutator skipped during bp2build.`, dep, ctx.Module().Name()))
+ panic(fmt.Errorf("No module named %q found, but was a direct dep of %q", dep, ctx.Module().Name()))
}
otherLabel := bazelModuleLabel(ctx, m, tag)
label := bazelModuleLabel(ctx, ctx.Module(), "")
diff --git a/android/config.go b/android/config.go
index 396b1a6..871986c 100644
--- a/android/config.go
+++ b/android/config.go
@@ -108,6 +108,12 @@
ProductVariablesFileName string
+ // BuildOS stores the OsType for the OS that the build is running on.
+ BuildOS OsType
+
+ // BuildArch stores the ArchType for the CPU that the build is running on.
+ BuildArch ArchType
+
Targets map[OsType][]Target
BuildOSTarget Target // the Target for tools run on the build machine
BuildOSCommonTarget Target // the Target for common (java) tools run on the build machine
@@ -326,41 +332,28 @@
return Config{config}
}
-func fuchsiaTargets() map[OsType][]Target {
- return map[OsType][]Target{
- Fuchsia: {
- {Fuchsia, Arch{ArchType: Arm64, ArchVariant: "", Abi: []string{"arm64-v8a"}}, NativeBridgeDisabled, "", "", false},
- },
- BuildOs: {
- {BuildOs, Arch{ArchType: X86_64}, NativeBridgeDisabled, "", "", false},
- },
- }
-}
-
-var PrepareForTestSetDeviceToFuchsia = FixtureModifyConfig(func(config Config) {
- config.Targets = fuchsiaTargets()
-})
-
func modifyTestConfigToSupportArchMutator(testConfig Config) {
config := testConfig.config
+ determineBuildOS(config)
+
config.Targets = map[OsType][]Target{
Android: []Target{
{Android, Arch{ArchType: Arm64, ArchVariant: "armv8-a", Abi: []string{"arm64-v8a"}}, NativeBridgeDisabled, "", "", false},
{Android, Arch{ArchType: Arm, ArchVariant: "armv7-a-neon", Abi: []string{"armeabi-v7a"}}, NativeBridgeDisabled, "", "", false},
},
- BuildOs: []Target{
- {BuildOs, Arch{ArchType: X86_64}, NativeBridgeDisabled, "", "", false},
- {BuildOs, Arch{ArchType: X86}, NativeBridgeDisabled, "", "", false},
+ config.BuildOS: []Target{
+ {config.BuildOS, Arch{ArchType: X86_64}, NativeBridgeDisabled, "", "", false},
+ {config.BuildOS, Arch{ArchType: X86}, NativeBridgeDisabled, "", "", false},
},
}
if runtime.GOOS == "darwin" {
- config.Targets[BuildOs] = config.Targets[BuildOs][:1]
+ config.Targets[config.BuildOS] = config.Targets[config.BuildOS][:1]
}
- config.BuildOSTarget = config.Targets[BuildOs][0]
- config.BuildOSCommonTarget = getCommonTargets(config.Targets[BuildOs])[0]
+ config.BuildOSTarget = config.Targets[config.BuildOS][0]
+ config.BuildOSCommonTarget = getCommonTargets(config.Targets[config.BuildOS])[0]
config.AndroidCommonTarget = getCommonTargets(config.Targets[Android])[0]
config.AndroidFirstDeviceTarget = firstTarget(config.Targets[Android], "lib64", "lib32")[0]
config.TestProductVariables.DeviceArch = proptools.StringPtr("arm64")
@@ -439,6 +432,8 @@
config.katiEnabled = true
}
+ determineBuildOS(config)
+
// Sets up the map of target OSes to the finer grained compilation targets
// that are configured from the product variables.
targets, err := decodeTargetProductVariables(config)
@@ -476,8 +471,8 @@
config.Targets = targets
// Compilation targets for host tools.
- config.BuildOSTarget = config.Targets[BuildOs][0]
- config.BuildOSCommonTarget = getCommonTargets(config.Targets[BuildOs])[0]
+ config.BuildOSTarget = config.Targets[config.BuildOS][0]
+ config.BuildOSCommonTarget = getCommonTargets(config.Targets[config.BuildOS])[0]
// Compilation targets for Android.
if len(config.Targets[Android]) > 0 {
@@ -837,10 +832,6 @@
return Bool(c.productVariables.Skip_boot_jars_check)
}
-func (c *config) Fuchsia() bool {
- return Bool(c.productVariables.Fuchsia)
-}
-
func (c *config) MinimizeJavaDebugInfo() bool {
return Bool(c.productVariables.MinimizeJavaDebugInfo) && !Bool(c.productVariables.Eng)
}
diff --git a/android/module.go b/android/module.go
index 11f63bd..5f34e62 100644
--- a/android/module.go
+++ b/android/module.go
@@ -223,6 +223,8 @@
// the first DependencyTag.
GetDirectDep(name string) (blueprint.Module, blueprint.DependencyTag)
+ ModuleFromName(name string) (blueprint.Module, bool)
+
// VisitDirectDepsBlueprint calls visit for each direct dependency. If there are multiple
// direct dependencies on the same module visit will be called multiple times on that module
// and OtherModuleDependencyTag will return a different tag for each.
@@ -325,7 +327,6 @@
Host() bool
Device() bool
Darwin() bool
- Fuchsia() bool
Windows() bool
Debug() bool
PrimaryArch() bool
@@ -413,6 +414,7 @@
InstallInDebugRamdisk() bool
InstallInRecovery() bool
InstallInRoot() bool
+ InstallInVendor() bool
InstallBypassMake() bool
InstallForceOS() (*OsType, *ArchType)
@@ -471,6 +473,7 @@
InstallInDebugRamdisk() bool
InstallInRecovery() bool
InstallInRoot() bool
+ InstallInVendor() bool
InstallBypassMake() bool
InstallForceOS() (*OsType, *ArchType)
HideFromMake()
@@ -1579,6 +1582,10 @@
return Bool(m.commonProperties.Recovery)
}
+func (m *ModuleBase) InstallInVendor() bool {
+ return Bool(m.commonProperties.Vendor)
+}
+
func (m *ModuleBase) InstallInRoot() bool {
return false
}
@@ -2032,8 +2039,13 @@
tagPath []blueprint.DependencyTag
strictVisitDeps bool // If true, enforce that all dependencies are enabled
+
+ bazelConversionMode bool
}
+func (b *baseModuleContext) BazelConversionMode() bool {
+ return b.bazelConversionMode
+}
func (b *baseModuleContext) OtherModuleName(m blueprint.Module) string {
return b.bp.OtherModuleName(m)
}
@@ -2373,6 +2385,18 @@
return b.getDirectDepFirstTag(name)
}
+func (b *baseModuleContext) ModuleFromName(name string) (blueprint.Module, bool) {
+ if !b.BazelConversionMode() {
+ panic("cannot call ModuleFromName if not in bazel conversion mode")
+ }
+ if len(name) > 1 && (name[0] == ':' || (name[0] == '/' && name[1] == '/')) {
+ moduleName, _ := SrcIsModuleWithTag(name)
+ return b.bp.ModuleFromName(moduleName)
+ } else {
+ return b.bp.ModuleFromName(name)
+ }
+}
+
func (b *baseModuleContext) VisitDirectDepsBlueprint(visit func(blueprint.Module)) {
b.bp.VisitDirectDeps(visit)
}
@@ -2563,10 +2587,6 @@
return b.os == Darwin
}
-func (b *baseModuleContext) Fuchsia() bool {
- return b.os == Fuchsia
-}
-
func (b *baseModuleContext) Windows() bool {
return b.os == Windows
}
@@ -2645,6 +2665,10 @@
return m.module.InstallForceOS()
}
+func (m *moduleContext) InstallInVendor() bool {
+ return m.module.InstallInVendor()
+}
+
func (m *moduleContext) skipInstall() bool {
if m.module.base().commonProperties.SkipInstall {
return true
diff --git a/android/mutator.go b/android/mutator.go
index 819dd0f..d895669 100644
--- a/android/mutator.go
+++ b/android/mutator.go
@@ -35,7 +35,7 @@
// continue on to GenerateAndroidBuildActions
// RegisterMutatorsForBazelConversion is a alternate registration pipeline for bp2build. Exported for testing.
-func RegisterMutatorsForBazelConversion(ctx *Context, preArchMutators, depsMutators, bp2buildMutators []RegisterMutatorFunc) {
+func RegisterMutatorsForBazelConversion(ctx *Context, preArchMutators, bp2buildMutators []RegisterMutatorFunc) {
mctx := ®isterMutatorsContext{
bazelConversionMode: true,
}
@@ -53,16 +53,6 @@
f(mctx)
}
- bp2buildDepsMutators = append([]RegisterMutatorFunc{
- registerDepsMutatorBp2Build,
- registerPathDepsMutator,
- registerBp2buildArchPathDepsMutator,
- }, depsMutators...)
-
- for _, f := range bp2buildDepsMutators {
- f(mctx)
- }
-
// Register bp2build mutators
for _, f := range bp2buildMutators {
f(mctx)
@@ -227,7 +217,6 @@
}
var bp2buildPreArchMutators = []RegisterMutatorFunc{}
-var bp2buildDepsMutators = []RegisterMutatorFunc{}
var bp2buildMutators = map[string]RegisterMutatorFunc{}
// See http://b/192523357
@@ -254,12 +243,6 @@
bp2buildPreArchMutators = append(bp2buildPreArchMutators, f)
}
-// DepsBp2BuildMutators adds mutators to be register for converting Android Blueprint modules into
-// Bazel BUILD targets that should run prior to conversion to resolve dependencies.
-func DepsBp2BuildMutators(f RegisterMutatorFunc) {
- bp2buildDepsMutators = append(bp2buildDepsMutators, f)
-}
-
type BaseMutatorContext interface {
BaseModuleContext
@@ -269,6 +252,9 @@
// Rename all variants of a module. The new name is not visible to calls to ModuleName,
// AddDependency or OtherModuleName until after this mutator pass is complete.
Rename(name string)
+
+ // BazelConversionMode returns whether this mutator is being run as part of Bazel Conversion.
+ BazelConversionMode() bool
}
type TopDownMutator func(TopDownMutatorContext)
@@ -410,26 +396,24 @@
// variant of the current module. The value should not be modified after being passed to
// SetVariationProvider.
SetVariationProvider(module blueprint.Module, provider blueprint.ProviderKey, value interface{})
-
- // BazelConversionMode returns whether this mutator is being run as part of Bazel Conversion.
- BazelConversionMode() bool
}
type bottomUpMutatorContext struct {
bp blueprint.BottomUpMutatorContext
baseModuleContext
- finalPhase bool
- bazelConversionMode bool
+ finalPhase bool
}
func bottomUpMutatorContextFactory(ctx blueprint.BottomUpMutatorContext, a Module,
finalPhase, bazelConversionMode bool) BottomUpMutatorContext {
+ moduleContext := a.base().baseModuleContextFactory(ctx)
+ moduleContext.bazelConversionMode = bazelConversionMode
+
return &bottomUpMutatorContext{
- bp: ctx,
- baseModuleContext: a.base().baseModuleContextFactory(ctx),
- finalPhase: finalPhase,
- bazelConversionMode: bazelConversionMode,
+ bp: ctx,
+ baseModuleContext: a.base().baseModuleContextFactory(ctx),
+ finalPhase: finalPhase,
}
}
@@ -462,9 +446,11 @@
func (x *registerMutatorsContext) TopDown(name string, m TopDownMutator) MutatorHandle {
f := func(ctx blueprint.TopDownMutatorContext) {
if a, ok := ctx.Module().(Module); ok {
+ moduleContext := a.base().baseModuleContextFactory(ctx)
+ moduleContext.bazelConversionMode = x.bazelConversionMode
actx := &topDownMutatorContext{
bp: ctx,
- baseModuleContext: a.base().baseModuleContextFactory(ctx),
+ baseModuleContext: moduleContext,
}
m(actx)
}
@@ -733,7 +719,3 @@
func (b *bottomUpMutatorContext) SetVariationProvider(module blueprint.Module, provider blueprint.ProviderKey, value interface{}) {
b.bp.SetVariationProvider(module, provider, value)
}
-
-func (b *bottomUpMutatorContext) BazelConversionMode() bool {
- return b.bazelConversionMode
-}
diff --git a/android/prebuilt_build_tool.go b/android/prebuilt_build_tool.go
index 516d042..e5edf91 100644
--- a/android/prebuilt_build_tool.go
+++ b/android/prebuilt_build_tool.go
@@ -86,7 +86,7 @@
func (t *prebuiltBuildTool) MakeVars(ctx MakeVarsModuleContext) {
if makeVar := String(t.properties.Export_to_make_var); makeVar != "" {
- if t.Target().Os != BuildOs {
+ if t.Target().Os != ctx.Config().BuildOS {
return
}
ctx.StrictRaw(makeVar, t.toolPath.String())
diff --git a/android/prebuilt_test.go b/android/prebuilt_test.go
index dcd77ea..a1f8e63 100644
--- a/android/prebuilt_test.go
+++ b/android/prebuilt_test.go
@@ -21,360 +21,362 @@
"github.com/google/blueprint"
)
-var prebuiltsTests = []struct {
- name string
- replaceBp bool // modules is added to default bp boilerplate if false.
- modules string
- prebuilt []OsType
- preparer FixturePreparer
-}{
- {
- name: "no prebuilt",
- modules: `
- source {
- name: "bar",
- }`,
- prebuilt: nil,
- },
- {
- name: "no source prebuilt not preferred",
- modules: `
- prebuilt {
- name: "bar",
- prefer: false,
- srcs: ["prebuilt_file"],
- }`,
- prebuilt: []OsType{Android, BuildOs},
- },
- {
- name: "no source prebuilt preferred",
- modules: `
- prebuilt {
- name: "bar",
- prefer: true,
- srcs: ["prebuilt_file"],
- }`,
- prebuilt: []OsType{Android, BuildOs},
- },
- {
- name: "prebuilt not preferred",
- modules: `
- source {
- name: "bar",
- }
+func TestPrebuilts(t *testing.T) {
+ buildOS := TestArchConfig(t.TempDir(), nil, "", nil).BuildOS
- prebuilt {
- name: "bar",
- prefer: false,
- srcs: ["prebuilt_file"],
- }`,
- prebuilt: nil,
- },
- {
- name: "prebuilt preferred",
- modules: `
- source {
- name: "bar",
- }
+ var prebuiltsTests = []struct {
+ name string
+ replaceBp bool // modules is added to default bp boilerplate if false.
+ modules string
+ prebuilt []OsType
+ preparer FixturePreparer
+ }{
+ {
+ name: "no prebuilt",
+ modules: `
+ source {
+ name: "bar",
+ }`,
+ prebuilt: nil,
+ },
+ {
+ name: "no source prebuilt not preferred",
+ modules: `
+ prebuilt {
+ name: "bar",
+ prefer: false,
+ srcs: ["prebuilt_file"],
+ }`,
+ prebuilt: []OsType{Android, buildOS},
+ },
+ {
+ name: "no source prebuilt preferred",
+ modules: `
+ prebuilt {
+ name: "bar",
+ prefer: true,
+ srcs: ["prebuilt_file"],
+ }`,
+ prebuilt: []OsType{Android, buildOS},
+ },
+ {
+ name: "prebuilt not preferred",
+ modules: `
+ source {
+ name: "bar",
+ }
- prebuilt {
- name: "bar",
- prefer: true,
- srcs: ["prebuilt_file"],
- }`,
- prebuilt: []OsType{Android, BuildOs},
- },
- {
- name: "prebuilt no file not preferred",
- modules: `
- source {
- name: "bar",
- }
+ prebuilt {
+ name: "bar",
+ prefer: false,
+ srcs: ["prebuilt_file"],
+ }`,
+ prebuilt: nil,
+ },
+ {
+ name: "prebuilt preferred",
+ modules: `
+ source {
+ name: "bar",
+ }
- prebuilt {
- name: "bar",
- prefer: false,
- }`,
- prebuilt: nil,
- },
- {
- name: "prebuilt no file preferred",
- modules: `
- source {
- name: "bar",
- }
+ prebuilt {
+ name: "bar",
+ prefer: true,
+ srcs: ["prebuilt_file"],
+ }`,
+ prebuilt: []OsType{Android, buildOS},
+ },
+ {
+ name: "prebuilt no file not preferred",
+ modules: `
+ source {
+ name: "bar",
+ }
- prebuilt {
- name: "bar",
- prefer: true,
- }`,
- prebuilt: nil,
- },
- {
- name: "prebuilt file from filegroup preferred",
- modules: `
- filegroup {
- name: "fg",
- srcs: ["prebuilt_file"],
- }
- prebuilt {
- name: "bar",
- prefer: true,
- srcs: [":fg"],
- }`,
- prebuilt: []OsType{Android, BuildOs},
- },
- {
- name: "prebuilt module for device only",
- modules: `
- source {
- name: "bar",
- }
+ prebuilt {
+ name: "bar",
+ prefer: false,
+ }`,
+ prebuilt: nil,
+ },
+ {
+ name: "prebuilt no file preferred",
+ modules: `
+ source {
+ name: "bar",
+ }
- prebuilt {
- name: "bar",
- host_supported: false,
- prefer: true,
- srcs: ["prebuilt_file"],
- }`,
- prebuilt: []OsType{Android},
- },
- {
- name: "prebuilt file for host only",
- modules: `
- source {
- name: "bar",
- }
+ prebuilt {
+ name: "bar",
+ prefer: true,
+ }`,
+ prebuilt: nil,
+ },
+ {
+ name: "prebuilt file from filegroup preferred",
+ modules: `
+ filegroup {
+ name: "fg",
+ srcs: ["prebuilt_file"],
+ }
+ prebuilt {
+ name: "bar",
+ prefer: true,
+ srcs: [":fg"],
+ }`,
+ prebuilt: []OsType{Android, buildOS},
+ },
+ {
+ name: "prebuilt module for device only",
+ modules: `
+ source {
+ name: "bar",
+ }
- prebuilt {
- name: "bar",
- prefer: true,
- target: {
- host: {
- srcs: ["prebuilt_file"],
- },
- },
- }`,
- prebuilt: []OsType{BuildOs},
- },
- {
- name: "prebuilt override not preferred",
- modules: `
- source {
- name: "baz",
- }
+ prebuilt {
+ name: "bar",
+ host_supported: false,
+ prefer: true,
+ srcs: ["prebuilt_file"],
+ }`,
+ prebuilt: []OsType{Android},
+ },
+ {
+ name: "prebuilt file for host only",
+ modules: `
+ source {
+ name: "bar",
+ }
- override_source {
- name: "bar",
- base: "baz",
- }
-
- prebuilt {
- name: "bar",
- prefer: false,
- srcs: ["prebuilt_file"],
- }`,
- prebuilt: nil,
- },
- {
- name: "prebuilt override preferred",
- modules: `
- source {
- name: "baz",
- }
-
- override_source {
- name: "bar",
- base: "baz",
- }
-
- prebuilt {
- name: "bar",
- prefer: true,
- srcs: ["prebuilt_file"],
- }`,
- prebuilt: []OsType{Android, BuildOs},
- },
- {
- name: "prebuilt including default-disabled OS",
- replaceBp: true,
- modules: `
- source {
- name: "foo",
- deps: [":bar"],
- target: {
- windows: {
- enabled: true,
- },
- },
- }
-
- source {
- name: "bar",
- target: {
- windows: {
- enabled: true,
- },
- },
- }
-
- prebuilt {
- name: "bar",
- prefer: true,
- srcs: ["prebuilt_file"],
- target: {
- windows: {
- enabled: true,
- },
- },
- }`,
- prebuilt: []OsType{Android, BuildOs, Windows},
- },
- {
- name: "fall back to source for default-disabled OS",
- replaceBp: true,
- modules: `
- source {
- name: "foo",
- deps: [":bar"],
- target: {
- windows: {
- enabled: true,
- },
- },
- }
-
- source {
- name: "bar",
- target: {
- windows: {
- enabled: true,
- },
- },
- }
-
- prebuilt {
- name: "bar",
- prefer: true,
- srcs: ["prebuilt_file"],
- }`,
- prebuilt: []OsType{Android, BuildOs},
- },
- {
- name: "prebuilt properties customizable",
- replaceBp: true,
- modules: `
- source {
- name: "foo",
- deps: [":bar"],
- }
-
- soong_config_module_type {
- name: "prebuilt_with_config",
- module_type: "prebuilt",
- config_namespace: "any_namespace",
- bool_variables: ["bool_var"],
- properties: ["prefer"],
- }
-
- prebuilt_with_config {
- name: "bar",
- prefer: true,
- srcs: ["prebuilt_file"],
- soong_config_variables: {
- bool_var: {
- prefer: false,
- conditions_default: {
- prefer: true,
+ prebuilt {
+ name: "bar",
+ prefer: true,
+ target: {
+ host: {
+ srcs: ["prebuilt_file"],
},
},
- },
- }`,
- prebuilt: []OsType{Android, BuildOs},
- },
- {
- name: "prebuilt use_source_config_var={acme, use_source} - no var specified",
- modules: `
- source {
- name: "bar",
- }
+ }`,
+ prebuilt: []OsType{buildOS},
+ },
+ {
+ name: "prebuilt override not preferred",
+ modules: `
+ source {
+ name: "baz",
+ }
- prebuilt {
- name: "bar",
- use_source_config_var: {config_namespace: "acme", var_name: "use_source"},
- srcs: ["prebuilt_file"],
- }`,
- // When use_source_env is specified then it will use the prebuilt by default if the environment
- // variable is not set.
- prebuilt: []OsType{Android, BuildOs},
- },
- {
- name: "prebuilt use_source_config_var={acme, use_source} - acme_use_source=false",
- modules: `
- source {
- name: "bar",
- }
+ override_source {
+ name: "bar",
+ base: "baz",
+ }
- prebuilt {
- name: "bar",
- use_source_config_var: {config_namespace: "acme", var_name: "use_source"},
- srcs: ["prebuilt_file"],
- }`,
- preparer: FixtureModifyProductVariables(func(variables FixtureProductVariables) {
- variables.VendorVars = map[string]map[string]string{
- "acme": {
- "use_source": "false",
- },
- }
- }),
- // Setting the environment variable named in use_source_env to false will cause the prebuilt to
- // be used.
- prebuilt: []OsType{Android, BuildOs},
- },
- {
- name: "prebuilt use_source_config_var={acme, use_source} - acme_use_source=true",
- modules: `
- source {
- name: "bar",
- }
+ prebuilt {
+ name: "bar",
+ prefer: false,
+ srcs: ["prebuilt_file"],
+ }`,
+ prebuilt: nil,
+ },
+ {
+ name: "prebuilt override preferred",
+ modules: `
+ source {
+ name: "baz",
+ }
- prebuilt {
- name: "bar",
- use_source_config_var: {config_namespace: "acme", var_name: "use_source"},
- srcs: ["prebuilt_file"],
- }`,
- preparer: FixtureModifyProductVariables(func(variables FixtureProductVariables) {
- variables.VendorVars = map[string]map[string]string{
- "acme": {
- "use_source": "true",
- },
- }
- }),
- // Setting the environment variable named in use_source_env to true will cause the source to be
- // used.
- prebuilt: nil,
- },
- {
- name: "prebuilt use_source_config_var={acme, use_source} - acme_use_source=true, no source",
- modules: `
- prebuilt {
- name: "bar",
- use_source_config_var: {config_namespace: "acme", var_name: "use_source"},
- srcs: ["prebuilt_file"],
- }`,
- preparer: FixtureModifyProductVariables(func(variables FixtureProductVariables) {
- variables.VendorVars = map[string]map[string]string{
- "acme": {
- "use_source": "true",
- },
- }
- }),
- // Although the environment variable says to use source there is no source available.
- prebuilt: []OsType{Android, BuildOs},
- },
-}
+ override_source {
+ name: "bar",
+ base: "baz",
+ }
-func TestPrebuilts(t *testing.T) {
+ prebuilt {
+ name: "bar",
+ prefer: true,
+ srcs: ["prebuilt_file"],
+ }`,
+ prebuilt: []OsType{Android, buildOS},
+ },
+ {
+ name: "prebuilt including default-disabled OS",
+ replaceBp: true,
+ modules: `
+ source {
+ name: "foo",
+ deps: [":bar"],
+ target: {
+ windows: {
+ enabled: true,
+ },
+ },
+ }
+
+ source {
+ name: "bar",
+ target: {
+ windows: {
+ enabled: true,
+ },
+ },
+ }
+
+ prebuilt {
+ name: "bar",
+ prefer: true,
+ srcs: ["prebuilt_file"],
+ target: {
+ windows: {
+ enabled: true,
+ },
+ },
+ }`,
+ prebuilt: []OsType{Android, buildOS, Windows},
+ },
+ {
+ name: "fall back to source for default-disabled OS",
+ replaceBp: true,
+ modules: `
+ source {
+ name: "foo",
+ deps: [":bar"],
+ target: {
+ windows: {
+ enabled: true,
+ },
+ },
+ }
+
+ source {
+ name: "bar",
+ target: {
+ windows: {
+ enabled: true,
+ },
+ },
+ }
+
+ prebuilt {
+ name: "bar",
+ prefer: true,
+ srcs: ["prebuilt_file"],
+ }`,
+ prebuilt: []OsType{Android, buildOS},
+ },
+ {
+ name: "prebuilt properties customizable",
+ replaceBp: true,
+ modules: `
+ source {
+ name: "foo",
+ deps: [":bar"],
+ }
+
+ soong_config_module_type {
+ name: "prebuilt_with_config",
+ module_type: "prebuilt",
+ config_namespace: "any_namespace",
+ bool_variables: ["bool_var"],
+ properties: ["prefer"],
+ }
+
+ prebuilt_with_config {
+ name: "bar",
+ prefer: true,
+ srcs: ["prebuilt_file"],
+ soong_config_variables: {
+ bool_var: {
+ prefer: false,
+ conditions_default: {
+ prefer: true,
+ },
+ },
+ },
+ }`,
+ prebuilt: []OsType{Android, buildOS},
+ },
+ {
+ name: "prebuilt use_source_config_var={acme, use_source} - no var specified",
+ modules: `
+ source {
+ name: "bar",
+ }
+
+ prebuilt {
+ name: "bar",
+ use_source_config_var: {config_namespace: "acme", var_name: "use_source"},
+ srcs: ["prebuilt_file"],
+ }`,
+ // When use_source_env is specified then it will use the prebuilt by default if the environment
+ // variable is not set.
+ prebuilt: []OsType{Android, buildOS},
+ },
+ {
+ name: "prebuilt use_source_config_var={acme, use_source} - acme_use_source=false",
+ modules: `
+ source {
+ name: "bar",
+ }
+
+ prebuilt {
+ name: "bar",
+ use_source_config_var: {config_namespace: "acme", var_name: "use_source"},
+ srcs: ["prebuilt_file"],
+ }`,
+ preparer: FixtureModifyProductVariables(func(variables FixtureProductVariables) {
+ variables.VendorVars = map[string]map[string]string{
+ "acme": {
+ "use_source": "false",
+ },
+ }
+ }),
+ // Setting the environment variable named in use_source_env to false will cause the prebuilt to
+ // be used.
+ prebuilt: []OsType{Android, buildOS},
+ },
+ {
+ name: "prebuilt use_source_config_var={acme, use_source} - acme_use_source=true",
+ modules: `
+ source {
+ name: "bar",
+ }
+
+ prebuilt {
+ name: "bar",
+ use_source_config_var: {config_namespace: "acme", var_name: "use_source"},
+ srcs: ["prebuilt_file"],
+ }`,
+ preparer: FixtureModifyProductVariables(func(variables FixtureProductVariables) {
+ variables.VendorVars = map[string]map[string]string{
+ "acme": {
+ "use_source": "true",
+ },
+ }
+ }),
+ // Setting the environment variable named in use_source_env to true will cause the source to be
+ // used.
+ prebuilt: nil,
+ },
+ {
+ name: "prebuilt use_source_config_var={acme, use_source} - acme_use_source=true, no source",
+ modules: `
+ prebuilt {
+ name: "bar",
+ use_source_config_var: {config_namespace: "acme", var_name: "use_source"},
+ srcs: ["prebuilt_file"],
+ }`,
+ preparer: FixtureModifyProductVariables(func(variables FixtureProductVariables) {
+ variables.VendorVars = map[string]map[string]string{
+ "acme": {
+ "use_source": "true",
+ },
+ }
+ }),
+ // Although the environment variable says to use source there is no source available.
+ prebuilt: []OsType{Android, buildOS},
+ },
+ }
+
fs := MockFS{
"prebuilt_file": nil,
"source_file": nil,
diff --git a/android/register.go b/android/register.go
index 4c8088d..5984862 100644
--- a/android/register.go
+++ b/android/register.go
@@ -180,7 +180,7 @@
bp2buildMutatorList = append(bp2buildMutatorList, f)
}
- RegisterMutatorsForBazelConversion(ctx, bp2buildPreArchMutators, bp2buildDepsMutators, bp2buildMutatorList)
+ RegisterMutatorsForBazelConversion(ctx, bp2buildPreArchMutators, bp2buildMutatorList)
}
// Register the pipeline of singletons, module types, and mutators for
diff --git a/android/sdk.go b/android/sdk.go
index e700031..da740f3 100644
--- a/android/sdk.go
+++ b/android/sdk.go
@@ -239,6 +239,12 @@
// to the zip
CopyToSnapshot(src Path, dest string)
+ // Return the path to an empty file.
+ //
+ // This can be used by sdk member types that need to create an empty file in the snapshot, simply
+ // pass the value returned from this to the CopyToSnapshot() method.
+ EmptyFile() Path
+
// Unzip the supplied zip into the snapshot relative directory destDir.
UnzipToSnapshot(zipPath Path, destDir string)
diff --git a/android/test_suites.go b/android/test_suites.go
index 6b7b909..22f6cf2 100644
--- a/android/test_suites.go
+++ b/android/test_suites.go
@@ -60,7 +60,7 @@
for _, module := range SortedStringKeys(files) {
installedPaths = append(installedPaths, files[module]...)
}
- testCasesDir := pathForInstall(ctx, BuildOs, X86, "testcases", false).ToMakePath()
+ testCasesDir := pathForInstall(ctx, ctx.Config().BuildOS, X86, "testcases", false).ToMakePath()
outputFile := PathForOutput(ctx, "packaging", "robolectric-tests.zip")
rule := NewRuleBuilder(pctx, ctx)
diff --git a/android/testing.go b/android/testing.go
index 17a812e..6ba8e3c 100644
--- a/android/testing.go
+++ b/android/testing.go
@@ -171,9 +171,9 @@
type TestContext struct {
*Context
- preArch, preDeps, postDeps, finalDeps []RegisterMutatorFunc
- bp2buildPreArch, bp2buildDeps, bp2buildMutators []RegisterMutatorFunc
- NameResolver *NameResolver
+ preArch, preDeps, postDeps, finalDeps []RegisterMutatorFunc
+ bp2buildPreArch, bp2buildMutators []RegisterMutatorFunc
+ NameResolver *NameResolver
// The list of pre-singletons and singletons registered for the test.
preSingletons, singletons sortableComponents
@@ -224,12 +224,6 @@
ctx.bp2buildPreArch = append(ctx.bp2buildPreArch, f)
}
-// DepsBp2BuildMutators adds mutators to be register for converting Android Blueprint modules into
-// Bazel BUILD targets that should run prior to conversion to resolve dependencies.
-func (ctx *TestContext) DepsBp2BuildMutators(f RegisterMutatorFunc) {
- ctx.bp2buildDeps = append(ctx.bp2buildDeps, f)
-}
-
// registeredComponentOrder defines the order in which a sortableComponent type is registered at
// runtime and provides support for reordering the components registered for a test in the same
// way.
@@ -464,7 +458,7 @@
// RegisterForBazelConversion prepares a test context for bp2build conversion.
func (ctx *TestContext) RegisterForBazelConversion() {
- RegisterMutatorsForBazelConversion(ctx.Context, ctx.bp2buildPreArch, ctx.bp2buildDeps, ctx.bp2buildMutators)
+ RegisterMutatorsForBazelConversion(ctx.Context, ctx.bp2buildPreArch, ctx.bp2buildMutators)
}
func (ctx *TestContext) ParseFileList(rootDir string, filePaths []string) (deps []string, errs []error) {
diff --git a/android/variable.go b/android/variable.go
index bbb9868..d0a23aa 100644
--- a/android/variable.go
+++ b/android/variable.go
@@ -299,8 +299,6 @@
Override_rs_driver *string `json:",omitempty"`
- Fuchsia *bool `json:",omitempty"`
-
DeviceKernelHeaders []string `json:",omitempty"`
ExtraVndkVersions []string `json:",omitempty"`
diff --git a/apex/apex.go b/apex/apex.go
index 11df288..d385ac1 100644
--- a/apex/apex.go
+++ b/apex/apex.go
@@ -2240,6 +2240,7 @@
android.InitDefaultableModule(module)
android.InitSdkAwareModule(module)
android.InitOverridableModule(module, &module.overridableProperties.Overrides)
+ android.InitBazelModule(module)
return module
}
diff --git a/apex/apex_test.go b/apex/apex_test.go
index 422e46c..d6c7142 100644
--- a/apex/apex_test.go
+++ b/apex/apex_test.go
@@ -4667,6 +4667,13 @@
prebuilt_bootclasspath_fragment {
name: "art-bootclasspath-fragment",
contents: ["core-oj"],
+ hidden_api: {
+ annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
+ metadata: "my-bootclasspath-fragment/metadata.csv",
+ index: "my-bootclasspath-fragment/index.csv",
+ stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
+ all_flags: "my-bootclasspath-fragment/all-flags.csv",
+ },
}
java_import {
@@ -4890,7 +4897,7 @@
}
}
- checkHiddenAPIIndexInputs := func(t *testing.T, ctx *android.TestContext, expectedIntermediateInputs string) {
+ checkHiddenAPIIndexFromClassesInputs := func(t *testing.T, ctx *android.TestContext, expectedIntermediateInputs string) {
t.Helper()
platformBootclasspath := ctx.ModuleForTests("platform-bootclasspath", "android_common")
var rule android.TestingBuildParams
@@ -4899,6 +4906,15 @@
java.CheckHiddenAPIRuleInputs(t, "intermediate index", expectedIntermediateInputs, rule)
}
+ checkHiddenAPIIndexFromFlagsInputs := func(t *testing.T, ctx *android.TestContext, expectedIntermediateInputs string) {
+ t.Helper()
+ platformBootclasspath := ctx.ModuleForTests("platform-bootclasspath", "android_common")
+ var rule android.TestingBuildParams
+
+ rule = platformBootclasspath.Output("hiddenapi-index.csv")
+ java.CheckHiddenAPIRuleInputs(t, "monolithic index", expectedIntermediateInputs, rule)
+ }
+
fragment := java.ApexVariantReference{
Apex: proptools.StringPtr("myapex"),
Module: proptools.StringPtr("my-bootclasspath-fragment"),
@@ -4923,6 +4939,13 @@
name: "my-bootclasspath-fragment",
contents: ["libfoo", "libbar"],
apex_available: ["myapex"],
+ hidden_api: {
+ annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
+ metadata: "my-bootclasspath-fragment/metadata.csv",
+ index: "my-bootclasspath-fragment/index.csv",
+ stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
+ all_flags: "my-bootclasspath-fragment/all-flags.csv",
+ },
}
java_import {
@@ -4946,9 +4969,10 @@
checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")
// Verify the correct module jars contribute to the hiddenapi index file.
- checkHiddenAPIIndexInputs(t, ctx, `
- out/soong/.intermediates/libbar.stubs/android_common/combined/libbar.stubs.jar
- out/soong/.intermediates/libfoo/android_common_myapex/combined/libfoo.jar
+ checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
+ checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
+ my-bootclasspath-fragment/index.csv
+ out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
`)
})
@@ -4964,6 +4988,13 @@
name: "my-bootclasspath-fragment",
contents: ["libfoo", "libbar"],
apex_available: ["myapex"],
+ hidden_api: {
+ annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
+ metadata: "my-bootclasspath-fragment/metadata.csv",
+ index: "my-bootclasspath-fragment/index.csv",
+ stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
+ all_flags: "my-bootclasspath-fragment/all-flags.csv",
+ },
}
java_import {
@@ -4987,9 +5018,10 @@
checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")
// Verify the correct module jars contribute to the hiddenapi index file.
- checkHiddenAPIIndexInputs(t, ctx, `
- out/soong/.intermediates/libbar.stubs/android_common/combined/libbar.stubs.jar
- out/soong/.intermediates/libfoo/android_common_myapex/combined/libfoo.jar
+ checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
+ checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
+ my-bootclasspath-fragment/index.csv
+ out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
`)
})
@@ -5012,6 +5044,13 @@
name: "my-bootclasspath-fragment",
contents: ["libfoo", "libbar"],
apex_available: ["myapex"],
+ hidden_api: {
+ annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
+ metadata: "my-bootclasspath-fragment/metadata.csv",
+ index: "my-bootclasspath-fragment/index.csv",
+ stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
+ all_flags: "my-bootclasspath-fragment/all-flags.csv",
+ },
}
java_import {
@@ -5070,6 +5109,13 @@
name: "my-bootclasspath-fragment",
contents: ["libfoo", "libbar"],
apex_available: ["myapex"],
+ hidden_api: {
+ annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
+ metadata: "my-bootclasspath-fragment/metadata.csv",
+ index: "my-bootclasspath-fragment/index.csv",
+ stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
+ all_flags: "my-bootclasspath-fragment/all-flags.csv",
+ },
}
java_import {
@@ -5108,9 +5154,10 @@
checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")
// Verify the correct module jars contribute to the hiddenapi index file.
- checkHiddenAPIIndexInputs(t, ctx, `
- out/soong/.intermediates/prebuilt_libbar.stubs/android_common/combined/libbar.stubs.jar
- out/soong/.intermediates/prebuilt_libfoo/android_common_myapex/combined/libfoo.jar
+ checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
+ checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
+ my-bootclasspath-fragment/index.csv
+ out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
`)
})
@@ -5146,6 +5193,13 @@
name: "my-bootclasspath-fragment",
contents: ["libfoo", "libbar"],
apex_available: ["myapex"],
+ hidden_api: {
+ annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
+ metadata: "my-bootclasspath-fragment/metadata.csv",
+ index: "my-bootclasspath-fragment/index.csv",
+ stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
+ all_flags: "my-bootclasspath-fragment/all-flags.csv",
+ },
}
java_import {
@@ -5182,9 +5236,10 @@
checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/libbar/android_common_myapex/hiddenapi/libbar.jar")
// Verify the correct module jars contribute to the hiddenapi index file.
- checkHiddenAPIIndexInputs(t, ctx, `
- out/soong/.intermediates/libbar/android_common_myapex/javac/libbar.jar
- out/soong/.intermediates/libfoo/android_common_apex10000/javac/libfoo.jar
+ checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
+ checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
+ my-bootclasspath-fragment/index.csv
+ out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
`)
})
@@ -5220,6 +5275,13 @@
name: "my-bootclasspath-fragment",
contents: ["libfoo", "libbar"],
apex_available: ["myapex"],
+ hidden_api: {
+ annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
+ metadata: "my-bootclasspath-fragment/metadata.csv",
+ index: "my-bootclasspath-fragment/index.csv",
+ stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
+ all_flags: "my-bootclasspath-fragment/all-flags.csv",
+ },
}
java_import {
@@ -5258,9 +5320,10 @@
checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")
// Verify the correct module jars contribute to the hiddenapi index file.
- checkHiddenAPIIndexInputs(t, ctx, `
- out/soong/.intermediates/prebuilt_libbar.stubs/android_common/combined/libbar.stubs.jar
- out/soong/.intermediates/prebuilt_libfoo/android_common_myapex/combined/libfoo.jar
+ checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
+ checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
+ my-bootclasspath-fragment/index.csv
+ out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
`)
})
}
@@ -7183,6 +7246,13 @@
name: "my-bootclasspath-fragment",
contents: ["libfoo"],
apex_available: ["myapex"],
+ hidden_api: {
+ annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
+ metadata: "my-bootclasspath-fragment/metadata.csv",
+ index: "my-bootclasspath-fragment/index.csv",
+ stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
+ all_flags: "my-bootclasspath-fragment/all-flags.csv",
+ },
}
java_import {
diff --git a/apex/bootclasspath_fragment_test.go b/apex/bootclasspath_fragment_test.go
index 4b1600e..5cd3eab 100644
--- a/apex/bootclasspath_fragment_test.go
+++ b/apex/bootclasspath_fragment_test.go
@@ -383,6 +383,13 @@
apex_available: [
"com.android.art",
],
+ hidden_api: {
+ annotation_flags: "mybootclasspathfragment/annotation-flags.csv",
+ metadata: "mybootclasspathfragment/metadata.csv",
+ index: "mybootclasspathfragment/index.csv",
+ stub_flags: "mybootclasspathfragment/stub-flags.csv",
+ all_flags: "mybootclasspathfragment/all-flags.csv",
+ },
}
`, contentsInsert(contents), prefer)
return android.FixtureAddTextFile("prebuilts/module_sdk/art/Android.bp", text)
@@ -582,6 +589,13 @@
apex_available: [
"com.android.art",
],
+ hidden_api: {
+ annotation_flags: "mybootclasspathfragment/annotation-flags.csv",
+ metadata: "mybootclasspathfragment/metadata.csv",
+ index: "mybootclasspathfragment/index.csv",
+ stub_flags: "mybootclasspathfragment/stub-flags.csv",
+ all_flags: "mybootclasspathfragment/all-flags.csv",
+ },
}
`)
diff --git a/apex/builder.go b/apex/builder.go
index 24c049b..148f42f 100644
--- a/apex/builder.go
+++ b/apex/builder.go
@@ -761,7 +761,7 @@
rule := java.Signapk
args := map[string]string{
"certificates": pem.String() + " " + key.String(),
- "flags": "-a 4096", //alignment
+ "flags": "-a 4096 --align-file-size", //alignment
}
implicits := android.Paths{pem, key}
if ctx.Config().UseRBE() && ctx.Config().IsEnvTrue("RBE_SIGNAPK") {
diff --git a/bazel/configurability.go b/bazel/configurability.go
index 282c606..3277bd0 100644
--- a/bazel/configurability.go
+++ b/bazel/configurability.go
@@ -29,7 +29,6 @@
// OsType names in arch.go
osAndroid = "android"
osDarwin = "darwin"
- osFuchsia = "fuchsia"
osLinux = "linux_glibc"
osLinuxBionic = "linux_bionic"
osWindows = "windows"
@@ -40,8 +39,6 @@
osArchAndroidX86 = "android_x86"
osArchAndroidX86_64 = "android_x86_64"
osArchDarwinX86_64 = "darwin_x86_64"
- osArchFuchsiaArm64 = "fuchsia_arm64"
- osArchFuchsiaX86_64 = "fuchsia_x86_64"
osArchLinuxX86 = "linux_glibc_x86"
osArchLinuxX86_64 = "linux_glibc_x86_64"
osArchLinuxBionicArm64 = "linux_bionic_arm64"
@@ -84,21 +81,23 @@
platformOsMap = map[string]string{
osAndroid: "//build/bazel/platforms/os:android",
osDarwin: "//build/bazel/platforms/os:darwin",
- osFuchsia: "//build/bazel/platforms/os:fuchsia",
osLinux: "//build/bazel/platforms/os:linux",
osLinuxBionic: "//build/bazel/platforms/os:linux_bionic",
osWindows: "//build/bazel/platforms/os:windows",
conditionsDefault: ConditionsDefaultSelectKey, // The default condition of an os select map.
}
+ platformBionicMap = map[string]string{
+ "bionic": "//build/bazel/platforms/os:bionic",
+ conditionsDefault: ConditionsDefaultSelectKey, // The default condition of an os select map.
+ }
+
platformOsArchMap = map[string]string{
osArchAndroidArm: "//build/bazel/platforms/os_arch:android_arm",
osArchAndroidArm64: "//build/bazel/platforms/os_arch:android_arm64",
osArchAndroidX86: "//build/bazel/platforms/os_arch:android_x86",
osArchAndroidX86_64: "//build/bazel/platforms/os_arch:android_x86_64",
osArchDarwinX86_64: "//build/bazel/platforms/os_arch:darwin_x86_64",
- osArchFuchsiaArm64: "//build/bazel/platforms/os_arch:fuchsia_arm64",
- osArchFuchsiaX86_64: "//build/bazel/platforms/os_arch:fuchsia_x86_64",
osArchLinuxX86: "//build/bazel/platforms/os_arch:linux_glibc_x86",
osArchLinuxX86_64: "//build/bazel/platforms/os_arch:linux_glibc_x86_64",
osArchLinuxBionicArm64: "//build/bazel/platforms/os_arch:linux_bionic_arm64",
@@ -117,6 +116,7 @@
arch
os
osArch
+ bionic
productVariables
)
@@ -126,6 +126,7 @@
arch: "arch",
os: "os",
osArch: "arch_os",
+ bionic: "bionic",
productVariables: "product_variables",
}[ct]
}
@@ -148,6 +149,10 @@
if _, ok := platformOsArchMap[config]; !ok {
panic(fmt.Errorf("Unknown os+arch: %s", config))
}
+ case bionic:
+ if _, ok := platformBionicMap[config]; !ok {
+ panic(fmt.Errorf("Unknown for %s: %s", ct.String(), config))
+ }
case productVariables:
// do nothing
default:
@@ -167,6 +172,8 @@
return platformOsMap[config]
case osArch:
return platformOsArchMap[config]
+ case bionic:
+ return platformBionicMap[config]
case productVariables:
if config == conditionsDefault {
return ConditionsDefaultSelectKey
@@ -186,6 +193,8 @@
OsConfigurationAxis = ConfigurationAxis{configurationType: os}
// An axis for arch+os-specific configurations
OsArchConfigurationAxis = ConfigurationAxis{configurationType: osArch}
+ // An axis for bionic os-specific configurations
+ BionicConfigurationAxis = ConfigurationAxis{configurationType: bionic}
)
// ProductVariableConfigurationAxis returns an axis for the given product variable
diff --git a/bazel/properties.go b/bazel/properties.go
index 7ecc92b..2656bad 100644
--- a/bazel/properties.go
+++ b/bazel/properties.go
@@ -321,7 +321,7 @@
switch axis.configurationType {
case noConfig:
la.Value = &value
- case arch, os, osArch, productVariables:
+ case arch, os, osArch, bionic, productVariables:
if la.ConfigurableValues == nil {
la.ConfigurableValues = make(configurableLabels)
}
@@ -337,7 +337,7 @@
switch axis.configurationType {
case noConfig:
return *la.Value
- case arch, os, osArch, productVariables:
+ case arch, os, osArch, bionic, productVariables:
return *la.ConfigurableValues[axis][config]
default:
panic(fmt.Errorf("Unrecognized ConfigurationAxis %s", axis))
@@ -394,7 +394,7 @@
switch axis.configurationType {
case noConfig:
ba.Value = value
- case arch, os, osArch, productVariables:
+ case arch, os, osArch, bionic, productVariables:
if ba.ConfigurableValues == nil {
ba.ConfigurableValues = make(configurableBools)
}
@@ -410,7 +410,7 @@
switch axis.configurationType {
case noConfig:
return ba.Value
- case arch, os, osArch, productVariables:
+ case arch, os, osArch, bionic, productVariables:
if v, ok := ba.ConfigurableValues[axis][config]; ok {
return &v
} else {
@@ -509,7 +509,7 @@
switch axis.configurationType {
case noConfig:
lla.Value = list
- case arch, os, osArch, productVariables:
+ case arch, os, osArch, bionic, productVariables:
if lla.ConfigurableValues == nil {
lla.ConfigurableValues = make(configurableLabelLists)
}
@@ -525,7 +525,7 @@
switch axis.configurationType {
case noConfig:
return lla.Value
- case arch, os, osArch, productVariables:
+ case arch, os, osArch, bionic, productVariables:
return lla.ConfigurableValues[axis][config]
default:
panic(fmt.Errorf("Unrecognized ConfigurationAxis %s", axis))
@@ -682,7 +682,7 @@
switch axis.configurationType {
case noConfig:
sla.Value = list
- case arch, os, osArch, productVariables:
+ case arch, os, osArch, bionic, productVariables:
if sla.ConfigurableValues == nil {
sla.ConfigurableValues = make(configurableStringLists)
}
@@ -698,7 +698,7 @@
switch axis.configurationType {
case noConfig:
return sla.Value
- case arch, os, osArch, productVariables:
+ case arch, os, osArch, bionic, productVariables:
return sla.ConfigurableValues[axis][config]
default:
panic(fmt.Errorf("Unrecognized ConfigurationAxis %s", axis))
diff --git a/bp2build/apex_conversion_test.go b/bp2build/apex_conversion_test.go
index fbf6fa2..f4a1016 100644
--- a/bp2build/apex_conversion_test.go
+++ b/bp2build/apex_conversion_test.go
@@ -46,3 +46,23 @@
manifest = "manifest.json",
)`}})
}
+
+func TestApexBundleHasBazelModuleProps(t *testing.T) {
+ runApexTestCase(t, bp2buildTestCase{
+ description: "apex - has bazel module props",
+ moduleTypeUnderTest: "apex",
+ moduleTypeUnderTestFactory: apex.BundleFactory,
+ moduleTypeUnderTestBp2BuildMutator: apex.ApexBundleBp2Build,
+ filesystem: map[string]string{},
+ blueprint: `
+apex {
+ name: "apogee",
+ manifest: "manifest.json",
+ bazel_module: { bp2build_available: true },
+}
+`,
+ expectedBazelTargets: []string{`apex(
+ name = "apogee",
+ manifest = "manifest.json",
+)`}})
+}
diff --git a/bp2build/build_conversion_test.go b/bp2build/build_conversion_test.go
index 0e52f2a..e5dbda6 100644
--- a/bp2build/build_conversion_test.go
+++ b/bp2build/build_conversion_test.go
@@ -556,7 +556,6 @@
moduleTypeUnderTestFactory android.ModuleFactory
moduleTypeUnderTestBp2BuildMutator func(android.TopDownMutatorContext)
preArchMutators []android.RegisterMutatorFunc
- depsMutators []android.RegisterMutatorFunc
bp string
expectedBazelTargets []string
fs map[string]string
@@ -720,7 +719,6 @@
moduleTypeUnderTest: "genrule",
moduleTypeUnderTestFactory: genrule.GenRuleFactory,
moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build,
- depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps},
bp: `genrule {
name: "foo.tool",
out: ["foo_tool.out"],
@@ -758,7 +756,6 @@
moduleTypeUnderTest: "genrule",
moduleTypeUnderTestFactory: genrule.GenRuleFactory,
moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build,
- depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps},
bp: `genrule {
name: "foo.tools",
out: ["foo_tool.out", "foo_tool2.out"],
@@ -798,7 +795,6 @@
moduleTypeUnderTest: "genrule",
moduleTypeUnderTestFactory: genrule.GenRuleFactory,
moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build,
- depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps},
bp: `genrule {
name: "foo",
out: ["foo.out"],
@@ -822,7 +818,6 @@
moduleTypeUnderTest: "genrule",
moduleTypeUnderTestFactory: genrule.GenRuleFactory,
moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build,
- depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps},
bp: `genrule {
name: "foo",
out: ["foo.out"],
@@ -846,7 +841,6 @@
moduleTypeUnderTest: "genrule",
moduleTypeUnderTestFactory: genrule.GenRuleFactory,
moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build,
- depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps},
bp: `genrule {
name: "foo",
out: ["foo.out"],
@@ -873,7 +867,6 @@
moduleTypeUnderTest: "genrule",
moduleTypeUnderTestFactory: genrule.GenRuleFactory,
moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build,
- depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps},
bp: `genrule {
name: "foo",
out: ["foo.out"],
@@ -900,7 +893,6 @@
moduleTypeUnderTest: "genrule",
moduleTypeUnderTestFactory: genrule.GenRuleFactory,
moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build,
- depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps},
bp: `genrule {
name: "foo",
out: ["foo.out"],
@@ -933,9 +925,6 @@
config := android.TestConfig(buildDir, nil, testCase.bp, fs)
ctx := android.NewTestContext(config)
ctx.RegisterModuleType(testCase.moduleTypeUnderTest, testCase.moduleTypeUnderTestFactory)
- for _, m := range testCase.depsMutators {
- ctx.DepsBp2BuildMutators(m)
- }
ctx.RegisterBp2BuildMutator(testCase.moduleTypeUnderTest, testCase.moduleTypeUnderTestBp2BuildMutator)
ctx.RegisterForBazelConversion()
@@ -1370,7 +1359,6 @@
moduleTypeUnderTestFactory android.ModuleFactory
moduleTypeUnderTestBp2BuildMutator func(android.TopDownMutatorContext)
preArchMutators []android.RegisterMutatorFunc
- depsMutators []android.RegisterMutatorFunc
bp string
expectedBazelTargets []string
fs map[string]string
@@ -1487,9 +1475,6 @@
config := android.TestConfig(buildDir, nil, testCase.bp, fs)
ctx := android.NewTestContext(config)
ctx.RegisterModuleType(testCase.moduleTypeUnderTest, testCase.moduleTypeUnderTestFactory)
- for _, m := range testCase.depsMutators {
- ctx.DepsBp2BuildMutators(m)
- }
ctx.RegisterBp2BuildMutator(testCase.moduleTypeUnderTest, testCase.moduleTypeUnderTestBp2BuildMutator)
ctx.RegisterForBazelConversion()
diff --git a/bp2build/cc_library_conversion_test.go b/bp2build/cc_library_conversion_test.go
index 4f720f5..8dcba55 100644
--- a/bp2build/cc_library_conversion_test.go
+++ b/bp2build/cc_library_conversion_test.go
@@ -73,9 +73,6 @@
registerModuleTypes(ctx)
ctx.RegisterModuleType(tc.moduleTypeUnderTest, tc.moduleTypeUnderTestFactory)
ctx.RegisterBp2BuildConfig(bp2buildConfig)
- for _, m := range tc.depsMutators {
- ctx.DepsBp2BuildMutators(m)
- }
ctx.RegisterBp2BuildMutator(tc.moduleTypeUnderTest, tc.moduleTypeUnderTestBp2BuildMutator)
ctx.RegisterForBazelConversion()
@@ -118,6 +115,7 @@
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
filesystem: map[string]string{
"android.cpp": "",
+ "bionic.cpp": "",
"darwin.cpp": "",
// Refer to cc.headerExts for the supported header extensions in Soong.
"header.h": "",
@@ -164,6 +162,9 @@
darwin: {
srcs: ["darwin.cpp"],
},
+ bionic: {
+ srcs: ["bionic.cpp"]
+ },
},
}
`,
@@ -190,6 +191,9 @@
"//build/bazel/platforms/os:darwin": ["darwin.cpp"],
"//build/bazel/platforms/os:linux": ["linux.cpp"],
"//conditions:default": [],
+ }) + select({
+ "//build/bazel/platforms/os:bionic": ["bionic.cpp"],
+ "//conditions:default": [],
}),
)`}})
}
@@ -326,7 +330,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/both.cpp": "",
@@ -411,7 +414,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `
@@ -458,7 +460,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/arm.cpp": "",
@@ -597,7 +598,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/both_source.cpp": "",
@@ -738,7 +738,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `
@@ -769,7 +768,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `
@@ -812,7 +810,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `
@@ -852,7 +849,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `
@@ -926,7 +922,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `
@@ -956,7 +951,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `cc_library {
@@ -1012,7 +1006,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `
@@ -1054,7 +1047,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryStaticPreamble + `
cc_library {
@@ -1301,7 +1293,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `
@@ -1408,7 +1399,6 @@
moduleTypeUnderTest: "cc_library",
moduleTypeUnderTestFactory: cc.LibraryFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
dir: "foo/bar",
filesystem: map[string]string{
"foo/bar/Android.bp": `
diff --git a/bp2build/cc_library_headers_conversion_test.go b/bp2build/cc_library_headers_conversion_test.go
index db344de..712d0bd 100644
--- a/bp2build/cc_library_headers_conversion_test.go
+++ b/bp2build/cc_library_headers_conversion_test.go
@@ -45,7 +45,6 @@
moduleTypeUnderTest string
moduleTypeUnderTestFactory android.ModuleFactory
moduleTypeUnderTestBp2BuildMutator func(android.TopDownMutatorContext)
- depsMutators []android.RegisterMutatorFunc
blueprint string
expectedBazelTargets []string
filesystem map[string]string
@@ -181,13 +180,11 @@
moduleTypeUnderTest: "cc_library_headers",
moduleTypeUnderTestFactory: cc.LibraryHeaderFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryHeadersBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryPreamble + `
cc_library_headers { name: "android-lib" }
cc_library_headers { name: "base-lib" }
cc_library_headers { name: "darwin-lib" }
-cc_library_headers { name: "fuchsia-lib" }
cc_library_headers { name: "linux-lib" }
cc_library_headers { name: "linux_bionic-lib" }
cc_library_headers { name: "windows-lib" }
@@ -197,7 +194,6 @@
target: {
android: { header_libs: ["android-lib"] },
darwin: { header_libs: ["darwin-lib"] },
- fuchsia: { header_libs: ["fuchsia-lib"] },
linux_bionic: { header_libs: ["linux_bionic-lib"] },
linux_glibc: { header_libs: ["linux-lib"] },
windows: { header_libs: ["windows-lib"] },
@@ -231,19 +227,12 @@
implementation_deps = [":base-lib"] + select({
"//build/bazel/platforms/os:android": [":android-lib"],
"//build/bazel/platforms/os:darwin": [":darwin-lib"],
- "//build/bazel/platforms/os:fuchsia": [":fuchsia-lib"],
"//build/bazel/platforms/os:linux": [":linux-lib"],
"//build/bazel/platforms/os:linux_bionic": [":linux_bionic-lib"],
"//build/bazel/platforms/os:windows": [":windows-lib"],
"//conditions:default": [],
}),
)`, `cc_library_headers(
- name = "fuchsia-lib",
- copts = [
- "-I.",
- "-I$(BINDIR)/.",
- ],
-)`, `cc_library_headers(
name = "linux-lib",
copts = [
"-I.",
@@ -271,7 +260,6 @@
moduleTypeUnderTest: "cc_library_headers",
moduleTypeUnderTestFactory: cc.LibraryHeaderFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryHeadersBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryPreamble + `
cc_library_headers { name: "android-lib" }
@@ -318,7 +306,6 @@
moduleTypeUnderTest: "cc_library_headers",
moduleTypeUnderTestFactory: cc.LibraryHeaderFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryHeadersBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryPreamble + `cc_library_headers {
name: "foo_headers",
diff --git a/bp2build/cc_library_static_conversion_test.go b/bp2build/cc_library_static_conversion_test.go
index c33889f..1dc6713 100644
--- a/bp2build/cc_library_static_conversion_test.go
+++ b/bp2build/cc_library_static_conversion_test.go
@@ -469,7 +469,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryStaticPreamble + `
cc_library_static { name: "static_dep" }
@@ -517,7 +516,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryStaticPreamble + `
cc_library_static { name: "static_dep" }
@@ -565,7 +563,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryStaticPreamble + `
cc_library_static { name: "static_dep" }
@@ -632,7 +629,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.c": "",
"foo-a.c": "",
@@ -665,7 +661,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.c": "",
"foo-arm.c": "",
@@ -697,7 +692,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.c": "",
"for-arm.c": "",
@@ -734,7 +728,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.c": "",
"for-arm.c": "",
@@ -782,7 +775,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.c": "",
"for-arm.c": "",
@@ -856,7 +848,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.cc": "",
"foo-no-arm.cc": "",
@@ -892,7 +883,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.cc": "",
"foo-no-arm.cc": "",
@@ -934,7 +924,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryStaticPreamble + `
cc_library_static { name: "static_dep" }
@@ -967,7 +956,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.c": "",
"for-lib32.c": "",
@@ -1003,7 +991,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.c": "",
"for-lib32.c": "",
@@ -1059,7 +1046,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.c": "",
"for-arm.c": "",
@@ -1151,7 +1137,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{
"common.cpp": "",
"for-x86.cpp": "",
@@ -1243,7 +1228,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
blueprint: soongCcLibraryStaticPreamble + `
cc_library_static {
name: "foo_static",
@@ -1300,8 +1284,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
- filesystem: map[string]string{},
blueprint: soongCcLibraryStaticPreamble + `
cc_library_static {
name: "foo_static",
@@ -1345,7 +1327,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryStaticPreamble + `
cc_library_static {
@@ -1417,7 +1398,6 @@
moduleTypeUnderTest: "cc_library_static",
moduleTypeUnderTestFactory: cc.LibraryStaticFactory,
moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build,
- depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build},
filesystem: map[string]string{},
blueprint: soongCcLibraryStaticPreamble + `
cc_library_static {
diff --git a/cc/Android.bp b/cc/Android.bp
index 46740dc..164d32b 100644
--- a/cc/Android.bp
+++ b/cc/Android.bp
@@ -14,6 +14,7 @@
"soong-cc-config",
"soong-etc",
"soong-genrule",
+ "soong-snapshot",
"soong-tradefed",
],
srcs: [
@@ -58,6 +59,7 @@
"binary.go",
"binary_sdk_member.go",
"fuzz.go",
+ "fuzz_common.go",
"library.go",
"library_headers.go",
"library_sdk_member.go",
diff --git a/cc/androidmk.go b/cc/androidmk.go
index e58d166..bda1006 100644
--- a/cc/androidmk.go
+++ b/cc/androidmk.go
@@ -401,24 +401,24 @@
ctx.subAndroidMk(entries, fuzz.binaryDecorator)
var fuzzFiles []string
- for _, d := range fuzz.corpus {
+ for _, d := range fuzz.fuzzPackagedModule.Corpus {
fuzzFiles = append(fuzzFiles,
- filepath.Dir(fuzz.corpusIntermediateDir.String())+":corpus/"+d.Base())
+ filepath.Dir(fuzz.fuzzPackagedModule.CorpusIntermediateDir.String())+":corpus/"+d.Base())
}
- for _, d := range fuzz.data {
+ for _, d := range fuzz.fuzzPackagedModule.Data {
fuzzFiles = append(fuzzFiles,
- filepath.Dir(fuzz.dataIntermediateDir.String())+":data/"+d.Rel())
+ filepath.Dir(fuzz.fuzzPackagedModule.DataIntermediateDir.String())+":data/"+d.Rel())
}
- if fuzz.dictionary != nil {
+ if fuzz.fuzzPackagedModule.Dictionary != nil {
fuzzFiles = append(fuzzFiles,
- filepath.Dir(fuzz.dictionary.String())+":"+fuzz.dictionary.Base())
+ filepath.Dir(fuzz.fuzzPackagedModule.Dictionary.String())+":"+fuzz.fuzzPackagedModule.Dictionary.Base())
}
- if fuzz.config != nil {
+ if fuzz.fuzzPackagedModule.Config != nil {
fuzzFiles = append(fuzzFiles,
- filepath.Dir(fuzz.config.String())+":config.json")
+ filepath.Dir(fuzz.fuzzPackagedModule.Config.String())+":config.json")
}
entries.ExtraEntries = append(entries.ExtraEntries, func(ctx android.AndroidMkExtraEntriesContext, entries *android.AndroidMkEntries) {
diff --git a/cc/binary.go b/cc/binary.go
index c177a08..c6d61ab 100644
--- a/cc/binary.go
+++ b/cc/binary.go
@@ -215,7 +215,7 @@
if binary.Properties.Static_executable == nil && ctx.Config().HostStaticBinaries() {
binary.Properties.Static_executable = BoolPtr(true)
}
- } else if !ctx.Fuchsia() {
+ } else {
// Static executables are not supported on Darwin or Windows
binary.Properties.Static_executable = nil
}
diff --git a/cc/bp2build.go b/cc/bp2build.go
index 536f112..68afd0d 100644
--- a/cc/bp2build.go
+++ b/cc/bp2build.go
@@ -24,124 +24,6 @@
"github.com/google/blueprint/proptools"
)
-// bp2build functions and helpers for converting cc_* modules to Bazel.
-
-func init() {
- android.DepsBp2BuildMutators(RegisterDepsBp2Build)
-}
-
-func RegisterDepsBp2Build(ctx android.RegisterMutatorsContext) {
- ctx.BottomUp("cc_bp2build_deps", depsBp2BuildMutator)
-}
-
-// A naive deps mutator to add deps on all modules across all combinations of
-// target props for cc modules. This is needed to make module -> bazel label
-// resolution work in the bp2build mutator later. This is probably
-// the wrong way to do it, but it works.
-//
-// TODO(jingwen): can we create a custom os mutator in depsBp2BuildMutator to do this?
-func depsBp2BuildMutator(ctx android.BottomUpMutatorContext) {
- module, ok := ctx.Module().(*Module)
- if !ok {
- // Not a cc module
- return
- }
-
- if !module.ConvertWithBp2build(ctx) {
- return
- }
-
- var allDeps []string
-
- for _, configToProps := range module.GetArchVariantProperties(ctx, &BaseCompilerProperties{}) {
- for _, props := range configToProps {
- if baseCompilerProps, ok := props.(*BaseCompilerProperties); ok {
- allDeps = append(allDeps, baseCompilerProps.Generated_headers...)
- allDeps = append(allDeps, baseCompilerProps.Generated_sources...)
- }
- }
- }
-
- for _, configToProps := range module.GetArchVariantProperties(ctx, &BaseLinkerProperties{}) {
- for _, props := range configToProps {
- if baseLinkerProps, ok := props.(*BaseLinkerProperties); ok {
- allDeps = append(allDeps, baseLinkerProps.Header_libs...)
- allDeps = append(allDeps, baseLinkerProps.Export_header_lib_headers...)
- allDeps = append(allDeps, baseLinkerProps.Static_libs...)
- allDeps = append(allDeps, baseLinkerProps.Exclude_static_libs...)
- allDeps = append(allDeps, baseLinkerProps.Whole_static_libs...)
- allDeps = append(allDeps, baseLinkerProps.Shared_libs...)
- allDeps = append(allDeps, baseLinkerProps.Exclude_shared_libs...)
- }
- }
- }
-
- // Deps in the static: { .. } and shared: { .. } props of a cc_library.
- if lib, ok := module.compiler.(*libraryDecorator); ok {
- appendDeps := func(deps []string, p StaticOrSharedProperties) []string {
- deps = append(deps, p.Static_libs...)
- deps = append(deps, p.Whole_static_libs...)
- deps = append(deps, p.Shared_libs...)
- return deps
- }
-
- allDeps = appendDeps(allDeps, lib.SharedProperties.Shared)
- allDeps = appendDeps(allDeps, lib.StaticProperties.Static)
-
- // TODO(b/186024507, b/186489250): Temporarily exclude adding
- // system_shared_libs deps until libc and libm builds.
- if lib.static() {
- allDeps = append(allDeps, lib.StaticProperties.Static.System_shared_libs...)
- } else if lib.shared() {
- allDeps = append(allDeps, lib.SharedProperties.Shared.System_shared_libs...)
- }
-
- // Deps in the target/arch nested static: { .. } and shared: { .. } props of a cc_library.
- // target: { <target>: shared: { ... } }
- for _, configToProps := range module.GetArchVariantProperties(ctx, &SharedProperties{}) {
- for _, props := range configToProps {
- if p, ok := props.(*SharedProperties); ok {
- allDeps = appendDeps(allDeps, p.Shared)
- }
- }
- }
-
- for _, configToProps := range module.GetArchVariantProperties(ctx, &StaticProperties{}) {
- for _, props := range configToProps {
- if p, ok := props.(*StaticProperties); ok {
- allDeps = appendDeps(allDeps, p.Static)
- }
- }
- }
- }
-
- // product variables only support a limited set of fields, this is the full list of field names
- // related to cc module dependency management that are supported.
- productVariableDepFields := [4]string{
- "Shared_libs",
- "Static_libs",
- "Exclude_static_libs",
- "Whole_static_libs",
- }
-
- productVariableProps := android.ProductVariableProperties(ctx)
- for _, name := range productVariableDepFields {
- props, exists := productVariableProps[name]
- if !exists {
- continue
- }
- for _, prop := range props {
- if p, ok := prop.Property.([]string); !ok {
- ctx.ModuleErrorf("Could not convert product variable %s property", name)
- } else {
- allDeps = append(allDeps, p...)
- }
- }
- }
-
- ctx.AddDependency(module, nil, android.SortedUniqueStrings(allDeps)...)
-}
-
// staticOrSharedAttributes are the Bazel-ified versions of StaticOrSharedProperties --
// properties which apply to either the shared or static version of a cc_library module.
type staticOrSharedAttributes struct {
@@ -185,30 +67,33 @@
// Convert the filegroup dependencies into the extension-specific filegroups
// filtered in the filegroup.bzl macro.
cppFilegroup := func(label string) string {
- ctx.VisitDirectDeps(func(m android.Module) {
- if isFilegroupNamed(m, label) {
+ m, exists := ctx.ModuleFromName(label)
+ if exists {
+ aModule, _ := m.(android.Module)
+ if isFilegroupNamed(aModule, label) {
label = label + "_cpp_srcs"
- return
}
- })
+ }
return label
}
cFilegroup := func(label string) string {
- ctx.VisitDirectDeps(func(m android.Module) {
- if isFilegroupNamed(m, label) {
+ m, exists := ctx.ModuleFromName(label)
+ if exists {
+ aModule, _ := m.(android.Module)
+ if isFilegroupNamed(aModule, label) {
label = label + "_c_srcs"
- return
}
- })
+ }
return label
}
asFilegroup := func(label string) string {
- ctx.VisitDirectDeps(func(m android.Module) {
- if isFilegroupNamed(m, label) {
+ m, exists := ctx.ModuleFromName(label)
+ if exists {
+ aModule, _ := m.(android.Module)
+ if isFilegroupNamed(aModule, label) {
label = label + "_as_srcs"
- return
}
- })
+ }
return label
}
diff --git a/cc/builder.go b/cc/builder.go
index b0842ec..842ce85 100644
--- a/cc/builder.go
+++ b/cc/builder.go
@@ -237,7 +237,7 @@
// -w has been added since header-abi-dumper does not need to produce any sort of diagnostic information.
sAbiDump, sAbiDumpRE = pctx.RemoteStaticRules("sAbiDump",
blueprint.RuleParams{
- Command: "rm -f $out && $reTemplate$sAbiDumper -o ${out} $in $exportDirs -- $cFlags -w -isystem prebuilts/clang-tools/${config.HostPrebuiltTag}/clang-headers",
+ Command: "rm -f $out && $reTemplate$sAbiDumper --root-dir . --root-dir $$OUT_DIR:out -o ${out} $in $exportDirs -- $cFlags -w -isystem prebuilts/clang-tools/${config.HostPrebuiltTag}/clang-headers",
CommandDeps: []string{"$sAbiDumper"},
}, &remoteexec.REParams{
Labels: map[string]string{"type": "abi-dump", "tool": "header-abi-dumper"},
@@ -255,7 +255,7 @@
// sAbi dump file.
sAbiLink, sAbiLinkRE = pctx.RemoteStaticRules("sAbiLink",
blueprint.RuleParams{
- Command: "$reTemplate$sAbiLinker -o ${out} $symbolFilter -arch $arch $exportedHeaderFlags @${out}.rsp ",
+ Command: "$reTemplate$sAbiLinker --root-dir . --root-dir $$OUT_DIR:out -o ${out} $symbolFilter -arch $arch $exportedHeaderFlags @${out}.rsp",
CommandDeps: []string{"$sAbiLinker"},
Rspfile: "${out}.rsp",
RspfileContent: "${in}",
diff --git a/cc/cc.go b/cc/cc.go
index aeebaef..e3ca4d7 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -756,14 +756,13 @@
// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
// installer logic.
type Module struct {
- android.ModuleBase
- android.DefaultableModuleBase
- android.ApexModuleBase
+ FuzzModule
+
android.SdkBase
android.BazelModuleBase
- Properties BaseProperties
VendorProperties VendorProperties
+ Properties BaseProperties
// initialize before calling Init
hod android.HostOrDeviceSupported
diff --git a/cc/cc_test.go b/cc/cc_test.go
index 0a3acb9..dd51fe8 100644
--- a/cc/cc_test.go
+++ b/cc/cc_test.go
@@ -152,71 +152,6 @@
).RunTest(t)
}
-func TestFuchsiaDeps(t *testing.T) {
- t.Helper()
-
- bp := `
- cc_library {
- name: "libTest",
- srcs: ["foo.c"],
- target: {
- fuchsia: {
- srcs: ["bar.c"],
- },
- },
- }`
-
- result := android.GroupFixturePreparers(
- prepareForCcTest,
- PrepareForTestOnFuchsia,
- ).RunTestWithBp(t, bp)
-
- rt := false
- fb := false
-
- ld := result.ModuleForTests("libTest", "fuchsia_arm64_shared").Rule("ld")
- implicits := ld.Implicits
- for _, lib := range implicits {
- if strings.Contains(lib.Rel(), "libcompiler_rt") {
- rt = true
- }
-
- if strings.Contains(lib.Rel(), "libbioniccompat") {
- fb = true
- }
- }
-
- if !rt || !fb {
- t.Errorf("fuchsia libs must link libcompiler_rt and libbioniccompat")
- }
-}
-
-func TestFuchsiaTargetDecl(t *testing.T) {
- t.Helper()
-
- bp := `
- cc_library {
- name: "libTest",
- srcs: ["foo.c"],
- target: {
- fuchsia: {
- srcs: ["bar.c"],
- },
- },
- }`
-
- result := android.GroupFixturePreparers(
- prepareForCcTest,
- PrepareForTestOnFuchsia,
- ).RunTestWithBp(t, bp)
- ld := result.ModuleForTests("libTest", "fuchsia_arm64_shared").Rule("ld")
- var objs []string
- for _, o := range ld.Inputs {
- objs = append(objs, o.Base())
- }
- android.AssertArrayString(t, "libTest inputs", []string{"foo.o", "bar.o"}, objs)
-}
-
func TestVendorSrc(t *testing.T) {
ctx := testCc(t, `
cc_library {
diff --git a/cc/config/Android.bp b/cc/config/Android.bp
index c1d4f17..3e8ee48 100644
--- a/cc/config/Android.bp
+++ b/cc/config/Android.bp
@@ -21,10 +21,8 @@
"arm_device.go",
"arm64_device.go",
- "arm64_fuchsia_device.go",
"x86_device.go",
"x86_64_device.go",
- "x86_64_fuchsia_device.go",
"x86_darwin_host.go",
"x86_linux_host.go",
diff --git a/cc/config/arm64_fuchsia_device.go b/cc/config/arm64_fuchsia_device.go
deleted file mode 100644
index 5ab27a0..0000000
--- a/cc/config/arm64_fuchsia_device.go
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2018 Google Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package config
-
-import (
- "android/soong/android"
-)
-
-var fuchsiaArm64SysRoot string = "prebuilts/fuchsia_sdk/arch/arm64/sysroot"
-var fuchsiaArm64PrebuiltLibsRoot string = "fuchsia/prebuilt_libs/"
-
-type toolchainFuchsiaArm64 struct {
- toolchain64Bit
- toolchainFuchsia
-}
-
-func (t *toolchainFuchsiaArm64) Name() string {
- return "arm64"
-}
-
-func (t *toolchainFuchsiaArm64) GccRoot() string {
- return "${config.Arm64GccRoot}"
-}
-
-func (t *toolchainFuchsiaArm64) GccTriple() string {
- return "aarch64-linux-android"
-}
-
-func (t *toolchainFuchsiaArm64) GccVersion() string {
- return arm64GccVersion
-}
-
-func (t *toolchainFuchsiaArm64) IncludeFlags() string {
- return ""
-}
-
-func (t *toolchainFuchsiaArm64) ClangTriple() string {
- return "arm64-fuchsia-android"
-}
-
-func (t *toolchainFuchsiaArm64) Cppflags() string {
- return "-Wno-error=deprecated-declarations"
-}
-
-func (t *toolchainFuchsiaArm64) Ldflags() string {
- return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/"
-}
-
-func (t *toolchainFuchsiaArm64) Lldflags() string {
- return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/"
-}
-
-func (t *toolchainFuchsiaArm64) Cflags() string {
- return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -I" + fuchsiaArm64SysRoot + "/include"
-}
-
-func (t *toolchainFuchsiaArm64) ToolchainCflags() string {
- return "-march=armv8-a"
-}
-
-var toolchainArm64FuchsiaSingleton Toolchain = &toolchainFuchsiaArm64{}
-
-func arm64FuchsiaToolchainFactory(arch android.Arch) Toolchain {
- return toolchainArm64FuchsiaSingleton
-}
-
-func init() {
- registerToolchainFactory(android.Fuchsia, android.Arm64, arm64FuchsiaToolchainFactory)
-}
diff --git a/cc/config/clang.go b/cc/config/clang.go
index 9cfe28f..53a7306 100644
--- a/cc/config/clang.go
+++ b/cc/config/clang.go
@@ -92,64 +92,6 @@
"readability-function-cognitive-complexity", // http://b/175055536
}
-func init() {
- exportStringListStaticVariable("ClangExtraCflags", []string{
- "-D__compiler_offsetof=__builtin_offsetof",
-
- // Emit address-significance table which allows linker to perform safe ICF. Clang does
- // not emit the table by default on Android since NDK still uses GNU binutils.
- "-faddrsig",
-
- // Turn on -fcommon explicitly, since Clang now defaults to -fno-common. The cleanup bug
- // tracking this is http://b/151457797.
- "-fcommon",
-
- // Help catch common 32/64-bit errors.
- "-Werror=int-conversion",
-
- // Enable the new pass manager.
- "-fexperimental-new-pass-manager",
-
- // Disable overly aggressive warning for macros defined with a leading underscore
- // This happens in AndroidConfig.h, which is included nearly everywhere.
- // TODO: can we remove this now?
- "-Wno-reserved-id-macro",
-
- // Workaround for ccache with clang.
- // See http://petereisentraut.blogspot.com/2011/05/ccache-and-clang.html.
- "-Wno-unused-command-line-argument",
-
- // Force clang to always output color diagnostics. Ninja will strip the ANSI
- // color codes if it is not running in a terminal.
- "-fcolor-diagnostics",
-
- // Warnings from clang-7.0
- "-Wno-sign-compare",
-
- // Warnings from clang-8.0
- "-Wno-defaulted-function-deleted",
-
- // Disable -Winconsistent-missing-override until we can clean up the existing
- // codebase for it.
- "-Wno-inconsistent-missing-override",
-
- // Warnings from clang-10
- // Nested and array designated initialization is nice to have.
- "-Wno-c99-designator",
-
- // Warnings from clang-12
- "-Wno-gnu-folding-constant",
-
- // Calls to the APIs that are newer than the min sdk version of the caller should be
- // guarded with __builtin_available.
- "-Wunguarded-availability",
- // This macro allows the bionic versioning.h to indirectly determine whether the
- // option -Wunguarded-availability is on or not.
- "-D__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__",
- })
-
-}
-
func ClangFilterUnknownCflags(cflags []string) []string {
result, _ := android.FilterList(cflags, ClangUnknownCflags)
return result
diff --git a/cc/config/global.go b/cc/config/global.go
index bcee06a..55e0d79 100644
--- a/cc/config/global.go
+++ b/cc/config/global.go
@@ -15,6 +15,7 @@
package config
import (
+ "runtime"
"strings"
"android/soong/android"
@@ -55,6 +56,59 @@
"-Werror=pragma-pack-suspicious-include",
"-Werror=string-plus-int",
"-Werror=unreachable-code-loop-increment",
+
+ "-D__compiler_offsetof=__builtin_offsetof",
+
+ // Emit address-significance table which allows linker to perform safe ICF. Clang does
+ // not emit the table by default on Android since NDK still uses GNU binutils.
+ "-faddrsig",
+
+ // Turn on -fcommon explicitly, since Clang now defaults to -fno-common. The cleanup bug
+ // tracking this is http://b/151457797.
+ "-fcommon",
+
+ // Help catch common 32/64-bit errors.
+ "-Werror=int-conversion",
+
+ // Enable the new pass manager.
+ "-fexperimental-new-pass-manager",
+
+ // Disable overly aggressive warning for macros defined with a leading underscore
+ // This happens in AndroidConfig.h, which is included nearly everywhere.
+ // TODO: can we remove this now?
+ "-Wno-reserved-id-macro",
+
+ // Workaround for ccache with clang.
+ // See http://petereisentraut.blogspot.com/2011/05/ccache-and-clang.html.
+ "-Wno-unused-command-line-argument",
+
+ // Force clang to always output color diagnostics. Ninja will strip the ANSI
+ // color codes if it is not running in a terminal.
+ "-fcolor-diagnostics",
+
+ // Warnings from clang-7.0
+ "-Wno-sign-compare",
+
+ // Warnings from clang-8.0
+ "-Wno-defaulted-function-deleted",
+
+ // Disable -Winconsistent-missing-override until we can clean up the existing
+ // codebase for it.
+ "-Wno-inconsistent-missing-override",
+
+ // Warnings from clang-10
+ // Nested and array designated initialization is nice to have.
+ "-Wno-c99-designator",
+
+ // Warnings from clang-12
+ "-Wno-gnu-folding-constant",
+
+ // Calls to the APIs that are newer than the min sdk version of the caller should be
+ // guarded with __builtin_available.
+ "-Wunguarded-availability",
+ // This macro allows the bionic versioning.h to indirectly determine whether the
+ // option -Wunguarded-availability is on or not.
+ "-D__ANDROID_UNAVAILABLE_SYMBOLS_ARE_WEAK__",
}
commonGlobalConlyflags = []string{}
@@ -229,7 +283,7 @@
var pctx = android.NewPackageContext("android/soong/cc/config")
func init() {
- if android.BuildOs == android.Linux {
+ if runtime.GOOS == "linux" {
commonGlobalCflags = append(commonGlobalCflags, "-fdebug-prefix-map=/proc/self/cwd=")
}
@@ -246,7 +300,6 @@
bazelCommonGlobalCflags := append(
commonGlobalCflags,
[]string{
- "${ClangExtraCflags}",
// Default to zero initialization.
"-ftrivial-auto-var-init=zero",
"-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang",
@@ -255,7 +308,6 @@
pctx.VariableFunc("CommonGlobalCflags", func(ctx android.PackageVarContext) string {
flags := commonGlobalCflags
- flags = append(flags, "${ClangExtraCflags}")
// http://b/131390872
// Automatically initialize any uninitialized stack variables.
diff --git a/cc/config/x86_64_fuchsia_device.go b/cc/config/x86_64_fuchsia_device.go
deleted file mode 100644
index 86558a6..0000000
--- a/cc/config/x86_64_fuchsia_device.go
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright 2018 Google Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package config
-
-import (
- "android/soong/android"
-)
-
-var fuchsiaSysRoot string = "prebuilts/fuchsia_sdk/arch/x64/sysroot"
-var fuchsiaPrebuiltLibsRoot string = "fuchsia/prebuilt_libs"
-
-type toolchainFuchsia struct {
- cFlags, ldFlags string
-}
-
-type toolchainFuchsiaX8664 struct {
- toolchain64Bit
- toolchainFuchsia
-}
-
-func (t *toolchainFuchsiaX8664) Name() string {
- return "x86_64"
-}
-
-func (t *toolchainFuchsiaX8664) GccRoot() string {
- return "${config.X86_64GccRoot}"
-}
-
-func (t *toolchainFuchsiaX8664) GccTriple() string {
- return "x86_64-linux-android"
-}
-
-func (t *toolchainFuchsiaX8664) GccVersion() string {
- return x86_64GccVersion
-}
-
-func (t *toolchainFuchsiaX8664) IncludeFlags() string {
- return ""
-}
-
-func (t *toolchainFuchsiaX8664) ClangTriple() string {
- return "x86_64-fuchsia-android"
-}
-
-func (t *toolchainFuchsiaX8664) Cppflags() string {
- return "-Wno-error=deprecated-declarations"
-}
-
-func (t *toolchainFuchsiaX8664) Ldflags() string {
- return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/"
-
-}
-
-func (t *toolchainFuchsiaX8664) Lldflags() string {
- return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/"
-}
-
-func (t *toolchainFuchsiaX8664) Cflags() string {
- return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -I" + fuchsiaSysRoot + "/include"
-}
-
-func (t *toolchainFuchsiaX8664) YasmFlags() string {
- return "-f elf64 -m amd64"
-}
-
-func (t *toolchainFuchsiaX8664) ToolchainCflags() string {
- return "-mssse3"
-}
-
-var toolchainFuchsiaSingleton Toolchain = &toolchainFuchsiaX8664{}
-
-func fuchsiaToolchainFactory(arch android.Arch) Toolchain {
- return toolchainFuchsiaSingleton
-}
-
-func init() {
- registerToolchainFactory(android.Fuchsia, android.X86_64, fuchsiaToolchainFactory)
-}
diff --git a/cc/fuzz.go b/cc/fuzz.go
index c780b6f..8b0f93e 100644
--- a/cc/fuzz.go
+++ b/cc/fuzz.go
@@ -94,19 +94,14 @@
*binaryDecorator
*baseCompiler
- Properties FuzzProperties
- dictionary android.Path
- corpus android.Paths
- corpusIntermediateDir android.Path
- config android.Path
- data android.Paths
- dataIntermediateDir android.Path
- installedSharedDeps []string
+ fuzzPackagedModule FuzzPackagedModule
+
+ installedSharedDeps []string
}
func (fuzz *fuzzBinary) linkerProps() []interface{} {
props := fuzz.binaryDecorator.linkerProps()
- props = append(props, &fuzz.Properties)
+ props = append(props, &fuzz.fuzzPackagedModule.FuzzProperties)
return props
}
@@ -257,41 +252,41 @@
"fuzz", ctx.Target().Arch.ArchType.String(), ctx.ModuleName())
fuzz.binaryDecorator.baseInstaller.install(ctx, file)
- fuzz.corpus = android.PathsForModuleSrc(ctx, fuzz.Properties.Corpus)
+ fuzz.fuzzPackagedModule.Corpus = android.PathsForModuleSrc(ctx, fuzz.fuzzPackagedModule.FuzzProperties.Corpus)
builder := android.NewRuleBuilder(pctx, ctx)
intermediateDir := android.PathForModuleOut(ctx, "corpus")
- for _, entry := range fuzz.corpus {
+ for _, entry := range fuzz.fuzzPackagedModule.Corpus {
builder.Command().Text("cp").
Input(entry).
Output(intermediateDir.Join(ctx, entry.Base()))
}
builder.Build("copy_corpus", "copy corpus")
- fuzz.corpusIntermediateDir = intermediateDir
+ fuzz.fuzzPackagedModule.CorpusIntermediateDir = intermediateDir
- fuzz.data = android.PathsForModuleSrc(ctx, fuzz.Properties.Data)
+ fuzz.fuzzPackagedModule.Data = android.PathsForModuleSrc(ctx, fuzz.fuzzPackagedModule.FuzzProperties.Data)
builder = android.NewRuleBuilder(pctx, ctx)
intermediateDir = android.PathForModuleOut(ctx, "data")
- for _, entry := range fuzz.data {
+ for _, entry := range fuzz.fuzzPackagedModule.Data {
builder.Command().Text("cp").
Input(entry).
Output(intermediateDir.Join(ctx, entry.Rel()))
}
builder.Build("copy_data", "copy data")
- fuzz.dataIntermediateDir = intermediateDir
+ fuzz.fuzzPackagedModule.DataIntermediateDir = intermediateDir
- if fuzz.Properties.Dictionary != nil {
- fuzz.dictionary = android.PathForModuleSrc(ctx, *fuzz.Properties.Dictionary)
- if fuzz.dictionary.Ext() != ".dict" {
+ if fuzz.fuzzPackagedModule.FuzzProperties.Dictionary != nil {
+ fuzz.fuzzPackagedModule.Dictionary = android.PathForModuleSrc(ctx, *fuzz.fuzzPackagedModule.FuzzProperties.Dictionary)
+ if fuzz.fuzzPackagedModule.Dictionary.Ext() != ".dict" {
ctx.PropertyErrorf("dictionary",
"Fuzzer dictionary %q does not have '.dict' extension",
- fuzz.dictionary.String())
+ fuzz.fuzzPackagedModule.Dictionary.String())
}
}
- if fuzz.Properties.Fuzz_config != nil {
+ if fuzz.fuzzPackagedModule.FuzzProperties.Fuzz_config != nil {
configPath := android.PathForModuleOut(ctx, "config").Join(ctx, "config.json")
- android.WriteFileRule(ctx, configPath, fuzz.Properties.Fuzz_config.String())
- fuzz.config = configPath
+ android.WriteFileRule(ctx, configPath, fuzz.fuzzPackagedModule.FuzzProperties.Fuzz_config.String())
+ fuzz.fuzzPackagedModule.Config = configPath
}
// Grab the list of required shared libraries.
@@ -359,32 +354,20 @@
// Responsible for generating GNU Make rules that package fuzz targets into
// their architecture & target/host specific zip file.
-type fuzzPackager struct {
- packages android.Paths
+type ccFuzzPackager struct {
+ FuzzPackager
sharedLibInstallStrings []string
- fuzzTargets map[string]bool
}
func fuzzPackagingFactory() android.Singleton {
- return &fuzzPackager{}
+ return &ccFuzzPackager{}
}
-type fileToZip struct {
- SourceFilePath android.Path
- DestinationPathPrefix string
-}
-
-type archOs struct {
- hostOrTarget string
- arch string
- dir string
-}
-
-func (s *fuzzPackager) GenerateBuildActions(ctx android.SingletonContext) {
+func (s *ccFuzzPackager) GenerateBuildActions(ctx android.SingletonContext) {
// Map between each architecture + host/device combination, and the files that
// need to be packaged (in the tuple of {source file, destination folder in
// archive}).
- archDirs := make(map[archOs][]fileToZip)
+ archDirs := make(map[ArchOs][]FileToZip)
// Map tracking whether each shared library has an install rule to avoid duplicate install rules from
// multiple fuzzers that depend on the same shared library.
@@ -392,12 +375,16 @@
// List of individual fuzz targets, so that 'make fuzz' also installs the targets
// to the correct output directories as well.
- s.fuzzTargets = make(map[string]bool)
+ s.FuzzTargets = make(map[string]bool)
ctx.VisitAllModules(func(module android.Module) {
- // Discard non-fuzz targets.
ccModule, ok := module.(*Module)
- if !ok {
+ if !ok || ccModule.Properties.PreventInstall {
+ return
+ }
+
+ // Discard non-fuzz targets.
+ if ok := IsValid(ccModule.FuzzModule); !ok {
return
}
@@ -406,18 +393,6 @@
return
}
- // Discard ramdisk + vendor_ramdisk + recovery modules, they're duplicates of
- // fuzz targets we're going to package anyway.
- if !ccModule.Enabled() || ccModule.Properties.PreventInstall ||
- ccModule.InRamdisk() || ccModule.InVendorRamdisk() || ccModule.InRecovery() {
- return
- }
-
- // Discard modules that are in an unavailable namespace.
- if !ccModule.ExportedToMake() {
- return
- }
-
hostOrTargetString := "target"
if ccModule.Host() {
hostOrTargetString = "host"
@@ -425,42 +400,21 @@
archString := ccModule.Arch().ArchType.String()
archDir := android.PathForIntermediates(ctx, "fuzz", hostOrTargetString, archString)
- archOs := archOs{hostOrTarget: hostOrTargetString, arch: archString, dir: archDir.String()}
+ archOs := ArchOs{HostOrTarget: hostOrTargetString, Arch: archString, Dir: archDir.String()}
// Grab the list of required shared libraries.
sharedLibraries := collectAllSharedDependencies(ctx, module)
- var files []fileToZip
+ var files []FileToZip
builder := android.NewRuleBuilder(pctx, ctx)
- // Package the corpora into a zipfile.
- if fuzzModule.corpus != nil {
- corpusZip := archDir.Join(ctx, module.Name()+"_seed_corpus.zip")
- command := builder.Command().BuiltTool("soong_zip").
- Flag("-j").
- FlagWithOutput("-o ", corpusZip)
- rspFile := corpusZip.ReplaceExtension(ctx, "rsp")
- command.FlagWithRspFileInputList("-r ", rspFile, fuzzModule.corpus)
- files = append(files, fileToZip{corpusZip, ""})
- }
-
- // Package the data into a zipfile.
- if fuzzModule.data != nil {
- dataZip := archDir.Join(ctx, module.Name()+"_data.zip")
- command := builder.Command().BuiltTool("soong_zip").
- FlagWithOutput("-o ", dataZip)
- for _, f := range fuzzModule.data {
- intermediateDir := strings.TrimSuffix(f.String(), f.Rel())
- command.FlagWithArg("-C ", intermediateDir)
- command.FlagWithInput("-f ", f)
- }
- files = append(files, fileToZip{dataZip, ""})
- }
+ // Package the corpus, data, dict and config into a zipfile.
+ files = s.PackageArtifacts(ctx, module, fuzzModule.fuzzPackagedModule, archDir, builder)
// Find and mark all the transiently-dependent shared libraries for
// packaging.
for _, library := range sharedLibraries {
- files = append(files, fileToZip{library, "lib"})
+ files = append(files, FileToZip{library, "lib"})
// For each architecture-specific shared library dependency, we need to
// install it to the output directory. Setup the install destination here,
@@ -492,83 +446,20 @@
}
// The executable.
- files = append(files, fileToZip{ccModule.UnstrippedOutputFile(), ""})
+ files = append(files, FileToZip{ccModule.UnstrippedOutputFile(), ""})
- // The dictionary.
- if fuzzModule.dictionary != nil {
- files = append(files, fileToZip{fuzzModule.dictionary, ""})
+ archDirs[archOs], ok = s.BuildZipFile(ctx, module, fuzzModule.fuzzPackagedModule, files, builder, archDir, archString, hostOrTargetString, archOs, archDirs)
+ if !ok {
+ return
}
-
- // Additional fuzz config.
- if fuzzModule.config != nil {
- files = append(files, fileToZip{fuzzModule.config, ""})
- }
-
- fuzzZip := archDir.Join(ctx, module.Name()+".zip")
- command := builder.Command().BuiltTool("soong_zip").
- Flag("-j").
- FlagWithOutput("-o ", fuzzZip)
- for _, file := range files {
- if file.DestinationPathPrefix != "" {
- command.FlagWithArg("-P ", file.DestinationPathPrefix)
- } else {
- command.Flag("-P ''")
- }
- command.FlagWithInput("-f ", file.SourceFilePath)
- }
-
- builder.Build("create-"+fuzzZip.String(),
- "Package "+module.Name()+" for "+archString+"-"+hostOrTargetString)
-
- // Don't add modules to 'make haiku' that are set to not be exported to the
- // fuzzing infrastructure.
- if config := fuzzModule.Properties.Fuzz_config; config != nil {
- if ccModule.Host() && !BoolDefault(config.Fuzz_on_haiku_host, true) {
- return
- } else if !BoolDefault(config.Fuzz_on_haiku_device, true) {
- return
- }
- }
-
- s.fuzzTargets[module.Name()] = true
- archDirs[archOs] = append(archDirs[archOs], fileToZip{fuzzZip, ""})
})
- var archOsList []archOs
- for archOs := range archDirs {
- archOsList = append(archOsList, archOs)
- }
- sort.Slice(archOsList, func(i, j int) bool { return archOsList[i].dir < archOsList[j].dir })
+ s.CreateFuzzPackage(ctx, archDirs, Cc)
- for _, archOs := range archOsList {
- filesToZip := archDirs[archOs]
- arch := archOs.arch
- hostOrTarget := archOs.hostOrTarget
- builder := android.NewRuleBuilder(pctx, ctx)
- outputFile := android.PathForOutput(ctx, "fuzz-"+hostOrTarget+"-"+arch+".zip")
- s.packages = append(s.packages, outputFile)
-
- command := builder.Command().BuiltTool("soong_zip").
- Flag("-j").
- FlagWithOutput("-o ", outputFile).
- Flag("-L 0") // No need to try and re-compress the zipfiles.
-
- for _, fileToZip := range filesToZip {
- if fileToZip.DestinationPathPrefix != "" {
- command.FlagWithArg("-P ", fileToZip.DestinationPathPrefix)
- } else {
- command.Flag("-P ''")
- }
- command.FlagWithInput("-f ", fileToZip.SourceFilePath)
- }
-
- builder.Build("create-fuzz-package-"+arch+"-"+hostOrTarget,
- "Create fuzz target packages for "+arch+"-"+hostOrTarget)
- }
}
-func (s *fuzzPackager) MakeVars(ctx android.MakeVarsContext) {
- packages := s.packages.Strings()
+func (s *ccFuzzPackager) MakeVars(ctx android.MakeVarsContext) {
+ packages := s.Packages.Strings()
sort.Strings(packages)
sort.Strings(s.sharedLibInstallStrings)
// TODO(mitchp): Migrate this to use MakeVarsContext::DistForGoal() when it's
@@ -580,10 +471,5 @@
strings.Join(s.sharedLibInstallStrings, " "))
// Preallocate the slice of fuzz targets to minimise memory allocations.
- fuzzTargets := make([]string, 0, len(s.fuzzTargets))
- for target, _ := range s.fuzzTargets {
- fuzzTargets = append(fuzzTargets, target)
- }
- sort.Strings(fuzzTargets)
- ctx.Strict("ALL_FUZZ_TARGETS", strings.Join(fuzzTargets, " "))
+ s.PreallocateSlice(ctx, "ALL_FUZZ_TARGETS")
}
diff --git a/cc/fuzz_common.go b/cc/fuzz_common.go
new file mode 100644
index 0000000..98ed7f4
--- /dev/null
+++ b/cc/fuzz_common.go
@@ -0,0 +1,201 @@
+// Copyright 2021 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cc
+
+// This file contains the common code for compiling C/C++ and Rust fuzzers for Android.
+
+import (
+ "sort"
+ "strings"
+
+ "android/soong/android"
+)
+
+type Lang string
+
+const (
+ Cc Lang = ""
+ Rust Lang = "rust"
+)
+
+type FuzzModule struct {
+ android.ModuleBase
+ android.DefaultableModuleBase
+ android.ApexModuleBase
+}
+
+type FuzzPackager struct {
+ Packages android.Paths
+ FuzzTargets map[string]bool
+}
+
+type FileToZip struct {
+ SourceFilePath android.Path
+ DestinationPathPrefix string
+}
+
+type ArchOs struct {
+ HostOrTarget string
+ Arch string
+ Dir string
+}
+
+type FuzzPackagedModule struct {
+ FuzzProperties FuzzProperties
+ Dictionary android.Path
+ Corpus android.Paths
+ CorpusIntermediateDir android.Path
+ Config android.Path
+ Data android.Paths
+ DataIntermediateDir android.Path
+}
+
+func IsValid(fuzzModule FuzzModule) bool {
+ // Discard ramdisk + vendor_ramdisk + recovery modules, they're duplicates of
+ // fuzz targets we're going to package anyway.
+ if !fuzzModule.Enabled() || fuzzModule.InRamdisk() || fuzzModule.InVendorRamdisk() || fuzzModule.InRecovery() {
+ return false
+ }
+
+ // Discard modules that are in an unavailable namespace.
+ if !fuzzModule.ExportedToMake() {
+ return false
+ }
+
+ return true
+}
+
+func (s *FuzzPackager) PackageArtifacts(ctx android.SingletonContext, module android.Module, fuzzModule FuzzPackagedModule, archDir android.OutputPath, builder *android.RuleBuilder) []FileToZip {
+ // Package the corpora into a zipfile.
+ var files []FileToZip
+ if fuzzModule.Corpus != nil {
+ corpusZip := archDir.Join(ctx, module.Name()+"_seed_corpus.zip")
+ command := builder.Command().BuiltTool("soong_zip").
+ Flag("-j").
+ FlagWithOutput("-o ", corpusZip)
+ rspFile := corpusZip.ReplaceExtension(ctx, "rsp")
+ command.FlagWithRspFileInputList("-r ", rspFile, fuzzModule.Corpus)
+ files = append(files, FileToZip{corpusZip, ""})
+ }
+
+ // Package the data into a zipfile.
+ if fuzzModule.Data != nil {
+ dataZip := archDir.Join(ctx, module.Name()+"_data.zip")
+ command := builder.Command().BuiltTool("soong_zip").
+ FlagWithOutput("-o ", dataZip)
+ for _, f := range fuzzModule.Data {
+ intermediateDir := strings.TrimSuffix(f.String(), f.Rel())
+ command.FlagWithArg("-C ", intermediateDir)
+ command.FlagWithInput("-f ", f)
+ }
+ files = append(files, FileToZip{dataZip, ""})
+ }
+
+ // The dictionary.
+ if fuzzModule.Dictionary != nil {
+ files = append(files, FileToZip{fuzzModule.Dictionary, ""})
+ }
+
+ // Additional fuzz config.
+ if fuzzModule.Config != nil {
+ files = append(files, FileToZip{fuzzModule.Config, ""})
+ }
+
+ return files
+}
+
+func (s *FuzzPackager) BuildZipFile(ctx android.SingletonContext, module android.Module, fuzzModule FuzzPackagedModule, files []FileToZip, builder *android.RuleBuilder, archDir android.OutputPath, archString string, hostOrTargetString string, archOs ArchOs, archDirs map[ArchOs][]FileToZip) ([]FileToZip, bool) {
+ fuzzZip := archDir.Join(ctx, module.Name()+".zip")
+
+ command := builder.Command().BuiltTool("soong_zip").
+ Flag("-j").
+ FlagWithOutput("-o ", fuzzZip)
+
+ for _, file := range files {
+ if file.DestinationPathPrefix != "" {
+ command.FlagWithArg("-P ", file.DestinationPathPrefix)
+ } else {
+ command.Flag("-P ''")
+ }
+ command.FlagWithInput("-f ", file.SourceFilePath)
+ }
+
+ builder.Build("create-"+fuzzZip.String(),
+ "Package "+module.Name()+" for "+archString+"-"+hostOrTargetString)
+
+ // Don't add modules to 'make haiku-rust' that are set to not be
+ // exported to the fuzzing infrastructure.
+ if config := fuzzModule.FuzzProperties.Fuzz_config; config != nil {
+ if strings.Contains(hostOrTargetString, "host") && !BoolDefault(config.Fuzz_on_haiku_host, true) {
+ return archDirs[archOs], false
+ } else if !BoolDefault(config.Fuzz_on_haiku_device, true) {
+ return archDirs[archOs], false
+ }
+ }
+
+ s.FuzzTargets[module.Name()] = true
+ archDirs[archOs] = append(archDirs[archOs], FileToZip{fuzzZip, ""})
+
+ return archDirs[archOs], true
+}
+
+func (s *FuzzPackager) CreateFuzzPackage(ctx android.SingletonContext, archDirs map[ArchOs][]FileToZip, lang Lang) {
+ var archOsList []ArchOs
+ for archOs := range archDirs {
+ archOsList = append(archOsList, archOs)
+ }
+ sort.Slice(archOsList, func(i, j int) bool { return archOsList[i].Dir < archOsList[j].Dir })
+
+ for _, archOs := range archOsList {
+ filesToZip := archDirs[archOs]
+ arch := archOs.Arch
+ hostOrTarget := archOs.HostOrTarget
+ builder := android.NewRuleBuilder(pctx, ctx)
+ zipFileName := "fuzz-" + hostOrTarget + "-" + arch + ".zip"
+ if lang == Rust {
+ zipFileName = "fuzz-rust-" + hostOrTarget + "-" + arch + ".zip"
+ }
+ outputFile := android.PathForOutput(ctx, zipFileName)
+
+ s.Packages = append(s.Packages, outputFile)
+
+ command := builder.Command().BuiltTool("soong_zip").
+ Flag("-j").
+ FlagWithOutput("-o ", outputFile).
+ Flag("-L 0") // No need to try and re-compress the zipfiles.
+
+ for _, fileToZip := range filesToZip {
+
+ if fileToZip.DestinationPathPrefix != "" {
+ command.FlagWithArg("-P ", fileToZip.DestinationPathPrefix)
+ } else {
+ command.Flag("-P ''")
+ }
+ command.FlagWithInput("-f ", fileToZip.SourceFilePath)
+
+ }
+ builder.Build("create-fuzz-package-"+arch+"-"+hostOrTarget,
+ "Create fuzz target packages for "+arch+"-"+hostOrTarget)
+ }
+}
+
+func (s *FuzzPackager) PreallocateSlice(ctx android.MakeVarsContext, targets string) {
+ fuzzTargets := make([]string, 0, len(s.FuzzTargets))
+ for target, _ := range s.FuzzTargets {
+ fuzzTargets = append(fuzzTargets, target)
+ }
+ sort.Strings(fuzzTargets)
+ ctx.Strict(targets, strings.Join(fuzzTargets, " "))
+}
diff --git a/cc/genrule.go b/cc/genrule.go
index b0efc6c..0ca901e 100644
--- a/cc/genrule.go
+++ b/cc/genrule.go
@@ -17,6 +17,7 @@
import (
"android/soong/android"
"android/soong/genrule"
+ "android/soong/snapshot"
)
func init() {
@@ -84,7 +85,7 @@
// is not needed.
recoverySnapshotVersion := ctx.DeviceConfig().RecoverySnapshotVersion()
if recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" &&
- !isRecoveryProprietaryModule(ctx) {
+ !snapshot.IsRecoveryProprietaryModule(ctx) {
return false
} else {
return Bool(g.Recovery_available)
@@ -103,7 +104,7 @@
// If not, we assume modules under proprietary paths are compatible for
// BOARD_VNDK_VERSION. The other modules are regarded as AOSP, that is
// PLATFORM_VNDK_VERSION.
- if vndkVersion == "current" || !IsVendorProprietaryModule(ctx) {
+ if vndkVersion == "current" || !snapshot.IsVendorProprietaryModule(ctx) {
variants = append(variants, VendorVariationPrefix+ctx.DeviceConfig().PlatformVndkVersion())
} else {
variants = append(variants, VendorVariationPrefix+vndkVersion)
diff --git a/cc/image.go b/cc/image.go
index 15ec1c8..3a0857b 100644
--- a/cc/image.go
+++ b/cc/image.go
@@ -22,6 +22,7 @@
"strings"
"android/soong/android"
+ "android/soong/snapshot"
)
var _ android.ImageInterface = (*Module)(nil)
@@ -496,7 +497,7 @@
// BOARD_VNDK_VERSION. The other modules are regarded as AOSP, or
// PLATFORM_VNDK_VERSION.
if m.HasVendorVariant() {
- if IsVendorProprietaryModule(mctx) {
+ if snapshot.IsVendorProprietaryModule(mctx) {
vendorVariants = append(vendorVariants, boardVndkVersion)
} else {
vendorVariants = append(vendorVariants, platformVndkVersion)
@@ -525,7 +526,7 @@
platformVndkVersion,
boardVndkVersion,
)
- } else if IsVendorProprietaryModule(mctx) {
+ } else if snapshot.IsVendorProprietaryModule(mctx) {
vendorVariants = append(vendorVariants, boardVndkVersion)
} else {
vendorVariants = append(vendorVariants, platformVndkVersion)
@@ -582,7 +583,7 @@
if !m.KernelHeadersDecorator() &&
!m.IsSnapshotPrebuilt() &&
usingRecoverySnapshot &&
- !isRecoveryProprietaryModule(mctx) {
+ !snapshot.IsRecoveryProprietaryModule(mctx) {
recoveryVariantNeeded = false
}
diff --git a/cc/linkable.go b/cc/linkable.go
index 6232efb..b510508 100644
--- a/cc/linkable.go
+++ b/cc/linkable.go
@@ -3,6 +3,7 @@
import (
"android/soong/android"
"android/soong/bazel/cquery"
+ "android/soong/snapshot"
"github.com/google/blueprint"
)
@@ -71,15 +72,12 @@
// Snapshottable defines those functions necessary for handling module snapshots.
type Snapshottable interface {
+ snapshot.VendorSnapshotModuleInterface
+ snapshot.RecoverySnapshotModuleInterface
+
// SnapshotHeaders returns a list of header paths provided by this module.
SnapshotHeaders() android.Paths
- // ExcludeFromVendorSnapshot returns true if this module should be otherwise excluded from the vendor snapshot.
- ExcludeFromVendorSnapshot() bool
-
- // ExcludeFromRecoverySnapshot returns true if this module should be otherwise excluded from the recovery snapshot.
- ExcludeFromRecoverySnapshot() bool
-
// SnapshotLibrary returns true if this module is a snapshot library.
IsSnapshotLibrary() bool
diff --git a/cc/linker.go b/cc/linker.go
index a712391..82449a6 100644
--- a/cc/linker.go
+++ b/cc/linker.go
@@ -15,9 +15,10 @@
package cc
import (
+ "fmt"
+
"android/soong/android"
"android/soong/cc/config"
- "fmt"
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
@@ -244,8 +245,7 @@
if linker.Properties.System_shared_libs != nil && linker.Properties.Default_shared_libs != nil {
ctx.PropertyErrorf("system_shared_libs", "cannot be specified if default_shared_libs is also specified")
}
- if ctx.toolchain().Bionic() && linker.Properties.System_shared_libs != nil {
- // system_shared_libs is only honored when building against bionic.
+ if linker.Properties.System_shared_libs != nil {
return linker.Properties.System_shared_libs
}
return linker.Properties.Default_shared_libs
@@ -389,18 +389,6 @@
deps.LateSharedLibs = append(deps.LateSharedLibs, deps.SystemSharedLibs...)
- if ctx.Fuchsia() {
- if ctx.ModuleName() != "libbioniccompat" &&
- ctx.ModuleName() != "libcompiler_rt-extras" &&
- ctx.ModuleName() != "libcompiler_rt" {
- deps.StaticLibs = append(deps.StaticLibs, "libbioniccompat")
- }
- if ctx.ModuleName() != "libcompiler_rt" && ctx.ModuleName() != "libcompiler_rt-extras" {
- deps.LateStaticLibs = append(deps.LateStaticLibs, "libcompiler_rt")
- }
-
- }
-
if ctx.Windows() {
deps.LateStaticLibs = append(deps.LateStaticLibs, "libwinpthread")
}
@@ -484,7 +472,7 @@
flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.Ldflags())
}
- if !ctx.toolchain().Bionic() && !ctx.Fuchsia() {
+ if !ctx.toolchain().Bionic() {
CheckBadHostLdlibs(ctx, "host_ldlibs", linker.Properties.Host_ldlibs)
flags.Local.LdFlags = append(flags.Local.LdFlags, linker.Properties.Host_ldlibs...)
@@ -503,10 +491,6 @@
}
}
- if ctx.Fuchsia() {
- flags.Global.LdFlags = append(flags.Global.LdFlags, "-lfdio", "-lzircon")
- }
-
if ctx.toolchain().LibclangRuntimeLibraryArch() != "" {
flags.Global.LdFlags = append(flags.Global.LdFlags, "-Wl,--exclude-libs="+config.BuiltinsRuntimeLibrary(ctx.toolchain())+".a")
}
diff --git a/cc/makevars.go b/cc/makevars.go
index 393170a..8d7a163 100644
--- a/cc/makevars.go
+++ b/cc/makevars.go
@@ -165,7 +165,7 @@
sort.Strings(ndkKnownLibs)
ctx.Strict("NDK_KNOWN_LIBS", strings.Join(ndkKnownLibs, " "))
- hostTargets := ctx.Config().Targets[android.BuildOs]
+ hostTargets := ctx.Config().Targets[ctx.Config().BuildOS]
makeVarsToolchain(ctx, "", hostTargets[0])
if len(hostTargets) > 1 {
makeVarsToolchain(ctx, "2ND_", hostTargets[1])
diff --git a/cc/ndk_library.go b/cc/ndk_library.go
index a458380..63e8261 100644
--- a/cc/ndk_library.go
+++ b/cc/ndk_library.go
@@ -150,12 +150,6 @@
if !ctx.Module().Enabled() {
return nil
}
- if ctx.Os() != android.Android {
- // These modules are always android.DeviceEnabled only, but
- // those include Fuchsia devices, which we don't support.
- ctx.Module().Disable()
- return nil
- }
if ctx.Target().NativeBridge == android.NativeBridgeEnabled {
ctx.Module().Disable()
return nil
diff --git a/cc/prebuilt_test.go b/cc/prebuilt_test.go
index fa6dd87..c8f8103 100644
--- a/cc/prebuilt_test.go
+++ b/cc/prebuilt_test.go
@@ -15,6 +15,7 @@
package cc
import (
+ "runtime"
"testing"
"android/soong/android"
@@ -271,8 +272,8 @@
}
func TestPrebuiltSymlinkedHostBinary(t *testing.T) {
- if android.BuildOs != android.Linux {
- t.Skipf("Skipping host prebuilt testing that is only supported on %s not %s", android.Linux, android.BuildOs)
+ if runtime.GOOS != "linux" {
+ t.Skipf("Skipping host prebuilt testing that is only supported on linux not %s", runtime.GOOS)
}
ctx := testPrebuilt(t, `
diff --git a/cc/proto_test.go b/cc/proto_test.go
index b9c89c7..abcb273 100644
--- a/cc/proto_test.go
+++ b/cc/proto_test.go
@@ -51,7 +51,7 @@
},
}`)
- buildOS := android.BuildOs.String()
+ buildOS := ctx.Config().BuildOS.String()
proto := ctx.ModuleForTests("libfoo", "android_arm_armv7-a-neon_shared").Output("proto/a.pb.cc")
foobar := ctx.ModuleForTests("protoc-gen-foobar", buildOS+"_x86_64")
diff --git a/cc/sabi.go b/cc/sabi.go
index 5fd6f5d..e62ca66 100644
--- a/cc/sabi.go
+++ b/cc/sabi.go
@@ -101,10 +101,6 @@
// Called from sabiDepsMutator to check whether ABI dumps should be created for this module.
// ctx should be wrapping a native library type module.
func shouldCreateSourceAbiDumpForLibrary(ctx android.BaseModuleContext) bool {
- if ctx.Fuchsia() {
- return false
- }
-
// Only generate ABI dump for device modules.
if !ctx.Device() {
return false
diff --git a/cc/sanitize.go b/cc/sanitize.go
index defe8fd..3911f48 100644
--- a/cc/sanitize.go
+++ b/cc/sanitize.go
@@ -25,6 +25,7 @@
"android/soong/android"
"android/soong/cc/config"
+ "android/soong/snapshot"
)
var (
@@ -265,7 +266,6 @@
}
type SanitizeProperties struct {
- // Sanitizers are not supported for Fuchsia.
Sanitize SanitizeUserProps `android:"arch_variant"`
SanitizerEnabled bool `blueprint:"mutated"`
SanitizeDep bool `blueprint:"mutated"`
@@ -305,11 +305,6 @@
s.Never = BoolPtr(true)
}
- // Sanitizers do not work on Fuchsia yet.
- if ctx.Fuchsia() {
- s.Never = BoolPtr(true)
- }
-
// Never always wins.
if Bool(s.Never) {
return
@@ -907,7 +902,7 @@
// as vendor snapshot. Such modules must create both cfi and non-cfi variants,
// except for ones which explicitly disable cfi.
func needsCfiForVendorSnapshot(mctx android.TopDownMutatorContext) bool {
- if IsVendorProprietaryModule(mctx) {
+ if snapshot.IsVendorProprietaryModule(mctx) {
return false
}
diff --git a/cc/sdk.go b/cc/sdk.go
index 69ad311..a83e5ad 100644
--- a/cc/sdk.go
+++ b/cc/sdk.go
@@ -76,7 +76,7 @@
}
ctx.AliasVariation("")
}
- case *snapshot:
+ case *snapshotModule:
ctx.CreateVariations("")
}
}
diff --git a/cc/snapshot_prebuilt.go b/cc/snapshot_prebuilt.go
index 4f031ff..9672c0f 100644
--- a/cc/snapshot_prebuilt.go
+++ b/cc/snapshot_prebuilt.go
@@ -18,57 +18,17 @@
// snapshot mutators and snapshot information maps which are also defined in this file.
import (
- "path/filepath"
"strings"
"android/soong/android"
+ "android/soong/snapshot"
"github.com/google/blueprint"
)
-// Defines the specifics of different images to which the snapshot process is applicable, e.g.,
-// vendor, recovery, ramdisk.
+// This interface overrides snapshot.SnapshotImage to implement cc module specific functions
type SnapshotImage interface {
- // Returns true if a snapshot should be generated for this image.
- shouldGenerateSnapshot(ctx android.SingletonContext) bool
-
- // Function that returns true if the module is included in this image.
- // Using a function return instead of a value to prevent early
- // evalution of a function that may be not be defined.
- inImage(m LinkableInterface) func() bool
-
- // Returns true if the module is private and must not be included in the
- // snapshot. For example VNDK-private modules must return true for the
- // vendor snapshots. But false for the recovery snapshots.
- private(m LinkableInterface) bool
-
- // Returns true if a dir under source tree is an SoC-owned proprietary
- // directory, such as device/, vendor/, etc.
- //
- // For a given snapshot (e.g., vendor, recovery, etc.) if
- // isProprietaryPath(dir, deviceConfig) returns true, then the module in dir
- // will be built from sources.
- isProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool
-
- // Whether to include VNDK in the snapshot for this image.
- includeVndk() bool
-
- // Whether a given module has been explicitly excluded from the
- // snapshot, e.g., using the exclude_from_vendor_snapshot or
- // exclude_from_recovery_snapshot properties.
- excludeFromSnapshot(m LinkableInterface) bool
-
- // Returns true if the build is using a snapshot for this image.
- isUsingSnapshot(cfg android.DeviceConfig) bool
-
- // Returns a version of which the snapshot should be used in this target.
- // This will only be meaningful when isUsingSnapshot is true.
- targetSnapshotVersion(cfg android.DeviceConfig) string
-
- // Whether to exclude a given module from the directed snapshot or not.
- // If the makefile variable DIRECTED_{IMAGE}_SNAPSHOT is true, directed snapshot is turned on,
- // and only modules listed in {IMAGE}_SNAPSHOT_MODULES will be captured.
- excludeFromDirectedSnapshot(cfg android.DeviceConfig, name string) bool
+ snapshot.SnapshotImage
// The image variant name for this snapshot image.
// For example, recovery snapshot image will return "recovery", and vendor snapshot image will
@@ -80,110 +40,12 @@
moduleNameSuffix() string
}
-type vendorSnapshotImage struct{}
-type recoverySnapshotImage struct{}
-
-type directoryMap map[string]bool
-
-var (
- // Modules under following directories are ignored. They are OEM's and vendor's
- // proprietary modules(device/, kernel/, vendor/, and hardware/).
- defaultDirectoryExcludedMap = directoryMap{
- "device": true,
- "hardware": true,
- "kernel": true,
- "vendor": true,
- }
-
- // Modules under following directories are included as they are in AOSP,
- // although hardware/ and kernel/ are normally for vendor's own.
- defaultDirectoryIncludedMap = directoryMap{
- "kernel/configs": true,
- "kernel/prebuilts": true,
- "kernel/tests": true,
- "hardware/interfaces": true,
- "hardware/libhardware": true,
- "hardware/libhardware_legacy": true,
- "hardware/ril": true,
- }
-)
-
-func (vendorSnapshotImage) Init(ctx android.RegistrationContext) {
- ctx.RegisterSingletonType("vendor-snapshot", VendorSnapshotSingleton)
- ctx.RegisterModuleType("vendor_snapshot", vendorSnapshotFactory)
- ctx.RegisterModuleType("vendor_snapshot_shared", VendorSnapshotSharedFactory)
- ctx.RegisterModuleType("vendor_snapshot_static", VendorSnapshotStaticFactory)
- ctx.RegisterModuleType("vendor_snapshot_header", VendorSnapshotHeaderFactory)
- ctx.RegisterModuleType("vendor_snapshot_binary", VendorSnapshotBinaryFactory)
- ctx.RegisterModuleType("vendor_snapshot_object", VendorSnapshotObjectFactory)
-
- ctx.RegisterSingletonType("vendor-fake-snapshot", VendorFakeSnapshotSingleton)
+type vendorSnapshotImage struct {
+ *snapshot.VendorSnapshotImage
}
-func (vendorSnapshotImage) RegisterAdditionalModule(ctx android.RegistrationContext, name string, factory android.ModuleFactory) {
- ctx.RegisterModuleType(name, factory)
-}
-
-func (vendorSnapshotImage) shouldGenerateSnapshot(ctx android.SingletonContext) bool {
- // BOARD_VNDK_VERSION must be set to 'current' in order to generate a snapshot.
- return ctx.DeviceConfig().VndkVersion() == "current"
-}
-
-func (vendorSnapshotImage) inImage(m LinkableInterface) func() bool {
- return m.InVendor
-}
-
-func (vendorSnapshotImage) private(m LinkableInterface) bool {
- return m.IsVndkPrivate()
-}
-
-func isDirectoryExcluded(dir string, excludedMap directoryMap, includedMap directoryMap) bool {
- if dir == "." || dir == "/" {
- return false
- }
- if includedMap[dir] {
- return false
- } else if excludedMap[dir] {
- return true
- } else if defaultDirectoryIncludedMap[dir] {
- return false
- } else if defaultDirectoryExcludedMap[dir] {
- return true
- } else {
- return isDirectoryExcluded(filepath.Dir(dir), excludedMap, includedMap)
- }
-}
-
-func (vendorSnapshotImage) isProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool {
- return isDirectoryExcluded(dir, deviceConfig.VendorSnapshotDirsExcludedMap(), deviceConfig.VendorSnapshotDirsIncludedMap())
-}
-
-// vendor snapshot includes static/header libraries with vndk: {enabled: true}.
-func (vendorSnapshotImage) includeVndk() bool {
- return true
-}
-
-func (vendorSnapshotImage) excludeFromSnapshot(m LinkableInterface) bool {
- return m.ExcludeFromVendorSnapshot()
-}
-
-func (vendorSnapshotImage) isUsingSnapshot(cfg android.DeviceConfig) bool {
- vndkVersion := cfg.VndkVersion()
- return vndkVersion != "current" && vndkVersion != ""
-}
-
-func (vendorSnapshotImage) targetSnapshotVersion(cfg android.DeviceConfig) string {
- return cfg.VndkVersion()
-}
-
-// returns true iff a given module SHOULD BE EXCLUDED, false if included
-func (vendorSnapshotImage) excludeFromDirectedSnapshot(cfg android.DeviceConfig, name string) bool {
- // If we're using full snapshot, not directed snapshot, capture every module
- if !cfg.DirectedVendorSnapshot() {
- return false
- }
- // Else, checks if name is in VENDOR_SNAPSHOT_MODULES.
- return !cfg.VendorSnapshotModules()[name]
+type recoverySnapshotImage struct {
+ *snapshot.RecoverySnapshotImage
}
func (vendorSnapshotImage) imageVariantName(cfg android.DeviceConfig) string {
@@ -194,62 +56,6 @@
return VendorSuffix
}
-func (recoverySnapshotImage) init(ctx android.RegistrationContext) {
- ctx.RegisterSingletonType("recovery-snapshot", RecoverySnapshotSingleton)
- ctx.RegisterModuleType("recovery_snapshot", recoverySnapshotFactory)
- ctx.RegisterModuleType("recovery_snapshot_shared", RecoverySnapshotSharedFactory)
- ctx.RegisterModuleType("recovery_snapshot_static", RecoverySnapshotStaticFactory)
- ctx.RegisterModuleType("recovery_snapshot_header", RecoverySnapshotHeaderFactory)
- ctx.RegisterModuleType("recovery_snapshot_binary", RecoverySnapshotBinaryFactory)
- ctx.RegisterModuleType("recovery_snapshot_object", RecoverySnapshotObjectFactory)
-}
-
-func (recoverySnapshotImage) shouldGenerateSnapshot(ctx android.SingletonContext) bool {
- // RECOVERY_SNAPSHOT_VERSION must be set to 'current' in order to generate a
- // snapshot.
- return ctx.DeviceConfig().RecoverySnapshotVersion() == "current"
-}
-
-func (recoverySnapshotImage) inImage(m LinkableInterface) func() bool {
- return m.InRecovery
-}
-
-// recovery snapshot does not have private libraries.
-func (recoverySnapshotImage) private(m LinkableInterface) bool {
- return false
-}
-
-func (recoverySnapshotImage) isProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool {
- return isDirectoryExcluded(dir, deviceConfig.RecoverySnapshotDirsExcludedMap(), deviceConfig.RecoverySnapshotDirsIncludedMap())
-}
-
-// recovery snapshot does NOT treat vndk specially.
-func (recoverySnapshotImage) includeVndk() bool {
- return false
-}
-
-func (recoverySnapshotImage) excludeFromSnapshot(m LinkableInterface) bool {
- return m.ExcludeFromRecoverySnapshot()
-}
-
-func (recoverySnapshotImage) isUsingSnapshot(cfg android.DeviceConfig) bool {
- recoverySnapshotVersion := cfg.RecoverySnapshotVersion()
- return recoverySnapshotVersion != "current" && recoverySnapshotVersion != ""
-}
-
-func (recoverySnapshotImage) targetSnapshotVersion(cfg android.DeviceConfig) string {
- return cfg.RecoverySnapshotVersion()
-}
-
-func (recoverySnapshotImage) excludeFromDirectedSnapshot(cfg android.DeviceConfig, name string) bool {
- // If we're using full snapshot, not directed snapshot, capture every module
- if !cfg.DirectedRecoverySnapshot() {
- return false
- }
- // Else, checks if name is in RECOVERY_SNAPSHOT_MODULES.
- return !cfg.RecoverySnapshotModules()[name]
-}
-
func (recoverySnapshotImage) imageVariantName(cfg android.DeviceConfig) string {
return android.RecoveryVariation
}
@@ -258,12 +64,31 @@
return recoverySuffix
}
-var VendorSnapshotImageSingleton vendorSnapshotImage
-var recoverySnapshotImageSingleton recoverySnapshotImage
+// Override existing vendor and recovery snapshot for cc module specific extra functions
+var VendorSnapshotImageSingleton vendorSnapshotImage = vendorSnapshotImage{&snapshot.VendorSnapshotImageSingleton}
+var recoverySnapshotImageSingleton recoverySnapshotImage = recoverySnapshotImage{&snapshot.RecoverySnapshotImageSingleton}
+
+func RegisterVendorSnapshotModules(ctx android.RegistrationContext) {
+ ctx.RegisterModuleType("vendor_snapshot", vendorSnapshotFactory)
+ ctx.RegisterModuleType("vendor_snapshot_shared", VendorSnapshotSharedFactory)
+ ctx.RegisterModuleType("vendor_snapshot_static", VendorSnapshotStaticFactory)
+ ctx.RegisterModuleType("vendor_snapshot_header", VendorSnapshotHeaderFactory)
+ ctx.RegisterModuleType("vendor_snapshot_binary", VendorSnapshotBinaryFactory)
+ ctx.RegisterModuleType("vendor_snapshot_object", VendorSnapshotObjectFactory)
+}
+
+func RegisterRecoverySnapshotModules(ctx android.RegistrationContext) {
+ ctx.RegisterModuleType("recovery_snapshot", recoverySnapshotFactory)
+ ctx.RegisterModuleType("recovery_snapshot_shared", RecoverySnapshotSharedFactory)
+ ctx.RegisterModuleType("recovery_snapshot_static", RecoverySnapshotStaticFactory)
+ ctx.RegisterModuleType("recovery_snapshot_header", RecoverySnapshotHeaderFactory)
+ ctx.RegisterModuleType("recovery_snapshot_binary", RecoverySnapshotBinaryFactory)
+ ctx.RegisterModuleType("recovery_snapshot_object", RecoverySnapshotObjectFactory)
+}
func init() {
- VendorSnapshotImageSingleton.Init(android.InitRegistrationContext)
- recoverySnapshotImageSingleton.init(android.InitRegistrationContext)
+ RegisterVendorSnapshotModules(android.InitRegistrationContext)
+ RegisterRecoverySnapshotModules(android.InitRegistrationContext)
android.RegisterMakeVarsProvider(pctx, snapshotMakeVarsProvider)
}
@@ -285,8 +110,7 @@
Binaries []string `android:"arch_variant"`
Objects []string `android:"arch_variant"`
}
-
-type snapshot struct {
+type snapshotModule struct {
android.ModuleBase
properties SnapshotProperties
@@ -296,41 +120,41 @@
image SnapshotImage
}
-func (s *snapshot) ImageMutatorBegin(ctx android.BaseModuleContext) {
+func (s *snapshotModule) ImageMutatorBegin(ctx android.BaseModuleContext) {
cfg := ctx.DeviceConfig()
- if !s.image.isUsingSnapshot(cfg) || s.image.targetSnapshotVersion(cfg) != s.baseSnapshot.Version() {
+ if !s.image.IsUsingSnapshot(cfg) || s.image.TargetSnapshotVersion(cfg) != s.baseSnapshot.Version() {
s.Disable()
}
}
-func (s *snapshot) CoreVariantNeeded(ctx android.BaseModuleContext) bool {
+func (s *snapshotModule) CoreVariantNeeded(ctx android.BaseModuleContext) bool {
return false
}
-func (s *snapshot) RamdiskVariantNeeded(ctx android.BaseModuleContext) bool {
+func (s *snapshotModule) RamdiskVariantNeeded(ctx android.BaseModuleContext) bool {
return false
}
-func (s *snapshot) VendorRamdiskVariantNeeded(ctx android.BaseModuleContext) bool {
+func (s *snapshotModule) VendorRamdiskVariantNeeded(ctx android.BaseModuleContext) bool {
return false
}
-func (s *snapshot) DebugRamdiskVariantNeeded(ctx android.BaseModuleContext) bool {
+func (s *snapshotModule) DebugRamdiskVariantNeeded(ctx android.BaseModuleContext) bool {
return false
}
-func (s *snapshot) RecoveryVariantNeeded(ctx android.BaseModuleContext) bool {
+func (s *snapshotModule) RecoveryVariantNeeded(ctx android.BaseModuleContext) bool {
return false
}
-func (s *snapshot) ExtraImageVariations(ctx android.BaseModuleContext) []string {
+func (s *snapshotModule) ExtraImageVariations(ctx android.BaseModuleContext) []string {
return []string{s.image.imageVariantName(ctx.DeviceConfig())}
}
-func (s *snapshot) SetImageVariation(ctx android.BaseModuleContext, variation string, module android.Module) {
+func (s *snapshotModule) SetImageVariation(ctx android.BaseModuleContext, variation string, module android.Module) {
}
-func (s *snapshot) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+func (s *snapshotModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
// Nothing, the snapshot module is only used to forward dependency information in DepsMutator.
}
@@ -342,7 +166,7 @@
return moduleSuffix + versionSuffix
}
-func (s *snapshot) DepsMutator(ctx android.BottomUpMutatorContext) {
+func (s *snapshotModule) DepsMutator(ctx android.BottomUpMutatorContext) {
collectSnapshotMap := func(names []string, snapshotSuffix, moduleSuffix string) map[string]string {
snapshotMap := make(map[string]string)
for _, name := range names {
@@ -382,12 +206,12 @@
var SnapshotInfoProvider = blueprint.NewMutatorProvider(SnapshotInfo{}, "deps")
-var _ android.ImageInterface = (*snapshot)(nil)
+var _ android.ImageInterface = (*snapshotModule)(nil)
func snapshotMakeVarsProvider(ctx android.MakeVarsContext) {
snapshotSet := map[string]struct{}{}
ctx.VisitAllModules(func(m android.Module) {
- if s, ok := m.(*snapshot); ok {
+ if s, ok := m.(*snapshotModule); ok {
if _, ok := snapshotSet[s.Name()]; ok {
// arch variant generates duplicated modules
// skip this as we only need to know the path of the module.
@@ -411,13 +235,13 @@
}
func snapshotFactory(image SnapshotImage) android.Module {
- snapshot := &snapshot{}
- snapshot.image = image
- snapshot.AddProperties(
- &snapshot.properties,
- &snapshot.baseSnapshot.baseProperties)
- android.InitAndroidArchModule(snapshot, android.DeviceSupported, android.MultilibBoth)
- return snapshot
+ snapshotModule := &snapshotModule{}
+ snapshotModule.image = image
+ snapshotModule.AddProperties(
+ &snapshotModule.properties,
+ &snapshotModule.baseSnapshot.baseProperties)
+ android.InitAndroidArchModule(snapshotModule, android.DeviceSupported, android.MultilibBoth)
+ return snapshotModule
}
type BaseSnapshotDecoratorProperties struct {
@@ -449,7 +273,7 @@
// will be seen as "libbase.vendor_static.30.arm64" by Soong.
type BaseSnapshotDecorator struct {
baseProperties BaseSnapshotDecoratorProperties
- image SnapshotImage
+ Image SnapshotImage
}
func (p *BaseSnapshotDecorator) Name(name string) string {
@@ -489,7 +313,7 @@
Variation: android.CoreVariation})
if ctx.OtherModuleFarDependencyVariantExists(variations, ctx.Module().(LinkableInterface).BaseModuleName()) {
- p.baseProperties.Androidmk_suffix = p.image.moduleNameSuffix()
+ p.baseProperties.Androidmk_suffix = p.Image.moduleNameSuffix()
return
}
@@ -498,14 +322,14 @@
Variation: ProductVariationPrefix + ctx.DeviceConfig().PlatformVndkVersion()})
if ctx.OtherModuleFarDependencyVariantExists(variations, ctx.Module().(LinkableInterface).BaseModuleName()) {
- p.baseProperties.Androidmk_suffix = p.image.moduleNameSuffix()
+ p.baseProperties.Androidmk_suffix = p.Image.moduleNameSuffix()
return
}
images := []SnapshotImage{VendorSnapshotImageSingleton, recoverySnapshotImageSingleton}
for _, image := range images {
- if p.image == image {
+ if p.Image == image {
continue
}
variations = append(ctx.Target().Variations(), blueprint.Variation{
@@ -518,7 +342,7 @@
image.moduleNameSuffix()+variant,
p.Version(),
ctx.DeviceConfig().Arches()[0].ArchType.String())) {
- p.baseProperties.Androidmk_suffix = p.image.moduleNameSuffix()
+ p.baseProperties.Androidmk_suffix = p.Image.moduleNameSuffix()
return
}
}
@@ -529,7 +353,7 @@
// Call this with a module suffix after creating a snapshot module, such as
// vendorSnapshotSharedSuffix, recoverySnapshotBinarySuffix, etc.
func (p *BaseSnapshotDecorator) Init(m LinkableInterface, image SnapshotImage, moduleSuffix string) {
- p.image = image
+ p.Image = image
p.baseProperties.ModuleSuffix = image.moduleNameSuffix() + moduleSuffix
m.AddProperties(&p.baseProperties)
android.AddLoadHook(m, func(ctx android.LoadHookContext) {
diff --git a/cc/snapshot_utils.go b/cc/snapshot_utils.go
index b0538be..24abcce 100644
--- a/cc/snapshot_utils.go
+++ b/cc/snapshot_utils.go
@@ -114,7 +114,7 @@
}
for _, image := range []SnapshotImage{VendorSnapshotImageSingleton, recoverySnapshotImageSingleton} {
- if isSnapshotAware(ctx.DeviceConfig(), m, image.isProprietaryPath(ctx.ModuleDir(), ctx.DeviceConfig()), apexInfo, image) {
+ if isSnapshotAware(ctx.DeviceConfig(), m, image.IsProprietaryPath(ctx.ModuleDir(), ctx.DeviceConfig()), apexInfo, image) {
return true
}
}
diff --git a/cc/stl.go b/cc/stl.go
index 06dc840..0f2a878 100644
--- a/cc/stl.go
+++ b/cc/stl.go
@@ -15,8 +15,9 @@
package cc
import (
- "android/soong/android"
"fmt"
+
+ "android/soong/android"
)
func getNdkStlFamily(m LinkableInterface) string {
@@ -92,26 +93,6 @@
ctx.ModuleErrorf("stl: %q is not a supported STL for windows", s)
return ""
}
- } else if ctx.Fuchsia() {
- switch s {
- case "c++_static":
- return "libc++_static"
- case "c++_shared":
- return "libc++"
- case "libc++", "libc++_static":
- return s
- case "none":
- return ""
- case "":
- if ctx.static() {
- return "libc++_static"
- } else {
- return "libc++"
- }
- default:
- ctx.ModuleErrorf("stl: %q is not a supported STL on Fuchsia", s)
- return ""
- }
} else {
switch s {
case "libc++", "libc++_static":
diff --git a/cc/testing.go b/cc/testing.go
index b9d84f6..19513e3 100644
--- a/cc/testing.go
+++ b/cc/testing.go
@@ -20,6 +20,7 @@
"android/soong/android"
"android/soong/genrule"
+ "android/soong/snapshot"
)
func RegisterRequiredBuildComponentsForTest(ctx android.RegistrationContext) {
@@ -44,9 +45,6 @@
supportLinuxBionic := false
for _, os := range oses {
- if os == android.Fuchsia {
- ret += withFuchsiaModules()
- }
if os == android.Windows {
ret += withWindowsModules()
}
@@ -471,19 +469,6 @@
`
}
-func withFuchsiaModules() string {
- return `
- cc_library {
- name: "libbioniccompat",
- stl: "none",
- }
- cc_library {
- name: "libcompiler_rt",
- stl: "none",
- }
- `
-}
-
func withLinuxBionic() string {
return `
cc_binary {
@@ -625,21 +610,15 @@
android.FixtureOverrideTextFile(linuxBionicDefaultsPath, withLinuxBionic()),
)
-// The preparer to include if running a cc related test for fuchsia.
-var PrepareForTestOnFuchsia = android.GroupFixturePreparers(
- // Place the default cc test modules for fuschia in a location that will not conflict with default
- // test modules defined by other packages.
- android.FixtureAddTextFile("defaults/cc/fuschia/Android.bp", withFuchsiaModules()),
- android.PrepareForTestSetDeviceToFuchsia,
-)
-
// This adds some additional modules and singletons which might negatively impact the performance
// of tests so they are not included in the PrepareForIntegrationTestWithCc.
var PrepareForTestWithCcIncludeVndk = android.GroupFixturePreparers(
PrepareForIntegrationTestWithCc,
android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
- VendorSnapshotImageSingleton.Init(ctx)
- recoverySnapshotImageSingleton.init(ctx)
+ snapshot.VendorSnapshotImageSingleton.Init(ctx)
+ snapshot.RecoverySnapshotImageSingleton.Init(ctx)
+ RegisterVendorSnapshotModules(ctx)
+ RegisterRecoverySnapshotModules(ctx)
ctx.RegisterSingletonType("vndk-snapshot", VndkSnapshotSingleton)
}),
)
@@ -663,14 +642,7 @@
mockFS[k] = v
}
- var config android.Config
- if os == android.Fuchsia {
- panic("Fuchsia not supported use test fixture instead")
- } else {
- config = android.TestArchConfig(buildDir, env, bp, mockFS)
- }
-
- return config
+ return android.TestArchConfig(buildDir, env, bp, mockFS)
}
// CreateTestContext is the legacy way of creating a TestContext for testing cc modules.
@@ -687,8 +659,10 @@
ctx.RegisterModuleType("filegroup", android.FileGroupFactory)
ctx.RegisterModuleType("vndk_prebuilt_shared", VndkPrebuiltSharedFactory)
- VendorSnapshotImageSingleton.Init(ctx)
- recoverySnapshotImageSingleton.init(ctx)
+ snapshot.VendorSnapshotImageSingleton.Init(ctx)
+ snapshot.RecoverySnapshotImageSingleton.Init(ctx)
+ RegisterVendorSnapshotModules(ctx)
+ RegisterRecoverySnapshotModules(ctx)
ctx.RegisterSingletonType("vndk-snapshot", VndkSnapshotSingleton)
RegisterVndkLibraryTxtTypes(ctx)
diff --git a/cc/util.go b/cc/util.go
index 1220d84..9bba876 100644
--- a/cc/util.go
+++ b/cc/util.go
@@ -21,6 +21,7 @@
"strings"
"android/soong/android"
+ "android/soong/snapshot"
)
// Efficiently converts a list of include directories to a single string
@@ -126,20 +127,6 @@
"ln -sf " + target + " " + filepath.Join(dir, linkName)
}
-func copyFileRule(ctx android.SingletonContext, path android.Path, out string) android.OutputPath {
- outPath := android.PathForOutput(ctx, out)
- ctx.Build(pctx, android.BuildParams{
- Rule: android.Cp,
- Input: path,
- Output: outPath,
- Description: "copy " + path.String() + " -> " + out,
- Args: map[string]string{
- "cpFlags": "-f -L",
- },
- })
- return outPath
-}
-
func combineNoticesRule(ctx android.SingletonContext, paths android.Paths, out string) android.OutputPath {
outPath := android.PathForOutput(ctx, out)
ctx.Build(pctx, android.BuildParams{
@@ -151,12 +138,6 @@
return outPath
}
-func writeStringToFileRule(ctx android.SingletonContext, content, out string) android.OutputPath {
- outPath := android.PathForOutput(ctx, out)
- android.WriteFileRule(ctx, outPath, content)
- return outPath
-}
-
// Dump a map to a list file as:
//
// {key1} {value1}
@@ -172,5 +153,5 @@
txtBuilder.WriteString(" ")
txtBuilder.WriteString(m[k])
}
- return writeStringToFileRule(ctx, txtBuilder.String(), path)
+ return snapshot.WriteStringToFileRule(ctx, txtBuilder.String(), path)
}
diff --git a/cc/vendor_snapshot.go b/cc/vendor_snapshot.go
index 003b7c9..ba4d79f 100644
--- a/cc/vendor_snapshot.go
+++ b/cc/vendor_snapshot.go
@@ -13,141 +13,46 @@
// limitations under the License.
package cc
-// This file contains singletons to capture vendor and recovery snapshot. They consist of prebuilt
-// modules under AOSP so older vendor and recovery can be built with a newer system in a single
-// source tree.
-
import (
"encoding/json"
"path/filepath"
- "sort"
"strings"
"android/soong/android"
+ "android/soong/snapshot"
)
-var vendorSnapshotSingleton = snapshotSingleton{
- "vendor",
- "SOONG_VENDOR_SNAPSHOT_ZIP",
- android.OptionalPath{},
- true,
- VendorSnapshotImageSingleton,
- false, /* fake */
-}
+// This file defines how to capture cc modules into snapshot package.
-var vendorFakeSnapshotSingleton = snapshotSingleton{
- "vendor",
- "SOONG_VENDOR_FAKE_SNAPSHOT_ZIP",
- android.OptionalPath{},
- true,
- VendorSnapshotImageSingleton,
- true, /* fake */
-}
-
-var recoverySnapshotSingleton = snapshotSingleton{
- "recovery",
- "SOONG_RECOVERY_SNAPSHOT_ZIP",
- android.OptionalPath{},
- false,
- recoverySnapshotImageSingleton,
- false, /* fake */
-}
-
-func VendorSnapshotSingleton() android.Singleton {
- return &vendorSnapshotSingleton
-}
-
-func VendorFakeSnapshotSingleton() android.Singleton {
- return &vendorFakeSnapshotSingleton
-}
-
-func RecoverySnapshotSingleton() android.Singleton {
- return &recoverySnapshotSingleton
-}
-
-type snapshotSingleton struct {
- // Name, e.g., "vendor", "recovery", "ramdisk".
- name string
-
- // Make variable that points to the snapshot file, e.g.,
- // "SOONG_RECOVERY_SNAPSHOT_ZIP".
- makeVar string
-
- // Path to the snapshot zip file.
- snapshotZipFile android.OptionalPath
-
- // Whether the image supports VNDK extension modules.
- supportsVndkExt bool
-
- // Implementation of the image interface specific to the image
- // associated with this snapshot (e.g., specific to the vendor image,
- // recovery image, etc.).
- image SnapshotImage
-
- // Whether this singleton is for fake snapshot or not.
- // Fake snapshot is a snapshot whose prebuilt binaries and headers are empty.
- // It is much faster to generate, and can be used to inspect dependencies.
- fake bool
-}
-
-// Determine if a dir under source tree is an SoC-owned proprietary directory based
-// on vendor snapshot configuration
-// Examples: device/, vendor/
-func isVendorProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool {
- return VendorSnapshotSingleton().(*snapshotSingleton).image.isProprietaryPath(dir, deviceConfig)
-}
-
-// Determine if a dir under source tree is an SoC-owned proprietary directory based
-// on recovery snapshot configuration
-// Examples: device/, vendor/
-func isRecoveryProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool {
- return RecoverySnapshotSingleton().(*snapshotSingleton).image.isProprietaryPath(dir, deviceConfig)
-}
-
-func IsVendorProprietaryModule(ctx android.BaseModuleContext) bool {
- // Any module in a vendor proprietary path is a vendor proprietary
- // module.
- if isVendorProprietaryPath(ctx.ModuleDir(), ctx.DeviceConfig()) {
+// Checks if the target image would contain VNDK
+func includeVndk(image snapshot.SnapshotImage) bool {
+ if image.ImageName() == snapshot.VendorSnapshotImageName {
return true
}
- // However if the module is not in a vendor proprietary path, it may
- // still be a vendor proprietary module. This happens for cc modules
- // that are excluded from the vendor snapshot, and it means that the
- // vendor has assumed control of the framework-provided module.
- if c, ok := ctx.Module().(LinkableInterface); ok {
- if c.ExcludeFromVendorSnapshot() {
- return true
- }
- }
-
return false
}
-func isRecoveryProprietaryModule(ctx android.BaseModuleContext) bool {
-
- // Any module in a recovery proprietary path is a recovery proprietary
- // module.
- if isRecoveryProprietaryPath(ctx.ModuleDir(), ctx.DeviceConfig()) {
+// Check if the module is VNDK private
+func isPrivate(image snapshot.SnapshotImage, m LinkableInterface) bool {
+ if image.ImageName() == snapshot.VendorSnapshotImageName && m.IsVndkPrivate() {
return true
}
- // However if the module is not in a recovery proprietary path, it may
- // still be a recovery proprietary module. This happens for cc modules
- // that are excluded from the recovery snapshot, and it means that the
- // vendor has assumed control of the framework-provided module.
+ return false
+}
- if c, ok := ctx.Module().(LinkableInterface); ok {
- if c.ExcludeFromRecoverySnapshot() {
- return true
- }
+// Checks if target image supports VNDK Ext
+func supportsVndkExt(image snapshot.SnapshotImage) bool {
+ if image.ImageName() == snapshot.VendorSnapshotImageName {
+ return true
}
return false
}
// Determines if the module is a candidate for snapshot.
-func isSnapshotAware(cfg android.DeviceConfig, m LinkableInterface, inProprietaryPath bool, apexInfo android.ApexInfo, image SnapshotImage) bool {
+func isSnapshotAware(cfg android.DeviceConfig, m LinkableInterface, inProprietaryPath bool, apexInfo android.ApexInfo, image snapshot.SnapshotImage) bool {
if !m.Enabled() || m.HiddenFromMake() {
return false
}
@@ -158,12 +63,12 @@
}
// skip proprietary modules, but (for the vendor snapshot only)
// include all VNDK (static)
- if inProprietaryPath && (!image.includeVndk() || !m.IsVndk()) {
+ if inProprietaryPath && (!includeVndk(image) || !m.IsVndk()) {
return false
}
// If the module would be included based on its path, check to see if
// the module is marked to be excluded. If so, skip it.
- if image.excludeFromSnapshot(m) {
+ if image.ExcludeFromSnapshot(m) {
return false
}
if m.Target().Os.Class != android.Device {
@@ -173,7 +78,7 @@
return false
}
// the module must be installed in target image
- if !apexInfo.IsForPlatform() || m.IsSnapshotPrebuilt() || !image.inImage(m)() {
+ if !apexInfo.IsForPlatform() || m.IsSnapshotPrebuilt() || !image.InImage(m)() {
return false
}
// skip kernel_headers which always depend on vendor
@@ -203,13 +108,13 @@
}
}
if sanitizable.Static() {
- return sanitizable.OutputFile().Valid() && !image.private(m)
+ return sanitizable.OutputFile().Valid() && !isPrivate(image, m)
}
if sanitizable.Shared() || sanitizable.Rlib() {
if !sanitizable.OutputFile().Valid() {
return false
}
- if image.includeVndk() {
+ if includeVndk(image) {
if !sanitizable.IsVndk() {
return true
}
@@ -256,15 +161,9 @@
VintfFragments []string `json:",omitempty"`
}
-func (c *snapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) {
- if !c.image.shouldGenerateSnapshot(ctx) {
- return
- }
-
- var snapshotOutputs android.Paths
-
+var ccSnapshotAction snapshot.GenerateSnapshotAction = func(s snapshot.SnapshotSingleton, ctx android.SingletonContext, snapshotArchDir string) android.Paths {
/*
- Vendor snapshot zipped artifacts directory structure:
+ Vendor snapshot zipped artifacts directory structure for cc modules:
{SNAPSHOT_ARCH}/
arch-{TARGET_ARCH}-{TARGET_ARCH_VARIANT}/
shared/
@@ -296,13 +195,7 @@
(header files of same directory structure with source tree)
*/
- snapshotDir := c.name + "-snapshot"
- if c.fake {
- // If this is a fake snapshot singleton, place all files under fake/ subdirectory to avoid
- // collision with real snapshot files
- snapshotDir = filepath.Join("fake", snapshotDir)
- }
- snapshotArchDir := filepath.Join(snapshotDir, ctx.DeviceConfig().DeviceArch())
+ var snapshotOutputs android.Paths
includeDir := filepath.Join(snapshotArchDir, "include")
configsDir := filepath.Join(snapshotArchDir, "configs")
@@ -317,9 +210,9 @@
if fake {
// All prebuilt binaries and headers are installed by copyFile function. This makes a fake
// snapshot just touch prebuilts and headers, rather than installing real files.
- return writeStringToFileRule(ctx, "", out)
+ return snapshot.WriteStringToFileRule(ctx, "", out)
} else {
- return copyFileRule(ctx, path, out)
+ return snapshot.CopyFileRule(pctx, ctx, path, out)
}
}
@@ -337,7 +230,7 @@
// Common properties among snapshots.
prop.ModuleName = ctx.ModuleName(m)
- if c.supportsVndkExt && m.IsVndkExt() {
+ if supportsVndkExt(s.Image) && m.IsVndkExt() {
// vndk exts are installed to /vendor/lib(64)?/vndk(-sp)?
if m.IsVndkSp() {
prop.RelativeInstallPath = "vndk-sp"
@@ -457,7 +350,7 @@
ctx.Errorf("json marshal to %q failed: %#v", propOut, err)
return nil
}
- ret = append(ret, writeStringToFileRule(ctx, string(j), propOut))
+ ret = append(ret, snapshot.WriteStringToFileRule(ctx, string(j), propOut))
return ret
}
@@ -469,10 +362,10 @@
}
moduleDir := ctx.ModuleDir(module)
- inProprietaryPath := c.image.isProprietaryPath(moduleDir, ctx.DeviceConfig())
+ inProprietaryPath := s.Image.IsProprietaryPath(moduleDir, ctx.DeviceConfig())
apexInfo := ctx.ModuleProvider(module, android.ApexInfoProvider).(android.ApexInfo)
- if c.image.excludeFromSnapshot(m) {
+ if s.Image.ExcludeFromSnapshot(m) {
if inProprietaryPath {
// Error: exclude_from_vendor_snapshot applies
// to framework-path modules only.
@@ -481,7 +374,7 @@
}
}
- if !isSnapshotAware(ctx.DeviceConfig(), m, inProprietaryPath, apexInfo, c.image) {
+ if !isSnapshotAware(ctx.DeviceConfig(), m, inProprietaryPath, apexInfo, s.Image) {
return
}
@@ -489,8 +382,8 @@
// list, we will still include the module as if it was a fake module.
// The reason is that soong needs all the dependencies to be present, even
// if they are not using during the build.
- installAsFake := c.fake
- if c.image.excludeFromDirectedSnapshot(ctx.DeviceConfig(), m.BaseModuleName()) {
+ installAsFake := s.Fake
+ if s.Image.ExcludeFromDirectedSnapshot(ctx.DeviceConfig(), m.BaseModuleName()) {
installAsFake = true
}
@@ -514,47 +407,12 @@
// install all headers after removing duplicates
for _, header := range android.FirstUniquePaths(headers) {
- snapshotOutputs = append(snapshotOutputs, copyFile(ctx, header, filepath.Join(includeDir, header.String()), c.fake))
+ snapshotOutputs = append(snapshotOutputs, copyFile(ctx, header, filepath.Join(includeDir, header.String()), s.Fake))
}
- // All artifacts are ready. Sort them to normalize ninja and then zip.
- sort.Slice(snapshotOutputs, func(i, j int) bool {
- return snapshotOutputs[i].String() < snapshotOutputs[j].String()
- })
-
- zipPath := android.PathForOutput(
- ctx,
- snapshotDir,
- c.name+"-"+ctx.Config().DeviceName()+".zip")
- zipRule := android.NewRuleBuilder(pctx, ctx)
-
- // filenames in rspfile from FlagWithRspFileInputList might be single-quoted. Remove it with tr
- snapshotOutputList := android.PathForOutput(
- ctx,
- snapshotDir,
- c.name+"-"+ctx.Config().DeviceName()+"_list")
- rspFile := snapshotOutputList.ReplaceExtension(ctx, "rsp")
- zipRule.Command().
- Text("tr").
- FlagWithArg("-d ", "\\'").
- FlagWithRspFileInputList("< ", rspFile, snapshotOutputs).
- FlagWithOutput("> ", snapshotOutputList)
-
- zipRule.Temporary(snapshotOutputList)
-
- zipRule.Command().
- BuiltTool("soong_zip").
- FlagWithOutput("-o ", zipPath).
- FlagWithArg("-C ", android.PathForOutput(ctx, snapshotDir).String()).
- FlagWithInput("-l ", snapshotOutputList)
-
- zipRule.Build(zipPath.String(), c.name+" snapshot "+zipPath.String())
- zipRule.DeleteTemporaryFiles()
- c.snapshotZipFile = android.OptionalPathForPath(zipPath)
+ return snapshotOutputs
}
-func (c *snapshotSingleton) MakeVars(ctx android.MakeVarsContext) {
- ctx.Strict(
- c.makeVar,
- c.snapshotZipFile.String())
+func init() {
+ snapshot.RegisterSnapshotAction(ccSnapshotAction)
}
diff --git a/cc/vndk.go b/cc/vndk.go
index 499d428..1ae79de 100644
--- a/cc/vndk.go
+++ b/cc/vndk.go
@@ -25,6 +25,7 @@
"android/soong/android"
"android/soong/cc/config"
"android/soong/etc"
+ "android/soong/snapshot"
"github.com/google/blueprint"
)
@@ -698,7 +699,7 @@
libPath := m.outputFile.Path()
snapshotLibOut := filepath.Join(snapshotArchDir, targetArch, "shared", vndkType, libPath.Base())
- ret = append(ret, copyFileRule(ctx, libPath, snapshotLibOut))
+ ret = append(ret, snapshot.CopyFileRule(pctx, ctx, libPath, snapshotLibOut))
if ctx.Config().VndkSnapshotBuildArtifacts() {
prop := struct {
@@ -720,7 +721,7 @@
ctx.Errorf("json marshal to %q failed: %#v", propOut, err)
return nil, false
}
- ret = append(ret, writeStringToFileRule(ctx, string(j), propOut))
+ ret = append(ret, snapshot.WriteStringToFileRule(ctx, string(j), propOut))
}
return ret, true
}
@@ -778,8 +779,8 @@
// install all headers after removing duplicates
for _, header := range android.FirstUniquePaths(headers) {
- snapshotOutputs = append(snapshotOutputs, copyFileRule(
- ctx, header, filepath.Join(includeDir, header.String())))
+ snapshotOutputs = append(snapshotOutputs, snapshot.CopyFileRule(
+ pctx, ctx, header, filepath.Join(includeDir, header.String())))
}
// install *.libraries.txt except vndkcorevariant.libraries.txt
@@ -788,8 +789,8 @@
if !ok || !m.Enabled() || m.Name() == vndkUsingCoreVariantLibrariesTxt {
return
}
- snapshotOutputs = append(snapshotOutputs, copyFileRule(
- ctx, m.OutputFile(), filepath.Join(configsDir, m.Name())))
+ snapshotOutputs = append(snapshotOutputs, snapshot.CopyFileRule(
+ pctx, ctx, m.OutputFile(), filepath.Join(configsDir, m.Name())))
})
/*
diff --git a/cmd/extract_linker/main.go b/cmd/extract_linker/main.go
index 2dcb894..f1f7bc7 100644
--- a/cmd/extract_linker/main.go
+++ b/cmd/extract_linker/main.go
@@ -85,7 +85,7 @@
fmt.Fprintf(asm, ".globl %s\n%s:\n\n", symName, symName)
- fmt.Fprintf(script, " %s %d : {\n", sectionName, baseLoadAddr+prog.Vaddr)
+ fmt.Fprintf(script, " %s 0x%x : {\n", sectionName, baseLoadAddr+prog.Vaddr)
fmt.Fprintf(script, " KEEP(*(%s));\n", sectionName)
fmt.Fprintln(script, " }")
@@ -106,8 +106,10 @@
load += 1
}
+ fmt.Fprintln(asm, `.section .note.android.embedded_linker,"a",%note`)
+
fmt.Fprintln(script, "}")
- fmt.Fprintln(script, "INSERT BEFORE .note.android.ident;")
+ fmt.Fprintln(script, "INSERT BEFORE .note.android.embedded_linker;")
if asmPath != "" {
if err := ioutil.WriteFile(asmPath, asm.Bytes(), 0777); err != nil {
diff --git a/cmd/go2bp/go2bp.go b/cmd/go2bp/go2bp.go
index 67138f1..07cb5df 100644
--- a/cmd/go2bp/go2bp.go
+++ b/cmd/go2bp/go2bp.go
@@ -88,11 +88,24 @@
var excludeDeps = make(Exclude)
var excludeSrcs = make(Exclude)
+type StringList []string
+
+func (l *StringList) String() string {
+ return strings.Join(*l, " ")
+}
+
+func (l *StringList) Set(v string) error {
+ *l = append(*l, strings.Fields(v)...)
+ return nil
+}
+
type GoModule struct {
Dir string
}
type GoPackage struct {
+ ExportToAndroid bool
+
Dir string
ImportPath string
Name string
@@ -117,7 +130,7 @@
func (g GoPackage) BpName() string {
if g.IsCommand() {
- return filepath.Base(g.ImportPath)
+ return rewriteNames.GoToBp(filepath.Base(g.ImportPath))
}
return rewriteNames.GoToBp(g.ImportPath)
}
@@ -279,6 +292,10 @@
Don't put the specified go package in the dependency lists.
-exclude-srcs <module>
Don't put the specified source files in srcs or testSrcs lists.
+ -limit <package>
+ If set, limit the output to the specified packages and their dependencies.
+ -skip-tests
+ If passed, don't write out any test srcs or dependencies to the Android.bp output.
-regen <file>
Read arguments from <file> and overwrite it.
@@ -286,11 +303,15 @@
}
var regen string
+ var skipTests bool
+ limit := StringList{}
flag.Var(&excludes, "exclude", "Exclude go package")
flag.Var(&excludeDeps, "exclude-dep", "Exclude go package from deps")
flag.Var(&excludeSrcs, "exclude-src", "Exclude go file from source lists")
flag.Var(&rewriteNames, "rewrite", "Regex(es) to rewrite artifact names")
+ flag.Var(&limit, "limit", "If set, only includes the dependencies of the listed packages")
+ flag.BoolVar(&skipTests, "skip-tests", false, "Whether to skip test sources")
flag.StringVar(®en, "regen", "", "Rewrite specified file")
flag.Parse()
@@ -321,7 +342,8 @@
}
decoder := json.NewDecoder(bytes.NewReader(output))
- pkgs := []GoPackage{}
+ pkgs := []*GoPackage{}
+ pkgMap := map[string]*GoPackage{}
for decoder.More() {
pkg := GoPackage{}
err := decoder.Decode(&pkg)
@@ -329,7 +351,15 @@
fmt.Fprintf(os.Stderr, "Failed to parse json: %v\n", err)
os.Exit(1)
}
- pkgs = append(pkgs, pkg)
+ if len(limit) == 0 {
+ pkg.ExportToAndroid = true
+ }
+ if skipTests {
+ pkg.TestGoFiles = nil
+ pkg.TestImports = nil
+ }
+ pkgs = append(pkgs, &pkg)
+ pkgMap[pkg.ImportPath] = &pkg
}
buf := &bytes.Buffer{}
@@ -337,8 +367,27 @@
fmt.Fprintln(buf, "// Automatically generated with:")
fmt.Fprintln(buf, "// go2bp", strings.Join(proptools.ShellEscapeList(os.Args[1:]), " "))
+ var mark func(string)
+ mark = func(pkgName string) {
+ if excludes[pkgName] {
+ return
+ }
+ if pkg, ok := pkgMap[pkgName]; ok && !pkg.ExportToAndroid {
+ pkg.ExportToAndroid = true
+ for _, dep := range pkg.AllImports() {
+ if !excludeDeps[dep] {
+ mark(dep)
+ }
+ }
+ }
+ }
+
+ for _, pkgName := range limit {
+ mark(pkgName)
+ }
+
for _, pkg := range pkgs {
- if excludes[pkg.ImportPath] {
+ if !pkg.ExportToAndroid || excludes[pkg.ImportPath] {
continue
}
if len(pkg.BpSrcs(pkg.GoFiles)) == 0 && len(pkg.BpSrcs(pkg.TestGoFiles)) == 0 {
diff --git a/dexpreopt/class_loader_context.go b/dexpreopt/class_loader_context.go
index 94b9adf..245af2c 100644
--- a/dexpreopt/class_loader_context.go
+++ b/dexpreopt/class_loader_context.go
@@ -286,11 +286,19 @@
}
subcontexts := nestedClcMap[AnySdkVersion]
- // If the library with this name is already present as one of the unconditional top-level
- // components, do not re-add it.
+ // Check if the library with this name is already present in unconditional top-level CLC.
for _, clc := range clcMap[sdkVer] {
- if clc.Name == lib {
+ if clc.Name != lib {
+ // Ok, a different library.
+ } else if clc.Host == hostPath && clc.Device == devicePath {
+ // Ok, the same library with the same paths. Don't re-add it, but don't raise an error
+ // either, as the same library may be reachable via different transitional dependencies.
return nil
+ } else {
+ // Fail, as someone is trying to add the same library with different paths. This likely
+ // indicates an error somewhere else, like trying to add a stub library.
+ return fmt.Errorf("a <uses-library> named %q is already in class loader context,"+
+ "but the library paths are different:\t\n", lib)
}
}
diff --git a/etc/Android.bp b/etc/Android.bp
index cab7389..06a2fa1 100644
--- a/etc/Android.bp
+++ b/etc/Android.bp
@@ -9,6 +9,7 @@
"blueprint",
"soong",
"soong-android",
+ "soong-snapshot",
],
srcs: [
"prebuilt_etc.go",
diff --git a/etc/prebuilt_etc.go b/etc/prebuilt_etc.go
index 4dd383d..4107916 100644
--- a/etc/prebuilt_etc.go
+++ b/etc/prebuilt_etc.go
@@ -28,12 +28,15 @@
// various `prebuilt_*` mutators.
import (
+ "encoding/json"
"fmt"
+ "path/filepath"
"strings"
"github.com/google/blueprint/proptools"
"android/soong/android"
+ "android/soong/snapshot"
)
var pctx = android.NewPackageContext("android/soong/etc")
@@ -43,6 +46,7 @@
func init() {
pctx.Import("android/soong/android")
RegisterPrebuiltEtcBuildComponents(android.InitRegistrationContext)
+ snapshot.RegisterSnapshotAction(generatePrebuiltSnapshot)
}
func RegisterPrebuiltEtcBuildComponents(ctx android.RegistrationContext) {
@@ -128,6 +132,9 @@
android.ModuleBase
android.DefaultableModuleBase
+ snapshot.VendorSnapshotModuleInterface
+ snapshot.RecoverySnapshotModuleInterface
+
properties prebuiltEtcProperties
subdirProperties prebuiltSubdirProperties
@@ -183,7 +190,7 @@
return p.inDebugRamdisk()
}
-func (p *PrebuiltEtc) inRecovery() bool {
+func (p *PrebuiltEtc) InRecovery() bool {
return p.ModuleBase.InRecovery() || p.ModuleBase.InstallInRecovery()
}
@@ -192,7 +199,7 @@
}
func (p *PrebuiltEtc) InstallInRecovery() bool {
- return p.inRecovery()
+ return p.InRecovery()
}
var _ android.ImageInterface = (*PrebuiltEtc)(nil)
@@ -271,6 +278,18 @@
return p.properties.Installable == nil || proptools.Bool(p.properties.Installable)
}
+func (p *PrebuiltEtc) InVendor() bool {
+ return p.ModuleBase.InstallInVendor()
+}
+
+func (p *PrebuiltEtc) ExcludeFromVendorSnapshot() bool {
+ return false
+}
+
+func (p *PrebuiltEtc) ExcludeFromRecoverySnapshot() bool {
+ return false
+}
+
func (p *PrebuiltEtc) GenerateAndroidBuildActions(ctx android.ModuleContext) {
if p.properties.Src == nil {
ctx.PropertyErrorf("src", "missing prebuilt source file")
@@ -344,7 +363,7 @@
if p.inDebugRamdisk() && !p.onlyInDebugRamdisk() {
nameSuffix = ".debug_ramdisk"
}
- if p.inRecovery() && !p.onlyInRecovery() {
+ if p.InRecovery() && !p.onlyInRecovery() {
nameSuffix = ".recovery"
}
return []android.AndroidMkEntries{android.AndroidMkEntries{
@@ -494,3 +513,137 @@
android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibFirst)
return module
}
+
+// Flags to be included in the snapshot
+type snapshotJsonFlags struct {
+ ModuleName string `json:",omitempty"`
+ Filename string `json:",omitempty"`
+ RelativeInstallPath string `json:",omitempty"`
+}
+
+// Copy file into the snapshot
+func copyFile(ctx android.SingletonContext, path android.Path, out string, fake bool) android.OutputPath {
+ if fake {
+ // Create empty file instead for the fake snapshot
+ return snapshot.WriteStringToFileRule(ctx, "", out)
+ } else {
+ return snapshot.CopyFileRule(pctx, ctx, path, out)
+ }
+}
+
+// Check if the module is target of the snapshot
+func isSnapshotAware(ctx android.SingletonContext, m *PrebuiltEtc, image snapshot.SnapshotImage) bool {
+ if !m.Enabled() {
+ return false
+ }
+
+ // Skip if the module is not included in the image
+ if !image.InImage(m)() {
+ return false
+ }
+
+ // When android/prebuilt.go selects between source and prebuilt, it sets
+ // HideFromMake on the other one to avoid duplicate install rules in make.
+ if m.IsHideFromMake() {
+ return false
+ }
+
+ // There are some prebuilt_etc module with multiple definition of same name.
+ // Check if the target would be included from the build
+ if !m.ExportedToMake() {
+ return false
+ }
+
+ // Skip if the module is in the predefined path list to skip
+ if image.IsProprietaryPath(ctx.ModuleDir(m), ctx.DeviceConfig()) {
+ return false
+ }
+
+ // Skip if the module should be excluded
+ if image.ExcludeFromSnapshot(m) || image.ExcludeFromDirectedSnapshot(ctx.DeviceConfig(), m.BaseModuleName()) {
+ return false
+ }
+
+ // Skip from other exceptional cases
+ if m.Target().Os.Class != android.Device {
+ return false
+ }
+ if m.Target().NativeBridge == android.NativeBridgeEnabled {
+ return false
+ }
+
+ return true
+}
+
+func generatePrebuiltSnapshot(s snapshot.SnapshotSingleton, ctx android.SingletonContext, snapshotArchDir string) android.Paths {
+ /*
+ Snapshot zipped artifacts directory structure for etc modules:
+ {SNAPSHOT_ARCH}/
+ arch-{TARGET_ARCH}-{TARGET_ARCH_VARIANT}/
+ etc/
+ (prebuilt etc files)
+ arch-{TARGET_2ND_ARCH}-{TARGET_2ND_ARCH_VARIANT}/
+ etc/
+ (prebuilt etc files)
+ NOTICE_FILES/
+ (notice files)
+ */
+ var snapshotOutputs android.Paths
+ noticeDir := filepath.Join(snapshotArchDir, "NOTICE_FILES")
+ installedNotices := make(map[string]bool)
+
+ ctx.VisitAllModules(func(module android.Module) {
+ m, ok := module.(*PrebuiltEtc)
+ if !ok {
+ return
+ }
+
+ if !isSnapshotAware(ctx, m, s.Image) {
+ return
+ }
+
+ targetArch := "arch-" + m.Target().Arch.ArchType.String()
+
+ snapshotLibOut := filepath.Join(snapshotArchDir, targetArch, "etc", m.BaseModuleName())
+ snapshotOutputs = append(snapshotOutputs, copyFile(ctx, m.OutputFile(), snapshotLibOut, s.Fake))
+
+ prop := snapshotJsonFlags{}
+ propOut := snapshotLibOut + ".json"
+ prop.ModuleName = m.BaseModuleName()
+ if m.subdirProperties.Relative_install_path != nil {
+ prop.RelativeInstallPath = *m.subdirProperties.Relative_install_path
+ }
+
+ if m.properties.Filename != nil {
+ prop.Filename = *m.properties.Filename
+ }
+
+ j, err := json.Marshal(prop)
+ if err != nil {
+ ctx.Errorf("json marshal to %q failed: %#v", propOut, err)
+ return
+ }
+ snapshotOutputs = append(snapshotOutputs, snapshot.WriteStringToFileRule(ctx, string(j), propOut))
+
+ if len(m.EffectiveLicenseFiles()) > 0 {
+ noticeName := ctx.ModuleName(m) + ".txt"
+ noticeOut := filepath.Join(noticeDir, noticeName)
+ // skip already copied notice file
+ if !installedNotices[noticeOut] {
+ installedNotices[noticeOut] = true
+
+ noticeOutPath := android.PathForOutput(ctx, noticeOut)
+ ctx.Build(pctx, android.BuildParams{
+ Rule: android.Cat,
+ Inputs: m.EffectiveLicenseFiles(),
+ Output: noticeOutPath,
+ Description: "combine notices for " + noticeOut,
+ })
+ snapshotOutputs = append(snapshotOutputs, noticeOutPath)
+ }
+ }
+
+ })
+
+ return snapshotOutputs
+}
diff --git a/etc/prebuilt_etc_test.go b/etc/prebuilt_etc_test.go
index 354f6bb..cf1f6d7 100644
--- a/etc/prebuilt_etc_test.go
+++ b/etc/prebuilt_etc_test.go
@@ -15,11 +15,15 @@
package etc
import (
+ "fmt"
"os"
"path/filepath"
"testing"
+ "github.com/google/blueprint/proptools"
+
"android/soong/android"
+ "android/soong/snapshot"
)
func TestMain(m *testing.M) {
@@ -36,6 +40,18 @@
}),
)
+var prepareForPrebuiltEtcSnapshotTest = android.GroupFixturePreparers(
+ prepareForPrebuiltEtcTest,
+ android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
+ snapshot.VendorSnapshotImageSingleton.Init(ctx)
+ snapshot.RecoverySnapshotImageSingleton.Init(ctx)
+ }),
+ android.FixtureModifyConfig(func(config android.Config) {
+ config.TestProductVariables.DeviceVndkVersion = proptools.StringPtr("current")
+ config.TestProductVariables.RecoverySnapshotVersion = proptools.StringPtr("current")
+ }),
+)
+
func TestPrebuiltEtcVariants(t *testing.T) {
result := prepareForPrebuiltEtcTest.RunTestWithBp(t, `
prebuilt_etc {
@@ -172,7 +188,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := result.Config.BuildOS.String()
p := result.Module("foo.conf", buildOS+"_common").(*PrebuiltEtc)
if !p.Host() {
t.Errorf("host bit is not set for a prebuilt_etc_host module.")
@@ -226,7 +242,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := result.Config.BuildOS.String()
p := result.Module("foo.conf", buildOS+"_common").(*PrebuiltEtc)
expected := filepath.Join("out/soong/host", result.Config.PrebuiltOS(), "usr", "share", "bar")
android.AssertPathRelativeToTopEquals(t, "install dir", expected, p.installDirPath)
@@ -346,3 +362,110 @@
})
}
}
+
+func checkIfSnapshotTaken(t *testing.T, result *android.TestResult, image string, moduleName string) {
+ checkIfSnapshotExistAsExpected(t, result, image, moduleName, true)
+}
+
+func checkIfSnapshotNotTaken(t *testing.T, result *android.TestResult, image string, moduleName string) {
+ checkIfSnapshotExistAsExpected(t, result, image, moduleName, false)
+}
+
+func checkIfSnapshotExistAsExpected(t *testing.T, result *android.TestResult, image string, moduleName string, expectToExist bool) {
+ snapshotSingleton := result.SingletonForTests(image + "-snapshot")
+ archType := "arm64"
+ archVariant := "armv8-a"
+ archDir := fmt.Sprintf("arch-%s", archType)
+
+ snapshotDir := fmt.Sprintf("%s-snapshot", image)
+ snapshotVariantPath := filepath.Join(snapshotDir, archType)
+ outputDir := filepath.Join(snapshotVariantPath, archDir, "etc")
+ imageVariant := ""
+ if image == "recovery" {
+ imageVariant = "recovery_"
+ }
+ mod := result.ModuleForTests(moduleName, fmt.Sprintf("android_%s%s_%s", imageVariant, archType, archVariant))
+ outputFiles := mod.OutputFiles(t, "")
+ if len(outputFiles) != 1 {
+ t.Errorf("%q must have single output\n", moduleName)
+ return
+ }
+ snapshotPath := filepath.Join(outputDir, moduleName)
+
+ if expectToExist {
+ out := snapshotSingleton.Output(snapshotPath)
+
+ if out.Input.String() != outputFiles[0].String() {
+ t.Errorf("The input of snapshot %q must be %q, but %q", "prebuilt_vendor", out.Input.String(), outputFiles[0])
+ }
+
+ snapshotJsonPath := snapshotPath + ".json"
+
+ if snapshotSingleton.MaybeOutput(snapshotJsonPath).Rule == nil {
+ t.Errorf("%q expected but not found", snapshotJsonPath)
+ }
+ } else {
+ out := snapshotSingleton.MaybeOutput(snapshotPath)
+ if out.Rule != nil {
+ t.Errorf("There must be no rule for module %q output file %q", moduleName, outputFiles[0])
+ }
+ }
+}
+
+func TestPrebuiltTakeSnapshot(t *testing.T) {
+ var testBp = `
+ prebuilt_etc {
+ name: "prebuilt_vendor",
+ src: "foo.conf",
+ vendor: true,
+ }
+
+ prebuilt_etc {
+ name: "prebuilt_vendor_indirect",
+ src: "foo.conf",
+ vendor: true,
+ }
+
+ prebuilt_etc {
+ name: "prebuilt_recovery",
+ src: "bar.conf",
+ recovery: true,
+ }
+
+ prebuilt_etc {
+ name: "prebuilt_recovery_indirect",
+ src: "bar.conf",
+ recovery: true,
+ }
+ `
+
+ t.Run("prebuilt: vendor and recovery snapshot", func(t *testing.T) {
+ result := prepareForPrebuiltEtcSnapshotTest.RunTestWithBp(t, testBp)
+
+ checkIfSnapshotTaken(t, result, "vendor", "prebuilt_vendor")
+ checkIfSnapshotTaken(t, result, "vendor", "prebuilt_vendor_indirect")
+ checkIfSnapshotTaken(t, result, "recovery", "prebuilt_recovery")
+ checkIfSnapshotTaken(t, result, "recovery", "prebuilt_recovery_indirect")
+ })
+
+ t.Run("prebuilt: directed snapshot", func(t *testing.T) {
+ prepareForPrebuiltEtcDirectedSnapshotTest := android.GroupFixturePreparers(
+ prepareForPrebuiltEtcSnapshotTest,
+ android.FixtureModifyConfig(func(config android.Config) {
+ config.TestProductVariables.DirectedVendorSnapshot = true
+ config.TestProductVariables.VendorSnapshotModules = make(map[string]bool)
+ config.TestProductVariables.VendorSnapshotModules["prebuilt_vendor"] = true
+ config.TestProductVariables.DirectedRecoverySnapshot = true
+ config.TestProductVariables.RecoverySnapshotModules = make(map[string]bool)
+ config.TestProductVariables.RecoverySnapshotModules["prebuilt_recovery"] = true
+ }),
+ )
+
+ result := prepareForPrebuiltEtcDirectedSnapshotTest.RunTestWithBp(t, testBp)
+
+ checkIfSnapshotTaken(t, result, "vendor", "prebuilt_vendor")
+ checkIfSnapshotNotTaken(t, result, "vendor", "prebuilt_vendor_indirect")
+ checkIfSnapshotTaken(t, result, "recovery", "prebuilt_recovery")
+ checkIfSnapshotNotTaken(t, result, "recovery", "prebuilt_recovery_indirect")
+ })
+}
diff --git a/genrule/genrule.go b/genrule/genrule.go
index 8372a64..c26b20c 100644
--- a/genrule/genrule.go
+++ b/genrule/genrule.go
@@ -68,7 +68,6 @@
ctx.BottomUp("genrule_tool_deps", toolDepsMutator).Parallel()
})
- android.DepsBp2BuildMutators(RegisterGenruleBp2BuildDeps)
android.RegisterBp2BuildMutator("genrule", GenruleBp2Build)
}
diff --git a/java/app.go b/java/app.go
index 4456b22..4e967ad 100755
--- a/java/app.go
+++ b/java/app.go
@@ -1264,6 +1264,15 @@
dep := android.RemoveOptionalPrebuiltPrefix(ctx.OtherModuleName(m))
+ // Skip stub libraries. A dependency on the implementation library has been added earlier,
+ // so it will be added to CLC, but the stub shouldn't be. Stub libraries can be distingushed
+ // from implementation libraries by their name, which is different as it has a suffix.
+ if comp, ok := m.(SdkLibraryComponentDependency); ok {
+ if impl := comp.OptionalSdkLibraryImplementation(); impl != nil && *impl != dep {
+ return
+ }
+ }
+
if lib, ok := m.(UsesLibraryDependency); ok {
libName := dep
if ulib, ok := m.(ProvidesUsesLib); ok && ulib.ProvidesUsesLib() != nil {
diff --git a/java/bootclasspath_fragment.go b/java/bootclasspath_fragment.go
index bdf0dae..1ce9911 100644
--- a/java/bootclasspath_fragment.go
+++ b/java/bootclasspath_fragment.go
@@ -579,25 +579,9 @@
// Create hidden API input structure.
input := b.createHiddenAPIFlagInput(ctx, contents, fragments)
- var output *HiddenAPIOutput
-
- // Hidden API processing is conditional as a temporary workaround as not all
- // bootclasspath_fragments provide the appropriate information needed for hidden API processing
- // which leads to breakages of the build.
- // TODO(b/179354495): Stop hidden API processing being conditional once all bootclasspath_fragment
- // modules have been updated to support it.
- if input.canPerformHiddenAPIProcessing(ctx, b.properties) {
- // Delegate the production of the hidden API all-flags.csv file to a module type specific method.
- common := ctx.Module().(commonBootclasspathFragment)
- output = common.produceHiddenAPIOutput(ctx, contents, input)
- } else {
- // As hidden API processing cannot be performed fall back to trying to retrieve the legacy
- // encoded boot dex files, i.e. those files encoded by the individual libraries and returned
- // from the DexJarBuildPath() method.
- output = &HiddenAPIOutput{
- EncodedBootDexFilesByModule: retrieveLegacyEncodedBootDexFiles(ctx, contents),
- }
- }
+ // Delegate the production of the hidden API all-flags.csv file to a module type specific method.
+ common := ctx.Module().(commonBootclasspathFragment)
+ output := common.produceHiddenAPIOutput(ctx, contents, input)
// Initialize a HiddenAPIInfo structure.
hiddenAPIInfo := HiddenAPIInfo{
@@ -615,7 +599,7 @@
// The monolithic hidden API processing also needs access to all the output files produced by
// hidden API processing of this fragment.
- hiddenAPIInfo.HiddenAPIFlagOutput = (*output).HiddenAPIFlagOutput
+ hiddenAPIInfo.HiddenAPIFlagOutput = output.HiddenAPIFlagOutput
// Provide it for use by other modules.
ctx.SetProvider(HiddenAPIInfoProvider, hiddenAPIInfo)
@@ -912,10 +896,10 @@
// produceHiddenAPIOutput returns a path to the prebuilt all-flags.csv or nil if none is specified.
func (module *prebuiltBootclasspathFragmentModule) produceHiddenAPIOutput(ctx android.ModuleContext, contents []android.Module, input HiddenAPIFlagInput) *HiddenAPIOutput {
- pathForOptionalSrc := func(src *string) android.Path {
+ pathForSrc := func(property string, src *string) android.Path {
if src == nil {
- // TODO(b/179354495): Fail if this is not provided once prebuilts have been updated.
- return nil
+ ctx.PropertyErrorf(property, "is required but was not specified")
+ return android.PathForModuleSrc(ctx, "missing", property)
}
return android.PathForModuleSrc(ctx, *src)
}
@@ -926,11 +910,11 @@
output := HiddenAPIOutput{
HiddenAPIFlagOutput: HiddenAPIFlagOutput{
- StubFlagsPath: pathForOptionalSrc(module.prebuiltProperties.Hidden_api.Stub_flags),
- AnnotationFlagsPath: pathForOptionalSrc(module.prebuiltProperties.Hidden_api.Annotation_flags),
- MetadataPath: pathForOptionalSrc(module.prebuiltProperties.Hidden_api.Metadata),
- IndexPath: pathForOptionalSrc(module.prebuiltProperties.Hidden_api.Index),
- AllFlagsPath: pathForOptionalSrc(module.prebuiltProperties.Hidden_api.All_flags),
+ AnnotationFlagsPath: pathForSrc("hidden_api.annotation_flags", module.prebuiltProperties.Hidden_api.Annotation_flags),
+ MetadataPath: pathForSrc("hidden_api.metadata", module.prebuiltProperties.Hidden_api.Metadata),
+ IndexPath: pathForSrc("hidden_api.index", module.prebuiltProperties.Hidden_api.Index),
+ StubFlagsPath: pathForSrc("hidden_api.stub_flags", module.prebuiltProperties.Hidden_api.Stub_flags),
+ AllFlagsPath: pathForSrc("hidden_api.all_flags", module.prebuiltProperties.Hidden_api.All_flags),
},
EncodedBootDexFilesByModule: encodedBootDexJarsByModule,
}
diff --git a/java/dexpreopt_bootjars.go b/java/dexpreopt_bootjars.go
index dff9543..2c78d73 100644
--- a/java/dexpreopt_bootjars.go
+++ b/java/dexpreopt_bootjars.go
@@ -523,14 +523,14 @@
}
// buildBootImageVariantsForBuildOs generates rules to build the boot image variants for the
-// android.BuildOs OsType, i.e. the type of OS on which the build is being running.
+// config.BuildOS OsType, i.e. the type of OS on which the build is being running.
//
// The files need to be generated into their predefined location because they are used from there
// both within Soong and outside, e.g. for ART based host side testing and also for use by some
// cloud based tools. However, they are not needed by callers of this function and so the paths do
// not need to be returned from this func, unlike the buildBootImageVariantsForAndroidOs func.
func buildBootImageVariantsForBuildOs(ctx android.ModuleContext, image *bootImageConfig, profile android.WritablePath) {
- buildBootImageForOsType(ctx, image, profile, android.BuildOs)
+ buildBootImageForOsType(ctx, image, profile, ctx.Config().BuildOS)
}
// buildBootImageForOsType takes a bootImageConfig, a profile file and an android.OsType
diff --git a/java/dexpreopt_config.go b/java/dexpreopt_config.go
index b13955f..1507aaf 100644
--- a/java/dexpreopt_config.go
+++ b/java/dexpreopt_config.go
@@ -32,7 +32,7 @@
}
}
// We may also need the images on host in order to run host-based tests.
- for _, target := range ctx.Config().Targets[android.BuildOs] {
+ for _, target := range ctx.Config().Targets[ctx.Config().BuildOS] {
targets = append(targets, target)
}
diff --git a/java/dexpreopt_test.go b/java/dexpreopt_test.go
index b25dece..8dc7b79 100644
--- a/java/dexpreopt_test.go
+++ b/java/dexpreopt_test.go
@@ -16,6 +16,7 @@
import (
"fmt"
+ "runtime"
"testing"
"android/soong/android"
@@ -173,9 +174,9 @@
}
func TestDex2oatToolDeps(t *testing.T) {
- if android.BuildOs != android.Linux {
+ if runtime.GOOS != "linux" {
// The host binary paths checked below are build OS dependent.
- t.Skipf("Unsupported build OS %s", android.BuildOs)
+ t.Skipf("Unsupported build OS %s", runtime.GOOS)
}
preparers := android.GroupFixturePreparers(
diff --git a/java/hiddenapi_modular.go b/java/hiddenapi_modular.go
index c4832d2..86ab825 100644
--- a/java/hiddenapi_modular.go
+++ b/java/hiddenapi_modular.go
@@ -20,7 +20,6 @@
"android/soong/android"
"github.com/google/blueprint"
- "github.com/google/blueprint/proptools"
)
// Contains support for processing hiddenAPI in a modular fashion.
@@ -511,14 +510,6 @@
}
}
-// dedup removes duplicates in the flag files, while maintaining the order in which they were
-// appended.
-func (s FlagFilesByCategory) dedup() {
- for category, paths := range s {
- s[category] = android.FirstUniquePaths(paths)
- }
-}
-
// HiddenAPIInfo contains information provided by the hidden API processing.
//
// That includes paths resolved from HiddenAPIFlagFileProperties and also generated by hidden API
@@ -712,42 +703,6 @@
return input
}
-// canPerformHiddenAPIProcessing determines whether hidden API processing should be performed.
-//
-// A temporary workaround to avoid existing bootclasspath_fragments that do not provide the
-// appropriate information needed for hidden API processing breaking the build.
-// TODO(b/179354495): Remove this workaround.
-func (i *HiddenAPIFlagInput) canPerformHiddenAPIProcessing(ctx android.ModuleContext, properties bootclasspathFragmentProperties) bool {
- // Performing hidden API processing without stubs is not supported and it is unlikely to ever be
- // required as the whole point of adding something to the bootclasspath fragment is to add it to
- // the bootclasspath in order to be used by something else in the system. Without any stubs it
- // cannot do that.
- if len(i.StubDexJarsByScope) == 0 {
- return false
- }
-
- // Hidden API processing is always enabled in tests.
- if ctx.Config().TestProductVariables != nil {
- return true
- }
-
- // A module that has fragments should have access to the information it needs in order to perform
- // hidden API processing.
- if len(properties.Fragments) != 0 {
- return true
- }
-
- // The art bootclasspath fragment does not depend on any other fragments but already supports
- // hidden API processing.
- imageName := proptools.String(properties.Image_name)
- if imageName == "art" {
- return true
- }
-
- // Disable it for everything else.
- return false
-}
-
// gatherStubLibInfo gathers information from the stub libs needed by hidden API processing from the
// dependencies added in hiddenAPIAddStubLibDependencies.
//
diff --git a/java/hiddenapi_monolithic.go b/java/hiddenapi_monolithic.go
index 52f0770..404b4c1 100644
--- a/java/hiddenapi_monolithic.go
+++ b/java/hiddenapi_monolithic.go
@@ -58,68 +58,33 @@
// Merge all the information from the classpathElements. The fragments form a DAG so it is possible that
// this will introduce duplicates so they will be resolved after processing all the classpathElements.
for _, element := range classpathElements {
- var classesJars android.Paths
switch e := element.(type) {
case *ClasspathLibraryElement:
- classesJars = retrieveClassesJarsFromModule(e.Module())
+ classesJars := retrieveClassesJarsFromModule(e.Module())
+ monolithicInfo.ClassesJars = append(monolithicInfo.ClassesJars, classesJars...)
case *ClasspathFragmentElement:
fragment := e.Module()
if ctx.OtherModuleHasProvider(fragment, HiddenAPIInfoProvider) {
info := ctx.OtherModuleProvider(fragment, HiddenAPIInfoProvider).(HiddenAPIInfo)
monolithicInfo.append(&info)
-
- // If the bootclasspath fragment actually perform hidden API processing itself then use the
- // CSV files it provides and do not bother processing the classesJars files. This ensures
- // consistent behavior between source and prebuilt as prebuilt modules do not provide
- // classesJars.
- if info.AllFlagsPath != nil {
- continue
- }
+ } else {
+ ctx.ModuleErrorf("%s does not provide hidden API information", fragment)
}
-
- classesJars = extractClassesJarsFromModules(e.Contents)
}
-
- monolithicInfo.ClassesJars = append(monolithicInfo.ClassesJars, classesJars...)
}
- // Dedup paths.
- monolithicInfo.dedup()
-
return monolithicInfo
}
// append appends all the files from the supplied info to the corresponding files in this struct.
func (i *MonolithicHiddenAPIInfo) append(other *HiddenAPIInfo) {
i.FlagsFilesByCategory.append(other.FlagFilesByCategory)
-
- // The output may not be set if the bootclasspath_fragment has not yet been updated to support
- // hidden API processing.
- // TODO(b/179354495): Switch back to append once all bootclasspath_fragment modules have been
- // updated to support hidden API processing properly.
- appendIfNotNil := func(paths android.Paths, path android.Path) android.Paths {
- if path == nil {
- return paths
- }
- return append(paths, path)
- }
- i.StubFlagsPaths = appendIfNotNil(i.StubFlagsPaths, other.StubFlagsPath)
- i.AnnotationFlagsPaths = appendIfNotNil(i.AnnotationFlagsPaths, other.AnnotationFlagsPath)
- i.MetadataPaths = appendIfNotNil(i.MetadataPaths, other.MetadataPath)
- i.IndexPaths = appendIfNotNil(i.IndexPaths, other.IndexPath)
- i.AllFlagsPaths = appendIfNotNil(i.AllFlagsPaths, other.AllFlagsPath)
-}
-
-// dedup removes duplicates in all the paths, while maintaining the order in which they were
-// appended.
-func (i *MonolithicHiddenAPIInfo) dedup() {
- i.FlagsFilesByCategory.dedup()
- i.StubFlagsPaths = android.FirstUniquePaths(i.StubFlagsPaths)
- i.AnnotationFlagsPaths = android.FirstUniquePaths(i.AnnotationFlagsPaths)
- i.MetadataPaths = android.FirstUniquePaths(i.MetadataPaths)
- i.IndexPaths = android.FirstUniquePaths(i.IndexPaths)
- i.AllFlagsPaths = android.FirstUniquePaths(i.AllFlagsPaths)
+ i.StubFlagsPaths = append(i.StubFlagsPaths, other.StubFlagsPath)
+ i.AnnotationFlagsPaths = append(i.AnnotationFlagsPaths, other.AnnotationFlagsPath)
+ i.MetadataPaths = append(i.MetadataPaths, other.MetadataPath)
+ i.IndexPaths = append(i.IndexPaths, other.IndexPath)
+ i.AllFlagsPaths = append(i.AllFlagsPaths, other.AllFlagsPath)
}
var MonolithicHiddenAPIInfoProvider = blueprint.NewProvider(MonolithicHiddenAPIInfo{})
diff --git a/java/java.go b/java/java.go
index bd059b5..e38a714 100644
--- a/java/java.go
+++ b/java/java.go
@@ -130,11 +130,19 @@
PropertyName: "java_boot_libs",
SupportsSdk: true,
},
- // Temporarily export implementation classes jar for java_boot_libs as it is required for the
- // hiddenapi processing.
- // TODO(b/179354495): Revert once hiddenapi processing has been modularized.
- exportImplementationClassesJar,
- sdkSnapshotFilePathForJar,
+ func(ctx android.SdkMemberContext, j *Library) android.Path {
+ // Java boot libs are only provided in the SDK to provide access to their dex implementation
+ // jar for use by dexpreopting and boot jars package check. They do not need to provide an
+ // actual implementation jar but the java_import will need a file that exists so just copy an
+ // empty file. Any attempt to use that file as a jar will cause a build error.
+ return ctx.SnapshotBuilder().EmptyFile()
+ },
+ func(osPrefix, name string) string {
+ // Create a special name for the implementation jar to try and provide some useful information
+ // to a developer that attempts to compile against this.
+ // TODO(b/175714559): Provide a proper error message in Soong not ninja.
+ return filepath.Join(osPrefix, "java_boot_libs", "snapshot", "jars", "are", "invalid", name+jarFileSuffix)
+ },
onlyCopyJarToSnapshot,
}
@@ -1786,22 +1794,16 @@
return
}
- // Find out if the dependency is either an SDK library or an ordinary library that is disguised
- // as an SDK library by the means of `provides_uses_lib` property. If yes, the library is itself
- // a <uses-library> and should be added as a node in the CLC tree, and its CLC should be added
- // as subtree of that node. Otherwise the library is not a <uses_library> and should not be
- // added to CLC, but the transitive <uses-library> dependencies from its CLC should be added to
- // the current CLC.
- var implicitSdkLib *string
- comp, isComp := depModule.(SdkLibraryComponentDependency)
- if isComp {
- implicitSdkLib = comp.OptionalImplicitSdkLibrary()
- // OptionalImplicitSdkLibrary() may be nil so need to fall through to ProvidesUsesLib().
- }
- if implicitSdkLib == nil {
- if ulib, ok := depModule.(ProvidesUsesLib); ok {
- implicitSdkLib = ulib.ProvidesUsesLib()
- }
+ depName := android.RemoveOptionalPrebuiltPrefix(ctx.OtherModuleName(depModule))
+
+ var sdkLib *string
+ if lib, ok := depModule.(SdkLibraryDependency); ok && lib.sharedLibrary() {
+ // A shared SDK library. This should be added as a top-level CLC element.
+ sdkLib = &depName
+ } else if ulib, ok := depModule.(ProvidesUsesLib); ok {
+ // A non-SDK library disguised as an SDK library by the means of `provides_uses_lib`
+ // property. This should be handled in the same way as a shared SDK library.
+ sdkLib = ulib.ProvidesUsesLib()
}
depTag := ctx.OtherModuleDependencyTag(depModule)
@@ -1811,7 +1813,7 @@
// Propagate <uses-library> through static library dependencies, unless it is a component
// library (such as stubs). Component libraries have a dependency on their SDK library,
// which should not be pulled just because of a static component library.
- if implicitSdkLib != nil {
+ if sdkLib != nil {
return
}
} else {
@@ -1819,11 +1821,14 @@
return
}
- if implicitSdkLib != nil {
- clcMap.AddContext(ctx, dexpreopt.AnySdkVersion, *implicitSdkLib,
+ // If this is an SDK (or SDK-like) library, then it should be added as a node in the CLC tree,
+ // and its CLC should be added as subtree of that node. Otherwise the library is not a
+ // <uses_library> and should not be added to CLC, but the transitive <uses-library> dependencies
+ // from its CLC should be added to the current CLC.
+ if sdkLib != nil {
+ clcMap.AddContext(ctx, dexpreopt.AnySdkVersion, *sdkLib,
dep.DexJarBuildPath(), dep.DexJarInstallPath(), dep.ClassLoaderContexts())
} else {
- depName := ctx.OtherModuleName(depModule)
clcMap.AddContextMap(dep.ClassLoaderContexts(), depName)
}
}
diff --git a/java/java_test.go b/java/java_test.go
index 0f9965d..b6780c2 100644
--- a/java/java_test.go
+++ b/java/java_test.go
@@ -441,7 +441,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := ctx.Config().BuildOS.String()
bar := ctx.ModuleForTests("bar", buildOS+"_common")
barJar := bar.Output("bar.jar").Output.String()
@@ -478,7 +478,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := ctx.Config().BuildOS.String()
foo := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
@@ -523,7 +523,7 @@
}
// check that -g is not overridden for host modules
- buildOS := android.BuildOs.String()
+ buildOS := result.Config.BuildOS.String()
hostBinary := result.ModuleForTests("host_binary", buildOS+"_common")
hostJavaFlags := hostBinary.Module().VariablesForTests()["javacFlags"]
if strings.Contains(hostJavaFlags, "-g:source,lines") {
@@ -1371,7 +1371,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := ctx.Config().BuildOS.String()
test := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
entries := android.AndroidMkEntriesForTest(t, ctx, test)[0]
@@ -1387,7 +1387,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := ctx.Config().BuildOS.String()
module := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
assertDeepEquals(t, "Default installable value should be true.", proptools.BoolPtr(true),
module.properties.Installable)
diff --git a/java/kotlin_test.go b/java/kotlin_test.go
index fd2f3ca..db30696 100644
--- a/java/kotlin_test.go
+++ b/java/kotlin_test.go
@@ -15,10 +15,11 @@
package java
import (
- "android/soong/android"
"strconv"
"strings"
"testing"
+
+ "android/soong/android"
)
func TestKotlin(t *testing.T) {
@@ -114,7 +115,7 @@
t.Run("", func(t *testing.T) {
ctx, _ := testJava(t, bp)
- buildOS := android.BuildOs.String()
+ buildOS := ctx.Config().BuildOS.String()
kapt := ctx.ModuleForTests("foo", "android_common").Rule("kapt")
kotlinc := ctx.ModuleForTests("foo", "android_common").Rule("kotlinc")
@@ -182,7 +183,7 @@
android.FixtureMergeEnv(env),
).RunTestWithBp(t, bp)
- buildOS := android.BuildOs.String()
+ buildOS := result.Config.BuildOS.String()
kapt := result.ModuleForTests("foo", "android_common").Rule("kapt")
javac := result.ModuleForTests("foo", "android_common").Description("javac")
diff --git a/java/platform_bootclasspath.go b/java/platform_bootclasspath.go
index c1e14b2..8bed3e9 100644
--- a/java/platform_bootclasspath.go
+++ b/java/platform_bootclasspath.go
@@ -423,8 +423,13 @@
// Generate the framework profile rule
bootFrameworkProfileRule(ctx, imageConfig)
- // Generate the updatable bootclasspath packages rule.
- generateUpdatableBcpPackagesRule(ctx, imageConfig, updatableModules)
+ // If always using prebuilt sdks then do not generate the updatable-bcp-packages.txt file as it
+ // will break because the prebuilts do not yet specify a permitted_packages property.
+ // TODO(b/193889859): Remove when the prebuilts have been updated.
+ if !ctx.Config().AlwaysUsePrebuiltSdks() {
+ // Generate the updatable bootclasspath packages rule.
+ generateUpdatableBcpPackagesRule(ctx, imageConfig, updatableModules)
+ }
// Copy non-updatable module dex jars to their predefined locations.
nonUpdatableBootDexJarsByModule := extractEncodedDexJarsFromModules(ctx, nonUpdatableModules)
diff --git a/java/plugin_test.go b/java/plugin_test.go
index c7913d3..dc29b1c 100644
--- a/java/plugin_test.go
+++ b/java/plugin_test.go
@@ -15,7 +15,6 @@
package java
import (
- "android/soong/android"
"testing"
)
@@ -58,7 +57,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := ctx.Config().BuildOS.String()
javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
turbine := ctx.ModuleForTests("foo", "android_common").MaybeRule("turbine")
@@ -98,7 +97,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := ctx.Config().BuildOS.String()
javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
turbine := ctx.ModuleForTests("foo", "android_common").MaybeRule("turbine")
diff --git a/java/robolectric.go b/java/robolectric.go
index a37a118..a0c9c7f 100644
--- a/java/robolectric.go
+++ b/java/robolectric.go
@@ -83,6 +83,9 @@
testConfig android.Path
data android.Paths
+
+ forceOSType android.OsType
+ forceArchType android.ArchType
}
func (r *robolectricTest) TestSuites() []string {
@@ -115,6 +118,9 @@
}
func (r *robolectricTest) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+ r.forceOSType = ctx.Config().BuildOS
+ r.forceArchType = ctx.Config().BuildArch
+
r.testConfig = tradefed.AutoGenRobolectricTestConfig(ctx, r.testProperties.Test_config,
r.testProperties.Test_config_template, r.testProperties.Test_suites,
r.testProperties.Auto_gen_config)
@@ -345,7 +351,7 @@
func (r *robolectricTest) InstallBypassMake() bool { return true }
func (r *robolectricTest) InstallInTestcases() bool { return true }
func (r *robolectricTest) InstallForceOS() (*android.OsType, *android.ArchType) {
- return &android.BuildOs, &android.BuildArch
+ return &r.forceOSType, &r.forceArchType
}
func robolectricRuntimesFactory() android.Module {
@@ -366,6 +372,9 @@
props robolectricRuntimesProperties
runtimes []android.InstallPath
+
+ forceOSType android.OsType
+ forceArchType android.ArchType
}
func (r *robolectricRuntimes) TestSuites() []string {
@@ -385,6 +394,9 @@
return
}
+ r.forceOSType = ctx.Config().BuildOS
+ r.forceArchType = ctx.Config().BuildArch
+
files := android.PathsForModuleSrc(ctx, r.props.Jars)
androidAllDir := android.PathForModuleInstall(ctx, "android-all")
@@ -417,5 +429,5 @@
func (r *robolectricRuntimes) InstallBypassMake() bool { return true }
func (r *robolectricRuntimes) InstallInTestcases() bool { return true }
func (r *robolectricRuntimes) InstallForceOS() (*android.OsType, *android.ArchType) {
- return &android.BuildOs, &android.BuildArch
+ return &r.forceOSType, &r.forceArchType
}
diff --git a/java/sdk_library.go b/java/sdk_library.go
index d1b4a47..268e797 100644
--- a/java/sdk_library.go
+++ b/java/sdk_library.go
@@ -981,13 +981,15 @@
}
// to satisfy SdkLibraryComponentDependency
-func (e *EmbeddableSdkLibraryComponent) OptionalImplicitSdkLibrary() *string {
- return e.sdkLibraryComponentProperties.SdkLibraryToImplicitlyTrack
-}
-
-// to satisfy SdkLibraryComponentDependency
func (e *EmbeddableSdkLibraryComponent) OptionalSdkLibraryImplementation() *string {
- // Currently implementation library name is the same as the SDK library name.
+ // For shared libraries, this is the same as the SDK library name. If a Java library or app
+ // depends on a component library (e.g. a stub library) it still needs to know the name of the
+ // run-time library and the corresponding module that provides the implementation. This name is
+ // passed to manifest_fixer (to be added to AndroidManifest.xml) and added to CLC (to be used
+ // in dexpreopt).
+ //
+ // For non-shared SDK (component or not) libraries this returns `nil`, as they are not
+ // <uses-library> and should not be added to the manifest or to CLC.
return e.sdkLibraryComponentProperties.SdkLibraryToImplicitlyTrack
}
@@ -999,12 +1001,6 @@
// SdkLibraryName returns the name of the java_sdk_library/_import module.
SdkLibraryName() *string
- // The optional name of the sdk library that should be implicitly added to the
- // AndroidManifest of an app that contains code which references the sdk library.
- //
- // Returns the name of the optional implicit SDK library or nil, if there isn't one.
- OptionalImplicitSdkLibrary() *string
-
// The name of the implementation library for the optional SDK library or nil, if there isn't one.
OptionalSdkLibraryImplementation() *string
}
diff --git a/java/sdk_test.go b/java/sdk_test.go
index bb595a5..6d62130 100644
--- a/java/sdk_test.go
+++ b/java/sdk_test.go
@@ -255,9 +255,11 @@
` + testcase.properties + `
}`
- variant := "android_common"
- if testcase.host == android.Host {
- variant = android.BuildOs.String() + "_common"
+ variant := func(result *android.TestResult) string {
+ if testcase.host == android.Host {
+ return result.Config.BuildOS.String() + "_common"
+ }
+ return "android_common"
}
convertModulesToPaths := func(cp []string) []string {
@@ -312,7 +314,7 @@
}
checkClasspath := func(t *testing.T, result *android.TestResult, isJava8 bool) {
- foo := result.ModuleForTests("foo", variant)
+ foo := result.ModuleForTests("foo", variant(result))
javac := foo.Rule("javac")
var deps []string
@@ -376,7 +378,7 @@
checkClasspath(t, result, true /* isJava8 */)
if testcase.host != android.Host {
- aidl := result.ModuleForTests("foo", variant).Rule("aidl")
+ aidl := result.ModuleForTests("foo", variant(result)).Rule("aidl")
android.AssertStringDoesContain(t, "aidl command", aidl.RuleParams.Command, testcase.aidl+" -I.")
}
@@ -389,7 +391,7 @@
checkClasspath(t, result, false /* isJava8 */)
if testcase.host != android.Host {
- aidl := result.ModuleForTests("foo", variant).Rule("aidl")
+ aidl := result.ModuleForTests("foo", variant(result)).Rule("aidl")
android.AssertStringDoesContain(t, "aidl command", aidl.RuleParams.Command, testcase.aidl+" -I.")
}
diff --git a/rust/Android.bp b/rust/Android.bp
index 11069d1..221014e 100644
--- a/rust/Android.bp
+++ b/rust/Android.bp
@@ -11,6 +11,7 @@
"soong-bloaty",
"soong-cc",
"soong-rust-config",
+ "soong-snapshot",
],
srcs: [
"androidmk.go",
diff --git a/rust/androidmk.go b/rust/androidmk.go
index ea45ebd..630805a 100644
--- a/rust/androidmk.go
+++ b/rust/androidmk.go
@@ -205,24 +205,24 @@
ctx.SubAndroidMk(entries, fuzz.binaryDecorator)
var fuzzFiles []string
- for _, d := range fuzz.corpus {
+ for _, d := range fuzz.fuzzPackagedModule.Corpus {
fuzzFiles = append(fuzzFiles,
- filepath.Dir(fuzz.corpusIntermediateDir.String())+":corpus/"+d.Base())
+ filepath.Dir(fuzz.fuzzPackagedModule.CorpusIntermediateDir.String())+":corpus/"+d.Base())
}
- for _, d := range fuzz.data {
+ for _, d := range fuzz.fuzzPackagedModule.Data {
fuzzFiles = append(fuzzFiles,
- filepath.Dir(fuzz.dataIntermediateDir.String())+":data/"+d.Rel())
+ filepath.Dir(fuzz.fuzzPackagedModule.DataIntermediateDir.String())+":data/"+d.Rel())
}
- if fuzz.dictionary != nil {
+ if fuzz.fuzzPackagedModule.Dictionary != nil {
fuzzFiles = append(fuzzFiles,
- filepath.Dir(fuzz.dictionary.String())+":"+fuzz.dictionary.Base())
+ filepath.Dir(fuzz.fuzzPackagedModule.Dictionary.String())+":"+fuzz.fuzzPackagedModule.Dictionary.Base())
}
- if fuzz.config != nil {
+ if fuzz.fuzzPackagedModule.Config != nil {
fuzzFiles = append(fuzzFiles,
- filepath.Dir(fuzz.config.String())+":config.json")
+ filepath.Dir(fuzz.fuzzPackagedModule.Config.String())+":config.json")
}
entries.ExtraEntries = append(entries.ExtraEntries, func(ctx android.AndroidMkExtraEntriesContext,
diff --git a/rust/binary_test.go b/rust/binary_test.go
index 86f50d3..968c0c1 100644
--- a/rust/binary_test.go
+++ b/rust/binary_test.go
@@ -114,6 +114,23 @@
}
}
+// Test that the bootstrap property sets the appropriate linker
+func TestBootstrap(t *testing.T) {
+ ctx := testRust(t, `
+ rust_binary {
+ name: "foo",
+ srcs: ["foo.rs"],
+ bootstrap: true,
+ }`)
+
+ foo := ctx.ModuleForTests("foo", "android_arm64_armv8-a").Rule("rustc")
+
+ flag := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker64"
+ if !strings.Contains(foo.Args["linkFlags"], flag) {
+ t.Errorf("missing link flag to use bootstrap linker, expecting %#v, linkFlags: %#v", flag, foo.Args["linkFlags"])
+ }
+}
+
func TestStaticBinaryFlags(t *testing.T) {
ctx := testRust(t, `
rust_binary {
diff --git a/rust/builder.go b/rust/builder.go
index 6db508d..523428d 100644
--- a/rust/builder.go
+++ b/rust/builder.go
@@ -220,6 +220,15 @@
linkFlags = append(linkFlags, flags.GlobalLinkFlags...)
linkFlags = append(linkFlags, flags.LinkFlags...)
+ // Check if this module needs to use the bootstrap linker
+ if ctx.RustModule().Bootstrap() && !ctx.RustModule().InRecovery() && !ctx.RustModule().InRamdisk() && !ctx.RustModule().InVendorRamdisk() {
+ dynamicLinker := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker"
+ if ctx.toolchain().Is64Bit() {
+ dynamicLinker += "64"
+ }
+ linkFlags = append(linkFlags, dynamicLinker)
+ }
+
libFlags := makeLibFlags(deps)
// Collect dependencies
diff --git a/rust/compiler.go b/rust/compiler.go
index 0b28135..df77759 100644
--- a/rust/compiler.go
+++ b/rust/compiler.go
@@ -305,7 +305,7 @@
if !Bool(compiler.Properties.No_stdlibs) {
for _, stdlib := range config.Stdlibs {
// If we're building for the primary arch of the build host, use the compiler's stdlibs
- if ctx.Target().Os == android.BuildOs {
+ if ctx.Target().Os == ctx.Config().BuildOS {
stdlib = stdlib + "_" + ctx.toolchain().RustTriple()
}
deps.Stdlibs = append(deps.Stdlibs, stdlib)
diff --git a/rust/config/allowed_list.go b/rust/config/allowed_list.go
index 31ec3f1..f568f27 100644
--- a/rust/config/allowed_list.go
+++ b/rust/config/allowed_list.go
@@ -6,6 +6,7 @@
// for an example.
// TODO(b/160223496): enable rustfmt globally.
RustAllowedPaths = []string{
+ "bionic/libc",
"device/google/cuttlefish",
"external/adhd",
"external/crosvm",
diff --git a/rust/fuzz.go b/rust/fuzz.go
index 7e1c55a..18b2513 100644
--- a/rust/fuzz.go
+++ b/rust/fuzz.go
@@ -32,13 +32,7 @@
type fuzzDecorator struct {
*binaryDecorator
- Properties cc.FuzzProperties
- dictionary android.Path
- corpus android.Paths
- corpusIntermediateDir android.Path
- config android.Path
- data android.Paths
- dataIntermediateDir android.Path
+ fuzzPackagedModule cc.FuzzPackagedModule
}
var _ compiler = (*binaryDecorator)(nil)
@@ -88,7 +82,7 @@
func (fuzzer *fuzzDecorator) compilerProps() []interface{} {
return append(fuzzer.binaryDecorator.compilerProps(),
- &fuzzer.Properties)
+ &fuzzer.fuzzPackagedModule.FuzzProperties)
}
func (fuzzer *fuzzDecorator) stdLinkage(ctx *depsContext) RustLinkage {
@@ -102,32 +96,19 @@
// Responsible for generating GNU Make rules that package fuzz targets into
// their architecture & target/host specific zip file.
type rustFuzzPackager struct {
- packages android.Paths
- fuzzTargets map[string]bool
+ cc.FuzzPackager
}
func rustFuzzPackagingFactory() android.Singleton {
return &rustFuzzPackager{}
}
-type fileToZip struct {
- SourceFilePath android.Path
- DestinationPathPrefix string
-}
-
-type archOs struct {
- hostOrTarget string
- arch string
- dir string
-}
-
func (s *rustFuzzPackager) GenerateBuildActions(ctx android.SingletonContext) {
-
// Map between each architecture + host/device combination.
- archDirs := make(map[archOs][]fileToZip)
+ archDirs := make(map[cc.ArchOs][]cc.FileToZip)
// List of individual fuzz targets.
- s.fuzzTargets = make(map[string]bool)
+ s.FuzzTargets = make(map[string]bool)
ctx.VisitAllModules(func(module android.Module) {
// Discard non-fuzz targets.
@@ -136,23 +117,15 @@
return
}
+ if ok := cc.IsValid(rustModule.FuzzModule); !ok || rustModule.Properties.PreventInstall {
+ return
+ }
+
fuzzModule, ok := rustModule.compiler.(*fuzzDecorator)
if !ok {
return
}
- // Discard ramdisk + vendor_ramdisk + recovery modules, they're duplicates of
- // fuzz targets we're going to package anyway.
- if !rustModule.Enabled() || rustModule.Properties.PreventInstall ||
- rustModule.InRamdisk() || rustModule.InVendorRamdisk() || rustModule.InRecovery() {
- return
- }
-
- // Discard modules that are in an unavailable namespace.
- if !rustModule.ExportedToMake() {
- return
- }
-
hostOrTargetString := "target"
if rustModule.Host() {
hostOrTargetString = "host"
@@ -160,126 +133,34 @@
archString := rustModule.Arch().ArchType.String()
archDir := android.PathForIntermediates(ctx, "fuzz", hostOrTargetString, archString)
- archOs := archOs{hostOrTarget: hostOrTargetString, arch: archString, dir: archDir.String()}
+ archOs := cc.ArchOs{HostOrTarget: hostOrTargetString, Arch: archString, Dir: archDir.String()}
- var files []fileToZip
+ var files []cc.FileToZip
builder := android.NewRuleBuilder(pctx, ctx)
- // Package the corpora into a zipfile.
- if fuzzModule.corpus != nil {
- corpusZip := archDir.Join(ctx, module.Name()+"_seed_corpus.zip")
- command := builder.Command().BuiltTool("soong_zip").
- Flag("-j").
- FlagWithOutput("-o ", corpusZip)
- rspFile := corpusZip.ReplaceExtension(ctx, "rsp")
- command.FlagWithRspFileInputList("-r ", rspFile, fuzzModule.corpus)
- files = append(files, fileToZip{corpusZip, ""})
- }
-
- // Package the data into a zipfile.
- if fuzzModule.data != nil {
- dataZip := archDir.Join(ctx, module.Name()+"_data.zip")
- command := builder.Command().BuiltTool("soong_zip").
- FlagWithOutput("-o ", dataZip)
- for _, f := range fuzzModule.data {
- intermediateDir := strings.TrimSuffix(f.String(), f.Rel())
- command.FlagWithArg("-C ", intermediateDir)
- command.FlagWithInput("-f ", f)
- }
- files = append(files, fileToZip{dataZip, ""})
- }
+ // Package the artifacts (data, corpus, config and dictionary into a zipfile.
+ files = s.PackageArtifacts(ctx, module, fuzzModule.fuzzPackagedModule, archDir, builder)
// The executable.
- files = append(files, fileToZip{rustModule.unstrippedOutputFile.Path(), ""})
+ files = append(files, cc.FileToZip{rustModule.unstrippedOutputFile.Path(), ""})
- // The dictionary.
- if fuzzModule.dictionary != nil {
- files = append(files, fileToZip{fuzzModule.dictionary, ""})
+ archDirs[archOs], ok = s.BuildZipFile(ctx, module, fuzzModule.fuzzPackagedModule, files, builder, archDir, archString, hostOrTargetString, archOs, archDirs)
+ if !ok {
+ return
}
- // Additional fuzz config.
- if fuzzModule.config != nil {
- files = append(files, fileToZip{fuzzModule.config, ""})
- }
-
- fuzzZip := archDir.Join(ctx, module.Name()+".zip")
-
- command := builder.Command().BuiltTool("soong_zip").
- Flag("-j").
- FlagWithOutput("-o ", fuzzZip)
-
- for _, file := range files {
- if file.DestinationPathPrefix != "" {
- command.FlagWithArg("-P ", file.DestinationPathPrefix)
- } else {
- command.Flag("-P ''")
- }
- command.FlagWithInput("-f ", file.SourceFilePath)
- }
-
- builder.Build("create-"+fuzzZip.String(),
- "Package "+module.Name()+" for "+archString+"-"+hostOrTargetString)
-
- // Don't add modules to 'make haiku-rust' that are set to not be
- // exported to the fuzzing infrastructure.
- if config := fuzzModule.Properties.Fuzz_config; config != nil {
- if rustModule.Host() && !BoolDefault(config.Fuzz_on_haiku_host, true) {
- return
- } else if !BoolDefault(config.Fuzz_on_haiku_device, true) {
- return
- }
- }
-
- s.fuzzTargets[module.Name()] = true
- archDirs[archOs] = append(archDirs[archOs], fileToZip{fuzzZip, ""})
})
-
- var archOsList []archOs
- for archOs := range archDirs {
- archOsList = append(archOsList, archOs)
- }
- sort.Slice(archOsList, func(i, j int) bool { return archOsList[i].dir < archOsList[j].dir })
-
- for _, archOs := range archOsList {
- filesToZip := archDirs[archOs]
- arch := archOs.arch
- hostOrTarget := archOs.hostOrTarget
- builder := android.NewRuleBuilder(pctx, ctx)
- outputFile := android.PathForOutput(ctx, "fuzz-rust-"+hostOrTarget+"-"+arch+".zip")
- s.packages = append(s.packages, outputFile)
-
- command := builder.Command().BuiltTool("soong_zip").
- Flag("-j").
- FlagWithOutput("-o ", outputFile).
- Flag("-L 0") // No need to try and re-compress the zipfiles.
-
- for _, fileToZip := range filesToZip {
- if fileToZip.DestinationPathPrefix != "" {
- command.FlagWithArg("-P ", fileToZip.DestinationPathPrefix)
- } else {
- command.Flag("-P ''")
- }
- command.FlagWithInput("-f ", fileToZip.SourceFilePath)
- }
- builder.Build("create-fuzz-package-"+arch+"-"+hostOrTarget,
- "Create fuzz target packages for "+arch+"-"+hostOrTarget)
- }
-
+ s.CreateFuzzPackage(ctx, archDirs, cc.Rust)
}
func (s *rustFuzzPackager) MakeVars(ctx android.MakeVarsContext) {
- packages := s.packages.Strings()
+ packages := s.Packages.Strings()
sort.Strings(packages)
ctx.Strict("SOONG_RUST_FUZZ_PACKAGING_ARCH_MODULES", strings.Join(packages, " "))
- // Preallocate the slice of fuzz targets to minimise memory allocations.
- fuzzTargets := make([]string, 0, len(s.fuzzTargets))
- for target, _ := range s.fuzzTargets {
- fuzzTargets = append(fuzzTargets, target)
- }
- sort.Strings(fuzzTargets)
- ctx.Strict("ALL_RUST_FUZZ_TARGETS", strings.Join(fuzzTargets, " "))
+ // Preallocate the slice of fuzz targets to minimize memory allocations.
+ s.PreallocateSlice(ctx, "ALL_RUST_FUZZ_TARGETS")
}
func (fuzz *fuzzDecorator) install(ctx ModuleContext) {
@@ -289,13 +170,13 @@
"fuzz", ctx.Target().Arch.ArchType.String(), ctx.ModuleName())
fuzz.binaryDecorator.baseCompiler.install(ctx)
- if fuzz.Properties.Corpus != nil {
- fuzz.corpus = android.PathsForModuleSrc(ctx, fuzz.Properties.Corpus)
+ if fuzz.fuzzPackagedModule.FuzzProperties.Corpus != nil {
+ fuzz.fuzzPackagedModule.Corpus = android.PathsForModuleSrc(ctx, fuzz.fuzzPackagedModule.FuzzProperties.Corpus)
}
- if fuzz.Properties.Data != nil {
- fuzz.data = android.PathsForModuleSrc(ctx, fuzz.Properties.Data)
+ if fuzz.fuzzPackagedModule.FuzzProperties.Data != nil {
+ fuzz.fuzzPackagedModule.Data = android.PathsForModuleSrc(ctx, fuzz.fuzzPackagedModule.FuzzProperties.Data)
}
- if fuzz.Properties.Dictionary != nil {
- fuzz.dictionary = android.PathForModuleSrc(ctx, *fuzz.Properties.Dictionary)
+ if fuzz.fuzzPackagedModule.FuzzProperties.Dictionary != nil {
+ fuzz.fuzzPackagedModule.Dictionary = android.PathForModuleSrc(ctx, *fuzz.fuzzPackagedModule.FuzzProperties.Dictionary)
}
}
diff --git a/rust/library.go b/rust/library.go
index 747a29d..8c10e29 100644
--- a/rust/library.go
+++ b/rust/library.go
@@ -21,6 +21,7 @@
"android/soong/android"
"android/soong/cc"
+ "android/soong/snapshot"
)
var (
@@ -431,6 +432,12 @@
func (library *libraryDecorator) compilerFlags(ctx ModuleContext, flags Flags) Flags {
flags.RustFlags = append(flags.RustFlags, "-C metadata="+ctx.ModuleName())
+ if library.dylib() {
+ // We need to add a dependency on std in order to link crates as dylibs.
+ // The hack to add this dependency is guarded by the following cfg so
+ // that we don't force a dependency when it isn't needed.
+ library.baseCompiler.Properties.Cfgs = append(library.baseCompiler.Properties.Cfgs, "android_dylib")
+ }
flags = library.baseCompiler.compilerFlags(ctx, flags)
if library.shared() || library.static() {
library.includeDirs = append(library.includeDirs, android.PathsForModuleSrc(ctx, library.Properties.Include_dirs)...)
@@ -639,7 +646,7 @@
variation := v.(*Module).ModuleBase.ImageVariation().Variation
if strings.HasPrefix(variation, cc.VendorVariationPrefix) &&
m.HasVendorVariant() &&
- !cc.IsVendorProprietaryModule(mctx) &&
+ !snapshot.IsVendorProprietaryModule(mctx) &&
strings.TrimPrefix(variation, cc.VendorVariationPrefix) == mctx.DeviceConfig().VndkVersion() {
// cc.MutateImage runs before LibraryMutator, so vendor variations which are meant for rlibs only are
diff --git a/rust/library_test.go b/rust/library_test.go
index 54cd2a5..cb4ef7e 100644
--- a/rust/library_test.go
+++ b/rust/library_test.go
@@ -85,6 +85,22 @@
}
}
+// Check that we are passing the android_dylib config flag
+func TestAndroidDylib(t *testing.T) {
+ ctx := testRust(t, `
+ rust_library_host_dylib {
+ name: "libfoo",
+ srcs: ["foo.rs"],
+ crate_name: "foo",
+ }`)
+
+ libfooDylib := ctx.ModuleForTests("libfoo", "linux_glibc_x86_64_dylib").Output("libfoo.dylib.so")
+
+ if !strings.Contains(libfooDylib.Args["rustcFlags"], "--cfg 'android_dylib'") {
+ t.Errorf("missing android_dylib cfg flag for libfoo dylib, rustcFlags: %#v", libfooDylib.Args["rustcFlags"])
+ }
+}
+
func TestValidateLibraryStem(t *testing.T) {
testRustError(t, "crate_name must be defined.", `
rust_library_host {
diff --git a/rust/project_json_test.go b/rust/project_json_test.go
index 09d30db..bdd54c5 100644
--- a/rust/project_json_test.go
+++ b/rust/project_json_test.go
@@ -176,6 +176,8 @@
}
func TestProjectJsonBindGen(t *testing.T) {
+ buildOS := android.TestConfig(t.TempDir(), nil, "", nil).BuildOS
+
bp := `
rust_library {
name: "libd",
@@ -214,9 +216,9 @@
if strings.Contains(rootModule, "libbindings1") && !strings.Contains(rootModule, "android_arm64") {
t.Errorf("The source path for libbindings1 does not contain android_arm64, got %v", rootModule)
}
- if strings.Contains(rootModule, "libbindings2") && !strings.Contains(rootModule, android.BuildOs.String()) {
+ if strings.Contains(rootModule, "libbindings2") && !strings.Contains(rootModule, buildOS.String()) {
t.Errorf("The source path for libbindings2 does not contain the BuildOs, got %v; want %v",
- rootModule, android.BuildOs.String())
+ rootModule, buildOS.String())
}
// Check that libbindings1 does not depend on itself.
if strings.Contains(rootModule, "libbindings1") {
diff --git a/rust/rust.go b/rust/rust.go
index 38f1742..931cb9d 100644
--- a/rust/rust.go
+++ b/rust/rust.go
@@ -85,6 +85,10 @@
VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
ExtraVariants []string `blueprint:"mutated"`
+ // Allows this module to use non-APEX version of libraries. Useful
+ // for building binaries that are started before APEXes are activated.
+ Bootstrap *bool
+
// Used by vendor snapshot to record dependencies from snapshot modules.
SnapshotSharedLibs []string `blueprint:"mutated"`
SnapshotStaticLibs []string `blueprint:"mutated"`
@@ -119,9 +123,7 @@
}
type Module struct {
- android.ModuleBase
- android.DefaultableModuleBase
- android.ApexModuleBase
+ cc.FuzzModule
VendorProperties cc.VendorProperties
@@ -290,7 +292,7 @@
}
func (mod *Module) Bootstrap() bool {
- return false
+ return Bool(mod.Properties.Bootstrap)
}
func (mod *Module) MustUseVendorVariant() bool {
diff --git a/rust/snapshot_prebuilt.go b/rust/snapshot_prebuilt.go
index 2f54973..79eaab3 100644
--- a/rust/snapshot_prebuilt.go
+++ b/rust/snapshot_prebuilt.go
@@ -17,6 +17,7 @@
import (
"android/soong/android"
"android/soong/cc"
+
"github.com/google/blueprint/proptools"
)
diff --git a/scripts/hiddenapi/Android.bp b/scripts/hiddenapi/Android.bp
index 7472f52..c50dc24 100644
--- a/scripts/hiddenapi/Android.bp
+++ b/scripts/hiddenapi/Android.bp
@@ -48,6 +48,27 @@
},
}
+python_test_host {
+ name: "generate_hiddenapi_lists_test",
+ main: "generate_hiddenapi_lists_test.py",
+ srcs: [
+ "generate_hiddenapi_lists.py",
+ "generate_hiddenapi_lists_test.py",
+ ],
+ version: {
+ py2: {
+ enabled: false,
+ },
+ py3: {
+ enabled: true,
+ embedded_launcher: true,
+ },
+ },
+ test_options: {
+ unit_test: true,
+ },
+}
+
python_binary_host {
name: "verify_overlaps",
main: "verify_overlaps.py",
diff --git a/scripts/hiddenapi/generate_hiddenapi_lists_test.py b/scripts/hiddenapi/generate_hiddenapi_lists_test.py
index ff3d708..b81424b 100755
--- a/scripts/hiddenapi/generate_hiddenapi_lists_test.py
+++ b/scripts/hiddenapi/generate_hiddenapi_lists_test.py
@@ -101,4 +101,4 @@
self.assertEqual(extract_package(signature), expected_package)
if __name__ == '__main__':
- unittest.main()
+ unittest.main(verbosity=2)
diff --git a/scripts/manifest_check.py b/scripts/manifest_check.py
index 8168fbf..4ef4399 100755
--- a/scripts/manifest_check.py
+++ b/scripts/manifest_check.py
@@ -90,6 +90,15 @@
else:
manifest_required, manifest_optional, tags = extract_uses_libs_xml(manifest)
+ # Trim namespace component. Normally Soong does that automatically when it
+ # handles module names specified in Android.bp properties. However not all
+ # <uses-library> entries in the manifest correspond to real modules: some of
+ # the optional libraries may be missing at build time. Therefor this script
+ # accepts raw module names as spelled in Android.bp/Amdroid.mk and trims the
+ # optional namespace part manually.
+ required = trim_namespace_parts(required)
+ optional = trim_namespace_parts(optional)
+
if manifest_required == required and manifest_optional == optional:
return None
@@ -118,6 +127,17 @@
return errmsg
+MODULE_NAMESPACE = re.compile("^//[^:]+:")
+
+def trim_namespace_parts(modules):
+ """Trim the namespace part of each module, if present. Leave only the name."""
+
+ trimmed = []
+ for module in modules:
+ trimmed.append(MODULE_NAMESPACE.sub('', module))
+ return trimmed
+
+
def extract_uses_libs_apk(badging):
"""Extract <uses-library> tags from the manifest of an APK."""
diff --git a/scripts/manifest_check_test.py b/scripts/manifest_check_test.py
index 7159bdd..e3e8ac4 100755
--- a/scripts/manifest_check_test.py
+++ b/scripts/manifest_check_test.py
@@ -183,6 +183,15 @@
optional_uses_libraries=['bar'])
self.assertTrue(matches)
+ def test_mixed_with_namespace(self):
+ xml = self.xml_tmpl % ('\n'.join([uses_library_xml('foo'),
+ uses_library_xml('bar', required_xml(False))]))
+ apk = self.apk_tmpl % ('\n'.join([uses_library_apk('foo'),
+ uses_library_apk('bar', required_apk(False))]))
+ matches = self.run_test(xml, apk, uses_libraries=['//x/y/z:foo'],
+ optional_uses_libraries=['//x/y/z:bar'])
+ self.assertTrue(matches)
+
class ExtractTargetSdkVersionTest(unittest.TestCase):
def run_test(self, xml, apk, version):
diff --git a/sdk/bootclasspath_fragment_sdk_test.go b/sdk/bootclasspath_fragment_sdk_test.go
index 1d2ab42..efd2b5b 100644
--- a/sdk/bootclasspath_fragment_sdk_test.go
+++ b/sdk/bootclasspath_fragment_sdk_test.go
@@ -133,6 +133,13 @@
apex_available: ["com.android.art"],
image_name: "art",
contents: ["mybootlib"],
+ hidden_api: {
+ stub_flags: "hiddenapi/stub-flags.csv",
+ annotation_flags: "hiddenapi/annotation-flags.csv",
+ metadata: "hiddenapi/metadata.csv",
+ index: "hiddenapi/index.csv",
+ all_flags: "hiddenapi/all-flags.csv",
+ },
}
java_import {
@@ -140,7 +147,7 @@
prefer: false,
visibility: ["//visibility:public"],
apex_available: ["com.android.art"],
- jars: ["java/mybootlib.jar"],
+ jars: ["java_boot_libs/snapshot/jars/are/invalid/mybootlib.jar"],
}
`),
checkVersionedAndroidBpContents(`
@@ -153,6 +160,13 @@
apex_available: ["com.android.art"],
image_name: "art",
contents: ["mysdk_mybootlib@current"],
+ hidden_api: {
+ stub_flags: "hiddenapi/stub-flags.csv",
+ annotation_flags: "hiddenapi/annotation-flags.csv",
+ metadata: "hiddenapi/metadata.csv",
+ index: "hiddenapi/index.csv",
+ all_flags: "hiddenapi/all-flags.csv",
+ },
}
java_import {
@@ -160,7 +174,7 @@
sdk_member_name: "mybootlib",
visibility: ["//visibility:public"],
apex_available: ["com.android.art"],
- jars: ["java/mybootlib.jar"],
+ jars: ["java_boot_libs/snapshot/jars/are/invalid/mybootlib.jar"],
}
sdk_snapshot {
@@ -171,8 +185,13 @@
}
`),
checkAllCopyRules(`
-.intermediates/mybootlib/android_common/javac/mybootlib.jar -> java/mybootlib.jar
-`),
+.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/stub-flags.csv -> hiddenapi/stub-flags.csv
+.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/annotation-flags.csv -> hiddenapi/annotation-flags.csv
+.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/metadata.csv -> hiddenapi/metadata.csv
+.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/index.csv -> hiddenapi/index.csv
+.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/all-flags.csv -> hiddenapi/all-flags.csv
+.intermediates/mysdk/common_os/empty -> java_boot_libs/snapshot/jars/are/invalid/mybootlib.jar
+ `),
snapshotTestPreparer(checkSnapshotWithoutSource, preparerForSnapshot),
// Check the behavior of the snapshot without the source.
@@ -326,7 +345,7 @@
prefer: false,
visibility: ["//visibility:public"],
apex_available: ["myapex"],
- jars: ["java/mybootlib.jar"],
+ jars: ["java_boot_libs/snapshot/jars/are/invalid/mybootlib.jar"],
permitted_packages: ["mybootlib"],
}
@@ -410,7 +429,7 @@
sdk_member_name: "mybootlib",
visibility: ["//visibility:public"],
apex_available: ["myapex"],
- jars: ["java/mybootlib.jar"],
+ jars: ["java_boot_libs/snapshot/jars/are/invalid/mybootlib.jar"],
permitted_packages: ["mybootlib"],
}
@@ -480,7 +499,7 @@
.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/metadata.csv -> hiddenapi/metadata.csv
.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/index.csv -> hiddenapi/index.csv
.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/all-flags.csv -> hiddenapi/all-flags.csv
-.intermediates/mybootlib/android_common/javac/mybootlib.jar -> java/mybootlib.jar
+.intermediates/mysdk/common_os/empty -> java_boot_libs/snapshot/jars/are/invalid/mybootlib.jar
.intermediates/myothersdklibrary.stubs/android_common/javac/myothersdklibrary.stubs.jar -> sdk_library/public/myothersdklibrary-stubs.jar
.intermediates/myothersdklibrary.stubs.source/android_common/metalava/myothersdklibrary.stubs.source_api.txt -> sdk_library/public/myothersdklibrary.txt
.intermediates/myothersdklibrary.stubs.source/android_common/metalava/myothersdklibrary.stubs.source_removed.txt -> sdk_library/public/myothersdklibrary-removed.txt
@@ -832,7 +851,7 @@
prefer: false,
visibility: ["//visibility:public"],
apex_available: ["myapex"],
- jars: ["java/mybootlib.jar"],
+ jars: ["java_boot_libs/snapshot/jars/are/invalid/mybootlib.jar"],
permitted_packages: ["mybootlib"],
}
@@ -867,7 +886,7 @@
.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/metadata.csv -> hiddenapi/metadata.csv
.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/index.csv -> hiddenapi/index.csv
.intermediates/mybootclasspathfragment/android_common/modular-hiddenapi/all-flags.csv -> hiddenapi/all-flags.csv
-.intermediates/mybootlib/android_common/javac/mybootlib.jar -> java/mybootlib.jar
+.intermediates/mysdk/common_os/empty -> java_boot_libs/snapshot/jars/are/invalid/mybootlib.jar
.intermediates/mysdklibrary.stubs/android_common/javac/mysdklibrary.stubs.jar -> sdk_library/public/mysdklibrary-stubs.jar
.intermediates/mysdklibrary.stubs.source/android_common/metalava/mysdklibrary.stubs.source_api.txt -> sdk_library/public/mysdklibrary.txt
.intermediates/mysdklibrary.stubs.source/android_common/metalava/mysdklibrary.stubs.source_removed.txt -> sdk_library/public/mysdklibrary-removed.txt
diff --git a/sdk/java_sdk_test.go b/sdk/java_sdk_test.go
index 813dcfd..9efb3a4 100644
--- a/sdk/java_sdk_test.go
+++ b/sdk/java_sdk_test.go
@@ -453,7 +453,7 @@
prefer: false,
visibility: ["//visibility:public"],
apex_available: ["//apex_available:platform"],
- jars: ["java/myjavalib.jar"],
+ jars: ["java_boot_libs/snapshot/jars/are/invalid/myjavalib.jar"],
permitted_packages: ["pkg.myjavalib"],
}
`),
@@ -465,7 +465,7 @@
sdk_member_name: "myjavalib",
visibility: ["//visibility:public"],
apex_available: ["//apex_available:platform"],
- jars: ["java/myjavalib.jar"],
+ jars: ["java_boot_libs/snapshot/jars/are/invalid/myjavalib.jar"],
permitted_packages: ["pkg.myjavalib"],
}
@@ -474,9 +474,10 @@
visibility: ["//visibility:public"],
java_boot_libs: ["myexports_myjavalib@current"],
}
+
`),
checkAllCopyRules(`
-.intermediates/myjavalib/android_common/withres/myjavalib.jar -> java/myjavalib.jar
+.intermediates/myexports/common_os/empty -> java_boot_libs/snapshot/jars/are/invalid/myjavalib.jar
`),
)
}
diff --git a/sdk/sdk_test.go b/sdk/sdk_test.go
index 97fb248..85e3d87 100644
--- a/sdk/sdk_test.go
+++ b/sdk/sdk_test.go
@@ -15,19 +15,21 @@
package sdk
import (
- "android/soong/android"
"log"
"os"
+ "runtime"
"testing"
+ "android/soong/android"
+
"github.com/google/blueprint/proptools"
)
// Needed in an _test.go file in this package to ensure tests run correctly, particularly in IDE.
func TestMain(m *testing.M) {
- if android.BuildOs != android.Linux {
+ if runtime.GOOS != "linux" {
// b/145598135 - Generating host snapshots for anything other than linux is not supported.
- log.Printf("Skipping as sdk snapshot generation is only supported on %s not %s", android.Linux, android.BuildOs)
+ log.Printf("Skipping as sdk snapshot generation is only supported on linux not %s", runtime.GOOS)
os.Exit(0)
}
diff --git a/sdk/update.go b/sdk/update.go
index 6da3756..1cd8f13 100644
--- a/sdk/update.go
+++ b/sdk/update.go
@@ -22,6 +22,7 @@
"android/soong/apex"
"android/soong/cc"
+
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
@@ -1029,6 +1030,9 @@
filesToZip android.Paths
zipsToMerge android.Paths
+ // The path to an empty file.
+ emptyFile android.WritablePath
+
prebuiltModules map[string]*bpModule
prebuiltOrder []*bpModule
@@ -1079,6 +1083,19 @@
s.zipsToMerge = append(s.zipsToMerge, tmpZipPath)
}
+func (s *snapshotBuilder) EmptyFile() android.Path {
+ if s.emptyFile == nil {
+ ctx := s.ctx
+ s.emptyFile = android.PathForModuleOut(ctx, "empty")
+ s.ctx.Build(pctx, android.BuildParams{
+ Rule: android.Touch,
+ Output: s.emptyFile,
+ })
+ }
+
+ return s.emptyFile
+}
+
func (s *snapshotBuilder) AddPrebuiltModule(member android.SdkMember, moduleType string) android.BpModule {
name := member.Name()
if s.prebuiltModules[name] != nil {
@@ -1758,7 +1775,7 @@
var osTypes []android.OsType
for _, osType := range android.OsTypeList() {
if s.DeviceSupported() {
- if osType.Class == android.Device && osType != android.Fuchsia {
+ if osType.Class == android.Device {
osTypes = append(osTypes, osType)
}
}
diff --git a/sh/sh_binary_test.go b/sh/sh_binary_test.go
index 20317d8..865d5f3 100644
--- a/sh/sh_binary_test.go
+++ b/sh/sh_binary_test.go
@@ -115,7 +115,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := config.BuildOS.String()
arches := []string{"android_arm64_armv8-a", buildOS + "_x86_64"}
for _, arch := range arches {
variant := ctx.ModuleForTests("foo", arch)
@@ -155,7 +155,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := ctx.Config().BuildOS.String()
mod := ctx.ModuleForTests("foo", buildOS+"_x86_64").Module().(*ShTest)
if !mod.Host() {
t.Errorf("host bit is not set for a sh_test_host module.")
@@ -192,7 +192,7 @@
}
`)
- buildOS := android.BuildOs.String()
+ buildOS := config.BuildOS.String()
variant := ctx.ModuleForTests("foo", buildOS+"_x86_64")
relocated := variant.Output("relocated/lib64/libbar.so")
diff --git a/snapshot/Android.bp b/snapshot/Android.bp
new file mode 100644
index 0000000..f17ac53
--- /dev/null
+++ b/snapshot/Android.bp
@@ -0,0 +1,22 @@
+package {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+bootstrap_go_package {
+ name: "soong-snapshot",
+ pkgPath: "android/soong/snapshot",
+ deps: [
+ "blueprint",
+ "blueprint-pathtools",
+ "soong",
+ "soong-android",
+ ],
+ srcs: [
+ "recovery_snapshot.go",
+ "snapshot.go",
+ "snapshot_base.go",
+ "util.go",
+ "vendor_snapshot.go",
+ ],
+ pluginFor: ["soong_build"],
+}
diff --git a/snapshot/recovery_snapshot.go b/snapshot/recovery_snapshot.go
new file mode 100644
index 0000000..9b3919c
--- /dev/null
+++ b/snapshot/recovery_snapshot.go
@@ -0,0 +1,130 @@
+// Copyright 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package snapshot
+
+import "android/soong/android"
+
+// Interface for modules which can be captured in the recovery snapshot.
+type RecoverySnapshotModuleInterface interface {
+ SnapshotModuleInterfaceBase
+ InRecovery() bool
+ ExcludeFromRecoverySnapshot() bool
+}
+
+var recoverySnapshotSingleton = SnapshotSingleton{
+ "recovery", // name
+ "SOONG_RECOVERY_SNAPSHOT_ZIP", // makeVar
+ android.OptionalPath{}, // snapshotZipFile
+ RecoverySnapshotImageSingleton, // Image
+ false, // Fake
+}
+
+func RecoverySnapshotSingleton() android.Singleton {
+ return &recoverySnapshotSingleton
+}
+
+// Determine if a dir under source tree is an SoC-owned proprietary directory based
+// on recovery snapshot configuration
+// Examples: device/, vendor/
+func isRecoveryProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool {
+ return RecoverySnapshotSingleton().(*SnapshotSingleton).Image.IsProprietaryPath(dir, deviceConfig)
+}
+
+func IsRecoveryProprietaryModule(ctx android.BaseModuleContext) bool {
+
+ // Any module in a recovery proprietary path is a recovery proprietary
+ // module.
+ if isRecoveryProprietaryPath(ctx.ModuleDir(), ctx.DeviceConfig()) {
+ return true
+ }
+
+ // However if the module is not in a recovery proprietary path, it may
+ // still be a recovery proprietary module. This happens for cc modules
+ // that are excluded from the recovery snapshot, and it means that the
+ // vendor has assumed control of the framework-provided module.
+
+ if c, ok := ctx.Module().(RecoverySnapshotModuleInterface); ok {
+ if c.ExcludeFromRecoverySnapshot() {
+ return true
+ }
+ }
+
+ return false
+}
+
+var RecoverySnapshotImageName = "recovery"
+
+type RecoverySnapshotImage struct{}
+
+func (RecoverySnapshotImage) Init(ctx android.RegistrationContext) {
+ ctx.RegisterSingletonType("recovery-snapshot", RecoverySnapshotSingleton)
+}
+
+func (RecoverySnapshotImage) shouldGenerateSnapshot(ctx android.SingletonContext) bool {
+ // RECOVERY_SNAPSHOT_VERSION must be set to 'current' in order to generate a
+ // snapshot.
+ return ctx.DeviceConfig().RecoverySnapshotVersion() == "current"
+}
+
+func (RecoverySnapshotImage) InImage(m SnapshotModuleInterfaceBase) func() bool {
+ r, ok := m.(RecoverySnapshotModuleInterface)
+
+ if !ok {
+ // This module does not support recovery snapshot
+ return func() bool { return false }
+ }
+ return r.InRecovery
+}
+
+func (RecoverySnapshotImage) IsProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool {
+ return isDirectoryExcluded(dir, deviceConfig.RecoverySnapshotDirsExcludedMap(), deviceConfig.RecoverySnapshotDirsIncludedMap())
+}
+
+func (RecoverySnapshotImage) ExcludeFromSnapshot(m SnapshotModuleInterfaceBase) bool {
+ r, ok := m.(RecoverySnapshotModuleInterface)
+
+ if !ok {
+ // This module does not support recovery snapshot
+ return true
+ }
+ return r.ExcludeFromRecoverySnapshot()
+}
+
+func (RecoverySnapshotImage) IsUsingSnapshot(cfg android.DeviceConfig) bool {
+ recoverySnapshotVersion := cfg.RecoverySnapshotVersion()
+ return recoverySnapshotVersion != "current" && recoverySnapshotVersion != ""
+}
+
+func (RecoverySnapshotImage) TargetSnapshotVersion(cfg android.DeviceConfig) string {
+ return cfg.RecoverySnapshotVersion()
+}
+
+func (RecoverySnapshotImage) ExcludeFromDirectedSnapshot(cfg android.DeviceConfig, name string) bool {
+ // If we're using full snapshot, not directed snapshot, capture every module
+ if !cfg.DirectedRecoverySnapshot() {
+ return false
+ }
+ // Else, checks if name is in RECOVERY_SNAPSHOT_MODULES.
+ return !cfg.RecoverySnapshotModules()[name]
+}
+
+func (RecoverySnapshotImage) ImageName() string {
+ return RecoverySnapshotImageName
+}
+
+var RecoverySnapshotImageSingleton RecoverySnapshotImage
+
+func init() {
+ RecoverySnapshotImageSingleton.Init(android.InitRegistrationContext)
+}
diff --git a/snapshot/snapshot.go b/snapshot/snapshot.go
new file mode 100644
index 0000000..294f8b6
--- /dev/null
+++ b/snapshot/snapshot.go
@@ -0,0 +1,122 @@
+// Copyright 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package snapshot
+
+import (
+ "path/filepath"
+ "sort"
+
+ "android/soong/android"
+)
+
+// This file contains singletons to capture snapshots. This singleton will generate snapshot of each target
+// image, and capturing snapshot module will be delegated to each module which implements GenerateSnapshotAction
+// function and register with RegisterSnapshotAction.
+
+var pctx = android.NewPackageContext("android/soong/snapshot")
+
+type SnapshotSingleton struct {
+ // Name, e.g., "vendor", "recovery", "ramdisk".
+ name string
+
+ // Make variable that points to the snapshot file, e.g.,
+ // "SOONG_RECOVERY_SNAPSHOT_ZIP".
+ makeVar string
+
+ // Path to the snapshot zip file.
+ snapshotZipFile android.OptionalPath
+
+ // Implementation of the image interface specific to the image
+ // associated with this snapshot (e.g., specific to the vendor image,
+ // recovery image, etc.).
+ Image SnapshotImage
+
+ // Whether this singleton is for fake snapshot or not.
+ // Fake snapshot is a snapshot whose prebuilt binaries and headers are empty.
+ // It is much faster to generate, and can be used to inspect dependencies.
+ Fake bool
+}
+
+// Interface of function to capture snapshot from each module
+type GenerateSnapshotAction func(snapshot SnapshotSingleton, ctx android.SingletonContext, snapshotArchDir string) android.Paths
+
+var snapshotActionList []GenerateSnapshotAction
+
+// Register GenerateSnapshotAction function so it can be called while generating snapshot
+func RegisterSnapshotAction(x GenerateSnapshotAction) {
+ snapshotActionList = append(snapshotActionList, x)
+}
+
+func (c *SnapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) {
+ if !c.Image.shouldGenerateSnapshot(ctx) {
+ return
+ }
+
+ var snapshotOutputs android.Paths
+
+ // Snapshot zipped artifacts will be captured under {SNAPSHOT_ARCH} directory
+
+ snapshotDir := c.name + "-snapshot"
+ if c.Fake {
+ // If this is a fake snapshot singleton, place all files under fake/ subdirectory to avoid
+ // collision with real snapshot files
+ snapshotDir = filepath.Join("fake", snapshotDir)
+ }
+ snapshotArchDir := filepath.Join(snapshotDir, ctx.DeviceConfig().DeviceArch())
+
+ for _, f := range snapshotActionList {
+ snapshotOutputs = append(snapshotOutputs, f(*c, ctx, snapshotArchDir)...)
+ }
+
+ // All artifacts are ready. Sort them to normalize ninja and then zip.
+ sort.Slice(snapshotOutputs, func(i, j int) bool {
+ return snapshotOutputs[i].String() < snapshotOutputs[j].String()
+ })
+
+ zipPath := android.PathForOutput(
+ ctx,
+ snapshotDir,
+ c.name+"-"+ctx.Config().DeviceName()+".zip")
+ zipRule := android.NewRuleBuilder(pctx, ctx)
+
+ // filenames in rspfile from FlagWithRspFileInputList might be single-quoted. Remove it with tr
+ snapshotOutputList := android.PathForOutput(
+ ctx,
+ snapshotDir,
+ c.name+"-"+ctx.Config().DeviceName()+"_list")
+ rspFile := snapshotOutputList.ReplaceExtension(ctx, "rsp")
+ zipRule.Command().
+ Text("tr").
+ FlagWithArg("-d ", "\\'").
+ FlagWithRspFileInputList("< ", rspFile, snapshotOutputs).
+ FlagWithOutput("> ", snapshotOutputList)
+
+ zipRule.Temporary(snapshotOutputList)
+
+ zipRule.Command().
+ BuiltTool("soong_zip").
+ FlagWithOutput("-o ", zipPath).
+ FlagWithArg("-C ", android.PathForOutput(ctx, snapshotDir).String()).
+ FlagWithInput("-l ", snapshotOutputList)
+
+ zipRule.Build(zipPath.String(), c.name+" snapshot "+zipPath.String())
+ zipRule.DeleteTemporaryFiles()
+ c.snapshotZipFile = android.OptionalPathForPath(zipPath)
+}
+
+func (c *SnapshotSingleton) MakeVars(ctx android.MakeVarsContext) {
+ ctx.Strict(
+ c.makeVar,
+ c.snapshotZipFile.String())
+}
diff --git a/snapshot/snapshot_base.go b/snapshot/snapshot_base.go
new file mode 100644
index 0000000..de93f3e
--- /dev/null
+++ b/snapshot/snapshot_base.go
@@ -0,0 +1,104 @@
+// Copyright 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package snapshot
+
+import (
+ "android/soong/android"
+ "path/filepath"
+)
+
+// Interface for modules which can be captured in the snapshot.
+type SnapshotModuleInterfaceBase interface{}
+
+// Defines the specifics of different images to which the snapshot process is applicable, e.g.,
+// vendor, recovery, ramdisk.
+type SnapshotImage interface {
+ // Returns true if a snapshot should be generated for this image.
+ shouldGenerateSnapshot(ctx android.SingletonContext) bool
+
+ // Function that returns true if the module is included in this image.
+ // Using a function return instead of a value to prevent early
+ // evalution of a function that may be not be defined.
+ InImage(m SnapshotModuleInterfaceBase) func() bool
+
+ // Returns true if a dir under source tree is an SoC-owned proprietary
+ // directory, such as device/, vendor/, etc.
+ //
+ // For a given snapshot (e.g., vendor, recovery, etc.) if
+ // isProprietaryPath(dir, deviceConfig) returns true, then the module in dir
+ // will be built from sources.
+ IsProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool
+
+ // Whether a given module has been explicitly excluded from the
+ // snapshot, e.g., using the exclude_from_vendor_snapshot or
+ // exclude_from_recovery_snapshot properties.
+ ExcludeFromSnapshot(m SnapshotModuleInterfaceBase) bool
+
+ // Returns true if the build is using a snapshot for this image.
+ IsUsingSnapshot(cfg android.DeviceConfig) bool
+
+ // Returns a version of which the snapshot should be used in this target.
+ // This will only be meaningful when isUsingSnapshot is true.
+ TargetSnapshotVersion(cfg android.DeviceConfig) string
+
+ // Whether to exclude a given module from the directed snapshot or not.
+ // If the makefile variable DIRECTED_{IMAGE}_SNAPSHOT is true, directed snapshot is turned on,
+ // and only modules listed in {IMAGE}_SNAPSHOT_MODULES will be captured.
+ ExcludeFromDirectedSnapshot(cfg android.DeviceConfig, name string) bool
+
+ // Returns target image name
+ ImageName() string
+}
+
+type directoryMap map[string]bool
+
+var (
+ // Modules under following directories are ignored. They are OEM's and vendor's
+ // proprietary modules(device/, kernel/, vendor/, and hardware/).
+ defaultDirectoryExcludedMap = directoryMap{
+ "device": true,
+ "hardware": true,
+ "kernel": true,
+ "vendor": true,
+ }
+
+ // Modules under following directories are included as they are in AOSP,
+ // although hardware/ and kernel/ are normally for vendor's own.
+ defaultDirectoryIncludedMap = directoryMap{
+ "kernel/configs": true,
+ "kernel/prebuilts": true,
+ "kernel/tests": true,
+ "hardware/interfaces": true,
+ "hardware/libhardware": true,
+ "hardware/libhardware_legacy": true,
+ "hardware/ril": true,
+ }
+)
+
+func isDirectoryExcluded(dir string, excludedMap directoryMap, includedMap directoryMap) bool {
+ if dir == "." || dir == "/" {
+ return false
+ }
+ if includedMap[dir] {
+ return false
+ } else if excludedMap[dir] {
+ return true
+ } else if defaultDirectoryIncludedMap[dir] {
+ return false
+ } else if defaultDirectoryExcludedMap[dir] {
+ return true
+ } else {
+ return isDirectoryExcluded(filepath.Dir(dir), excludedMap, includedMap)
+ }
+}
diff --git a/snapshot/util.go b/snapshot/util.go
new file mode 100644
index 0000000..2297dfc
--- /dev/null
+++ b/snapshot/util.go
@@ -0,0 +1,36 @@
+// Copyright 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package snapshot
+
+import "android/soong/android"
+
+func WriteStringToFileRule(ctx android.SingletonContext, content, out string) android.OutputPath {
+ outPath := android.PathForOutput(ctx, out)
+ android.WriteFileRule(ctx, outPath, content)
+ return outPath
+}
+
+func CopyFileRule(pctx android.PackageContext, ctx android.SingletonContext, path android.Path, out string) android.OutputPath {
+ outPath := android.PathForOutput(ctx, out)
+ ctx.Build(pctx, android.BuildParams{
+ Rule: android.Cp,
+ Input: path,
+ Output: outPath,
+ Description: "copy " + path.String() + " -> " + out,
+ Args: map[string]string{
+ "cpFlags": "-f -L",
+ },
+ })
+ return outPath
+}
diff --git a/snapshot/vendor_snapshot.go b/snapshot/vendor_snapshot.go
new file mode 100644
index 0000000..9bd26c2
--- /dev/null
+++ b/snapshot/vendor_snapshot.go
@@ -0,0 +1,147 @@
+// Copyright 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package snapshot
+
+import "android/soong/android"
+
+// Interface for modules which can be captured in the vendor snapshot.
+type VendorSnapshotModuleInterface interface {
+ SnapshotModuleInterfaceBase
+ InVendor() bool
+ ExcludeFromVendorSnapshot() bool
+}
+
+var vendorSnapshotSingleton = SnapshotSingleton{
+ "vendor", // name
+ "SOONG_VENDOR_SNAPSHOT_ZIP", // makeVar
+ android.OptionalPath{}, // snapshotZipFile
+ VendorSnapshotImageSingleton, // Image
+ false, // Fake
+}
+
+var vendorFakeSnapshotSingleton = SnapshotSingleton{
+ "vendor", // name
+ "SOONG_VENDOR_FAKE_SNAPSHOT_ZIP", // makeVar
+ android.OptionalPath{}, // snapshotZipFile
+ VendorSnapshotImageSingleton, // Image
+ true, // Fake
+}
+
+func VendorSnapshotSingleton() android.Singleton {
+ return &vendorSnapshotSingleton
+}
+
+func VendorFakeSnapshotSingleton() android.Singleton {
+ return &vendorFakeSnapshotSingleton
+}
+
+// Determine if a dir under source tree is an SoC-owned proprietary directory based
+// on vendor snapshot configuration
+// Examples: device/, vendor/
+func isVendorProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool {
+ return VendorSnapshotSingleton().(*SnapshotSingleton).Image.IsProprietaryPath(dir, deviceConfig)
+}
+
+func IsVendorProprietaryModule(ctx android.BaseModuleContext) bool {
+ // Any module in a vendor proprietary path is a vendor proprietary
+ // module.
+ if isVendorProprietaryPath(ctx.ModuleDir(), ctx.DeviceConfig()) {
+ return true
+ }
+
+ // However if the module is not in a vendor proprietary path, it may
+ // still be a vendor proprietary module. This happens for cc modules
+ // that are excluded from the vendor snapshot, and it means that the
+ // vendor has assumed control of the framework-provided module.
+ if c, ok := ctx.Module().(VendorSnapshotModuleInterface); ok {
+ if c.ExcludeFromVendorSnapshot() {
+ return true
+ }
+ }
+
+ return false
+}
+
+var VendorSnapshotImageName = "vendor"
+
+type VendorSnapshotImage struct{}
+
+func (VendorSnapshotImage) Init(ctx android.RegistrationContext) {
+ ctx.RegisterSingletonType("vendor-snapshot", VendorSnapshotSingleton)
+ ctx.RegisterSingletonType("vendor-fake-snapshot", VendorFakeSnapshotSingleton)
+}
+
+func (VendorSnapshotImage) RegisterAdditionalModule(ctx android.RegistrationContext, name string, factory android.ModuleFactory) {
+ ctx.RegisterModuleType(name, factory)
+}
+
+func (VendorSnapshotImage) shouldGenerateSnapshot(ctx android.SingletonContext) bool {
+ // BOARD_VNDK_VERSION must be set to 'current' in order to generate a snapshot.
+ return ctx.DeviceConfig().VndkVersion() == "current"
+}
+
+func (VendorSnapshotImage) InImage(m SnapshotModuleInterfaceBase) func() bool {
+ v, ok := m.(VendorSnapshotModuleInterface)
+
+ if !ok {
+ // This module does not support Vendor snapshot
+ return func() bool { return false }
+ }
+
+ return v.InVendor
+}
+
+func (VendorSnapshotImage) IsProprietaryPath(dir string, deviceConfig android.DeviceConfig) bool {
+ return isDirectoryExcluded(dir, deviceConfig.VendorSnapshotDirsExcludedMap(), deviceConfig.VendorSnapshotDirsIncludedMap())
+}
+
+func (VendorSnapshotImage) ExcludeFromSnapshot(m SnapshotModuleInterfaceBase) bool {
+ v, ok := m.(VendorSnapshotModuleInterface)
+
+ if !ok {
+ // This module does not support Vendor snapshot
+ return true
+ }
+
+ return v.ExcludeFromVendorSnapshot()
+}
+
+func (VendorSnapshotImage) IsUsingSnapshot(cfg android.DeviceConfig) bool {
+ vndkVersion := cfg.VndkVersion()
+ return vndkVersion != "current" && vndkVersion != ""
+}
+
+func (VendorSnapshotImage) TargetSnapshotVersion(cfg android.DeviceConfig) string {
+ return cfg.VndkVersion()
+}
+
+// returns true iff a given module SHOULD BE EXCLUDED, false if included
+func (VendorSnapshotImage) ExcludeFromDirectedSnapshot(cfg android.DeviceConfig, name string) bool {
+ // If we're using full snapshot, not directed snapshot, capture every module
+ if !cfg.DirectedVendorSnapshot() {
+ return false
+ }
+ // Else, checks if name is in VENDOR_SNAPSHOT_MODULES.
+ return !cfg.VendorSnapshotModules()[name]
+}
+
+func (VendorSnapshotImage) ImageName() string {
+ return VendorSnapshotImageName
+}
+
+var VendorSnapshotImageSingleton VendorSnapshotImage
+
+func init() {
+ VendorSnapshotImageSingleton.Init(android.InitRegistrationContext)
+}