diff options
147 files changed, 4112 insertions, 2795 deletions
@@ -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 340f136c7..583793efe 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 @@ func osByName(name string) OsType { 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 @@ var ( // 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 @@ func (m *ModuleBase) setArchProperties(ctx BottomUpMutatorContext) { } } +// 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 @@ func decodeTargetProductVariables(config *config) (map[OsType][]Target, error) { 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 @@ func decodeTargetProductVariables(config *config) (map[OsType][]Target, error) { } // 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 @@ func decodeTargetProductVariables(config *config) (map[OsType][]Target, error) { // 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 @@ func (m *ModuleBase) GetArchVariantProperties(ctx ArchVariantContext, propertySe 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 3aa4779fe..2a2fd454e 100644 --- a/android/arch_test.go +++ b/android/arch_test.go @@ -473,3 +473,164 @@ func TestArchMutatorNativeBridge(t *testing.T) { }) } } + +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 992d8aa27..d40e6508e 100644 --- a/android/bazel.go +++ b/android/bazel.go @@ -129,7 +129,7 @@ var ( // 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 @@ var ( "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, @@ -180,7 +182,6 @@ var ( // also depends on //system/logging/liblog:liblog (http://b/186822772) "libc_ndk", // http://b/187013218, cc_library_static, depends on //bionic/libm:libm (http://b/183064661) "libc_malloc_hooks", // http://b/187016307, cc_library, ld.lld: error: undefined symbol: __malloc_hook - "libm", // http://b/183064661, cc_library, math.h:25:16: error: unexpected token in argument list // http://b/186823769: Needs C++ STL support, includes from unconverted standard libraries in //external/libcxx // c++_static @@ -189,7 +190,7 @@ var ( "libBionicBenchmarksUtils", // cc_library_static, fatal error: 'map' file not found, from libcxx "fmtlib", // cc_library_static, fatal error: 'cassert' file not found, from libcxx "fmtlib_ndk", // cc_library_static, fatal error: 'cassert' file not found - "libbase", // http://b/186826479, cc_library, fatal error: 'memory' file not found, from libcxx + "libbase", // Requires liblog. http://b/186826479, cc_library, fatal error: 'memory' file not found, from libcxx. // http://b/186024507: Includes errors because of the system_shared_libs default value. // Missing -isystem bionic/libc/include through the libc/libm/libdl diff --git a/android/bazel_paths.go b/android/bazel_paths.go index f74fed13f..26cacdba8 100644 --- a/android/bazel_paths.go +++ b/android/bazel_paths.go @@ -73,6 +73,7 @@ type BazelConversionPathContext interface { 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 @@ func expandSrcsForBazel(ctx BazelConversionPathContext, paths, expandedExcludes // 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 ed90c3181..871986c7c 100644 --- a/android/config.go +++ b/android/config.go @@ -108,6 +108,12 @@ type config struct { 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 @@ func TestConfig(buildDir string, env map[string]string, bp string, fs map[string 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 @@ func NewConfig(srcDir, buildDir string, moduleListFile string, availableEnv map[ 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 @@ func NewConfig(srcDir, buildDir string, moduleListFile string, availableEnv map[ 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 { @@ -821,6 +816,12 @@ func (c *config) UnbundledBuildApps() bool { return Bool(c.productVariables.Unbundled_build_apps) } +// Returns true if building image that aren't bundled with the platform. +// UnbundledBuild() is always true when this is true. +func (c *config) UnbundledBuildImage() bool { + return Bool(c.productVariables.Unbundled_build_image) +} + // Returns true if building modules against prebuilt SDKs. func (c *config) AlwaysUsePrebuiltSdks() bool { return Bool(c.productVariables.Always_use_prebuilt_sdks) @@ -831,10 +832,6 @@ func (c *config) SkipBootJarsCheck() bool { 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 196b095dd..5f34e6259 100644 --- a/android/module.go +++ b/android/module.go @@ -223,6 +223,8 @@ type BaseModuleContext interface { // 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 @@ type BaseModuleContext interface { Host() bool Device() bool Darwin() bool - Fuchsia() bool Windows() bool Debug() bool PrimaryArch() bool @@ -413,6 +414,7 @@ type ModuleContext interface { InstallInDebugRamdisk() bool InstallInRecovery() bool InstallInRoot() bool + InstallInVendor() bool InstallBypassMake() bool InstallForceOS() (*OsType, *ArchType) @@ -471,6 +473,7 @@ type Module interface { InstallInDebugRamdisk() bool InstallInRecovery() bool InstallInRoot() bool + InstallInVendor() bool InstallBypassMake() bool InstallForceOS() (*OsType, *ArchType) HideFromMake() @@ -1579,6 +1582,10 @@ func (m *ModuleBase) InstallInRecovery() bool { 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 @@ type baseModuleContext struct { 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 @@ func (b *baseModuleContext) GetDirectDep(name string) (blueprint.Module, bluepri 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 @@ func (b *baseModuleContext) Darwin() bool { 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 @@ func (m *moduleContext) InstallForceOS() (*OsType, *ArchType) { 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 @@ -2812,44 +2836,85 @@ func (m *moduleContext) blueprintModuleContext() blueprint.ModuleContext { return m.bp } -// SrcIsModule decodes module references in the format ":name" into the module name, or empty string if the input -// was not a module reference. +// SrcIsModule decodes module references in the format ":unqualified-name" or "//namespace:name" +// into the module name, or empty string if the input was not a module reference. func SrcIsModule(s string) (module string) { - if len(s) > 1 && s[0] == ':' { - return s[1:] + if len(s) > 1 { + if s[0] == ':' { + module = s[1:] + if !isUnqualifiedModuleName(module) { + // The module name should be unqualified but is not so do not treat it as a module. + module = "" + } + } else if s[0] == '/' && s[1] == '/' { + module = s + } } - return "" + return module } -// SrcIsModule decodes module references in the format ":name{.tag}" into the module name and tag, ":name" into the -// module name and an empty string for the tag, or empty strings if the input was not a module reference. +// SrcIsModuleWithTag decodes module references in the format ":unqualified-name{.tag}" or +// "//namespace:name{.tag}" into the module name and tag, ":unqualified-name" or "//namespace:name" +// into the module name and an empty string for the tag, or empty strings if the input was not a +// module reference. func SrcIsModuleWithTag(s string) (module, tag string) { - if len(s) > 1 && s[0] == ':' { - module = s[1:] - if tagStart := strings.IndexByte(module, '{'); tagStart > 0 { - if module[len(module)-1] == '}' { - tag = module[tagStart+1 : len(module)-1] - module = module[:tagStart] - return module, tag + if len(s) > 1 { + if s[0] == ':' { + module = s[1:] + } else if s[0] == '/' && s[1] == '/' { + module = s + } + + if module != "" { + if tagStart := strings.IndexByte(module, '{'); tagStart > 0 { + if module[len(module)-1] == '}' { + tag = module[tagStart+1 : len(module)-1] + module = module[:tagStart] + } + } + + if s[0] == ':' && !isUnqualifiedModuleName(module) { + // The module name should be unqualified but is not so do not treat it as a module. + module = "" + tag = "" } } - return module, "" } - return "", "" + + return module, tag +} + +// isUnqualifiedModuleName makes sure that the supplied module is an unqualified module name, i.e. +// does not contain any /. +func isUnqualifiedModuleName(module string) bool { + return strings.IndexByte(module, '/') == -1 } +// sourceOrOutputDependencyTag is the dependency tag added automatically by pathDepsMutator for any +// module reference in a property annotated with `android:"path"` or passed to ExtractSourceDeps +// or ExtractSourcesDeps. +// +// If uniquely identifies the dependency that was added as it contains both the module name used to +// add the dependency as well as the tag. That makes it very simple to find the matching dependency +// in GetModuleFromPathDep as all it needs to do is find the dependency whose tag matches the tag +// used to add it. It does not need to check that the module name as returned by one of +// Module.Name(), BaseModuleContext.OtherModuleName() or ModuleBase.BaseModuleName() matches the +// name supplied in the tag. That means it does not need to handle differences in module names +// caused by prebuilt_ prefix, or fully qualified module names. type sourceOrOutputDependencyTag struct { blueprint.BaseDependencyTag + + // The name of the module. + moduleName string + + // The tag that will be passed to the module's OutputFileProducer.OutputFiles(tag) method. tag string } -func sourceOrOutputDepTag(tag string) blueprint.DependencyTag { - return sourceOrOutputDependencyTag{tag: tag} +func sourceOrOutputDepTag(moduleName, tag string) blueprint.DependencyTag { + return sourceOrOutputDependencyTag{moduleName: moduleName, tag: tag} } -// Deprecated, use IsSourceDepTagWithOutputTag(tag, "") instead. -var SourceDepTag = sourceOrOutputDepTag("") - // IsSourceDepTag returns true if the supplied blueprint.DependencyTag is one that was used to add // dependencies by either ExtractSourceDeps, ExtractSourcesDeps or automatically for properties // tagged with `android:"path"`. @@ -2880,7 +2945,7 @@ func ExtractSourcesDeps(ctx BottomUpMutatorContext, srcFiles []string) { ctx.ModuleErrorf("found source dependency duplicate: %q!", s) } else { set[s] = true - ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(t), m) + ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m) } } } @@ -2893,7 +2958,7 @@ func ExtractSourcesDeps(ctx BottomUpMutatorContext, srcFiles []string) { func ExtractSourceDeps(ctx BottomUpMutatorContext, s *string) { if s != nil { if m, t := SrcIsModuleWithTag(*s); m != "" { - ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(t), m) + ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m) } } } diff --git a/android/module_test.go b/android/module_test.go index 9ac929179..9e2b0ca29 100644 --- a/android/module_test.go +++ b/android/module_test.go @@ -55,6 +55,27 @@ func TestSrcIsModule(t *testing.T) { }, wantModule: "foo:bar", }, + { + name: "fully qualified", + args: args{ + s: "//foo:bar", + }, + wantModule: "//foo:bar", + }, + { + name: "fully qualified with tag", + args: args{ + s: "//foo:bar{.tag}", + }, + wantModule: "//foo:bar{.tag}", + }, + { + name: "invalid unqualified name", + args: args{ + s: ":foo/bar", + }, + wantModule: "", + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -128,6 +149,35 @@ func TestSrcIsModuleWithTag(t *testing.T) { }, wantModule: "foo.bar}", }, + { + name: "fully qualified", + args: args{ + s: "//foo:bar", + }, + wantModule: "//foo:bar", + }, + { + name: "fully qualified with tag", + args: args{ + s: "//foo:bar{.tag}", + }, + wantModule: "//foo:bar", + wantTag: ".tag", + }, + { + name: "invalid unqualified name", + args: args{ + s: ":foo/bar", + }, + wantModule: "", + }, + { + name: "invalid unqualified name with tag", + args: args{ + s: ":foo/bar{.tag}", + }, + wantModule: "", + }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { diff --git a/android/mutator.go b/android/mutator.go index 819dd0f2e..d8956693a 100644 --- a/android/mutator.go +++ b/android/mutator.go @@ -35,7 +35,7 @@ import ( // 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 @@ func RegisterMutatorsForBazelConversion(ctx *Context, preArchMutators, depsMutat 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 @@ func FinalDepsMutators(f RegisterMutatorFunc) { } var bp2buildPreArchMutators = []RegisterMutatorFunc{} -var bp2buildDepsMutators = []RegisterMutatorFunc{} var bp2buildMutators = map[string]RegisterMutatorFunc{} // See http://b/192523357 @@ -254,12 +243,6 @@ func PreArchBp2BuildMutators(f RegisterMutatorFunc) { 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 @@ type BaseMutatorContext interface { // 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 @@ type BottomUpMutatorContext interface { // 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) mutatorName(name string) string { 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) CreateAliasVariation(fromVariationName, toVaria 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/path_properties.go b/android/path_properties.go index 44467730d..397688064 100644 --- a/android/path_properties.go +++ b/android/path_properties.go @@ -51,7 +51,7 @@ func addPathDepsForProps(ctx BottomUpMutatorContext, props []interface{}) { // Add dependencies to anything that is a module reference. for _, s := range pathProperties { if m, t := SrcIsModuleWithTag(s); m != "" { - ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(t), m) + ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m) } } } diff --git a/android/paths.go b/android/paths.go index c5e4806cf..bec8a51a2 100644 --- a/android/paths.go +++ b/android/paths.go @@ -88,7 +88,8 @@ func GlobFiles(ctx EarlyModulePathContext, globPattern string, excludes []string // the Path methods that rely on module dependencies having been resolved. type ModuleWithDepsPathContext interface { EarlyModulePathContext - GetDirectDepWithTag(name string, tag blueprint.DependencyTag) blueprint.Module + VisitDirectDepsBlueprint(visit func(blueprint.Module)) + OtherModuleDependencyTag(m blueprint.Module) blueprint.DependencyTag } // ModuleMissingDepsPathContext is a subset of *ModuleContext methods required by @@ -484,10 +485,27 @@ func getPathsFromModuleDep(ctx ModuleWithDepsPathContext, path, moduleName, tag // // If tag is "" then the returned module will be the dependency that was added for ":moduleName". // Otherwise, it is the dependency that was added for ":moduleName{tag}". -// -// TODO(b/193228441) Make this handle fully qualified names, e.g. //namespace:moduleName. func GetModuleFromPathDep(ctx ModuleWithDepsPathContext, moduleName, tag string) blueprint.Module { - return ctx.GetDirectDepWithTag(moduleName, sourceOrOutputDepTag(tag)) + var found blueprint.Module + // The sourceOrOutputDepTag uniquely identifies the module dependency as it contains both the + // module name and the tag. Dependencies added automatically for properties tagged with + // `android:"path"` are deduped so are guaranteed to be unique. It is possible for duplicate + // dependencies to be added manually using ExtractSourcesDeps or ExtractSourceDeps but even then + // it will always be the case that the dependencies will be identical, i.e. the same tag and same + // moduleName referring to the same dependency module. + // + // It does not matter whether the moduleName is a fully qualified name or if the module + // dependency is a prebuilt module. All that matters is the same information is supplied to + // create the tag here as was supplied to create the tag when the dependency was added so that + // this finds the matching dependency module. + expectedTag := sourceOrOutputDepTag(moduleName, tag) + ctx.VisitDirectDepsBlueprint(func(module blueprint.Module) { + depTag := ctx.OtherModuleDependencyTag(module) + if depTag == expectedTag { + found = module + } + }) + return found } // PathsAndMissingDepsForModuleSrcExcludes returns a Paths{} containing the resolved references in @@ -1268,10 +1286,11 @@ var _ resPathProvider = SourcePath{} // PathForModuleSrc returns a Path representing the paths... under the // module's local source directory. func PathForModuleSrc(ctx ModuleMissingDepsPathContext, pathComponents ...string) Path { - p, err := validatePath(pathComponents...) - if err != nil { - reportPathError(ctx, err) - } + // Just join the components textually just to make sure that it does not corrupt a fully qualified + // module reference, e.g. if the pathComponents is "://other:foo" then using filepath.Join() or + // validatePath() will corrupt it, e.g. replace "//" with "/". If the path is not a module + // reference then it will be validated by expandOneSrcPath anyway when it calls expandOneSrcPath. + p := strings.Join(pathComponents, string(filepath.Separator)) paths, err := expandOneSrcPath(ctx, p, nil) if err != nil { if depErr, ok := err.(missingDependencyError); ok { diff --git a/android/paths_test.go b/android/paths_test.go index 6f5d79e7e..f4e4ce16e 100644 --- a/android/paths_test.go +++ b/android/paths_test.go @@ -1125,6 +1125,12 @@ type pathForModuleSrcTestCase struct { rels []string src string rel string + + // Make test specific preparations to the test fixture. + preparer FixturePreparer + + // A test specific error handler. + errorHandler FixtureErrorHandler } func testPathForModuleSrc(t *testing.T, tests []pathForModuleSrcTestCase) { @@ -1157,14 +1163,23 @@ func testPathForModuleSrc(t *testing.T, tests []pathForModuleSrcTestCase) { "foo/src_special/$": nil, } + errorHandler := test.errorHandler + if errorHandler == nil { + errorHandler = FixtureExpectsNoErrors + } + result := GroupFixturePreparers( FixtureRegisterWithContext(func(ctx RegistrationContext) { ctx.RegisterModuleType("test", pathForModuleSrcTestModuleFactory) ctx.RegisterModuleType("output_file_provider", pathForModuleSrcOutputFileProviderModuleFactory) - ctx.RegisterModuleType("filegroup", FileGroupFactory) }), + PrepareForTestWithFilegroup, + PrepareForTestWithNamespace, mockFS.AddToFixture(), - ).RunTest(t) + OptionalFixturePreparer(test.preparer), + ). + ExtendWithErrorHandler(errorHandler). + RunTest(t) m := result.ModuleForTests("foo", "").Module().(*pathForModuleSrcTestModule) @@ -1333,6 +1348,73 @@ func TestPathForModuleSrc(t *testing.T) { src: "foo/src_special/$", rel: "src_special/$", }, + { + // This test makes sure that an unqualified module name cannot contain characters that make + // it appear as a qualified module name. + name: "output file provider, invalid fully qualified name", + bp: ` + test { + name: "foo", + src: "://other:b", + srcs: ["://other:c"], + }`, + preparer: FixtureAddTextFile("other/Android.bp", ` + soong_namespace {} + + output_file_provider { + name: "b", + outs: ["gen/b"], + } + + output_file_provider { + name: "c", + outs: ["gen/c"], + } + `), + src: "foo/:/other:b", + rel: ":/other:b", + srcs: []string{"foo/:/other:c"}, + rels: []string{":/other:c"}, + }, + { + name: "output file provider, missing fully qualified name", + bp: ` + test { + name: "foo", + src: "//other:b", + srcs: ["//other:c"], + }`, + errorHandler: FixtureExpectsAllErrorsToMatchAPattern([]string{ + `"foo" depends on undefined module "//other:b"`, + `"foo" depends on undefined module "//other:c"`, + }), + }, + { + name: "output file provider, fully qualified name", + bp: ` + test { + name: "foo", + src: "//other:b", + srcs: ["//other:c"], + }`, + src: "out/soong/.intermediates/other/b/gen/b", + rel: "gen/b", + srcs: []string{"out/soong/.intermediates/other/c/gen/c"}, + rels: []string{"gen/c"}, + preparer: FixtureAddTextFile("other/Android.bp", ` + soong_namespace {} + + output_file_provider { + name: "b", + outs: ["gen/b"], + } + + output_file_provider { + name: "c", + outs: ["gen/c"], + } + `), + }, } testPathForModuleSrc(t, tests) diff --git a/android/prebuilt.go b/android/prebuilt.go index f3493bd5a..e61150243 100644 --- a/android/prebuilt.go +++ b/android/prebuilt.go @@ -61,6 +61,16 @@ type PrebuiltProperties struct { // a matching name. Prefer *bool `android:"arch_variant"` + // When specified this names a Soong config variable that controls the prefer property. + // + // If the value of the named Soong config variable is true then prefer is set to false and vice + // versa. If the Soong config variable is not set then it defaults to false, so prefer defaults + // to true. + // + // If specified then the prefer property is ignored in favor of the value of the Soong config + // variable. + Use_source_config_var *ConfigVarProperties + SourceExists bool `blueprint:"mutated"` UsePrebuilt bool `blueprint:"mutated"` @@ -68,6 +78,22 @@ type PrebuiltProperties struct { PrebuiltRenamedToSource bool `blueprint:"mutated"` } +// Properties that can be used to select a Soong config variable. +type ConfigVarProperties struct { + // Allow instances of this struct to be used as a property value in a BpPropertySet. + BpPrintableBase + + // The name of the configuration namespace. + // + // As passed to add_soong_config_namespace in Make. + Config_namespace *string + + // The name of the configuration variable. + // + // As passed to add_soong_config_var_value in Make. + Var_name *string +} + type Prebuilt struct { properties PrebuiltProperties @@ -364,12 +390,18 @@ func (p *Prebuilt) usePrebuilt(ctx TopDownMutatorContext, source Module, prebuil return false } - // TODO: use p.Properties.Name and ctx.ModuleDir to override preference - if Bool(p.properties.Prefer) { + // If source is not available or is disabled then always use the prebuilt. + if source == nil || !source.Enabled() { return true } - return source == nil || !source.Enabled() + // If the use_source_config_var property is set then it overrides the prefer property setting. + if configVar := p.properties.Use_source_config_var; configVar != nil { + return !ctx.Config().VendorConfig(proptools.String(configVar.Config_namespace)).Bool(proptools.String(configVar.Var_name)) + } + + // TODO: use p.Properties.Name and ctx.ModuleDir to override preference + return Bool(p.properties.Prefer) } func (p *Prebuilt) SourceExists() bool { diff --git a/android/prebuilt_build_tool.go b/android/prebuilt_build_tool.go index 516d0420a..e5edf9129 100644 --- a/android/prebuilt_build_tool.go +++ b/android/prebuilt_build_tool.go @@ -86,7 +86,7 @@ func (t *prebuiltBuildTool) GenerateAndroidBuildActions(ctx ModuleContext) { 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 23524a533..a1f8e6367 100644 --- a/android/prebuilt_test.go +++ b/android/prebuilt_test.go @@ -21,279 +21,362 @@ import ( "github.com/google/blueprint" ) -var prebuiltsTests = []struct { - name string - replaceBp bool // modules is added to default bp boilerplate if false. - modules string - prebuilt []OsType -}{ - { - 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: false, - srcs: ["prebuilt_file"], - }`, - prebuilt: nil, - }, - { - name: "prebuilt 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, - }`, - prebuilt: nil, - }, - { - name: "prebuilt no file 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", - 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, - target: { - host: { - srcs: ["prebuilt_file"], +func TestPrebuilts(t *testing.T) { + buildOS := TestArchConfig(t.TempDir(), nil, "", nil).BuildOS + + 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: false, + srcs: ["prebuilt_file"], + }`, + prebuilt: nil, + }, + { + name: "prebuilt 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, + }`, + prebuilt: nil, + }, + { + name: "prebuilt no file 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", + 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, + target: { + host: { + srcs: ["prebuilt_file"], + }, }, - }, - }`, - prebuilt: []OsType{BuildOs}, - }, - { - name: "prebuilt override not preferred", - modules: ` - source { - name: "baz", - } - - 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, + }`, + prebuilt: []OsType{buildOS}, + }, + { + name: "prebuilt override not preferred", + modules: ` + source { + name: "baz", + } + + 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, + source { + name: "bar", + target: { + windows: { + enabled: true, + }, }, - }, - } - - prebuilt { - name: "bar", - prefer: true, - srcs: ["prebuilt_file"], - 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, + }`, + 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, + 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, + 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}, - }, -} + }`, + 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}, + }, + } -func TestPrebuilts(t *testing.T) { fs := MockFS{ "prebuilt_file": nil, "source_file": nil, @@ -329,6 +412,7 @@ func TestPrebuilts(t *testing.T) { }), fs.AddToFixture(), FixtureRegisterWithContext(registerTestPrebuiltModules), + OptionalFixturePreparer(test.preparer), ).RunTestWithBp(t, bp) for _, variant := range result.ModuleVariantsForTests("foo") { diff --git a/android/register.go b/android/register.go index 4c8088d0c..59848627a 100644 --- a/android/register.go +++ b/android/register.go @@ -180,7 +180,7 @@ func (ctx *Context) RegisterForBazelConversion() { 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 e70003144..da740f3cd 100644 --- a/android/sdk.go +++ b/android/sdk.go @@ -239,6 +239,12 @@ type SnapshotBuilder interface { // 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/soong_config_modules_test.go b/android/soong_config_modules_test.go index 8f252d944..b2f8eaad8 100644 --- a/android/soong_config_modules_test.go +++ b/android/soong_config_modules_test.go @@ -313,6 +313,51 @@ func TestSoongConfigModule(t *testing.T) { }) } +func TestNonExistentPropertyInSoongConfigModule(t *testing.T) { + bp := ` + soong_config_module_type { + name: "acme_test", + module_type: "test", + config_namespace: "acme", + bool_variables: ["feature1"], + properties: ["made_up_property"], + } + + acme_test { + name: "foo", + cflags: ["-DGENERIC"], + soong_config_variables: { + feature1: { + made_up_property: true, + }, + }, + } + ` + + fixtureForVendorVars := func(vars map[string]map[string]string) FixturePreparer { + return FixtureModifyProductVariables(func(variables FixtureProductVariables) { + variables.VendorVars = vars + }) + } + + GroupFixturePreparers( + fixtureForVendorVars(map[string]map[string]string{"acme": {"feature1": "1"}}), + PrepareForTestWithDefaults, + FixtureRegisterWithContext(func(ctx RegistrationContext) { + ctx.RegisterModuleType("soong_config_module_type_import", soongConfigModuleTypeImportFactory) + ctx.RegisterModuleType("soong_config_module_type", soongConfigModuleTypeFactory) + ctx.RegisterModuleType("soong_config_string_variable", soongConfigStringVariableDummyFactory) + ctx.RegisterModuleType("soong_config_bool_variable", soongConfigBoolVariableDummyFactory) + ctx.RegisterModuleType("test_defaults", soongConfigTestDefaultsModuleFactory) + ctx.RegisterModuleType("test", soongConfigTestModuleFactory) + }), + FixtureWithRootAndroidBp(bp), + ).ExtendWithErrorHandler(FixtureExpectsAllErrorsToMatchAPattern([]string{ + // TODO(b/171232169): improve the error message for non-existent properties + `unrecognized property "soong_config_variables`, + })).RunTest(t) +} + func testConfigWithVendorVars(buildDir, bp string, fs map[string][]byte, vendorVars map[string]map[string]string) Config { config := TestConfig(buildDir, nil, bp, fs) diff --git a/android/test_suites.go b/android/test_suites.go index 6b7b909fc..22f6cf229 100644 --- a/android/test_suites.go +++ b/android/test_suites.go @@ -60,7 +60,7 @@ func robolectricTestSuite(ctx SingletonContext, files map[string]InstallPaths) W 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 17a812ea1..6ba8e3cde 100644 --- a/android/testing.go +++ b/android/testing.go @@ -171,9 +171,9 @@ func NewTestArchContext(config Config) *TestContext { 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 @@ func (ctx *TestContext) PreArchBp2BuildMutators(f RegisterMutatorFunc) { 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 @@ func (ctx *TestContext) Register() { // 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 b6e168cbc..d0a23aaa1 100644 --- a/android/variable.go +++ b/android/variable.go @@ -225,6 +225,7 @@ type productVariables struct { Allow_missing_dependencies *bool `json:",omitempty"` Unbundled_build *bool `json:",omitempty"` Unbundled_build_apps *bool `json:",omitempty"` + Unbundled_build_image *bool `json:",omitempty"` Always_use_prebuilt_sdks *bool `json:",omitempty"` Skip_boot_jars_check *bool `json:",omitempty"` Malloc_not_svelte *bool `json:",omitempty"` @@ -298,8 +299,6 @@ type productVariables struct { 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 11df288a3..d385ac1c3 100644 --- a/apex/apex.go +++ b/apex/apex.go @@ -2240,6 +2240,7 @@ func newApexBundle() *apexBundle { 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 b5b1d4401..d6c714200 100644 --- a/apex/apex_test.go +++ b/apex/apex_test.go @@ -4667,6 +4667,13 @@ func TestPrebuiltApexNameWithPlatformBootclasspath(t *testing.T) { 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 { @@ -4687,16 +4694,26 @@ func TestPrebuiltExportDexImplementationJars(t *testing.T) { p := ctx.ModuleForTests(name, "android_common_myapex").Module().(java.UsesLibraryDependency) dexJarBuildPath := p.DexJarBuildPath() stem := android.RemoveOptionalPrebuiltPrefix(name) - if expected, actual := ".intermediates/myapex.deapexer/android_common/deapexer/javalib/"+stem+".jar", android.NormalizePathForTesting(dexJarBuildPath); actual != expected { - t.Errorf("Incorrect DexJarBuildPath value '%s', expected '%s'", actual, expected) - } + android.AssertStringEquals(t, "DexJarBuildPath should be apex-related path.", + ".intermediates/myapex.deapexer/android_common/deapexer/javalib/"+stem+".jar", + android.NormalizePathForTesting(dexJarBuildPath)) + } + + checkDexJarInstallPath := func(t *testing.T, ctx *android.TestContext, name string) { + // Make sure the import has been given the correct path to the dex jar. + p := ctx.ModuleForTests(name, "android_common_myapex").Module().(java.UsesLibraryDependency) + dexJarBuildPath := p.DexJarInstallPath() + stem := android.RemoveOptionalPrebuiltPrefix(name) + android.AssertStringEquals(t, "DexJarInstallPath should be apex-related path.", + "target/product/test_device/apex/myapex/javalib/"+stem+".jar", + android.NormalizePathForTesting(dexJarBuildPath)) } ensureNoSourceVariant := func(t *testing.T, ctx *android.TestContext, name string) { // Make sure that an apex variant is not created for the source module. - if expected, actual := []string{"android_common"}, ctx.ModuleVariantsForTests(name); !reflect.DeepEqual(expected, actual) { - t.Errorf("invalid set of variants for %q: expected %q, found %q", "libfoo", expected, actual) - } + android.AssertArrayString(t, "Check if there is no source variant", + []string{"android_common"}, + ctx.ModuleVariantsForTests(name)) } t.Run("prebuilt only", func(t *testing.T) { @@ -4745,8 +4762,10 @@ func TestPrebuiltExportDexImplementationJars(t *testing.T) { } checkDexJarBuildPath(t, ctx, "libfoo") + checkDexJarInstallPath(t, ctx, "libfoo") checkDexJarBuildPath(t, ctx, "libbar") + checkDexJarInstallPath(t, ctx, "libbar") }) t.Run("prebuilt with source preferred", func(t *testing.T) { @@ -4792,9 +4811,11 @@ func TestPrebuiltExportDexImplementationJars(t *testing.T) { ctx := testDexpreoptWithApexes(t, bp, "", transform) checkDexJarBuildPath(t, ctx, "prebuilt_libfoo") + checkDexJarInstallPath(t, ctx, "prebuilt_libfoo") ensureNoSourceVariant(t, ctx, "libfoo") checkDexJarBuildPath(t, ctx, "prebuilt_libbar") + checkDexJarInstallPath(t, ctx, "prebuilt_libbar") ensureNoSourceVariant(t, ctx, "libbar") }) @@ -4842,9 +4863,11 @@ func TestPrebuiltExportDexImplementationJars(t *testing.T) { ctx := testDexpreoptWithApexes(t, bp, "", transform) checkDexJarBuildPath(t, ctx, "prebuilt_libfoo") + checkDexJarInstallPath(t, ctx, "prebuilt_libfoo") ensureNoSourceVariant(t, ctx, "libfoo") checkDexJarBuildPath(t, ctx, "prebuilt_libbar") + checkDexJarInstallPath(t, ctx, "prebuilt_libbar") ensureNoSourceVariant(t, ctx, "libbar") }) } @@ -4874,7 +4897,7 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { } } - 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 @@ -4883,6 +4906,15 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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"), @@ -4907,6 +4939,13 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 { @@ -4930,9 +4969,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 `) }) @@ -4948,6 +4988,13 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 { @@ -4971,9 +5018,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 `) }) @@ -4996,6 +5044,13 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 { @@ -5054,6 +5109,13 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 { @@ -5092,9 +5154,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 `) }) @@ -5130,6 +5193,13 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 { @@ -5166,9 +5236,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 `) }) @@ -5204,6 +5275,13 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 { @@ -5242,9 +5320,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) { 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 `) }) } @@ -7167,6 +7246,13 @@ func TestDexpreoptAccessDexFilesFromPrebuiltApex(t *testing.T) { 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 4b1600e1c..5cd3eab6a 100644 --- a/apex/bootclasspath_fragment_test.go +++ b/apex/bootclasspath_fragment_test.go @@ -383,6 +383,13 @@ func TestBootclasspathFragmentInArtApex(t *testing.T) { 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 @@ func TestBootclasspathFragmentInPrebuiltArtApex(t *testing.T) { 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 24c049bcd..148f42f09 100644 --- a/apex/builder.go +++ b/apex/builder.go @@ -761,7 +761,7 @@ func (a *apexBundle) buildUnflattenedApex(ctx android.ModuleContext) { 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/apex/platform_bootclasspath_test.go b/apex/platform_bootclasspath_test.go index 279cf54de..7209c0275 100644 --- a/apex/platform_bootclasspath_test.go +++ b/apex/platform_bootclasspath_test.go @@ -398,6 +398,7 @@ func TestPlatformBootclasspath_AlwaysUsePrebuiltSdks(t *testing.T) { name: "foo", prefer: false, shared_library: false, + permitted_packages: ["foo"], public: { jars: ["sdk_library/public/foo-stubs.jar"], stub_srcs: ["sdk_library/public/foo_stub_sources"], diff --git a/bazel/configurability.go b/bazel/configurability.go index 282c6061a..3277bd049 100644 --- a/bazel/configurability.go +++ b/bazel/configurability.go @@ -29,7 +29,6 @@ const ( // OsType names in arch.go osAndroid = "android" osDarwin = "darwin" - osFuchsia = "fuchsia" osLinux = "linux_glibc" osLinuxBionic = "linux_bionic" osWindows = "windows" @@ -40,8 +39,6 @@ const ( 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 @@ var ( 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 @@ const ( arch os osArch + bionic productVariables ) @@ -126,6 +126,7 @@ func (ct configurationType) String() string { arch: "arch", os: "os", osArch: "arch_os", + bionic: "bionic", productVariables: "product_variables", }[ct] } @@ -148,6 +149,10 @@ func (ct configurationType) validateConfig(config string) { 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 @@ func (ct configurationType) SelectKey(config string) string { return platformOsMap[config] case osArch: return platformOsArchMap[config] + case bionic: + return platformBionicMap[config] case productVariables: if config == conditionsDefault { return ConditionsDefaultSelectKey @@ -186,6 +193,8 @@ var ( 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 0dd47da73..2656badb5 100644 --- a/bazel/properties.go +++ b/bazel/properties.go @@ -321,7 +321,7 @@ func (la *LabelAttribute) SetSelectValue(axis ConfigurationAxis, config string, 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 @@ func (la *LabelAttribute) SelectValue(axis ConfigurationAxis, config string) Lab 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 @@ func (ba *BoolAttribute) SetSelectValue(axis ConfigurationAxis, config string, v 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 @@ func (ba BoolAttribute) SelectValue(axis ConfigurationAxis, config string) *bool 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 @@ func (lla *LabelListAttribute) SetSelectValue(axis ConfigurationAxis, config str 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 @@ func (lla *LabelListAttribute) SelectValue(axis ConfigurationAxis, config string 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)) @@ -558,6 +558,19 @@ func (lla LabelListAttribute) HasConfigurableValues() bool { return len(lla.ConfigurableValues) > 0 } +// IsEmpty returns true if the attribute has no values under any configuration. +func (lla LabelListAttribute) IsEmpty() bool { + if len(lla.Value.Includes) > 0 { + return false + } + for axis, _ := range lla.ConfigurableValues { + if lla.ConfigurableValues[axis].HasConfigurableValues() { + return false + } + } + return true +} + // ResolveExcludes handles excludes across the various axes, ensuring that items are removed from // the base value and included in default values as appropriate. func (lla *LabelListAttribute) ResolveExcludes() { @@ -669,7 +682,7 @@ func (sla *StringListAttribute) SetSelectValue(axis ConfigurationAxis, config st 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) } @@ -685,7 +698,7 @@ func (sla *StringListAttribute) SelectValue(axis ConfigurationAxis, config strin 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 fbf6fa289..f4a1016bc 100644 --- a/bp2build/apex_conversion_test.go +++ b/bp2build/apex_conversion_test.go @@ -46,3 +46,23 @@ apex { 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 0e52f2aa9..e5dbda605 100644 --- a/bp2build/build_conversion_test.go +++ b/bp2build/build_conversion_test.go @@ -556,7 +556,6 @@ genrule { 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 @@ genrule { 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 @@ genrule { 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 @@ genrule { moduleTypeUnderTest: "genrule", moduleTypeUnderTestFactory: genrule.GenRuleFactory, moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build, - depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps}, bp: `genrule { name: "foo", out: ["foo.out"], @@ -822,7 +818,6 @@ genrule { moduleTypeUnderTest: "genrule", moduleTypeUnderTestFactory: genrule.GenRuleFactory, moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build, - depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps}, bp: `genrule { name: "foo", out: ["foo.out"], @@ -846,7 +841,6 @@ genrule { moduleTypeUnderTest: "genrule", moduleTypeUnderTestFactory: genrule.GenRuleFactory, moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build, - depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps}, bp: `genrule { name: "foo", out: ["foo.out"], @@ -873,7 +867,6 @@ genrule { moduleTypeUnderTest: "genrule", moduleTypeUnderTestFactory: genrule.GenRuleFactory, moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build, - depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps}, bp: `genrule { name: "foo", out: ["foo.out"], @@ -900,7 +893,6 @@ genrule { moduleTypeUnderTest: "genrule", moduleTypeUnderTestFactory: genrule.GenRuleFactory, moduleTypeUnderTestBp2BuildMutator: genrule.GenruleBp2Build, - depsMutators: []android.RegisterMutatorFunc{genrule.RegisterGenruleBp2BuildDeps}, bp: `genrule { name: "foo", out: ["foo.out"], @@ -933,9 +925,6 @@ genrule { 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 @@ func TestCombineBuildFilesBp2buildTargets(t *testing.T) { 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 @@ func TestCombineBuildFilesBp2buildTargets(t *testing.T) { 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 285677a1c..8dcba5500 100644 --- a/bp2build/cc_library_conversion_test.go +++ b/bp2build/cc_library_conversion_test.go @@ -73,9 +73,6 @@ func runBp2BuildTestCase(t *testing.T, registerModuleTypes func(ctx android.Regi 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 @@ func TestCcLibrarySimple(t *testing.T) { 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 @@ cc_library { darwin: { srcs: ["darwin.cpp"], }, + bionic: { + srcs: ["bionic.cpp"] + }, }, } `, @@ -190,6 +191,9 @@ cc_library { "//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 @@ func TestCcLibrarySharedStaticProps(t *testing.T) { 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 @@ func TestCcLibraryWholeStaticLibsAlwaysLink(t *testing.T) { 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 @@ func TestCcLibrarySharedStaticPropsInArch(t *testing.T) { 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 @@ func TestCcLibrarySharedStaticPropsWithMixedSources(t *testing.T) { 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": "", @@ -674,6 +674,10 @@ filegroup { blueprint: soongCcLibraryPreamble, expectedBazelTargets: []string{`cc_library( name = "a", + asflags = [ + "-Ifoo/bar", + "-I$(BINDIR)/foo/bar", + ], copts = [ "-Ifoo/bar", "-I$(BINDIR)/foo/bar", @@ -734,7 +738,6 @@ func TestCcLibraryNonConfiguredVersionScript(t *testing.T) { 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": ` @@ -765,7 +768,6 @@ func TestCcLibraryConfiguredVersionScript(t *testing.T) { 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": ` @@ -808,7 +810,6 @@ func TestCcLibrarySharedLibs(t *testing.T) { 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": ` @@ -848,7 +849,6 @@ func TestCcLibraryPackRelocations(t *testing.T) { 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": ` @@ -922,7 +922,6 @@ func TestCcLibrarySpacesInCopts(t *testing.T) { 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": ` @@ -952,7 +951,6 @@ func TestCcLibraryCppFlagsGoesIntoCopts(t *testing.T) { 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 { @@ -1008,7 +1006,6 @@ func TestCcLibraryLabelAttributeGetTargetProperties(t *testing.T) { 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": ` @@ -1050,7 +1047,6 @@ func TestCcLibraryExcludeLibs(t *testing.T) { moduleTypeUnderTest: "cc_library", moduleTypeUnderTestFactory: cc.LibraryFactory, moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryBp2Build, - depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build}, filesystem: map[string]string{}, blueprint: soongCcLibraryStaticPreamble + ` cc_library { @@ -1297,7 +1293,6 @@ func TestCcLibraryStrip(t *testing.T) { 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": ` @@ -1404,7 +1399,6 @@ func TestCcLibraryStripWithArch(t *testing.T) { 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 db344decc..712d0bd5a 100644 --- a/bp2build/cc_library_headers_conversion_test.go +++ b/bp2build/cc_library_headers_conversion_test.go @@ -45,7 +45,6 @@ type bp2buildTestCase struct { moduleTypeUnderTest string moduleTypeUnderTestFactory android.ModuleFactory moduleTypeUnderTestBp2BuildMutator func(android.TopDownMutatorContext) - depsMutators []android.RegisterMutatorFunc blueprint string expectedBazelTargets []string filesystem map[string]string @@ -181,13 +180,11 @@ func TestCcLibraryHeadersOSSpecificHeader(t *testing.T) { 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 @@ cc_library_headers { 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 @@ cc_library_headers { 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 @@ func TestCcLibraryHeadersOsSpecficHeaderLibsExportHeaderLibHeaders(t *testing.T) 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 @@ func TestCcLibraryHeadersArchAndTargetExportSystemIncludes(t *testing.T) { 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 40edec80b..1dc6713de 100644 --- a/bp2build/cc_library_static_conversion_test.go +++ b/bp2build/cc_library_static_conversion_test.go @@ -469,7 +469,6 @@ func TestCcLibraryStaticArchSpecificStaticLib(t *testing.T) { 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 @@ func TestCcLibraryStaticOsSpecificStaticLib(t *testing.T) { 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 @@ func TestCcLibraryStaticBaseArchOsSpecificStaticLib(t *testing.T) { 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 @@ func TestCcLibraryStaticSimpleExcludeSrcs(t *testing.T) { 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 @@ func TestCcLibraryStaticOneArchSrcs(t *testing.T) { 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 @@ func TestCcLibraryStaticOneArchSrcsExcludeSrcs(t *testing.T) { 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 @@ func TestCcLibraryStaticTwoArchExcludeSrcs(t *testing.T) { 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 @@ func TestCcLibraryStaticFourArchExcludeSrcs(t *testing.T) { 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 @@ func TestCcLibraryStaticOneArchEmpty(t *testing.T) { 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 @@ func TestCcLibraryStaticOneArchEmptyOtherSet(t *testing.T) { 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 @@ func TestCcLibraryStaticMultipleDepSameName(t *testing.T) { 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 @@ func TestCcLibraryStaticOneMultilibSrcsExcludeSrcs(t *testing.T) { 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 @@ func TestCcLibraryStaticTwoMultilibSrcsExcludeSrcs(t *testing.T) { 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 @@ func TestCcLibrarySTaticArchMultilibSrcsExcludeSrcs(t *testing.T) { 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 @@ func TestCcLibraryStaticArchSrcsExcludeSrcsGeneratedFiles(t *testing.T) { 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 @@ func TestCcLibraryStaticGetTargetProperties(t *testing.T) { 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 @@ func TestCcLibraryStaticProductVariableSelects(t *testing.T) { 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 @@ func TestCcLibraryStaticProductVariableArchSpecificSelects(t *testing.T) { moduleTypeUnderTest: "cc_library_static", moduleTypeUnderTestFactory: cc.LibraryStaticFactory, moduleTypeUnderTestBp2BuildMutator: cc.CcLibraryStaticBp2Build, - depsMutators: []android.RegisterMutatorFunc{cc.RegisterDepsBp2Build}, filesystem: map[string]string{}, blueprint: soongCcLibraryStaticPreamble + ` cc_library_static { @@ -1413,16 +1394,15 @@ cc_library_static { func TestCcLibraryStaticProductVariableStringReplacement(t *testing.T) { runCcLibraryStaticTestCase(t, bp2buildTestCase{ - description: "cc_library_static product variable selects", + description: "cc_library_static product variable string replacement", 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", - srcs: ["common.c"], + srcs: ["common.S"], product_variables: { platform_sdk_version: { asflags: ["-DPLATFORM_SDK_VERSION=%d"], @@ -1431,7 +1411,10 @@ cc_library_static { } `, expectedBazelTargets: []string{`cc_library_static( name = "foo_static", - asflags = select({ + asflags = [ + "-I.", + "-I$(BINDIR)/.", + ] + select({ "//build/bazel/product_variables:platform_sdk_version": ["-DPLATFORM_SDK_VERSION=$(Platform_sdk_version)"], "//conditions:default": [], }), @@ -1440,7 +1423,7 @@ cc_library_static { "-I$(BINDIR)/.", ], linkstatic = True, - srcs_c = ["common.c"], + srcs_as = ["common.S"], )`}, }) } diff --git a/bp2build/cc_object_conversion_test.go b/bp2build/cc_object_conversion_test.go index 8ede2267d..df4924bfe 100644 --- a/bp2build/cc_object_conversion_test.go +++ b/bp2build/cc_object_conversion_test.go @@ -211,6 +211,7 @@ func TestCcObjectProductVariable(t *testing.T) { asflags: ["-DPLATFORM_SDK_VERSION=%d"], }, }, + srcs: ["src.S"], } `, expectedBazelTargets: []string{`cc_object( @@ -220,6 +221,7 @@ func TestCcObjectProductVariable(t *testing.T) { "//conditions:default": [], }), copts = ["-fno-addrsig"], + srcs_as = ["src.S"], )`, }, }) @@ -240,7 +242,7 @@ func TestCcObjectCflagsOneArch(t *testing.T) { cflags: ["-fPIC"], // string list }, arm: { - srcs: ["arch/arm/file.S"], // label list + srcs: ["arch/arm/file.cpp"], // label list }, }, } @@ -257,7 +259,7 @@ func TestCcObjectCflagsOneArch(t *testing.T) { "//conditions:default": [], }), srcs = ["a.cpp"] + select({ - "//build/bazel/platforms/arch:arm": ["arch/arm/file.S"], + "//build/bazel/platforms/arch:arm": ["arch/arm/file.cpp"], "//conditions:default": [], }), )`, diff --git a/bpfix/bpfix/bpfix.go b/bpfix/bpfix/bpfix.go index adb0a7bb9..a60863036 100644 --- a/bpfix/bpfix/bpfix.go +++ b/bpfix/bpfix/bpfix.go @@ -136,6 +136,10 @@ var fixSteps = []FixStep{ Name: "removeScudoProperty", Fix: runPatchListMod(removeObsoleteProperty("sanitize.scudo")), }, + { + Name: "formatFlagProperties", + Fix: runPatchListMod(formatFlagProperties), + }, } func NewFixRequest() FixRequest { @@ -1343,3 +1347,69 @@ func inList(s string, list []string) bool { } return false } + +func formatFlagProperty(mod *parser.Module, field string, buf []byte, patchlist *parser.PatchList) error { + // the comment or empty lines in the value of the field are skipped + listValue, ok := getLiteralListProperty(mod, field) + if !ok { + // if do not find + return nil + } + for i := 0; i < len(listValue.Values); i++ { + curValue, ok := listValue.Values[i].(*parser.String) + if !ok { + return fmt.Errorf("Expecting string for %s.%s fields", mod.Type, field) + } + if !strings.HasPrefix(curValue.Value, "-") { + return fmt.Errorf("Expecting the string `%s` starting with '-'", curValue.Value) + } + if i+1 < len(listValue.Values) { + nextValue, ok := listValue.Values[i+1].(*parser.String) + if !ok { + return fmt.Errorf("Expecting string for %s.%s fields", mod.Type, field) + } + if !strings.HasPrefix(nextValue.Value, "-") { + // delete the line + err := patchlist.Add(curValue.Pos().Offset, curValue.End().Offset+2, "") + if err != nil { + return err + } + // replace the line + value := "\"" + curValue.Value + " " + nextValue.Value + "\"," + err = patchlist.Add(nextValue.Pos().Offset, nextValue.End().Offset+1, value) + if err != nil { + return err + } + // combined two lines to one + i++ + } + } + } + return nil +} + +func formatFlagProperties(mod *parser.Module, buf []byte, patchlist *parser.PatchList) error { + relevantFields := []string{ + // cc flags + "asflags", + "cflags", + "clang_asflags", + "clang_cflags", + "conlyflags", + "cppflags", + "ldflags", + "tidy_flags", + // java flags + "aaptflags", + "dxflags", + "javacflags", + "kotlincflags", + } + for _, field := range relevantFields { + err := formatFlagProperty(mod, field, buf, patchlist) + if err != nil { + return err + } + } + return nil +} diff --git a/bpfix/bpfix/bpfix_test.go b/bpfix/bpfix/bpfix_test.go index b994e2547..d8772c10d 100644 --- a/bpfix/bpfix/bpfix_test.go +++ b/bpfix/bpfix/bpfix_test.go @@ -1336,3 +1336,275 @@ func TestRewriteTestModuleTypes(t *testing.T) { }) } } + +func TestFormatFlagProperty(t *testing.T) { + tests := []struct { + name string + in string + out string + }{ + { + name: "group options and values for apptflags, dxflags, javacflags, and kotlincflags", + in: ` + android_test { + name: "foo", + aaptflags: [ + // comment1_1 + "--flag1", + // comment1_2 + "1", + // comment2_1 + // comment2_2 + "--flag2", + // comment3_1 + // comment3_2 + // comment3_3 + "--flag3", + // comment3_4 + // comment3_5 + // comment3_6 + "3", + // other comment1_1 + // other comment1_2 + ], + dxflags: [ + "--flag1", + // comment1_1 + "1", + // comment2_1 + "--flag2", + // comment3_1 + "--flag3", + // comment3_2 + "3", + ], + javacflags: [ + "--flag1", + + "1", + "--flag2", + "--flag3", + "3", + ], + kotlincflags: [ + + "--flag1", + "1", + + "--flag2", + "--flag3", + "3", + + ], + } + `, + out: ` + android_test { + name: "foo", + aaptflags: [ + // comment1_1 + // comment1_2 + "--flag1 1", + // comment2_1 + // comment2_2 + "--flag2", + // comment3_1 + // comment3_2 + // comment3_3 + // comment3_4 + // comment3_5 + // comment3_6 + "--flag3 3", + // other comment1_1 + // other comment1_2 + ], + dxflags: [ + // comment1_1 + "--flag1 1", + // comment2_1 + "--flag2", + // comment3_1 + // comment3_2 + "--flag3 3", + ], + javacflags: [ + + "--flag1 1", + "--flag2", + "--flag3 3", + ], + kotlincflags: [ + + "--flag1 1", + + "--flag2", + "--flag3 3", + + ], + } + `, + }, + { + name: "group options and values for asflags, cflags, clang_asflags, clang_cflags, conlyflags, cppflags, ldflags, and tidy_flags", + in: ` + cc_test { + name: "foo", + asflags: [ + // comment1_1 + "--flag1", + "1", + // comment2_1 + // comment2_2 + "--flag2", + // comment2_3 + "2", + // comment3_1 + // comment3_2 + "--flag3", + // comment3_3 + // comment3_4 + // comment3_4 + "3", + // comment4_1 + // comment4_2 + // comment4_3 + "--flag4", + ], + cflags: [ + "--flag1", + "1", + "--flag2", + "2", + "--flag3", + "3", + "--flag4", + ], + clang_asflags: [ + "--flag1", + "1", + "--flag2", + "2", + "--flag3", + "3", + "--flag4", + ], + clang_cflags: [ + "--flag1", + "1", + "--flag2", + "2", + "--flag3", + "3", + "--flag4", + ], + conlyflags: [ + "--flag1", + "1", + "--flag2", + "2", + "--flag3", + "3", + "--flag4", + ], + cppflags: [ + "--flag1", + "1", + "--flag2", + "2", + "--flag3", + "3", + "--flag4", + ], + ldflags: [ + "--flag1", + "1", + "--flag2", + "2", + "--flag3", + "3", + "--flag4", + ], + tidy_flags: [ + "--flag1", + "1", + "--flag2", + "2", + "--flag3", + "3", + "--flag4", + ], + } + `, + out: ` + cc_test { + name: "foo", + asflags: [ + // comment1_1 + "--flag1 1", + // comment2_1 + // comment2_2 + // comment2_3 + "--flag2 2", + // comment3_1 + // comment3_2 + // comment3_3 + // comment3_4 + // comment3_4 + "--flag3 3", + // comment4_1 + // comment4_2 + // comment4_3 + "--flag4", + ], + cflags: [ + "--flag1 1", + "--flag2 2", + "--flag3 3", + "--flag4", + ], + clang_asflags: [ + "--flag1 1", + "--flag2 2", + "--flag3 3", + "--flag4", + ], + clang_cflags: [ + "--flag1 1", + "--flag2 2", + "--flag3 3", + "--flag4", + ], + conlyflags: [ + "--flag1 1", + "--flag2 2", + "--flag3 3", + "--flag4", + ], + cppflags: [ + "--flag1 1", + "--flag2 2", + "--flag3 3", + "--flag4", + ], + ldflags: [ + "--flag1 1", + "--flag2 2", + "--flag3 3", + "--flag4", + ], + tidy_flags: [ + "--flag1 1", + "--flag2 2", + "--flag3 3", + "--flag4", + ], + } + `, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + runPass(t, test.in, test.out, runPatchListMod(formatFlagProperties)) + }) + } +} diff --git a/cc/Android.bp b/cc/Android.bp index 46740dcf2..164d32b12 100644 --- a/cc/Android.bp +++ b/cc/Android.bp @@ -14,6 +14,7 @@ bootstrap_go_package { "soong-cc-config", "soong-etc", "soong-genrule", + "soong-snapshot", "soong-tradefed", ], srcs: [ @@ -58,6 +59,7 @@ bootstrap_go_package { "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 e58d166a3..bda10067b 100644 --- a/cc/androidmk.go +++ b/cc/androidmk.go @@ -401,24 +401,24 @@ func (fuzz *fuzzBinary) AndroidMkEntries(ctx AndroidMkContext, entries *android. 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 c177a0899..c6d61abbb 100644 --- a/cc/binary.go +++ b/cc/binary.go @@ -215,7 +215,7 @@ func (binary *binaryDecorator) linkerInit(ctx BaseModuleContext) { 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 76c5f3be9..68afd0db5 100644 --- a/cc/bp2build.go +++ b/cc/bp2build.go @@ -24,121 +24,6 @@ import ( "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. - // allDeps = append(allDeps, lib.SharedProperties.Shared.System_shared_libs...) - // allDeps = append(allDeps, lib.StaticProperties.Static.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 { @@ -182,30 +67,33 @@ func groupSrcsByExtension(ctx android.TopDownMutatorContext, srcs bazel.LabelLis // 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 } @@ -253,7 +141,7 @@ func bp2buildParseStaticOrSharedProps(ctx android.TopDownMutatorContext, module Copts: bazel.StringListAttribute{Value: props.Cflags}, Srcs: bazel.MakeLabelListAttribute(android.BazelLabelForModuleSrc(ctx, props.Srcs)), Static_deps: bazel.MakeLabelListAttribute(android.BazelLabelForModuleDeps(ctx, props.Static_libs)), - Dynamic_deps: bazel.MakeLabelListAttribute(android.BazelLabelForModuleDeps(ctx, props.Shared_libs)), + Dynamic_deps: bazel.MakeLabelListAttribute(android.BazelLabelForModuleDeps(ctx, append(props.Shared_libs, props.System_shared_libs...))), Whole_archive_deps: bazel.MakeLabelListAttribute(android.BazelLabelForModuleWholeDeps(ctx, props.Whole_static_libs)), } @@ -385,16 +273,6 @@ func bp2BuildParseCompilerProps(ctx android.TopDownMutatorContext, module *Modul return result } - // Parse the list of copts. - parseCopts := func(baseCompilerProps *BaseCompilerProperties) []string { - var copts []string - copts = append(copts, parseCommandLineFlags(baseCompilerProps.Cflags)...) - for _, dir := range parseLocalIncludeDirs(baseCompilerProps) { - copts = append(copts, includeFlags(dir)...) - } - return copts - } - // Parse srcs from an arch or OS's props value. parseSrcs := func(baseCompilerProps *BaseCompilerProperties) bazel.LabelList { // Add srcs-like dependencies such as generated files. @@ -410,11 +288,15 @@ func bp2BuildParseCompilerProps(ctx android.TopDownMutatorContext, module *Modul for _, props := range module.compiler.compilerProps() { if baseCompilerProps, ok := props.(*BaseCompilerProperties); ok { srcs.SetValue(parseSrcs(baseCompilerProps)) - copts.Value = parseCopts(baseCompilerProps) + copts.Value = parseCommandLineFlags(baseCompilerProps.Cflags) asFlags.Value = parseCommandLineFlags(baseCompilerProps.Asflags) conlyFlags.Value = parseCommandLineFlags(baseCompilerProps.Conlyflags) cppFlags.Value = parseCommandLineFlags(baseCompilerProps.Cppflags) + for _, dir := range parseLocalIncludeDirs(baseCompilerProps) { + copts.Value = append(copts.Value, includeFlags(dir)...) + asFlags.Value = append(asFlags.Value, includeFlags(dir)...) + } break } } @@ -424,8 +306,10 @@ func bp2BuildParseCompilerProps(ctx android.TopDownMutatorContext, module *Modul // "-I<module-dir>" in its copts. if c, ok := module.compiler.(*baseCompiler); ok && c.includeBuildDirectory() { copts.Value = append(copts.Value, includeFlags(".")...) + asFlags.Value = append(asFlags.Value, includeFlags(".")...) } else if c, ok := module.compiler.(*libraryDecorator); ok && c.includeBuildDirectory() { copts.Value = append(copts.Value, includeFlags(".")...) + asFlags.Value = append(asFlags.Value, includeFlags(".")...) } archVariantCompilerProps := module.GetArchVariantProperties(ctx, &BaseCompilerProperties{}) @@ -440,8 +324,15 @@ func bp2BuildParseCompilerProps(ctx android.TopDownMutatorContext, module *Modul srcs.SetSelectValue(axis, config, srcsList) } - copts.SetSelectValue(axis, config, parseCopts(baseCompilerProps)) - asFlags.SetSelectValue(axis, config, parseCommandLineFlags(baseCompilerProps.Asflags)) + archVariantCopts := parseCommandLineFlags(baseCompilerProps.Cflags) + archVariantAsflags := parseCommandLineFlags(baseCompilerProps.Asflags) + for _, dir := range parseLocalIncludeDirs(baseCompilerProps) { + archVariantCopts = append(archVariantCopts, includeFlags(dir)...) + archVariantAsflags = append(archVariantAsflags, includeFlags(dir)...) + } + + copts.SetSelectValue(axis, config, archVariantCopts) + asFlags.SetSelectValue(axis, config, archVariantAsflags) conlyFlags.SetSelectValue(axis, config, parseCommandLineFlags(baseCompilerProps.Conlyflags)) cppFlags.SetSelectValue(axis, config, parseCommandLineFlags(baseCompilerProps.Cppflags)) } @@ -554,7 +445,9 @@ func bp2BuildParseLinkerProps(ctx android.TopDownMutatorContext, module *Module) staticDeps.Value = android.BazelLabelForModuleDepsExcludes(ctx, staticLibs, baseLinkerProps.Exclude_static_libs) wholeArchiveLibs := android.FirstUniqueStrings(baseLinkerProps.Whole_static_libs) wholeArchiveDeps = bazel.MakeLabelListAttribute(android.BazelLabelForModuleWholeDepsExcludes(ctx, wholeArchiveLibs, baseLinkerProps.Exclude_static_libs)) - sharedLibs := android.FirstUniqueStrings(baseLinkerProps.Shared_libs) + // TODO(b/186024507): Handle system_shared_libs as its own attribute, so that the appropriate default + // may be supported. + sharedLibs := android.FirstUniqueStrings(append(baseLinkerProps.Shared_libs, baseLinkerProps.System_shared_libs...)) dynamicDeps = bazel.MakeLabelListAttribute(android.BazelLabelForModuleDepsExcludes(ctx, sharedLibs, baseLinkerProps.Exclude_shared_libs)) headerLibs := android.FirstUniqueStrings(baseLinkerProps.Header_libs) @@ -581,7 +474,7 @@ func bp2BuildParseLinkerProps(ctx android.TopDownMutatorContext, module *Module) staticDeps.SetSelectValue(axis, config, android.BazelLabelForModuleDepsExcludes(ctx, staticLibs, baseLinkerProps.Exclude_static_libs)) wholeArchiveLibs := android.FirstUniqueStrings(baseLinkerProps.Whole_static_libs) wholeArchiveDeps.SetSelectValue(axis, config, android.BazelLabelForModuleWholeDepsExcludes(ctx, wholeArchiveLibs, baseLinkerProps.Exclude_static_libs)) - sharedLibs := android.FirstUniqueStrings(baseLinkerProps.Shared_libs) + sharedLibs := android.FirstUniqueStrings(append(baseLinkerProps.Shared_libs, baseLinkerProps.System_shared_libs...)) dynamicDeps.SetSelectValue(axis, config, android.BazelLabelForModuleDepsExcludes(ctx, sharedLibs, baseLinkerProps.Exclude_shared_libs)) headerLibs := android.FirstUniqueStrings(baseLinkerProps.Header_libs) diff --git a/cc/builder.go b/cc/builder.go index bde8c9647..842ce8515 100644 --- a/cc/builder.go +++ b/cc/builder.go @@ -237,7 +237,7 @@ var ( // -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 @@ var ( // 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}", @@ -500,10 +500,10 @@ func transformSourceToObj(ctx android.ModuleContext, subdir string, srcFiles and sAbiDumpFiles = make(android.Paths, 0, len(srcFiles)) } - cflags += " ${config.NoOverrideClangGlobalCflags}" - toolingCflags += " ${config.NoOverrideClangGlobalCflags}" - cppflags += " ${config.NoOverrideClangGlobalCflags}" - toolingCppflags += " ${config.NoOverrideClangGlobalCflags}" + cflags += " ${config.NoOverrideGlobalCflags}" + toolingCflags += " ${config.NoOverrideGlobalCflags}" + cppflags += " ${config.NoOverrideGlobalCflags}" + toolingCppflags += " ${config.NoOverrideGlobalCflags}" for i, srcFile := range srcFiles { objFile := android.ObjPathWithExt(ctx, subdir, srcFile, "o") @@ -756,14 +756,13 @@ func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool { // 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 @@ -2014,9 +2013,9 @@ func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mo } func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo { - // Only modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of + // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of // SnapshotInfo, which provides no mappings. - if *snapshotInfo == nil { + if *snapshotInfo == nil && c.Device() { // Only retrieve the snapshot on demand in order to avoid circular dependencies // between the modules in the snapshot and the snapshot itself. var snapshotModule []blueprint.Module @@ -2025,16 +2024,16 @@ func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android. } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() { snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot") } - if len(snapshotModule) > 0 { + if len(snapshotModule) > 0 && snapshotModule[0] != nil { snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo) *snapshotInfo = &snapshot // republish the snapshot for use in later mutators on this module actx.SetProvider(SnapshotInfoProvider, snapshot) - } else { - *snapshotInfo = &SnapshotInfo{} } } - + if *snapshotInfo == nil { + *snapshotInfo = &SnapshotInfo{} + } return **snapshotInfo } diff --git a/cc/cc_test.go b/cc/cc_test.go index 0a74e5824..dd51fe853 100644 --- a/cc/cc_test.go +++ b/cc/cc_test.go @@ -152,71 +152,6 @@ func TestPrepareForTestWithCcDefaultModules(t *testing.T) { ).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 { @@ -4038,14 +3973,14 @@ func TestIncludeDirectoryOrdering(t *testing.T) { } want := []string{ - "${config.ArmClangThumbCflags}", - "${config.ArmClangCflags}", - "${config.CommonClangGlobalCflags}", - "${config.DeviceClangGlobalCflags}", - "${config.ClangExternalCflags}", - "${config.ArmToolchainClangCflags}", - "${config.ArmClangArmv7ANeonCflags}", - "${config.ArmClangGenericCflags}", + "${config.ArmThumbCflags}", + "${config.ArmCflags}", + "${config.CommonGlobalCflags}", + "${config.DeviceGlobalCflags}", + "${config.ExternalCflags}", + "${config.ArmToolchainCflags}", + "${config.ArmArmv7ANeonCflags}", + "${config.ArmGenericCflags}", "android_arm_export_include_dirs", "lib32_export_include_dirs", "arm_export_include_dirs", @@ -4076,7 +4011,7 @@ func TestIncludeDirectoryOrdering(t *testing.T) { "defaults/cc/common/ndk_libandroid_support", "out/soong/ndk/sysroot/usr/include", "out/soong/ndk/sysroot/usr/include/arm-linux-androideabi", - "${config.NoOverrideClangGlobalCflags}", + "${config.NoOverrideGlobalCflags}", } android.AssertArrayString(t, "includes", want, includes) diff --git a/cc/compiler.go b/cc/compiler.go index 69ead3089..b01ba4326 100644 --- a/cc/compiler.go +++ b/cc/compiler.go @@ -392,7 +392,7 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps if flags.RequiredInstructionSet != "" { instructionSet = flags.RequiredInstructionSet } - instructionSetFlags, err := tc.ClangInstructionSetFlags(instructionSet) + instructionSetFlags, err := tc.InstructionSetFlags(instructionSet) if err != nil { ctx.ModuleErrorf("%s", err) } @@ -437,15 +437,15 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps flags.Global.ConlyFlags = append([]string{"${config.CommonGlobalConlyflags}"}, flags.Global.ConlyFlags...) flags.Global.CppFlags = append([]string{fmt.Sprintf("${config.%sGlobalCppflags}", hod)}, flags.Global.CppFlags...) - flags.Global.AsFlags = append(flags.Global.AsFlags, tc.ClangAsflags()) - flags.Global.CppFlags = append([]string{"${config.CommonClangGlobalCppflags}"}, flags.Global.CppFlags...) + flags.Global.AsFlags = append(flags.Global.AsFlags, tc.Asflags()) + flags.Global.CppFlags = append([]string{"${config.CommonGlobalCppflags}"}, flags.Global.CppFlags...) flags.Global.CommonFlags = append(flags.Global.CommonFlags, - tc.ClangCflags(), - "${config.CommonClangGlobalCflags}", - fmt.Sprintf("${config.%sClangGlobalCflags}", hod)) + tc.Cflags(), + "${config.CommonGlobalCflags}", + fmt.Sprintf("${config.%sGlobalCflags}", hod)) if isThirdParty(modulePath) { - flags.Global.CommonFlags = append(flags.Global.CommonFlags, "${config.ClangExternalCflags}") + flags.Global.CommonFlags = append(flags.Global.CommonFlags, "${config.ExternalCflags}") } if tc.Bionic() { @@ -458,11 +458,11 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps flags.Global.AsFlags = append(flags.Global.AsFlags, "-D__ASSEMBLY__") - flags.Global.CppFlags = append(flags.Global.CppFlags, tc.ClangCppflags()) + flags.Global.CppFlags = append(flags.Global.CppFlags, tc.Cppflags()) flags.Global.YasmFlags = append(flags.Global.YasmFlags, tc.YasmFlags()) - flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainClangCflags()) + flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainCflags()) cStd := config.CStdVersion if String(compiler.Properties.C_std) == "experimental" { diff --git a/cc/config/Android.bp b/cc/config/Android.bp index c1d4f1755..3e8ee48ca 100644 --- a/cc/config/Android.bp +++ b/cc/config/Android.bp @@ -21,10 +21,8 @@ bootstrap_go_package { "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_device.go b/cc/config/arm64_device.go index af6361bff..812a245d2 100644 --- a/cc/config/arm64_device.go +++ b/cc/config/arm64_device.go @@ -48,12 +48,12 @@ var ( "-Wl,-z,separate-code", } - arm64Lldflags = append(ClangFilterUnknownLldflags(arm64Ldflags), + arm64Lldflags = append(arm64Ldflags, "-Wl,-z,max-page-size=4096") arm64Cppflags = []string{} - arm64ClangCpuVariantCflags = map[string][]string{ + arm64CpuVariantCflags = map[string][]string{ "cortex-a53": []string{ "-mcpu=cortex-a53", }, @@ -99,52 +99,50 @@ func init() { pctx.StaticVariable("Arm64Ldflags", strings.Join(arm64Ldflags, " ")) pctx.StaticVariable("Arm64Lldflags", strings.Join(arm64Lldflags, " ")) - pctx.StaticVariable("Arm64ClangCflags", strings.Join(ClangFilterUnknownCflags(arm64Cflags), " ")) - pctx.StaticVariable("Arm64ClangLdflags", strings.Join(ClangFilterUnknownCflags(arm64Ldflags), " ")) - pctx.StaticVariable("Arm64ClangLldflags", strings.Join(ClangFilterUnknownCflags(arm64Lldflags), " ")) - pctx.StaticVariable("Arm64ClangCppflags", strings.Join(ClangFilterUnknownCflags(arm64Cppflags), " ")) + pctx.StaticVariable("Arm64Cflags", strings.Join(arm64Cflags, " ")) + pctx.StaticVariable("Arm64Cppflags", strings.Join(arm64Cppflags, " ")) - pctx.StaticVariable("Arm64ClangArmv8ACflags", strings.Join(arm64ArchVariantCflags["armv8-a"], " ")) - pctx.StaticVariable("Arm64ClangArmv8ABranchProtCflags", strings.Join(arm64ArchVariantCflags["armv8-a-branchprot"], " ")) - pctx.StaticVariable("Arm64ClangArmv82ACflags", strings.Join(arm64ArchVariantCflags["armv8-2a"], " ")) - pctx.StaticVariable("Arm64ClangArmv82ADotprodCflags", strings.Join(arm64ArchVariantCflags["armv8-2a-dotprod"], " ")) + pctx.StaticVariable("Arm64Armv8ACflags", strings.Join(arm64ArchVariantCflags["armv8-a"], " ")) + pctx.StaticVariable("Arm64Armv8ABranchProtCflags", strings.Join(arm64ArchVariantCflags["armv8-a-branchprot"], " ")) + pctx.StaticVariable("Arm64Armv82ACflags", strings.Join(arm64ArchVariantCflags["armv8-2a"], " ")) + pctx.StaticVariable("Arm64Armv82ADotprodCflags", strings.Join(arm64ArchVariantCflags["armv8-2a-dotprod"], " ")) - pctx.StaticVariable("Arm64ClangCortexA53Cflags", - strings.Join(arm64ClangCpuVariantCflags["cortex-a53"], " ")) + pctx.StaticVariable("Arm64CortexA53Cflags", + strings.Join(arm64CpuVariantCflags["cortex-a53"], " ")) - pctx.StaticVariable("Arm64ClangCortexA55Cflags", - strings.Join(arm64ClangCpuVariantCflags["cortex-a55"], " ")) + pctx.StaticVariable("Arm64CortexA55Cflags", + strings.Join(arm64CpuVariantCflags["cortex-a55"], " ")) - pctx.StaticVariable("Arm64ClangKryoCflags", - strings.Join(arm64ClangCpuVariantCflags["kryo"], " ")) + pctx.StaticVariable("Arm64KryoCflags", + strings.Join(arm64CpuVariantCflags["kryo"], " ")) - pctx.StaticVariable("Arm64ClangExynosM1Cflags", - strings.Join(arm64ClangCpuVariantCflags["exynos-m1"], " ")) + pctx.StaticVariable("Arm64ExynosM1Cflags", + strings.Join(arm64CpuVariantCflags["exynos-m1"], " ")) - pctx.StaticVariable("Arm64ClangExynosM2Cflags", - strings.Join(arm64ClangCpuVariantCflags["exynos-m2"], " ")) + pctx.StaticVariable("Arm64ExynosM2Cflags", + strings.Join(arm64CpuVariantCflags["exynos-m2"], " ")) } var ( - arm64ClangArchVariantCflagsVar = map[string]string{ - "armv8-a": "${config.Arm64ClangArmv8ACflags}", - "armv8-a-branchprot": "${config.Arm64ClangArmv8ABranchProtCflags}", - "armv8-2a": "${config.Arm64ClangArmv82ACflags}", - "armv8-2a-dotprod": "${config.Arm64ClangArmv82ADotprodCflags}", + arm64ArchVariantCflagsVar = map[string]string{ + "armv8-a": "${config.Arm64Armv8ACflags}", + "armv8-a-branchprot": "${config.Arm64Armv8ABranchProtCflags}", + "armv8-2a": "${config.Arm64Armv82ACflags}", + "armv8-2a-dotprod": "${config.Arm64Armv82ADotprodCflags}", } - arm64ClangCpuVariantCflagsVar = map[string]string{ + arm64CpuVariantCflagsVar = map[string]string{ "": "", - "cortex-a53": "${config.Arm64ClangCortexA53Cflags}", - "cortex-a55": "${config.Arm64ClangCortexA55Cflags}", - "cortex-a72": "${config.Arm64ClangCortexA53Cflags}", - "cortex-a73": "${config.Arm64ClangCortexA53Cflags}", - "cortex-a75": "${config.Arm64ClangCortexA55Cflags}", - "cortex-a76": "${config.Arm64ClangCortexA55Cflags}", - "kryo": "${config.Arm64ClangKryoCflags}", - "kryo385": "${config.Arm64ClangCortexA53Cflags}", - "exynos-m1": "${config.Arm64ClangExynosM1Cflags}", - "exynos-m2": "${config.Arm64ClangExynosM2Cflags}", + "cortex-a53": "${config.Arm64CortexA53Cflags}", + "cortex-a55": "${config.Arm64CortexA55Cflags}", + "cortex-a72": "${config.Arm64CortexA53Cflags}", + "cortex-a73": "${config.Arm64CortexA53Cflags}", + "cortex-a75": "${config.Arm64CortexA55Cflags}", + "cortex-a76": "${config.Arm64CortexA55Cflags}", + "kryo": "${config.Arm64KryoCflags}", + "kryo385": "${config.Arm64CortexA53Cflags}", + "exynos-m1": "${config.Arm64ExynosM1Cflags}", + "exynos-m2": "${config.Arm64ExynosM2Cflags}", } ) @@ -152,9 +150,9 @@ type toolchainArm64 struct { toolchainBionic toolchain64Bit - ldflags string - lldflags string - toolchainClangCflags string + ldflags string + lldflags string + toolchainCflags string } func (t *toolchainArm64) Name() string { @@ -181,24 +179,24 @@ func (t *toolchainArm64) ClangTriple() string { return t.GccTriple() } -func (t *toolchainArm64) ClangCflags() string { - return "${config.Arm64ClangCflags}" +func (t *toolchainArm64) Cflags() string { + return "${config.Arm64Cflags}" } -func (t *toolchainArm64) ClangCppflags() string { - return "${config.Arm64ClangCppflags}" +func (t *toolchainArm64) Cppflags() string { + return "${config.Arm64Cppflags}" } -func (t *toolchainArm64) ClangLdflags() string { +func (t *toolchainArm64) Ldflags() string { return t.ldflags } -func (t *toolchainArm64) ClangLldflags() string { +func (t *toolchainArm64) Lldflags() string { return t.lldflags } -func (t *toolchainArm64) ToolchainClangCflags() string { - return t.toolchainClangCflags +func (t *toolchainArm64) ToolchainCflags() string { + return t.toolchainCflags } func (toolchainArm64) LibclangRuntimeLibraryArch() string { @@ -216,9 +214,9 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain { panic(fmt.Sprintf("Unknown ARM architecture version: %q", arch.ArchVariant)) } - toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[arch.ArchVariant]} - toolchainClangCflags = append(toolchainClangCflags, - variantOrDefault(arm64ClangCpuVariantCflagsVar, arch.CpuVariant)) + toolchainCflags := []string{arm64ArchVariantCflagsVar[arch.ArchVariant]} + toolchainCflags = append(toolchainCflags, + variantOrDefault(arm64CpuVariantCflagsVar, arch.CpuVariant)) var extraLdflags string switch arch.CpuVariant { @@ -235,7 +233,7 @@ func arm64ToolchainFactory(arch android.Arch) Toolchain { "${config.Arm64Lldflags}", extraLdflags, }, " "), - toolchainClangCflags: strings.Join(toolchainClangCflags, " "), + toolchainCflags: strings.Join(toolchainCflags, " "), } } diff --git a/cc/config/arm64_fuchsia_device.go b/cc/config/arm64_fuchsia_device.go deleted file mode 100644 index a6b5e8c67..000000000 --- a/cc/config/arm64_fuchsia_device.go +++ /dev/null @@ -1,97 +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) Cflags() string { - return "" -} - -func (t *toolchainFuchsiaArm64) Cppflags() string { - return "" -} - -func (t *toolchainFuchsiaArm64) Ldflags() string { - return "-Wl,--fix-cortex-a53-843419" -} - -func (t *toolchainFuchsiaArm64) IncludeFlags() string { - return "" -} - -func (t *toolchainFuchsiaArm64) ToolchainCflags() string { - return "-mcpu=cortex-a53" -} - -func (t *toolchainFuchsiaArm64) ClangTriple() string { - return "arm64-fuchsia-android" -} - -func (t *toolchainFuchsiaArm64) ClangCppflags() string { - return "-Wno-error=deprecated-declarations" -} - -func (t *toolchainFuchsiaArm64) ClangLdflags() string { - return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/" -} - -func (t *toolchainFuchsiaArm64) ClangLldflags() string { - return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -L" + fuchsiaArm64PrebuiltLibsRoot + "/aarch64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/arm64/dist/" -} - -func (t *toolchainFuchsiaArm64) ClangCflags() string { - return "--target=arm64-fuchsia --sysroot=" + fuchsiaArm64SysRoot + " -I" + fuchsiaArm64SysRoot + "/include" -} - -func (t *toolchainFuchsiaArm64) ToolchainClangCflags() 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/arm64_linux_host.go b/cc/config/arm64_linux_host.go index 83bd7997b..853d818f1 100644 --- a/cc/config/arm64_linux_host.go +++ b/cc/config/arm64_linux_host.go @@ -15,14 +15,15 @@ package config import ( - "android/soong/android" "strings" + + "android/soong/android" ) var ( // This is a host toolchain but flags for device toolchain are required // as the flags are actually for Bionic-based builds. - linuxCrossCflags = ClangFilterUnknownCflags(append(deviceGlobalCflags, + linuxCrossCflags = append(deviceGlobalCflags, // clang by default enables PIC when the clang triple is set to *-android. // See toolchain/llvm-project/clang/lib/Driver/ToolChains/CommonArgs.cpp#920. // However, for this host target, we don't set "-android" to avoid __ANDROID__ macro @@ -33,9 +34,9 @@ var ( // This is normally in ClangExtraTargetCflags, but that's for device and we need // the same for host "-nostdlibinc", - )) + ) - linuxCrossLdflags = ClangFilterUnknownCflags([]string{ + linuxCrossLdflags = []string{ "-Wl,-z,noexecstack", "-Wl,-z,relro", "-Wl,-z,now", @@ -44,7 +45,7 @@ var ( "-Wl,--fatal-warnings", "-Wl,--hash-style=gnu", "-Wl,--no-undefined-version", - }) + } // Embed the linker into host bionic binaries. This is needed to support host bionic, // as the linux kernel requires that the ELF interpreter referenced by PT_INTERP be @@ -73,9 +74,9 @@ func (toolchainLinuxArm64) ClangTriple() string { return "aarch64-linux" } -func (toolchainLinuxArm64) ClangCflags() string { +func (toolchainLinuxArm64) Cflags() string { // The inherited flags + extra flags - return "${config.Arm64ClangCflags} ${config.LinuxBionicArm64Cflags}" + return "${config.Arm64Cflags} ${config.LinuxBionicArm64Cflags}" } func (toolchainLinuxArm64) CrtBeginSharedBinary() []string { @@ -84,7 +85,7 @@ func (toolchainLinuxArm64) CrtBeginSharedBinary() []string { func linuxArm64ToolchainFactory(arch android.Arch) Toolchain { archVariant := "armv8-a" // for host, default to armv8-a - toolchainClangCflags := []string{arm64ClangArchVariantCflagsVar[archVariant]} + toolchainCflags := []string{arm64ArchVariantCflagsVar[archVariant]} // We don't specify CPU architecture for host. Conservatively assume // the host CPU needs the fix @@ -103,7 +104,7 @@ func linuxArm64ToolchainFactory(arch android.Arch) Toolchain { "${config.LinuxBionicArm64Ldflags}", extraLdflags, }, " ") - ret.toolchainArm64.toolchainClangCflags = strings.Join(toolchainClangCflags, " ") + ret.toolchainArm64.toolchainCflags = strings.Join(toolchainCflags, " ") return &ret } diff --git a/cc/config/arm_device.go b/cc/config/arm_device.go index 3c2773021..b5afe408f 100644 --- a/cc/config/arm_device.go +++ b/cc/config/arm_device.go @@ -23,7 +23,6 @@ import ( var ( armToolchainCflags = []string{ - "-mthumb-interwork", "-msoft-float", } @@ -38,7 +37,7 @@ var ( "-Wl,-m,armelf", } - armLldflags = ClangFilterUnknownLldflags(armLdflags) + armLldflags = armLdflags armArmCflags = []string{ "-fstrict-aliasing", @@ -49,7 +48,7 @@ var ( "-Os", } - armClangArchVariantCflags = map[string][]string{ + armArchVariantCflags = map[string][]string{ "armv7-a": []string{ "-march=armv7-a", "-mfloat-abi=softfp", @@ -72,7 +71,7 @@ var ( }, } - armClangCpuVariantCflags = map[string][]string{ + armCpuVariantCflags = map[string][]string{ "cortex-a7": []string{ "-mcpu=cortex-a7", "-mfpu=neon-vfpv4", @@ -181,67 +180,65 @@ func init() { exportStringListStaticVariable("ArmLldflags", armLldflags) // Clang cflags - exportStringListStaticVariable("ArmToolchainClangCflags", ClangFilterUnknownCflags(armToolchainCflags)) - exportStringListStaticVariable("ArmClangCflags", ClangFilterUnknownCflags(armCflags)) - exportStringListStaticVariable("ArmClangLdflags", ClangFilterUnknownCflags(armLdflags)) - exportStringListStaticVariable("ArmClangLldflags", ClangFilterUnknownCflags(armLldflags)) - exportStringListStaticVariable("ArmClangCppflags", ClangFilterUnknownCflags(armCppflags)) + exportStringListStaticVariable("ArmToolchainCflags", armToolchainCflags) + exportStringListStaticVariable("ArmCflags", armCflags) + exportStringListStaticVariable("ArmCppflags", armCppflags) // Clang ARM vs. Thumb instruction set cflags - exportStringListStaticVariable("ArmClangArmCflags", ClangFilterUnknownCflags(armArmCflags)) - exportStringListStaticVariable("ArmClangThumbCflags", ClangFilterUnknownCflags(armThumbCflags)) + exportStringListStaticVariable("ArmArmCflags", armArmCflags) + exportStringListStaticVariable("ArmThumbCflags", armThumbCflags) // Clang arch variant cflags - exportStringListStaticVariable("ArmClangArmv7ACflags", armClangArchVariantCflags["armv7-a"]) - exportStringListStaticVariable("ArmClangArmv7ANeonCflags", armClangArchVariantCflags["armv7-a-neon"]) - exportStringListStaticVariable("ArmClangArmv8ACflags", armClangArchVariantCflags["armv8-a"]) - exportStringListStaticVariable("ArmClangArmv82ACflags", armClangArchVariantCflags["armv8-2a"]) + exportStringListStaticVariable("ArmArmv7ACflags", armArchVariantCflags["armv7-a"]) + exportStringListStaticVariable("ArmArmv7ANeonCflags", armArchVariantCflags["armv7-a-neon"]) + exportStringListStaticVariable("ArmArmv8ACflags", armArchVariantCflags["armv8-a"]) + exportStringListStaticVariable("ArmArmv82ACflags", armArchVariantCflags["armv8-2a"]) // Clang cpu variant cflags - exportStringListStaticVariable("ArmClangGenericCflags", armClangCpuVariantCflags[""]) - exportStringListStaticVariable("ArmClangCortexA7Cflags", armClangCpuVariantCflags["cortex-a7"]) - exportStringListStaticVariable("ArmClangCortexA8Cflags", armClangCpuVariantCflags["cortex-a8"]) - exportStringListStaticVariable("ArmClangCortexA15Cflags", armClangCpuVariantCflags["cortex-a15"]) - exportStringListStaticVariable("ArmClangCortexA53Cflags", armClangCpuVariantCflags["cortex-a53"]) - exportStringListStaticVariable("ArmClangCortexA55Cflags", armClangCpuVariantCflags["cortex-a55"]) - exportStringListStaticVariable("ArmClangKraitCflags", armClangCpuVariantCflags["krait"]) - exportStringListStaticVariable("ArmClangKryoCflags", armClangCpuVariantCflags["kryo"]) + exportStringListStaticVariable("ArmGenericCflags", armCpuVariantCflags[""]) + exportStringListStaticVariable("ArmCortexA7Cflags", armCpuVariantCflags["cortex-a7"]) + exportStringListStaticVariable("ArmCortexA8Cflags", armCpuVariantCflags["cortex-a8"]) + exportStringListStaticVariable("ArmCortexA15Cflags", armCpuVariantCflags["cortex-a15"]) + exportStringListStaticVariable("ArmCortexA53Cflags", armCpuVariantCflags["cortex-a53"]) + exportStringListStaticVariable("ArmCortexA55Cflags", armCpuVariantCflags["cortex-a55"]) + exportStringListStaticVariable("ArmKraitCflags", armCpuVariantCflags["krait"]) + exportStringListStaticVariable("ArmKryoCflags", armCpuVariantCflags["kryo"]) } var ( - armClangArchVariantCflagsVar = map[string]string{ - "armv7-a": "${config.ArmClangArmv7ACflags}", - "armv7-a-neon": "${config.ArmClangArmv7ANeonCflags}", - "armv8-a": "${config.ArmClangArmv8ACflags}", - "armv8-2a": "${config.ArmClangArmv82ACflags}", + armArchVariantCflagsVar = map[string]string{ + "armv7-a": "${config.ArmArmv7ACflags}", + "armv7-a-neon": "${config.ArmArmv7ANeonCflags}", + "armv8-a": "${config.ArmArmv8ACflags}", + "armv8-2a": "${config.ArmArmv82ACflags}", } - armClangCpuVariantCflagsVar = map[string]string{ - "": "${config.ArmClangGenericCflags}", - "cortex-a7": "${config.ArmClangCortexA7Cflags}", - "cortex-a8": "${config.ArmClangCortexA8Cflags}", - "cortex-a15": "${config.ArmClangCortexA15Cflags}", - "cortex-a53": "${config.ArmClangCortexA53Cflags}", - "cortex-a53.a57": "${config.ArmClangCortexA53Cflags}", - "cortex-a55": "${config.ArmClangCortexA55Cflags}", - "cortex-a72": "${config.ArmClangCortexA53Cflags}", - "cortex-a73": "${config.ArmClangCortexA53Cflags}", - "cortex-a75": "${config.ArmClangCortexA55Cflags}", - "cortex-a76": "${config.ArmClangCortexA55Cflags}", - "krait": "${config.ArmClangKraitCflags}", - "kryo": "${config.ArmClangKryoCflags}", - "kryo385": "${config.ArmClangCortexA53Cflags}", - "exynos-m1": "${config.ArmClangCortexA53Cflags}", - "exynos-m2": "${config.ArmClangCortexA53Cflags}", + armCpuVariantCflagsVar = map[string]string{ + "": "${config.ArmGenericCflags}", + "cortex-a7": "${config.ArmCortexA7Cflags}", + "cortex-a8": "${config.ArmCortexA8Cflags}", + "cortex-a15": "${config.ArmCortexA15Cflags}", + "cortex-a53": "${config.ArmCortexA53Cflags}", + "cortex-a53.a57": "${config.ArmCortexA53Cflags}", + "cortex-a55": "${config.ArmCortexA55Cflags}", + "cortex-a72": "${config.ArmCortexA53Cflags}", + "cortex-a73": "${config.ArmCortexA53Cflags}", + "cortex-a75": "${config.ArmCortexA55Cflags}", + "cortex-a76": "${config.ArmCortexA55Cflags}", + "krait": "${config.ArmKraitCflags}", + "kryo": "${config.ArmKryoCflags}", + "kryo385": "${config.ArmCortexA53Cflags}", + "exynos-m1": "${config.ArmCortexA53Cflags}", + "exynos-m2": "${config.ArmCortexA53Cflags}", } ) type toolchainArm struct { toolchainBionic toolchain32Bit - ldflags string - lldflags string - toolchainClangCflags string + ldflags string + lldflags string + toolchainCflags string } func (t *toolchainArm) Name() string { @@ -274,34 +271,34 @@ func (t *toolchainArm) ndkTriple() string { return t.GccTriple() } -func (t *toolchainArm) ToolchainClangCflags() string { - return t.toolchainClangCflags +func (t *toolchainArm) ToolchainCflags() string { + return t.toolchainCflags } -func (t *toolchainArm) ClangCflags() string { - return "${config.ArmClangCflags}" +func (t *toolchainArm) Cflags() string { + return "${config.ArmCflags}" } -func (t *toolchainArm) ClangCppflags() string { - return "${config.ArmClangCppflags}" +func (t *toolchainArm) Cppflags() string { + return "${config.ArmCppflags}" } -func (t *toolchainArm) ClangLdflags() string { +func (t *toolchainArm) Ldflags() string { return t.ldflags } -func (t *toolchainArm) ClangLldflags() string { +func (t *toolchainArm) Lldflags() string { return t.lldflags // TODO: handle V8 cases } -func (t *toolchainArm) ClangInstructionSetFlags(isa string) (string, error) { +func (t *toolchainArm) InstructionSetFlags(isa string) (string, error) { switch isa { case "arm": - return "${config.ArmClangArmCflags}", nil + return "${config.ArmArmCflags}", nil case "thumb", "": - return "${config.ArmClangThumbCflags}", nil + return "${config.ArmThumbCflags}", nil default: - return t.toolchainBase.ClangInstructionSetFlags(isa) + return t.toolchainBase.InstructionSetFlags(isa) } } @@ -311,13 +308,13 @@ func (toolchainArm) LibclangRuntimeLibraryArch() string { func armToolchainFactory(arch android.Arch) Toolchain { var fixCortexA8 string - toolchainClangCflags := make([]string, 2, 3) + toolchainCflags := make([]string, 2, 3) - toolchainClangCflags[0] = "${config.ArmToolchainClangCflags}" - toolchainClangCflags[1] = armClangArchVariantCflagsVar[arch.ArchVariant] + toolchainCflags[0] = "${config.ArmToolchainCflags}" + toolchainCflags[1] = armArchVariantCflagsVar[arch.ArchVariant] - toolchainClangCflags = append(toolchainClangCflags, - variantOrDefault(armClangCpuVariantCflagsVar, arch.CpuVariant)) + toolchainCflags = append(toolchainCflags, + variantOrDefault(armCpuVariantCflagsVar, arch.CpuVariant)) switch arch.ArchVariant { case "armv7-a-neon": @@ -341,8 +338,8 @@ func armToolchainFactory(arch android.Arch) Toolchain { "${config.ArmLdflags}", fixCortexA8, }, " "), - lldflags: "${config.ArmLldflags}", - toolchainClangCflags: strings.Join(toolchainClangCflags, " "), + lldflags: "${config.ArmLldflags}", + toolchainCflags: strings.Join(toolchainCflags, " "), } } diff --git a/cc/config/bp2build.go b/cc/config/bp2build.go index 19571f10d..e7e94a8a1 100644 --- a/cc/config/bp2build.go +++ b/cc/config/bp2build.go @@ -118,7 +118,7 @@ func BazelCcToolchainVars() string { // quite complex to track depth-first interpolations. It's also unlikely the // interpolation stacks are deep (n > 1). func expandVar(toExpand string, stringScope exportedStringVariables, stringListScope exportedStringListVariables) []string { - // e.g. "${ClangExternalCflags}" + // e.g. "${ExternalCflags}" r := regexp.MustCompile(`\${([a-zA-Z0-9_]+)}`) // Internal recursive function. diff --git a/cc/config/clang.go b/cc/config/clang.go index c484fc921..53a73066e 100644 --- a/cc/config/clang.go +++ b/cc/config/clang.go @@ -15,9 +15,10 @@ package config import ( - "android/soong/android" "sort" "strings" + + "android/soong/android" ) // Cflags that should be filtered out when compiling with clang @@ -80,12 +81,6 @@ var ClangUnknownCflags = sorted([]string{ "--enable-stdcall-fixup", }) -// Ldflags that should be filtered out when linking with clang lld -var ClangUnknownLldflags = sorted([]string{ - "-Wl,--fix-cortex-a8", - "-Wl,--no-fix-cortex-a8", -}) - var ClangLibToolingUnknownCflags = sorted([]string{}) // List of tidy checks that should be disabled globally. When the compiler is @@ -97,138 +92,6 @@ var ClangTidyDisableChecks = []string{ "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__", - }) - - exportStringListStaticVariable("ClangExtraCppflags", []string{ - // -Wimplicit-fallthrough is not enabled by -Wall. - "-Wimplicit-fallthrough", - - // Enable clang's thread-safety annotations in libcxx. - "-D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS", - - // libc++'s math.h has an #include_next outside of system_headers. - "-Wno-gnu-include-next", - }) - - exportStringListStaticVariable("ClangExtraTargetCflags", []string{"-nostdlibinc"}) - - exportStringListStaticVariable("ClangExtraNoOverrideCflags", []string{ - "-Werror=address-of-temporary", - // Bug: http://b/29823425 Disable -Wnull-dereference until the - // new cases detected by this warning in Clang r271374 are - // fixed. - //"-Werror=null-dereference", - "-Werror=return-type", - - // http://b/72331526 Disable -Wtautological-* until the instances detected by these - // new warnings are fixed. - "-Wno-tautological-constant-compare", - "-Wno-tautological-type-limit-compare", - // http://b/145210666 - "-Wno-reorder-init-list", - // http://b/145211066 - "-Wno-implicit-int-float-conversion", - // New warnings to be fixed after clang-r377782. - "-Wno-int-in-bool-context", // http://b/148287349 - "-Wno-sizeof-array-div", // http://b/148815709 - "-Wno-tautological-overlap-compare", // http://b/148815696 - // New warnings to be fixed after clang-r383902. - "-Wno-deprecated-copy", // http://b/153746672 - "-Wno-range-loop-construct", // http://b/153747076 - "-Wno-misleading-indentation", // http://b/153746954 - "-Wno-zero-as-null-pointer-constant", // http://b/68236239 - "-Wno-deprecated-anon-enum-enum-conversion", // http://b/153746485 - "-Wno-deprecated-enum-enum-conversion", // http://b/153746563 - "-Wno-string-compare", // http://b/153764102 - "-Wno-enum-enum-conversion", // http://b/154138986 - "-Wno-enum-float-conversion", // http://b/154255917 - "-Wno-pessimizing-move", // http://b/154270751 - // New warnings to be fixed after clang-r399163 - "-Wno-non-c-typedef-for-linkage", // http://b/161304145 - // New warnings to be fixed after clang-r407598 - "-Wno-string-concatenation", // http://b/175068488 - }) - - // Extra cflags for external third-party projects to disable warnings that - // are infeasible to fix in all the external projects and their upstream repos. - exportStringListStaticVariable("ClangExtraExternalCflags", []string{ - "-Wno-enum-compare", - "-Wno-enum-compare-switch", - - // http://b/72331524 Allow null pointer arithmetic until the instances detected by - // this new warning are fixed. - "-Wno-null-pointer-arithmetic", - - // Bug: http://b/29823425 Disable -Wnull-dereference until the - // new instances detected by this warning are fixed. - "-Wno-null-dereference", - - // http://b/145211477 - "-Wno-pointer-compare", - // http://b/145211022 - "-Wno-xor-used-as-pow", - // http://b/145211022 - "-Wno-final-dtor-non-final-class", - - // http://b/165945989 - "-Wno-psabi", - }) -} - func ClangFilterUnknownCflags(cflags []string) []string { result, _ := android.FilterList(cflags, ClangUnknownCflags) return result @@ -255,26 +118,10 @@ func ClangRewriteTidyChecks(checks []string) []string { return result } -func ClangFilterUnknownLldflags(lldflags []string) []string { - result, _ := android.FilterList(lldflags, ClangUnknownLldflags) - return result -} - func ClangLibToolingFilterUnknownCflags(libToolingFlags []string) []string { return android.RemoveListFromList(libToolingFlags, ClangLibToolingUnknownCflags) } -func inListSorted(s string, list []string) bool { - for _, l := range list { - if s == l { - return true - } else if s < l { - return false - } - } - return false -} - func sorted(list []string) []string { sort.Strings(list) return list diff --git a/cc/config/global.go b/cc/config/global.go index 495776795..55e0d7967 100644 --- a/cc/config/global.go +++ b/cc/config/global.go @@ -15,6 +15,7 @@ package config import ( + "runtime" "strings" "android/soong/android" @@ -36,7 +37,6 @@ var ( // Make paths in deps files relative "-no-canonical-prefixes", - "-fno-canonical-system-headers", "-DNDEBUG", "-UDEBUG", @@ -56,13 +56,64 @@ var ( "-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{} deviceGlobalCflags = []string{ - "-fdiagnostics-color", - "-ffunction-sections", "-fdata-sections", "-fno-short-enums", @@ -78,6 +129,7 @@ var ( "-Werror=address", "-Werror=sequence-point", "-Werror=format-security", + "-nostdlibinc", } deviceGlobalCppflags = []string{ @@ -101,7 +153,7 @@ var ( "-Wl,--icf=safe", } - deviceGlobalLldflags = append(ClangFilterUnknownLldflags(deviceGlobalLdflags), + deviceGlobalLldflags = append(deviceGlobalLdflags, []string{ "-fuse-ld=lld", }...) @@ -116,6 +168,15 @@ var ( commonGlobalCppflags = []string{ "-Wsign-promo", + + // -Wimplicit-fallthrough is not enabled by -Wall. + "-Wimplicit-fallthrough", + + // Enable clang's thread-safety annotations in libcxx. + "-D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS", + + // libc++'s math.h has an #include_next outside of system_headers. + "-Wno-gnu-include-next", } noOverrideGlobalCflags = []string{ @@ -133,6 +194,66 @@ var ( // http://b/161386391 for -Wno-pointer-to-int-cast "-Wno-pointer-to-int-cast", "-Werror=fortify-source", + + "-Werror=address-of-temporary", + // Bug: http://b/29823425 Disable -Wnull-dereference until the + // new cases detected by this warning in Clang r271374 are + // fixed. + //"-Werror=null-dereference", + "-Werror=return-type", + + // http://b/72331526 Disable -Wtautological-* until the instances detected by these + // new warnings are fixed. + "-Wno-tautological-constant-compare", + "-Wno-tautological-type-limit-compare", + // http://b/145210666 + "-Wno-reorder-init-list", + // http://b/145211066 + "-Wno-implicit-int-float-conversion", + // New warnings to be fixed after clang-r377782. + "-Wno-int-in-bool-context", // http://b/148287349 + "-Wno-sizeof-array-div", // http://b/148815709 + "-Wno-tautological-overlap-compare", // http://b/148815696 + // New warnings to be fixed after clang-r383902. + "-Wno-deprecated-copy", // http://b/153746672 + "-Wno-range-loop-construct", // http://b/153747076 + "-Wno-misleading-indentation", // http://b/153746954 + "-Wno-zero-as-null-pointer-constant", // http://b/68236239 + "-Wno-deprecated-anon-enum-enum-conversion", // http://b/153746485 + "-Wno-deprecated-enum-enum-conversion", // http://b/153746563 + "-Wno-string-compare", // http://b/153764102 + "-Wno-enum-enum-conversion", // http://b/154138986 + "-Wno-enum-float-conversion", // http://b/154255917 + "-Wno-pessimizing-move", // http://b/154270751 + // New warnings to be fixed after clang-r399163 + "-Wno-non-c-typedef-for-linkage", // http://b/161304145 + // New warnings to be fixed after clang-r407598 + "-Wno-string-concatenation", // http://b/175068488 + } + + // Extra cflags for external third-party projects to disable warnings that + // are infeasible to fix in all the external projects and their upstream repos. + extraExternalCflags = []string{ + "-Wno-enum-compare", + "-Wno-enum-compare-switch", + + // http://b/72331524 Allow null pointer arithmetic until the instances detected by + // this new warning are fixed. + "-Wno-null-pointer-arithmetic", + + // Bug: http://b/29823425 Disable -Wnull-dereference until the + // new instances detected by this warning are fixed. + "-Wno-null-dereference", + + // http://b/145211477 + "-Wno-pointer-compare", + // http://b/145211022 + "-Wno-xor-used-as-pow", + // http://b/145211022 + "-Wno-final-dtor-non-final-class", + + // http://b/165945989 + "-Wno-psabi", } IllegalFlags = []string{ @@ -162,7 +283,7 @@ var ( 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=") } @@ -174,21 +295,19 @@ func init() { exportStringListStaticVariable("HostGlobalLdflags", hostGlobalLdflags) exportStringListStaticVariable("HostGlobalLldflags", hostGlobalLldflags) - // Export the static default CommonClangGlobalCflags to Bazel. + // Export the static default CommonGlobalCflags to Bazel. // TODO(187086342): handle cflags that are set in VariableFuncs. - commonClangGlobalCFlags := append( - ClangFilterUnknownCflags(commonGlobalCflags), + 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", }...) - exportedStringListVars.Set("CommonClangGlobalCflags", commonClangGlobalCFlags) + exportedStringListVars.Set("CommonGlobalCflags", bazelCommonGlobalCflags) - pctx.VariableFunc("CommonClangGlobalCflags", func(ctx android.PackageVarContext) string { - flags := ClangFilterUnknownCflags(commonGlobalCflags) - flags = append(flags, "${ClangExtraCflags}") + pctx.VariableFunc("CommonGlobalCflags", func(ctx android.PackageVarContext) string { + flags := commonGlobalCflags // http://b/131390872 // Automatically initialize any uninitialized stack variables. @@ -206,23 +325,18 @@ func init() { return strings.Join(flags, " ") }) - // Export the static default DeviceClangGlobalCflags to Bazel. + // Export the static default DeviceGlobalCflags to Bazel. // TODO(187086342): handle cflags that are set in VariableFuncs. - deviceClangGlobalCflags := append(ClangFilterUnknownCflags(deviceGlobalCflags), "${ClangExtraTargetCflags}") - exportedStringListVars.Set("DeviceClangGlobalCflags", deviceClangGlobalCflags) + exportedStringListVars.Set("DeviceGlobalCflags", deviceGlobalCflags) - pctx.VariableFunc("DeviceClangGlobalCflags", func(ctx android.PackageVarContext) string { - if ctx.Config().Fuchsia() { - return strings.Join(ClangFilterUnknownCflags(deviceGlobalCflags), " ") - } else { - return strings.Join(deviceClangGlobalCflags, " ") - } + pctx.VariableFunc("DeviceGlobalCflags", func(ctx android.PackageVarContext) string { + return strings.Join(deviceGlobalCflags, " ") }) - exportStringListStaticVariable("HostClangGlobalCflags", ClangFilterUnknownCflags(hostGlobalCflags)) - exportStringListStaticVariable("NoOverrideClangGlobalCflags", append(ClangFilterUnknownCflags(noOverrideGlobalCflags), "${ClangExtraNoOverrideCflags}")) - exportStringListStaticVariable("CommonClangGlobalCppflags", append(ClangFilterUnknownCflags(commonGlobalCppflags), "${ClangExtraCppflags}")) - exportStringListStaticVariable("ClangExternalCflags", []string{"${ClangExtraExternalCflags}"}) + exportStringListStaticVariable("HostGlobalCflags", hostGlobalCflags) + exportStringListStaticVariable("NoOverrideGlobalCflags", noOverrideGlobalCflags) + exportStringListStaticVariable("CommonGlobalCppflags", commonGlobalCppflags) + exportStringListStaticVariable("ExternalCflags", extraExternalCflags) // Everything in these lists is a crime against abstraction and dependency tracking. // Do not add anything to this list. diff --git a/cc/config/toolchain.go b/cc/config/toolchain.go index ab09751ac..ff556f179 100644 --- a/cc/config/toolchain.go +++ b/cc/config/toolchain.go @@ -82,14 +82,14 @@ type Toolchain interface { IncludeFlags() string ClangTriple() string - ToolchainClangCflags() string - ToolchainClangLdflags() string - ClangAsflags() string - ClangCflags() string - ClangCppflags() string - ClangLdflags() string - ClangLldflags() string - ClangInstructionSetFlags(string) (string, error) + ToolchainCflags() string + ToolchainLdflags() string + Asflags() string + Cflags() string + Cppflags() string + Ldflags() string + Lldflags() string + InstructionSetFlags(string) (string, error) ndkTriple() string @@ -136,18 +136,18 @@ func NDKTriple(toolchain Toolchain) string { return triple } -func (toolchainBase) ClangInstructionSetFlags(s string) (string, error) { +func (toolchainBase) InstructionSetFlags(s string) (string, error) { if s != "" { return "", fmt.Errorf("instruction_set: %s is not a supported instruction set", s) } return "", nil } -func (toolchainBase) ToolchainClangCflags() string { +func (toolchainBase) ToolchainCflags() string { return "" } -func (toolchainBase) ToolchainClangLdflags() string { +func (toolchainBase) ToolchainLdflags() string { return "" } @@ -159,7 +159,7 @@ func (toolchainBase) ExecutableSuffix() string { return "" } -func (toolchainBase) ClangAsflags() string { +func (toolchainBase) Asflags() string { return "" } diff --git a/cc/config/x86_64_device.go b/cc/config/x86_64_device.go index 54dc6d523..c4f47a724 100644 --- a/cc/config/x86_64_device.go +++ b/cc/config/x86_64_device.go @@ -32,8 +32,6 @@ var ( "-Wl,--hash-style=gnu", } - x86_64Lldflags = ClangFilterUnknownLldflags(x86_64Ldflags) - x86_64ArchVariantCflags = map[string][]string{ "": []string{ "-march=x86-64", @@ -102,13 +100,11 @@ func init() { pctx.StaticVariable("X86_64ToolchainLdflags", "-m64") pctx.StaticVariable("X86_64Ldflags", strings.Join(x86_64Ldflags, " ")) - pctx.StaticVariable("X86_64Lldflags", strings.Join(x86_64Lldflags, " ")) + pctx.StaticVariable("X86_64Lldflags", strings.Join(x86_64Ldflags, " ")) // Clang cflags - pctx.StaticVariable("X86_64ClangCflags", strings.Join(ClangFilterUnknownCflags(x86_64Cflags), " ")) - pctx.StaticVariable("X86_64ClangLdflags", strings.Join(ClangFilterUnknownCflags(x86_64Ldflags), " ")) - pctx.StaticVariable("X86_64ClangLldflags", strings.Join(ClangFilterUnknownCflags(x86_64Lldflags), " ")) - pctx.StaticVariable("X86_64ClangCppflags", strings.Join(ClangFilterUnknownCflags(x86_64Cppflags), " ")) + pctx.StaticVariable("X86_64Cflags", strings.Join(x86_64Cflags, " ")) + pctx.StaticVariable("X86_64Cppflags", strings.Join(x86_64Cppflags, " ")) // Yasm flags pctx.StaticVariable("X86_64YasmFlags", "-f elf64 -m amd64") @@ -117,15 +113,15 @@ func init() { // Architecture variant cflags for variant, cflags := range x86_64ArchVariantCflags { - pctx.StaticVariable("X86_64"+variant+"VariantClangCflags", - strings.Join(ClangFilterUnknownCflags(cflags), " ")) + pctx.StaticVariable("X86_64"+variant+"VariantCflags", + strings.Join(cflags, " ")) } } type toolchainX86_64 struct { toolchainBionic toolchain64Bit - toolchainClangCflags string + toolchainCflags string } func (t *toolchainX86_64) Name() string { @@ -152,27 +148,27 @@ func (t *toolchainX86_64) ClangTriple() string { return t.GccTriple() } -func (t *toolchainX86_64) ToolchainClangLdflags() string { +func (t *toolchainX86_64) ToolchainLdflags() string { return "${config.X86_64ToolchainLdflags}" } -func (t *toolchainX86_64) ToolchainClangCflags() string { - return t.toolchainClangCflags +func (t *toolchainX86_64) ToolchainCflags() string { + return t.toolchainCflags } -func (t *toolchainX86_64) ClangCflags() string { - return "${config.X86_64ClangCflags}" +func (t *toolchainX86_64) Cflags() string { + return "${config.X86_64Cflags}" } -func (t *toolchainX86_64) ClangCppflags() string { - return "${config.X86_64ClangCppflags}" +func (t *toolchainX86_64) Cppflags() string { + return "${config.X86_64Cppflags}" } -func (t *toolchainX86_64) ClangLdflags() string { +func (t *toolchainX86_64) Ldflags() string { return "${config.X86_64Ldflags}" } -func (t *toolchainX86_64) ClangLldflags() string { +func (t *toolchainX86_64) Lldflags() string { return "${config.X86_64Lldflags}" } @@ -185,17 +181,17 @@ func (toolchainX86_64) LibclangRuntimeLibraryArch() string { } func x86_64ToolchainFactory(arch android.Arch) Toolchain { - toolchainClangCflags := []string{ + toolchainCflags := []string{ "${config.X86_64ToolchainCflags}", - "${config.X86_64" + arch.ArchVariant + "VariantClangCflags}", + "${config.X86_64" + arch.ArchVariant + "VariantCflags}", } for _, feature := range arch.ArchFeatures { - toolchainClangCflags = append(toolchainClangCflags, x86_64ArchFeatureCflags[feature]...) + toolchainCflags = append(toolchainCflags, x86_64ArchFeatureCflags[feature]...) } return &toolchainX86_64{ - toolchainClangCflags: strings.Join(toolchainClangCflags, " "), + toolchainCflags: strings.Join(toolchainCflags, " "), } } diff --git a/cc/config/x86_64_fuchsia_device.go b/cc/config/x86_64_fuchsia_device.go deleted file mode 100644 index d6837c8b4..000000000 --- a/cc/config/x86_64_fuchsia_device.go +++ /dev/null @@ -1,102 +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) Cflags() string { - return "" -} - -func (t *toolchainFuchsiaX8664) Cppflags() string { - return "" -} - -func (t *toolchainFuchsiaX8664) Ldflags() string { - return "" -} - -func (t *toolchainFuchsiaX8664) IncludeFlags() string { - return "" -} - -func (t *toolchainFuchsiaX8664) ClangTriple() string { - return "x86_64-fuchsia-android" -} - -func (t *toolchainFuchsiaX8664) ClangCppflags() string { - return "-Wno-error=deprecated-declarations" -} - -func (t *toolchainFuchsiaX8664) ClangLdflags() string { - return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/" - -} - -func (t *toolchainFuchsiaX8664) ClangLldflags() string { - return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -L" + fuchsiaPrebuiltLibsRoot + "/x86_64-fuchsia/lib " + "-Lprebuilts/fuchsia_sdk/arch/x64/dist/" -} - -func (t *toolchainFuchsiaX8664) ClangCflags() string { - return "--target=x86_64-fuchsia --sysroot=" + fuchsiaSysRoot + " -I" + fuchsiaSysRoot + "/include" -} - -func (t *toolchainFuchsiaX8664) YasmFlags() string { - return "-f elf64 -m amd64" -} - -func (t *toolchainFuchsiaX8664) ToolchainClangCflags() 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/config/x86_darwin_host.go b/cc/config/x86_darwin_host.go index 4e3e2a69d..d8e70e1e7 100644 --- a/cc/config/x86_darwin_host.go +++ b/cc/config/x86_darwin_host.go @@ -26,8 +26,6 @@ import ( var ( darwinCflags = []string{ - "-fdiagnostics-color", - "-fPIC", "-funwind-tables", @@ -41,6 +39,9 @@ var ( "-DMACOSX_DEPLOYMENT_TARGET=${macMinVersion}", "-m64", + + "-integrated-as", + "-fstack-protector-strong", } darwinLdflags = []string{ @@ -50,15 +51,6 @@ var ( "-m64", } - darwinClangCflags = append(ClangFilterUnknownCflags(darwinCflags), []string{ - "-integrated-as", - "-fstack-protector-strong", - }...) - - darwinClangLdflags = ClangFilterUnknownCflags(darwinLdflags) - - darwinClangLldflags = ClangFilterUnknownLldflags(darwinClangLdflags) - darwinSupportedSdkVersions = []string{ "10.10", "10.11", @@ -115,9 +107,9 @@ func init() { pctx.StaticVariable("DarwinGccTriple", "i686-apple-darwin11") - pctx.StaticVariable("DarwinClangCflags", strings.Join(darwinClangCflags, " ")) - pctx.StaticVariable("DarwinClangLdflags", strings.Join(darwinClangLdflags, " ")) - pctx.StaticVariable("DarwinClangLldflags", strings.Join(darwinClangLldflags, " ")) + pctx.StaticVariable("DarwinCflags", strings.Join(darwinCflags, " ")) + pctx.StaticVariable("DarwinLdflags", strings.Join(darwinLdflags, " ")) + pctx.StaticVariable("DarwinLldflags", strings.Join(darwinLdflags, " ")) pctx.StaticVariable("DarwinYasmFlags", "-f macho -m amd64") } @@ -213,20 +205,20 @@ func (t *toolchainDarwin) ClangTriple() string { return "x86_64-apple-darwin" } -func (t *toolchainDarwin) ClangCflags() string { - return "${config.DarwinClangCflags}" +func (t *toolchainDarwin) Cflags() string { + return "${config.DarwinCflags}" } -func (t *toolchainDarwin) ClangCppflags() string { +func (t *toolchainDarwin) Cppflags() string { return "" } -func (t *toolchainDarwin) ClangLdflags() string { - return "${config.DarwinClangLdflags}" +func (t *toolchainDarwin) Ldflags() string { + return "${config.DarwinLdflags}" } -func (t *toolchainDarwin) ClangLldflags() string { - return "${config.DarwinClangLldflags}" +func (t *toolchainDarwin) Lldflags() string { + return "${config.DarwinLldflags}" } func (t *toolchainDarwin) YasmFlags() string { diff --git a/cc/config/x86_device.go b/cc/config/x86_device.go index 1507d9813..5e510a494 100644 --- a/cc/config/x86_device.go +++ b/cc/config/x86_device.go @@ -21,16 +21,14 @@ import ( ) var ( - x86Cflags = []string{} - - x86ClangCflags = append(x86Cflags, []string{ + x86Cflags = []string{ "-msse3", // -mstackrealign is needed to realign stack in native code // that could be called from JNI, so that movaps instruction // will work on assumed stack aligned local variables. "-mstackrealign", - }...) + } x86Cppflags = []string{} @@ -38,8 +36,6 @@ var ( "-Wl,--hash-style=gnu", } - x86Lldflags = ClangFilterUnknownLldflags(x86Ldflags) - x86ArchVariantCflags = map[string][]string{ "": []string{ "-march=prescott", @@ -49,35 +45,27 @@ var ( }, "atom": []string{ "-march=atom", - "-mfpmath=sse", }, "broadwell": []string{ "-march=broadwell", - "-mfpmath=sse", }, "haswell": []string{ "-march=core-avx2", - "-mfpmath=sse", }, "ivybridge": []string{ "-march=core-avx-i", - "-mfpmath=sse", }, "sandybridge": []string{ "-march=corei7", - "-mfpmath=sse", }, "silvermont": []string{ "-march=slm", - "-mfpmath=sse", }, "skylake": []string{ "-march=skylake", - "-mfpmath=sse", }, "stoneyridge": []string{ "-march=bdver4", - "-mfpmath=sse", }, } @@ -113,13 +101,11 @@ func init() { pctx.StaticVariable("X86ToolchainLdflags", "-m32") pctx.StaticVariable("X86Ldflags", strings.Join(x86Ldflags, " ")) - pctx.StaticVariable("X86Lldflags", strings.Join(x86Lldflags, " ")) + pctx.StaticVariable("X86Lldflags", strings.Join(x86Ldflags, " ")) // Clang cflags - pctx.StaticVariable("X86ClangCflags", strings.Join(ClangFilterUnknownCflags(x86ClangCflags), " ")) - pctx.StaticVariable("X86ClangLdflags", strings.Join(ClangFilterUnknownCflags(x86Ldflags), " ")) - pctx.StaticVariable("X86ClangLldflags", strings.Join(ClangFilterUnknownCflags(x86Lldflags), " ")) - pctx.StaticVariable("X86ClangCppflags", strings.Join(ClangFilterUnknownCflags(x86Cppflags), " ")) + pctx.StaticVariable("X86Cflags", strings.Join(x86Cflags, " ")) + pctx.StaticVariable("X86Cppflags", strings.Join(x86Cppflags, " ")) // Yasm flags pctx.StaticVariable("X86YasmFlags", "-f elf32 -m x86") @@ -128,15 +114,15 @@ func init() { // Architecture variant cflags for variant, cflags := range x86ArchVariantCflags { - pctx.StaticVariable("X86"+variant+"VariantClangCflags", - strings.Join(ClangFilterUnknownCflags(cflags), " ")) + pctx.StaticVariable("X86"+variant+"VariantCflags", + strings.Join(cflags, " ")) } } type toolchainX86 struct { toolchainBionic toolchain32Bit - toolchainClangCflags string + toolchainCflags string } func (t *toolchainX86) Name() string { @@ -163,27 +149,27 @@ func (t *toolchainX86) ClangTriple() string { return "i686-linux-android" } -func (t *toolchainX86) ToolchainClangLdflags() string { +func (t *toolchainX86) ToolchainLdflags() string { return "${config.X86ToolchainLdflags}" } -func (t *toolchainX86) ToolchainClangCflags() string { - return t.toolchainClangCflags +func (t *toolchainX86) ToolchainCflags() string { + return t.toolchainCflags } -func (t *toolchainX86) ClangCflags() string { - return "${config.X86ClangCflags}" +func (t *toolchainX86) Cflags() string { + return "${config.X86Cflags}" } -func (t *toolchainX86) ClangCppflags() string { - return "${config.X86ClangCppflags}" +func (t *toolchainX86) Cppflags() string { + return "${config.X86Cppflags}" } -func (t *toolchainX86) ClangLdflags() string { +func (t *toolchainX86) Ldflags() string { return "${config.X86Ldflags}" } -func (t *toolchainX86) ClangLldflags() string { +func (t *toolchainX86) Lldflags() string { return "${config.X86Lldflags}" } @@ -196,17 +182,17 @@ func (toolchainX86) LibclangRuntimeLibraryArch() string { } func x86ToolchainFactory(arch android.Arch) Toolchain { - toolchainClangCflags := []string{ + toolchainCflags := []string{ "${config.X86ToolchainCflags}", - "${config.X86" + arch.ArchVariant + "VariantClangCflags}", + "${config.X86" + arch.ArchVariant + "VariantCflags}", } for _, feature := range arch.ArchFeatures { - toolchainClangCflags = append(toolchainClangCflags, x86ArchFeatureCflags[feature]...) + toolchainCflags = append(toolchainCflags, x86ArchFeatureCflags[feature]...) } return &toolchainX86{ - toolchainClangCflags: strings.Join(toolchainClangCflags, " "), + toolchainCflags: strings.Join(toolchainCflags, " "), } } diff --git a/cc/config/x86_linux_bionic_host.go b/cc/config/x86_linux_bionic_host.go index e7e5f2dab..4b7ba6a85 100644 --- a/cc/config/x86_linux_bionic_host.go +++ b/cc/config/x86_linux_bionic_host.go @@ -21,9 +21,7 @@ import ( ) var ( - linuxBionicCflags = ClangFilterUnknownCflags([]string{ - "-fdiagnostics-color", - + linuxBionicCflags = []string{ "-Wa,--noexecstack", "-fPIC", @@ -34,21 +32,17 @@ var ( // From x86_64_device "-ffunction-sections", - "-finline-functions", - "-finline-limit=300", "-fno-short-enums", - "-funswitch-loops", "-funwind-tables", - "-fno-canonical-system-headers", // Tell clang where the gcc toolchain is "--gcc-toolchain=${LinuxBionicGccRoot}", // This is normally in ClangExtraTargetCflags, but this is considered host "-nostdlibinc", - }) + } - linuxBionicLdflags = ClangFilterUnknownCflags([]string{ + linuxBionicLdflags = []string{ "-Wl,-z,noexecstack", "-Wl,-z,relro", "-Wl,-z,now", @@ -60,9 +54,7 @@ var ( // Use the device gcc toolchain "--gcc-toolchain=${LinuxBionicGccRoot}", - }) - - linuxBionicLldflags = ClangFilterUnknownLldflags(linuxBionicLdflags) + } // Embed the linker into host bionic binaries. This is needed to support host bionic, // as the linux kernel requires that the ELF interpreter referenced by PT_INTERP be @@ -78,7 +70,7 @@ var ( func init() { pctx.StaticVariable("LinuxBionicCflags", strings.Join(linuxBionicCflags, " ")) pctx.StaticVariable("LinuxBionicLdflags", strings.Join(linuxBionicLdflags, " ")) - pctx.StaticVariable("LinuxBionicLldflags", strings.Join(linuxBionicLldflags, " ")) + pctx.StaticVariable("LinuxBionicLldflags", strings.Join(linuxBionicLdflags, " ")) // Use the device gcc toolchain for now pctx.StaticVariable("LinuxBionicGccRoot", "${X86_64GccRoot}") @@ -114,29 +106,29 @@ func (t *toolchainLinuxBionic) ClangTriple() string { return "x86_64-linux-android" } -func (t *toolchainLinuxBionic) ClangCflags() string { +func (t *toolchainLinuxBionic) Cflags() string { return "${config.LinuxBionicCflags}" } -func (t *toolchainLinuxBionic) ClangCppflags() string { +func (t *toolchainLinuxBionic) Cppflags() string { return "" } -func (t *toolchainLinuxBionic) ClangLdflags() string { +func (t *toolchainLinuxBionic) Ldflags() string { return "${config.LinuxBionicLdflags}" } -func (t *toolchainLinuxBionic) ClangLldflags() string { +func (t *toolchainLinuxBionic) Lldflags() string { return "${config.LinuxBionicLldflags}" } -func (t *toolchainLinuxBionic) ToolchainClangCflags() string { +func (t *toolchainLinuxBionic) ToolchainCflags() string { return "-m64 -march=x86-64" + // TODO: We're not really android, but we don't have a triple yet b/31393676 " -U__ANDROID__" } -func (t *toolchainLinuxBionic) ToolchainClangLdflags() string { +func (t *toolchainLinuxBionic) ToolchainLdflags() string { return "-m64" } diff --git a/cc/config/x86_linux_host.go b/cc/config/x86_linux_host.go index c406c885f..85d95d80f 100644 --- a/cc/config/x86_linux_host.go +++ b/cc/config/x86_linux_host.go @@ -22,8 +22,6 @@ import ( var ( linuxCflags = []string{ - "-fdiagnostics-color", - "-Wa,--noexecstack", "-fPIC", @@ -36,6 +34,10 @@ var ( //See bug 12708004. "-D__STDC_FORMAT_MACROS", "-D__STDC_CONSTANT_MACROS", + + "--gcc-toolchain=${LinuxGccRoot}", + "--sysroot ${LinuxGccRoot}/sysroot", + "-fstack-protector-strong", } linuxLdflags = []string{ @@ -43,12 +45,14 @@ var ( "-Wl,-z,relro", "-Wl,-z,now", "-Wl,--no-undefined-version", + + "--gcc-toolchain=${LinuxGccRoot}", + "--sysroot ${LinuxGccRoot}/sysroot", } // Extended cflags linuxX86Cflags = []string{ "-msse3", - "-mfpmath=sse", "-m32", "-march=prescott", "-D_FILE_OFFSET_BITS=64", @@ -61,40 +65,17 @@ var ( linuxX86Ldflags = []string{ "-m32", - } - - linuxX8664Ldflags = []string{ - "-m64", - } - - linuxClangCflags = append(ClangFilterUnknownCflags(linuxCflags), []string{ - "--gcc-toolchain=${LinuxGccRoot}", - "--sysroot ${LinuxGccRoot}/sysroot", - "-fstack-protector-strong", - }...) - - linuxClangLdflags = append(ClangFilterUnknownCflags(linuxLdflags), []string{ - "--gcc-toolchain=${LinuxGccRoot}", - "--sysroot ${LinuxGccRoot}/sysroot", - }...) - - linuxClangLldflags = ClangFilterUnknownLldflags(linuxClangLdflags) - - linuxX86ClangLdflags = append(ClangFilterUnknownCflags(linuxX86Ldflags), []string{ "-B${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}/32", "-L${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}/32", "-L${LinuxGccRoot}/${LinuxGccTriple}/lib32", - }...) - - linuxX86ClangLldflags = ClangFilterUnknownLldflags(linuxX86ClangLdflags) + } - linuxX8664ClangLdflags = append(ClangFilterUnknownCflags(linuxX8664Ldflags), []string{ + linuxX8664Ldflags = []string{ + "-m64", "-B${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}", "-L${LinuxGccRoot}/lib/gcc/${LinuxGccTriple}/${LinuxGccVersion}", "-L${LinuxGccRoot}/${LinuxGccTriple}/lib64", - }...) - - linuxX8664ClangLldflags = ClangFilterUnknownLldflags(linuxX8664ClangLdflags) + } linuxAvailableLibraries = addPrefix([]string{ "c", @@ -130,18 +111,16 @@ func init() { pctx.StaticVariable("LinuxGccTriple", "x86_64-linux") - pctx.StaticVariable("LinuxClangCflags", strings.Join(linuxClangCflags, " ")) - pctx.StaticVariable("LinuxClangLdflags", strings.Join(linuxClangLdflags, " ")) - pctx.StaticVariable("LinuxClangLldflags", strings.Join(linuxClangLldflags, " ")) - - pctx.StaticVariable("LinuxX86ClangCflags", - strings.Join(ClangFilterUnknownCflags(linuxX86Cflags), " ")) - pctx.StaticVariable("LinuxX8664ClangCflags", - strings.Join(ClangFilterUnknownCflags(linuxX8664Cflags), " ")) - pctx.StaticVariable("LinuxX86ClangLdflags", strings.Join(linuxX86ClangLdflags, " ")) - pctx.StaticVariable("LinuxX86ClangLldflags", strings.Join(linuxX86ClangLldflags, " ")) - pctx.StaticVariable("LinuxX8664ClangLdflags", strings.Join(linuxX8664ClangLdflags, " ")) - pctx.StaticVariable("LinuxX8664ClangLldflags", strings.Join(linuxX8664ClangLldflags, " ")) + pctx.StaticVariable("LinuxCflags", strings.Join(linuxCflags, " ")) + pctx.StaticVariable("LinuxLdflags", strings.Join(linuxLdflags, " ")) + pctx.StaticVariable("LinuxLldflags", strings.Join(linuxLdflags, " ")) + + pctx.StaticVariable("LinuxX86Cflags", strings.Join(linuxX86Cflags, " ")) + pctx.StaticVariable("LinuxX8664Cflags", strings.Join(linuxX8664Cflags, " ")) + pctx.StaticVariable("LinuxX86Ldflags", strings.Join(linuxX86Ldflags, " ")) + pctx.StaticVariable("LinuxX86Lldflags", strings.Join(linuxX86Ldflags, " ")) + pctx.StaticVariable("LinuxX8664Ldflags", strings.Join(linuxX8664Ldflags, " ")) + pctx.StaticVariable("LinuxX8664Lldflags", strings.Join(linuxX8664Ldflags, " ")) // Yasm flags pctx.StaticVariable("LinuxX86YasmFlags", "-f elf32 -m x86") pctx.StaticVariable("LinuxX8664YasmFlags", "-f elf64 -m amd64") @@ -189,11 +168,11 @@ func (t *toolchainLinuxX86) ClangTriple() string { return "i686-linux-gnu" } -func (t *toolchainLinuxX86) ClangCflags() string { - return "${config.LinuxClangCflags} ${config.LinuxX86ClangCflags}" +func (t *toolchainLinuxX86) Cflags() string { + return "${config.LinuxCflags} ${config.LinuxX86Cflags}" } -func (t *toolchainLinuxX86) ClangCppflags() string { +func (t *toolchainLinuxX86) Cppflags() string { return "" } @@ -201,28 +180,28 @@ func (t *toolchainLinuxX8664) ClangTriple() string { return "x86_64-linux-gnu" } -func (t *toolchainLinuxX8664) ClangCflags() string { - return "${config.LinuxClangCflags} ${config.LinuxX8664ClangCflags}" +func (t *toolchainLinuxX8664) Cflags() string { + return "${config.LinuxCflags} ${config.LinuxX8664Cflags}" } -func (t *toolchainLinuxX8664) ClangCppflags() string { +func (t *toolchainLinuxX8664) Cppflags() string { return "" } -func (t *toolchainLinuxX86) ClangLdflags() string { - return "${config.LinuxClangLdflags} ${config.LinuxX86ClangLdflags}" +func (t *toolchainLinuxX86) Ldflags() string { + return "${config.LinuxLdflags} ${config.LinuxX86Ldflags}" } -func (t *toolchainLinuxX86) ClangLldflags() string { - return "${config.LinuxClangLldflags} ${config.LinuxX86ClangLldflags}" +func (t *toolchainLinuxX86) Lldflags() string { + return "${config.LinuxLldflags} ${config.LinuxX86Lldflags}" } -func (t *toolchainLinuxX8664) ClangLdflags() string { - return "${config.LinuxClangLdflags} ${config.LinuxX8664ClangLdflags}" +func (t *toolchainLinuxX8664) Ldflags() string { + return "${config.LinuxLdflags} ${config.LinuxX8664Ldflags}" } -func (t *toolchainLinuxX8664) ClangLldflags() string { - return "${config.LinuxClangLldflags} ${config.LinuxX8664ClangLldflags}" +func (t *toolchainLinuxX8664) Lldflags() string { + return "${config.LinuxLldflags} ${config.LinuxX8664Lldflags}" } func (t *toolchainLinuxX86) YasmFlags() string { diff --git a/cc/config/x86_windows_host.go b/cc/config/x86_windows_host.go index b77df7906..d9a7537f3 100644 --- a/cc/config/x86_windows_host.go +++ b/cc/config/x86_windows_host.go @@ -44,32 +44,28 @@ var ( "--sysroot ${WindowsGccRoot}/${WindowsGccTriple}", } - windowsClangCflags = append(ClangFilterUnknownCflags(windowsCflags), []string{}...) windowsIncludeFlags = []string{ "-isystem ${WindowsGccRoot}/${WindowsGccTriple}/include", } - windowsClangCppflags = []string{} + windowsCppflags = []string{} - windowsX86ClangCppflags = []string{ + windowsX86Cppflags = []string{ // Use SjLj exceptions for 32-bit. libgcc_eh implements SjLj // exception model for 32-bit. "-fsjlj-exceptions", } - windowsX8664ClangCppflags = []string{} + windowsX8664Cppflags = []string{} windowsLdflags = []string{ - "--enable-stdcall-fixup", "-Wl,--dynamicbase", "-Wl,--nxcompat", } - windowsLldflags = []string{ + windowsLldflags = append(windowsLdflags, []string{ "-Wl,--Xlink=-Brepro", // Enable deterministic build - } - windowsClangLdflags = append(ClangFilterUnknownCflags(windowsLdflags), []string{}...) - windowsClangLldflags = append(ClangFilterUnknownLldflags(windowsClangLdflags), windowsLldflags...) + }...) windowsX86Cflags = []string{ "-m32", @@ -84,28 +80,24 @@ var ( "-Wl,--large-address-aware", "-L${WindowsGccRoot}/${WindowsGccTriple}/lib32", "-static-libgcc", - } - windowsX86ClangLdflags = append(ClangFilterUnknownCflags(windowsX86Ldflags), []string{ + "-B${WindowsGccRoot}/${WindowsGccTriple}/bin", "-B${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3/32", "-L${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3/32", "-B${WindowsGccRoot}/${WindowsGccTriple}/lib32", - }...) - windowsX86ClangLldflags = ClangFilterUnknownLldflags(windowsX86ClangLdflags) + } windowsX8664Ldflags = []string{ "-m64", "-L${WindowsGccRoot}/${WindowsGccTriple}/lib64", "-Wl,--high-entropy-va", "-static-libgcc", - } - windowsX8664ClangLdflags = append(ClangFilterUnknownCflags(windowsX8664Ldflags), []string{ + "-B${WindowsGccRoot}/${WindowsGccTriple}/bin", "-B${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3", "-L${WindowsGccRoot}/lib/gcc/${WindowsGccTriple}/4.8.3", "-B${WindowsGccRoot}/${WindowsGccTriple}/lib64", - }...) - windowsX8664ClangLldflags = ClangFilterUnknownLldflags(windowsX8664ClangLdflags) + } windowsAvailableLibraries = addPrefix([]string{ "gdi32", @@ -138,21 +130,19 @@ func init() { pctx.StaticVariable("WindowsGccTriple", "x86_64-w64-mingw32") - pctx.StaticVariable("WindowsClangCflags", strings.Join(windowsClangCflags, " ")) - pctx.StaticVariable("WindowsClangLdflags", strings.Join(windowsClangLdflags, " ")) - pctx.StaticVariable("WindowsClangLldflags", strings.Join(windowsClangLldflags, " ")) - pctx.StaticVariable("WindowsClangCppflags", strings.Join(windowsClangCppflags, " ")) - - pctx.StaticVariable("WindowsX86ClangCflags", - strings.Join(ClangFilterUnknownCflags(windowsX86Cflags), " ")) - pctx.StaticVariable("WindowsX8664ClangCflags", - strings.Join(ClangFilterUnknownCflags(windowsX8664Cflags), " ")) - pctx.StaticVariable("WindowsX86ClangLdflags", strings.Join(windowsX86ClangLdflags, " ")) - pctx.StaticVariable("WindowsX86ClangLldflags", strings.Join(windowsX86ClangLldflags, " ")) - pctx.StaticVariable("WindowsX8664ClangLdflags", strings.Join(windowsX8664ClangLdflags, " ")) - pctx.StaticVariable("WindowsX8664ClangLldflags", strings.Join(windowsX8664ClangLldflags, " ")) - pctx.StaticVariable("WindowsX86ClangCppflags", strings.Join(windowsX86ClangCppflags, " ")) - pctx.StaticVariable("WindowsX8664ClangCppflags", strings.Join(windowsX8664ClangCppflags, " ")) + pctx.StaticVariable("WindowsCflags", strings.Join(windowsCflags, " ")) + pctx.StaticVariable("WindowsLdflags", strings.Join(windowsLdflags, " ")) + pctx.StaticVariable("WindowsLldflags", strings.Join(windowsLldflags, " ")) + pctx.StaticVariable("WindowsCppflags", strings.Join(windowsCppflags, " ")) + + pctx.StaticVariable("WindowsX86Cflags", strings.Join(windowsX86Cflags, " ")) + pctx.StaticVariable("WindowsX8664Cflags", strings.Join(windowsX8664Cflags, " ")) + pctx.StaticVariable("WindowsX86Ldflags", strings.Join(windowsX86Ldflags, " ")) + pctx.StaticVariable("WindowsX86Lldflags", strings.Join(windowsX86Ldflags, " ")) + pctx.StaticVariable("WindowsX8664Ldflags", strings.Join(windowsX8664Ldflags, " ")) + pctx.StaticVariable("WindowsX8664Lldflags", strings.Join(windowsX8664Ldflags, " ")) + pctx.StaticVariable("WindowsX86Cppflags", strings.Join(windowsX86Cppflags, " ")) + pctx.StaticVariable("WindowsX8664Cppflags", strings.Join(windowsX8664Cppflags, " ")) pctx.StaticVariable("WindowsIncludeFlags", strings.Join(windowsIncludeFlags, " ")) // Yasm flags @@ -214,36 +204,36 @@ func (t *toolchainWindowsX8664) ClangTriple() string { return "x86_64-pc-windows-gnu" } -func (t *toolchainWindowsX86) ClangCflags() string { - return "${config.WindowsClangCflags} ${config.WindowsX86ClangCflags}" +func (t *toolchainWindowsX86) Cflags() string { + return "${config.WindowsCflags} ${config.WindowsX86Cflags}" } -func (t *toolchainWindowsX8664) ClangCflags() string { - return "${config.WindowsClangCflags} ${config.WindowsX8664ClangCflags}" +func (t *toolchainWindowsX8664) Cflags() string { + return "${config.WindowsCflags} ${config.WindowsX8664Cflags}" } -func (t *toolchainWindowsX86) ClangCppflags() string { - return "${config.WindowsClangCppflags} ${config.WindowsX86ClangCppflags}" +func (t *toolchainWindowsX86) Cppflags() string { + return "${config.WindowsCppflags} ${config.WindowsX86Cppflags}" } -func (t *toolchainWindowsX8664) ClangCppflags() string { - return "${config.WindowsClangCppflags} ${config.WindowsX8664ClangCppflags}" +func (t *toolchainWindowsX8664) Cppflags() string { + return "${config.WindowsCppflags} ${config.WindowsX8664Cppflags}" } -func (t *toolchainWindowsX86) ClangLdflags() string { - return "${config.WindowsClangLdflags} ${config.WindowsX86ClangLdflags}" +func (t *toolchainWindowsX86) Ldflags() string { + return "${config.WindowsLdflags} ${config.WindowsX86Ldflags}" } -func (t *toolchainWindowsX86) ClangLldflags() string { - return "${config.WindowsClangLldflags} ${config.WindowsX86ClangLldflags}" +func (t *toolchainWindowsX86) Lldflags() string { + return "${config.WindowsLldflags} ${config.WindowsX86Lldflags}" } -func (t *toolchainWindowsX8664) ClangLdflags() string { - return "${config.WindowsClangLdflags} ${config.WindowsX8664ClangLdflags}" +func (t *toolchainWindowsX8664) Ldflags() string { + return "${config.WindowsLdflags} ${config.WindowsX8664Ldflags}" } -func (t *toolchainWindowsX8664) ClangLldflags() string { - return "${config.WindowsClangLldflags} ${config.WindowsX8664ClangLldflags}" +func (t *toolchainWindowsX8664) Lldflags() string { + return "${config.WindowsLldflags} ${config.WindowsX8664Lldflags}" } func (t *toolchainWindowsX86) YasmFlags() string { diff --git a/cc/fuzz.go b/cc/fuzz.go index c780b6f97..8b0f93e0e 100644 --- a/cc/fuzz.go +++ b/cc/fuzz.go @@ -94,19 +94,14 @@ type fuzzBinary struct { *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 @@ func (fuzz *fuzzBinary) install(ctx ModuleContext, file android.Path) { "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 @@ func NewFuzz(hod android.HostOrDeviceSupported) *Module { // 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{} -} - -type fileToZip struct { - SourceFilePath android.Path - DestinationPathPrefix string -} - -type archOs struct { - hostOrTarget string - arch string - dir string + return &ccFuzzPackager{} } -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,29 +375,21 @@ func (s *fuzzPackager) GenerateBuildActions(ctx android.SingletonContext) { // 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 } - fuzzModule, ok := ccModule.compiler.(*fuzzBinary) - if !ok { - 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() { + // Discard non-fuzz targets. + if ok := IsValid(ccModule.FuzzModule); !ok { return } - // Discard modules that are in an unavailable namespace. - if !ccModule.ExportedToMake() { + fuzzModule, ok := ccModule.compiler.(*fuzzBinary) + if !ok { return } @@ -425,42 +400,21 @@ func (s *fuzzPackager) GenerateBuildActions(ctx android.SingletonContext) { 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 @@ func (s *fuzzPackager) GenerateBuildActions(ctx android.SingletonContext) { } // 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, ""}) - } - - // 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 - } + archDirs[archOs], ok = s.BuildZipFile(ctx, module, fuzzModule.fuzzPackagedModule, files, builder, archDir, archString, hostOrTargetString, archOs, archDirs) + if !ok { + 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 @@ func (s *fuzzPackager) MakeVars(ctx android.MakeVarsContext) { 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 000000000..98ed7f4bc --- /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 b0efc6ca4..0ca901e61 100644 --- a/cc/genrule.go +++ b/cc/genrule.go @@ -17,6 +17,7 @@ package cc import ( "android/soong/android" "android/soong/genrule" + "android/soong/snapshot" ) func init() { @@ -84,7 +85,7 @@ func (g *GenruleExtraProperties) RecoveryVariantNeeded(ctx android.BaseModuleCon // 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 @@ func (g *GenruleExtraProperties) ExtraImageVariations(ctx android.BaseModuleCont // 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 15ec1c867..3a0857b21 100644 --- a/cc/image.go +++ b/cc/image.go @@ -22,6 +22,7 @@ import ( "strings" "android/soong/android" + "android/soong/snapshot" ) var _ android.ImageInterface = (*Module)(nil) @@ -496,7 +497,7 @@ func MutateImage(mctx android.BaseModuleContext, m ImageMutatableModule) { // 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 @@ func MutateImage(mctx android.BaseModuleContext, m ImageMutatableModule) { platformVndkVersion, boardVndkVersion, ) - } else if IsVendorProprietaryModule(mctx) { + } else if snapshot.IsVendorProprietaryModule(mctx) { vendorVariants = append(vendorVariants, boardVndkVersion) } else { vendorVariants = append(vendorVariants, platformVndkVersion) @@ -582,7 +583,7 @@ func MutateImage(mctx android.BaseModuleContext, m ImageMutatableModule) { if !m.KernelHeadersDecorator() && !m.IsSnapshotPrebuilt() && usingRecoverySnapshot && - !isRecoveryProprietaryModule(mctx) { + !snapshot.IsRecoveryProprietaryModule(mctx) { recoveryVariantNeeded = false } diff --git a/cc/library.go b/cc/library.go index 4fd7c7475..56c460c24 100644 --- a/cc/library.go +++ b/cc/library.go @@ -300,6 +300,12 @@ func CcLibraryBp2Build(ctx android.TopDownMutatorContext) { srcs := compilerAttrs.srcs + asFlags := compilerAttrs.asFlags + if compilerAttrs.asSrcs.IsEmpty() && sharedAttrs.Srcs_as.IsEmpty() && staticAttrs.Srcs_as.IsEmpty() { + // Skip asflags for BUILD file simplicity if there are no assembly sources. + asFlags = bazel.MakeStringListAttribute(nil) + } + attrs := &bazelCcLibraryAttributes{ Srcs: srcs, Srcs_c: compilerAttrs.cSrcs, @@ -308,7 +314,7 @@ func CcLibraryBp2Build(ctx android.TopDownMutatorContext) { Copts: compilerAttrs.copts, Cppflags: compilerAttrs.cppFlags, Conlyflags: compilerAttrs.conlyFlags, - Asflags: compilerAttrs.asFlags, + Asflags: asFlags, Implementation_deps: linkerAttrs.deps, Deps: linkerAttrs.exportedDeps, @@ -2370,6 +2376,12 @@ func ccLibraryStaticBp2BuildInternal(ctx android.TopDownMutatorContext, module * linkerAttrs := bp2BuildParseLinkerProps(ctx, module) exportedIncludes := bp2BuildParseExportedIncludes(ctx, module) + asFlags := compilerAttrs.asFlags + if compilerAttrs.asSrcs.IsEmpty() { + // Skip asflags for BUILD file simplicity if there are no assembly sources. + asFlags = bazel.MakeStringListAttribute(nil) + } + attrs := &bazelCcLibraryStaticAttributes{ Copts: compilerAttrs.copts, Srcs: compilerAttrs.srcs, @@ -2386,7 +2398,7 @@ func ccLibraryStaticBp2BuildInternal(ctx android.TopDownMutatorContext, module * Srcs_c: compilerAttrs.cSrcs, Conlyflags: compilerAttrs.conlyFlags, Srcs_as: compilerAttrs.asSrcs, - Asflags: compilerAttrs.asFlags, + Asflags: asFlags, } props := bazel.BazelTargetModuleProperties{ diff --git a/cc/linkable.go b/cc/linkable.go index 84141e298..b510508a7 100644 --- a/cc/linkable.go +++ b/cc/linkable.go @@ -3,6 +3,7 @@ package cc import ( "android/soong/android" "android/soong/bazel/cquery" + "android/soong/snapshot" "github.com/google/blueprint" ) @@ -71,15 +72,12 @@ type SantizableDependencyTagChecker func(tag blueprint.DependencyTag) bool // 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 @@ -125,6 +123,7 @@ type LinkableInterface interface { IsPrebuilt() bool Toc() android.OptionalPath + Device() bool Host() bool InRamdisk() bool diff --git a/cc/linker.go b/cc/linker.go index 13df23296..82449a67c 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 @@ func (linker *baseLinker) overrideDefaultSharedLibraries(ctx BaseModuleContext) 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 @@ func (linker *baseLinker) linkerDeps(ctx DepsContext, deps Deps) Deps { 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") } @@ -479,12 +467,12 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { } if linker.useClangLld(ctx) { - flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ClangLldflags()) + flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.Lldflags()) } else { - flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ClangLdflags()) + 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 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { } } - 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") } @@ -535,7 +519,7 @@ func (linker *baseLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { flags.Global.LdFlags = append(flags.Global.LdFlags, "-Wl,--hash-style=both") } - flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ToolchainClangLdflags()) + flags.Global.LdFlags = append(flags.Global.LdFlags, toolchain.ToolchainLdflags()) if Bool(linker.Properties.Group_static_libs) { flags.GroupStaticLibs = true diff --git a/cc/makevars.go b/cc/makevars.go index 2b326ef4f..8d7a163e3 100644 --- a/cc/makevars.go +++ b/cc/makevars.go @@ -92,8 +92,8 @@ func makeVarsProvider(ctx android.MakeVarsContext) { ctx.Strict("RS_LLVM_AS", "${config.RSLLVMPrebuiltsPath}/llvm-as") ctx.Strict("RS_LLVM_LINK", "${config.RSLLVMPrebuiltsPath}/llvm-link") - ctx.Strict("CLANG_EXTERNAL_CFLAGS", "${config.ClangExternalCflags}") - ctx.Strict("GLOBAL_CLANG_CFLAGS_NO_OVERRIDE", "${config.NoOverrideClangGlobalCflags}") + ctx.Strict("CLANG_EXTERNAL_CFLAGS", "${config.ExternalCflags}") + ctx.Strict("GLOBAL_CLANG_CFLAGS_NO_OVERRIDE", "${config.NoOverrideGlobalCflags}") ctx.Strict("GLOBAL_CLANG_CPPFLAGS_NO_OVERRIDE", "") ctx.Strict("BOARD_VNDK_VERSION", ctx.DeviceConfig().VndkVersion()) @@ -165,7 +165,7 @@ func makeVarsProvider(ctx android.MakeVarsContext) { 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]) @@ -212,13 +212,13 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string, ctx.StrictRaw(makePrefix+"C_SYSTEM_INCLUDES", strings.Join(systemIncludes, " ")) if target.Arch.ArchType == android.Arm { - flags, err := toolchain.ClangInstructionSetFlags("arm") + flags, err := toolchain.InstructionSetFlags("arm") if err != nil { panic(err) } ctx.Strict(makePrefix+"arm_CFLAGS", flags) - flags, err = toolchain.ClangInstructionSetFlags("thumb") + flags, err = toolchain.InstructionSetFlags("thumb") if err != nil { panic(err) } @@ -230,29 +230,29 @@ func makeVarsToolchain(ctx android.MakeVarsContext, secondPrefix string, ctx.Strict(clangPrefix+"TRIPLE", toolchain.ClangTriple()) ctx.Strict(clangPrefix+"GLOBAL_CFLAGS", strings.Join([]string{ - toolchain.ClangCflags(), - "${config.CommonClangGlobalCflags}", - fmt.Sprintf("${config.%sClangGlobalCflags}", hod), - toolchain.ToolchainClangCflags(), + toolchain.Cflags(), + "${config.CommonGlobalCflags}", + fmt.Sprintf("${config.%sGlobalCflags}", hod), + toolchain.ToolchainCflags(), clangExtras, productExtraCflags, }, " ")) ctx.Strict(clangPrefix+"GLOBAL_CPPFLAGS", strings.Join([]string{ - "${config.CommonClangGlobalCppflags}", + "${config.CommonGlobalCppflags}", fmt.Sprintf("${config.%sGlobalCppflags}", hod), - toolchain.ClangCppflags(), + toolchain.Cppflags(), }, " ")) ctx.Strict(clangPrefix+"GLOBAL_LDFLAGS", strings.Join([]string{ fmt.Sprintf("${config.%sGlobalLdflags}", hod), - toolchain.ClangLdflags(), - toolchain.ToolchainClangLdflags(), + toolchain.Ldflags(), + toolchain.ToolchainLdflags(), productExtraLdflags, clangExtras, }, " ")) ctx.Strict(clangPrefix+"GLOBAL_LLDFLAGS", strings.Join([]string{ fmt.Sprintf("${config.%sGlobalLldflags}", hod), - toolchain.ClangLldflags(), - toolchain.ToolchainClangLdflags(), + toolchain.Lldflags(), + toolchain.ToolchainLdflags(), productExtraLdflags, clangExtras, }, " ")) diff --git a/cc/ndk_library.go b/cc/ndk_library.go index a45838063..63e8261e9 100644 --- a/cc/ndk_library.go +++ b/cc/ndk_library.go @@ -150,12 +150,6 @@ func (this *stubDecorator) stubsVersions(ctx android.BaseMutatorContext) []strin 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/object.go b/cc/object.go index 9f2db2ec2..0f983c861 100644 --- a/cc/object.go +++ b/cc/object.go @@ -123,6 +123,7 @@ func ObjectFactory() android.Module { // For bp2build conversion. type bazelObjectAttributes struct { Srcs bazel.LabelListAttribute + Srcs_as bazel.LabelListAttribute Hdrs bazel.LabelListAttribute Deps bazel.LabelListAttribute Copts bazel.StringListAttribute @@ -179,13 +180,19 @@ func ObjectBp2Build(ctx android.TopDownMutatorContext) { // and this isn't typically done for cc_object. srcs := compilerAttrs.srcs srcs.Append(compilerAttrs.cSrcs) - srcs.Append(compilerAttrs.asSrcs) + + asFlags := compilerAttrs.asFlags + if compilerAttrs.asSrcs.IsEmpty() { + // Skip asflags for BUILD file simplicity if there are no assembly sources. + asFlags = bazel.MakeStringListAttribute(nil) + } attrs := &bazelObjectAttributes{ Srcs: srcs, + Srcs_as: compilerAttrs.asSrcs, Deps: deps, Copts: compilerAttrs.copts, - Asflags: compilerAttrs.asFlags, + Asflags: asFlags, } props := bazel.BazelTargetModuleProperties{ @@ -224,7 +231,7 @@ func (object *objectLinker) linkerDeps(ctx DepsContext, deps Deps) Deps { } func (object *objectLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags { - flags.Global.LdFlags = append(flags.Global.LdFlags, ctx.toolchain().ToolchainClangLdflags()) + flags.Global.LdFlags = append(flags.Global.LdFlags, ctx.toolchain().ToolchainLdflags()) if lds := android.OptionalPathForModuleSrc(ctx, object.Properties.Linker_script); lds.Valid() { flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-T,"+lds.String()) diff --git a/cc/prebuilt_test.go b/cc/prebuilt_test.go index fa6dd87eb..c8f8103b0 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 TestPrebuiltLibrarySharedStem(t *testing.T) { } 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 b9c89c744..abcb27304 100644 --- a/cc/proto_test.go +++ b/cc/proto_test.go @@ -51,7 +51,7 @@ func TestProto(t *testing.T) { }, }`) - 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 5fd6f5da3..e62ca6622 100644 --- a/cc/sabi.go +++ b/cc/sabi.go @@ -101,10 +101,6 @@ func classifySourceAbiDump(ctx android.BaseModuleContext) string { // 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 defe8fde1..3911f48b3 100644 --- a/cc/sanitize.go +++ b/cc/sanitize.go @@ -25,6 +25,7 @@ import ( "android/soong/android" "android/soong/cc/config" + "android/soong/snapshot" ) var ( @@ -265,7 +266,6 @@ type SanitizeUserProps struct { } 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 @@ func (sanitize *sanitize) begin(ctx BaseModuleContext) { 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 @@ func (m *Module) SanitizableDepTagChecker() SantizableDependencyTagChecker { // 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 } @@ -76,7 +76,7 @@ func sdkMutator(ctx android.BottomUpMutatorContext) { } ctx.AliasVariation("") } - case *snapshot: + case *snapshotModule: ctx.CreateVariations("") } } diff --git a/cc/snapshot_prebuilt.go b/cc/snapshot_prebuilt.go index fb89224f3..9672c0fff 100644 --- a/cc/snapshot_prebuilt.go +++ b/cc/snapshot_prebuilt.go @@ -18,57 +18,17 @@ package cc // 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,122 +40,44 @@ type SnapshotImage interface { 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) -} - -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" +type vendorSnapshotImage struct { + *snapshot.VendorSnapshotImage } -func (vendorSnapshotImage) inImage(m LinkableInterface) func() bool { - return m.InVendor +type recoverySnapshotImage struct { + *snapshot.RecoverySnapshotImage } -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) imageVariantName(cfg android.DeviceConfig) string { + return VendorVariationPrefix + cfg.VndkVersion() } -func (vendorSnapshotImage) excludeFromSnapshot(m LinkableInterface) bool { - return m.ExcludeFromVendorSnapshot() +func (vendorSnapshotImage) moduleNameSuffix() string { + return VendorSuffix } -func (vendorSnapshotImage) isUsingSnapshot(cfg android.DeviceConfig) bool { - vndkVersion := cfg.VndkVersion() - return vndkVersion != "current" && vndkVersion != "" +func (recoverySnapshotImage) imageVariantName(cfg android.DeviceConfig) string { + return android.RecoveryVariation } -func (vendorSnapshotImage) targetSnapshotVersion(cfg android.DeviceConfig) string { - return cfg.VndkVersion() +func (recoverySnapshotImage) moduleNameSuffix() string { + return recoverySuffix } -// 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] -} +// 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 (vendorSnapshotImage) imageVariantName(cfg android.DeviceConfig) string { - return VendorVariationPrefix + cfg.VndkVersion() -} - -func (vendorSnapshotImage) moduleNameSuffix() string { - return VendorSuffix +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 (recoverySnapshotImage) init(ctx android.RegistrationContext) { - ctx.RegisterSingletonType("recovery-snapshot", RecoverySnapshotSingleton) +func RegisterRecoverySnapshotModules(ctx android.RegistrationContext) { ctx.RegisterModuleType("recovery_snapshot", recoverySnapshotFactory) ctx.RegisterModuleType("recovery_snapshot_shared", RecoverySnapshotSharedFactory) ctx.RegisterModuleType("recovery_snapshot_static", RecoverySnapshotStaticFactory) @@ -204,66 +86,10 @@ func (recoverySnapshotImage) init(ctx android.RegistrationContext) { 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 -} - -func (recoverySnapshotImage) moduleNameSuffix() string { - return recoverySuffix -} - -var VendorSnapshotImageSingleton vendorSnapshotImage -var recoverySnapshotImageSingleton recoverySnapshotImage - func init() { - VendorSnapshotImageSingleton.Init(android.InitRegistrationContext) - recoverySnapshotImageSingleton.init(android.InitRegistrationContext) + RegisterVendorSnapshotModules(android.InitRegistrationContext) + RegisterRecoverySnapshotModules(android.InitRegistrationContext) + android.RegisterMakeVarsProvider(pctx, snapshotMakeVarsProvider) } const ( @@ -284,8 +110,7 @@ type SnapshotProperties struct { Binaries []string `android:"arch_variant"` Objects []string `android:"arch_variant"` } - -type snapshot struct { +type snapshotModule struct { android.ModuleBase properties SnapshotProperties @@ -295,41 +120,41 @@ type snapshot struct { 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. } @@ -341,7 +166,7 @@ func getSnapshotNameSuffix(moduleSuffix, version, arch string) string { 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 { @@ -381,7 +206,25 @@ type SnapshotInfo struct { 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.(*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. + return + } + snapshotSet[s.Name()] = struct{}{} + imageNameVersion := strings.Split(s.image.imageVariantName(ctx.DeviceConfig()), ".") + ctx.Strict( + strings.Join([]string{strings.ToUpper(imageNameVersion[0]), s.baseSnapshot.Version(), "SNAPSHOT_DIR"}, "_"), + ctx.ModuleDir(s)) + } + }) +} func vendorSnapshotFactory() android.Module { return snapshotFactory(VendorSnapshotImageSingleton) @@ -392,13 +235,13 @@ func recoverySnapshotFactory() android.Module { } 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 { @@ -430,7 +273,7 @@ type BaseSnapshotDecoratorProperties struct { // 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 { @@ -470,7 +313,7 @@ func (p *BaseSnapshotDecorator) SetSnapshotAndroidMkSuffix(ctx android.ModuleCon 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 } @@ -479,14 +322,14 @@ func (p *BaseSnapshotDecorator) SetSnapshotAndroidMkSuffix(ctx android.ModuleCon 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{ @@ -499,7 +342,7 @@ func (p *BaseSnapshotDecorator) SetSnapshotAndroidMkSuffix(ctx android.ModuleCon 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 } } @@ -510,7 +353,7 @@ func (p *BaseSnapshotDecorator) SetSnapshotAndroidMkSuffix(ctx android.ModuleCon // 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 b0538bea0..24abcce55 100644 --- a/cc/snapshot_utils.go +++ b/cc/snapshot_utils.go @@ -114,7 +114,7 @@ func ShouldCollectHeadersForSnapshot(ctx android.ModuleContext, m LinkableInterf } 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 } } @@ -15,8 +15,9 @@ package cc import ( - "android/soong/android" "fmt" + + "android/soong/android" ) func getNdkStlFamily(m LinkableInterface) string { @@ -92,26 +93,6 @@ func (stl *stl) begin(ctx BaseModuleContext) { 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 b9d84f6cb..19513e357 100644 --- a/cc/testing.go +++ b/cc/testing.go @@ -20,6 +20,7 @@ import ( "android/soong/android" "android/soong/genrule" + "android/soong/snapshot" ) func RegisterRequiredBuildComponentsForTest(ctx android.RegistrationContext) { @@ -44,9 +45,6 @@ func GatherRequiredDepsForTest(oses ...android.OsType) string { supportLinuxBionic := false for _, os := range oses { - if os == android.Fuchsia { - ret += withFuchsiaModules() - } if os == android.Windows { ret += withWindowsModules() } @@ -471,19 +469,6 @@ func withWindowsModules() string { ` } -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 @@ var PrepareForTestOnLinuxBionic = android.GroupFixturePreparers( 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 @@ func TestConfig(buildDir string, os android.OsType, env map[string]string, 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 @@ func CreateTestContext(config android.Config) *android.TestContext { 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 1220d8432..9bba87676 100644 --- a/cc/util.go +++ b/cc/util.go @@ -21,6 +21,7 @@ import ( "strings" "android/soong/android" + "android/soong/snapshot" ) // Efficiently converts a list of include directories to a single string @@ -126,20 +127,6 @@ func makeSymlinkCmd(linkDirOnDevice string, linkName string, target string) stri "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 @@ func combineNoticesRule(ctx android.SingletonContext, paths android.Paths, out s 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 @@ func installMapListFileRule(ctx android.SingletonContext, m map[string]string, p 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 003b7c98b..ba4d79fcf 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 */ -} - -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 +// This file defines how to capture cc modules into snapshot package. - // 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 @@ func isSnapshotAware(cfg android.DeviceConfig, m LinkableInterface, inProprietar } // 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 @@ func isSnapshotAware(cfg android.DeviceConfig, m LinkableInterface, inProprietar 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 @@ func isSnapshotAware(cfg android.DeviceConfig, m LinkableInterface, inProprietar } } 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 @@ type snapshotJsonFlags struct { 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 @@ func (c *snapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) { (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 @@ func (c *snapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) { 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 @@ func (c *snapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) { // 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 @@ func (c *snapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) { 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 @@ func (c *snapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) { } 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 @@ func (c *snapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) { } } - if !isSnapshotAware(ctx.DeviceConfig(), m, inProprietaryPath, apexInfo, c.image) { + if !isSnapshotAware(ctx.DeviceConfig(), m, inProprietaryPath, apexInfo, s.Image) { return } @@ -489,8 +382,8 @@ func (c *snapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) { // 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 @@ func (c *snapshotSingleton) GenerateBuildActions(ctx android.SingletonContext) { // 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 499d4282c..1ae79de05 100644 --- a/cc/vndk.go +++ b/cc/vndk.go @@ -25,6 +25,7 @@ import ( "android/soong/android" "android/soong/cc/config" "android/soong/etc" + "android/soong/snapshot" "github.com/google/blueprint" ) @@ -698,7 +699,7 @@ func (c *vndkSnapshotSingleton) GenerateBuildActions(ctx android.SingletonContex 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 @@ func (c *vndkSnapshotSingleton) GenerateBuildActions(ctx android.SingletonContex 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 @@ func (c *vndkSnapshotSingleton) GenerateBuildActions(ctx android.SingletonContex // 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 @@ func (c *vndkSnapshotSingleton) GenerateBuildActions(ctx android.SingletonContex 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 2dcb8948e..f1f7bc74b 100644 --- a/cmd/extract_linker/main.go +++ b/cmd/extract_linker/main.go @@ -85,7 +85,7 @@ func main() { 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 @@ func main() { 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/dexpreopt/class_loader_context.go b/dexpreopt/class_loader_context.go index f76a205aa..245af2cea 100644 --- a/dexpreopt/class_loader_context.go +++ b/dexpreopt/class_loader_context.go @@ -15,6 +15,7 @@ package dexpreopt import ( + "encoding/json" "fmt" "sort" "strconv" @@ -257,6 +258,9 @@ const AnySdkVersion int = android.FutureApiLevelInt func (clcMap ClassLoaderContextMap) addContext(ctx android.ModuleInstallPathContext, sdkVer int, lib string, hostPath, installPath android.Path, nestedClcMap ClassLoaderContextMap) error { + // For prebuilts, library should have the same name as the source module. + lib = android.RemoveOptionalPrebuiltPrefix(lib) + devicePath := UnknownInstallLibraryPath if installPath == nil { if android.InList(lib, CompatUsesLibs) || android.InList(lib, OptionalCompatUsesLibs) { @@ -282,11 +286,19 @@ func (clcMap ClassLoaderContextMap) addContext(ctx android.ModuleInstallPathCont } 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) } } @@ -360,6 +372,15 @@ func (clcMap ClassLoaderContextMap) UsesLibs() (ulibs []string) { return ulibs } +func (clcMap ClassLoaderContextMap) Dump() string { + jsonCLC := toJsonClassLoaderContext(clcMap) + bytes, err := json.MarshalIndent(jsonCLC, "", " ") + if err != nil { + panic(err) + } + return string(bytes) +} + // Now that the full unconditional context is known, reconstruct conditional context. // Apply filters for individual libraries, mirroring what the PackageManager does when it // constructs class loader context on device. diff --git a/etc/Android.bp b/etc/Android.bp index cab7389b6..06a2fa15d 100644 --- a/etc/Android.bp +++ b/etc/Android.bp @@ -9,6 +9,7 @@ bootstrap_go_package { "blueprint", "soong", "soong-android", + "soong-snapshot", ], srcs: [ "prebuilt_etc.go", diff --git a/etc/prebuilt_etc.go b/etc/prebuilt_etc.go index 4dd383d77..4107916a7 100644 --- a/etc/prebuilt_etc.go +++ b/etc/prebuilt_etc.go @@ -28,12 +28,15 @@ package etc // 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 @@ var pctx = android.NewPackageContext("android/soong/etc") func init() { pctx.Import("android/soong/android") RegisterPrebuiltEtcBuildComponents(android.InitRegistrationContext) + snapshot.RegisterSnapshotAction(generatePrebuiltSnapshot) } func RegisterPrebuiltEtcBuildComponents(ctx android.RegistrationContext) { @@ -128,6 +132,9 @@ type PrebuiltEtc struct { android.ModuleBase android.DefaultableModuleBase + snapshot.VendorSnapshotModuleInterface + snapshot.RecoverySnapshotModuleInterface + properties prebuiltEtcProperties subdirProperties prebuiltSubdirProperties @@ -183,7 +190,7 @@ func (p *PrebuiltEtc) InstallInDebugRamdisk() bool { 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) onlyInRecovery() bool { } func (p *PrebuiltEtc) InstallInRecovery() bool { - return p.inRecovery() + return p.InRecovery() } var _ android.ImageInterface = (*PrebuiltEtc)(nil) @@ -271,6 +278,18 @@ func (p *PrebuiltEtc) Installable() bool { 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 @@ func (p *PrebuiltEtc) AndroidMkEntries() []android.AndroidMkEntries { 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 @@ func PrebuiltRFSAFactory() android.Module { 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 354f6bb6e..cf1f6d717 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 prepareForPrebuiltEtcTest = android.GroupFixturePreparers( }), ) +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 @@ func TestPrebuiltEtcHost(t *testing.T) { } `) - 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 @@ func TestPrebuiltUserShareHostInstallDirPath(t *testing.T) { } `) - 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 TestPrebuiltRFSADirPath(t *testing.T) { }) } } + +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 8372a6450..c26b20ced 100644 --- a/genrule/genrule.go +++ b/genrule/genrule.go @@ -68,7 +68,6 @@ func RegisterGenruleBuildComponents(ctx android.RegistrationContext) { 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 fc1ace07b..4e967ad45 100755 --- a/java/app.go +++ b/java/app.go @@ -1213,7 +1213,7 @@ func (u *usesLibrary) addLib(lib string, optional bool) { } func (u *usesLibrary) deps(ctx android.BottomUpMutatorContext, hasFrameworkLibs bool) { - if !ctx.Config().UnbundledBuild() { + if !ctx.Config().UnbundledBuild() || ctx.Config().UnbundledBuildImage() { ctx.AddVariationDependencies(nil, usesLibTag, u.usesLibraryProperties.Uses_libs...) ctx.AddVariationDependencies(nil, usesLibTag, u.presentOptionalUsesLibs(ctx)...) // Only add these extra dependencies if the module depends on framework libs. This avoids @@ -1245,36 +1245,52 @@ func replaceInList(list []string, oldstr, newstr string) { } } -// Returns a map of module names of shared library dependencies to the paths -// to their dex jars on host and on device. +// Returns a map of module names of shared library dependencies to the paths to their dex jars on +// host and on device. func (u *usesLibrary) classLoaderContextForUsesLibDeps(ctx android.ModuleContext) dexpreopt.ClassLoaderContextMap { clcMap := make(dexpreopt.ClassLoaderContextMap) - if !ctx.Config().UnbundledBuild() { - ctx.VisitDirectDeps(func(m android.Module) { - if tag, ok := ctx.OtherModuleDependencyTag(m).(usesLibraryDependencyTag); ok { - dep := ctx.OtherModuleName(m) - if lib, ok := m.(UsesLibraryDependency); ok { - libName := dep - if ulib, ok := m.(ProvidesUsesLib); ok && ulib.ProvidesUsesLib() != nil { - libName = *ulib.ProvidesUsesLib() - // Replace module name with library name in `uses_libs`/`optional_uses_libs` - // in order to pass verify_uses_libraries check (which compares these - // properties against library names written in the manifest). - replaceInList(u.usesLibraryProperties.Uses_libs, dep, libName) - replaceInList(u.usesLibraryProperties.Optional_uses_libs, dep, libName) - } - clcMap.AddContext(ctx, tag.sdkVersion, libName, - lib.DexJarBuildPath(), lib.DexJarInstallPath(), lib.ClassLoaderContexts()) - } else if ctx.Config().AllowMissingDependencies() { - ctx.AddMissingDependencies([]string{dep}) - } else { - ctx.ModuleErrorf("module %q in uses_libs or optional_uses_libs must be a java library", dep) - } - } - }) + // Skip when UnbundledBuild() is true, but UnbundledBuildImage() is false. With + // UnbundledBuildImage() it is necessary to generate dexpreopt.config for post-dexpreopting. + if ctx.Config().UnbundledBuild() && !ctx.Config().UnbundledBuildImage() { + return clcMap } + ctx.VisitDirectDeps(func(m android.Module) { + tag, isUsesLibTag := ctx.OtherModuleDependencyTag(m).(usesLibraryDependencyTag) + if !isUsesLibTag { + return + } + + 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 { + libName = *ulib.ProvidesUsesLib() + // Replace module name with library name in `uses_libs`/`optional_uses_libs` in + // order to pass verify_uses_libraries check (which compares these properties + // against library names written in the manifest). + replaceInList(u.usesLibraryProperties.Uses_libs, dep, libName) + replaceInList(u.usesLibraryProperties.Optional_uses_libs, dep, libName) + } + clcMap.AddContext(ctx, tag.sdkVersion, libName, + lib.DexJarBuildPath(), lib.DexJarInstallPath(), lib.ClassLoaderContexts()) + } else if ctx.Config().AllowMissingDependencies() { + ctx.AddMissingDependencies([]string{dep}) + } else { + ctx.ModuleErrorf("module %q in uses_libs or optional_uses_libs must be a java library", dep) + } + }) return clcMap } diff --git a/java/bootclasspath_fragment.go b/java/bootclasspath_fragment.go index bdf0daeaf..1ce9911b8 100644 --- a/java/bootclasspath_fragment.go +++ b/java/bootclasspath_fragment.go @@ -579,25 +579,9 @@ func (b *BootclasspathFragmentModule) generateHiddenAPIBuildActions(ctx android. // 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 @@ func (b *BootclasspathFragmentModule) generateHiddenAPIBuildActions(ctx android. // 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 @@ func (module *prebuiltBootclasspathFragmentModule) Name() string { // 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 @@ func (module *prebuiltBootclasspathFragmentModule) produceHiddenAPIOutput(ctx an 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.go b/java/dexpreopt.go index 2e46d74fa..0faae36ba 100644 --- a/java/dexpreopt.go +++ b/java/dexpreopt.go @@ -141,10 +141,9 @@ func (d *dexpreopter) dexpreopt(ctx android.ModuleContext, dexJarFile android.Wr } } - // If it is neither app nor test, make config files regardless of its dexpreopt setting. + // If it is test, make config files regardless of its dexpreopt setting. // The config files are required for apps defined in make which depend on the lib. - // TODO(b/158843648): The config for apps should be generated as well regardless of setting. - if (d.isApp || d.isTest) && d.dexpreoptDisabled(ctx) { + if d.isTest && d.dexpreoptDisabled(ctx) { return } diff --git a/java/dexpreopt_bootjars.go b/java/dexpreopt_bootjars.go index 19c65cac7..2c78d7362 100644 --- a/java/dexpreopt_bootjars.go +++ b/java/dexpreopt_bootjars.go @@ -154,12 +154,23 @@ import ( // PRODUCT_BOOT_JARS_EXTRA variables. The AOSP makefiles specify some common Framework libraries, // but more product-specific libraries can be added in the product makefiles. // -// Each component of the PRODUCT_BOOT_JARS and PRODUCT_BOOT_JARS_EXTRA variables is either a simple -// name (if the library is a part of the Platform), or a colon-separated pair <apex, name> (if the -// library is a part of a non-updatable APEX). +// Each component of the PRODUCT_BOOT_JARS and PRODUCT_BOOT_JARS_EXTRA variables is a +// colon-separated pair <apex>:<library>, where <apex> is the variant name of a non-updatable APEX, +// "platform" if the library is a part of the platform in the system partition, or "system_ext" if +// it's in the system_ext partition. +// +// In these variables APEXes are identified by their "variant names", i.e. the names they get +// mounted as in /apex on device. In Soong modules that is the name set in the "apex_name" +// properties, which default to the "name" values. For example, many APEXes have both +// com.android.xxx and com.google.android.xxx modules in Soong, but take the same place +// /apex/com.android.xxx at runtime. In these cases the variant name is always com.android.xxx, +// regardless which APEX goes into the product. See also android.ApexInfo.ApexVariationName and +// apex.apexBundleProperties.Apex_name. // // A related variable PRODUCT_UPDATABLE_BOOT_JARS contains bootclasspath libraries that are in -// updatable APEXes. They are not included in the boot image. +// APEXes. They are not included in the boot image. The only exception here is core-icu4j.jar that +// has been historically part of the boot image and is now in a non updatable apex; it is treated +// as being part of PRODUCT_BOOT_JARS and is in the boot image. // // One exception to the above rules are "coverage" builds (a special build flavor which requires // setting environment variable EMMA_INSTRUMENT_FRAMEWORK=true). In coverage builds the Java code in @@ -512,14 +523,14 @@ func buildBootImageVariantsForAndroidOs(ctx android.ModuleContext, image *bootIm } // 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 b13955fba..1507aaf00 100644 --- a/java/dexpreopt_config.go +++ b/java/dexpreopt_config.go @@ -32,7 +32,7 @@ func dexpreoptTargets(ctx android.PathContext) []android.Target { } } // 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 b25deceac..8dc7b798a 100644 --- a/java/dexpreopt_test.go +++ b/java/dexpreopt_test.go @@ -16,6 +16,7 @@ package java import ( "fmt" + "runtime" "testing" "android/soong/android" @@ -173,9 +174,9 @@ func enabledString(enabled bool) string { } 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 c4832d2f8..86ab8253e 100644 --- a/java/hiddenapi_modular.go +++ b/java/hiddenapi_modular.go @@ -20,7 +20,6 @@ import ( "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 @@ func (s FlagFilesByCategory) append(other FlagFilesByCategory) { } } -// 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 @@ func newHiddenAPIFlagInput() HiddenAPIFlagInput { 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 52f0770f3..404b4c133 100644 --- a/java/hiddenapi_monolithic.go +++ b/java/hiddenapi_monolithic.go @@ -58,68 +58,33 @@ func newMonolithicHiddenAPIInfo(ctx android.ModuleContext, flagFilesByCategory F // 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 be1ad874f..e38a7143b 100644 --- a/java/java.go +++ b/java/java.go @@ -21,7 +21,6 @@ package java import ( "fmt" "path/filepath" - "strings" "github.com/google/blueprint" "github.com/google/blueprint/proptools" @@ -131,11 +130,19 @@ var ( 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, } @@ -581,6 +588,10 @@ type librarySdkMemberProperties struct { JarToExport android.Path `android:"arch_variant"` AidlIncludeDirs android.Paths + + // The list of permitted packages that need to be passed to the prebuilts as they are used to + // create the updatable-bcp-packages.txt file. + PermittedPackages []string } func (p *librarySdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.Module) { @@ -589,6 +600,8 @@ func (p *librarySdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberCo p.JarToExport = ctx.MemberType().(*librarySdkMemberType).jarToExportGetter(ctx, j) p.AidlIncludeDirs = j.AidlIncludeDirs() + + p.PermittedPackages = j.PermittedPackagesForUpdatableBootJars() } func (p *librarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) { @@ -607,6 +620,10 @@ func (p *librarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberConte propertySet.AddProperty("jars", []string{snapshotRelativeJavaLibPath}) } + if len(p.PermittedPackages) > 0 { + propertySet.AddProperty("permitted_packages", p.PermittedPackages) + } + // Do not copy anything else to the snapshot. if memberType.onlyCopyJarToSnapshot { return @@ -1127,6 +1144,10 @@ type ImportProperties struct { Installable *bool + // If not empty, classes are restricted to the specified packages and their sub-packages. + // This information is used to generate the updatable-bcp-packages.txt file. + Permitted_packages []string + // List of shared java libs that this module has dependencies to Libs []string @@ -1166,7 +1187,8 @@ type Import struct { properties ImportProperties // output file containing classes.dex and resources - dexJarFile android.Path + dexJarFile android.Path + dexJarInstallFile android.Path combinedClasspathFile android.Path classLoaderContexts dexpreopt.ClassLoaderContextMap @@ -1178,6 +1200,12 @@ type Import struct { minSdkVersion android.SdkSpec } +var _ PermittedPackagesForUpdatableBootJars = (*Import)(nil) + +func (j *Import) PermittedPackagesForUpdatableBootJars() []string { + return j.properties.Permitted_packages +} + func (j *Import) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec { return android.SdkSpecFrom(ctx, String(j.properties.Sdk_version)) } @@ -1311,6 +1339,7 @@ func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) { di := ctx.OtherModuleProvider(deapexerModule, android.DeapexerProvider).(android.DeapexerInfo) if dexOutputPath := di.PrebuiltExportPath(apexRootRelativePathToJavaLib(j.BaseModuleName())); dexOutputPath != nil { j.dexJarFile = dexOutputPath + j.dexJarInstallFile = android.PathForModuleInPartitionInstall(ctx, "apex", ai.ApexVariationName, apexRootRelativePathToJavaLib(j.BaseModuleName())) // Initialize the hiddenapi structure. j.initHiddenAPI(ctx, dexOutputPath, outputFile, nil) @@ -1351,6 +1380,7 @@ func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) { dexOutputFile = j.hiddenAPIEncodeDex(ctx, dexOutputFile) j.dexJarFile = dexOutputFile + j.dexJarInstallFile = android.PathForModuleInstall(ctx, "framework", jarName) } } @@ -1392,7 +1422,7 @@ func (j *Import) DexJarBuildPath() android.Path { } func (j *Import) DexJarInstallPath() android.Path { - return nil + return j.dexJarInstallFile } func (j *Import) ClassLoaderContexts() dexpreopt.ClassLoaderContextMap { @@ -1462,11 +1492,7 @@ func (j *Import) IDECustomizedModuleName() string { // TODO(b/113562217): Extract the base module name from the Import name, often the Import name // has a prefix "prebuilt_". Remove the prefix explicitly if needed until we find a better // solution to get the Import name. - name := j.Name() - if strings.HasPrefix(name, removedPrefix) { - name = strings.TrimPrefix(name, removedPrefix) - } - return name + return android.RemoveOptionalPrebuiltPrefix(j.Name()) } var _ android.PrebuiltInterface = (*Import)(nil) @@ -1768,22 +1794,16 @@ func addCLCFromDep(ctx android.ModuleContext, depModule android.Module, 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) @@ -1793,7 +1813,7 @@ func addCLCFromDep(ctx android.ModuleContext, depModule android.Module, // 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 { @@ -1801,11 +1821,14 @@ func addCLCFromDep(ctx android.ModuleContext, depModule android.Module, 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 0f9965d03..b6780c20c 100644 --- a/java/java_test.go +++ b/java/java_test.go @@ -441,7 +441,7 @@ func TestBinary(t *testing.T) { } `) - 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 @@ func TestTest(t *testing.T) { } `) - buildOS := android.BuildOs.String() + buildOS := ctx.Config().BuildOS.String() foo := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost) @@ -523,7 +523,7 @@ func TestHostBinaryNoJavaDebugInfoOverride(t *testing.T) { } // 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 @@ func TestDataNativeBinaries(t *testing.T) { } `) - 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 @@ func TestDefaultInstallable(t *testing.T) { } `) - 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 fd2f3ca61..db3069693 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 @@ func TestKapt(t *testing.T) { 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 @@ func TestKapt(t *testing.T) { 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/lint.go b/java/lint.go index dd5e4fb13..fe3218e90 100644 --- a/java/lint.go +++ b/java/lint.go @@ -391,8 +391,9 @@ func (l *linter) lint(ctx android.ModuleContext) { rule.Command().Text("rm -f").Output(html).Output(text).Output(xml) var apiVersionsName, apiVersionsPrebuilt string - if l.compileSdkKind == android.SdkModule { - // When compiling an SDK module we use the filtered database because otherwise lint's + if l.compileSdkKind == android.SdkModule || l.compileSdkKind == android.SdkSystemServer { + // When compiling an SDK module (or system server) we use the filtered + // database because otherwise lint's // NewApi check produces too many false positives; This database excludes information // about classes created in mainline modules hence removing those false positives. apiVersionsName = "api_versions_public_filtered.xml" diff --git a/java/lint_test.go b/java/lint_test.go index 9cf1c33fe..456e6ba73 100644 --- a/java/lint_test.go +++ b/java/lint_test.go @@ -261,6 +261,9 @@ func TestJavaLintDatabaseSelectionFull(t *testing.T) { } func TestJavaLintDatabaseSelectionPublicFiltered(t *testing.T) { + testCases := []string{ + "module_current", "system_server_current", + } bp := ` java_library { name: "foo", @@ -274,17 +277,20 @@ func TestJavaLintDatabaseSelectionPublicFiltered(t *testing.T) { }, } ` - result := android.GroupFixturePreparers(PrepareForTestWithJavaDefaultModules). - RunTestWithBp(t, bp) + for _, testCase := range testCases { + thisBp := strings.Replace(bp, "XXX", testCase, 1) + result := android.GroupFixturePreparers(PrepareForTestWithJavaDefaultModules). + RunTestWithBp(t, thisBp) - foo := result.ModuleForTests("foo", "android_common") - sboxProto := android.RuleBuilderSboxProtoForTests(t, foo.Output("lint.sbox.textproto")) - if !strings.Contains(*sboxProto.Commands[0].Command, - "/api_versions_public_filtered.xml") { - t.Error("did not use public-filtered lint api database", *sboxProto.Commands[0].Command) - } - if strings.Contains(*sboxProto.Commands[0].Command, - "/api_versions.xml") { - t.Error("used full api database") + foo := result.ModuleForTests("foo", "android_common") + sboxProto := android.RuleBuilderSboxProtoForTests(t, foo.Output("lint.sbox.textproto")) + if !strings.Contains(*sboxProto.Commands[0].Command, + "/api_versions_public_filtered.xml") { + t.Error("did not use public-filtered lint api database for case", testCase) + } + if strings.Contains(*sboxProto.Commands[0].Command, + "/api_versions.xml") { + t.Error("used full api database for case", testCase) + } } } diff --git a/java/platform_bootclasspath.go b/java/platform_bootclasspath.go index c1e14b21e..8bed3e9e5 100644 --- a/java/platform_bootclasspath.go +++ b/java/platform_bootclasspath.go @@ -423,8 +423,13 @@ func (b *platformBootclasspathModule) generateBootImageBuildActions(ctx android. // 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 c7913d3db..dc29b1c3e 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 @@ func TestPlugin(t *testing.T) { } `) - 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 @@ func TestPluginGeneratesApi(t *testing.T) { } `) - 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 00f233ebf..a0c9c7fcd 100644 --- a/java/robolectric.go +++ b/java/robolectric.go @@ -83,6 +83,9 @@ type robolectricTest struct { testConfig android.Path data android.Paths + + forceOSType android.OsType + forceArchType android.ArchType } func (r *robolectricTest) TestSuites() []string { @@ -115,6 +118,9 @@ func (r *robolectricTest) DepsMutator(ctx android.BottomUpMutatorContext) { } 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) @@ -179,7 +185,7 @@ func (r *robolectricTest) GenerateAndroidBuildActions(ctx android.ModuleContext) continue } else if strings.HasSuffix(s, "/BaseRobolectricTest.java") { continue - } else if strings.HasPrefix(s, "src/") { + } else { s = strings.TrimPrefix(s, "src/") } r.tests = append(r.tests, s) @@ -345,7 +351,7 @@ func RobolectricTestFactory() android.Module { 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 @@ type robolectricRuntimes struct { props robolectricRuntimesProperties runtimes []android.InstallPath + + forceOSType android.OsType + forceArchType android.ArchType } func (r *robolectricRuntimes) TestSuites() []string { @@ -385,6 +394,9 @@ func (r *robolectricRuntimes) GenerateAndroidBuildActions(ctx android.ModuleCont 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) GenerateAndroidBuildActions(ctx android.ModuleCont 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 ed9aeffd4..268e7970d 100644 --- a/java/sdk_library.go +++ b/java/sdk_library.go @@ -981,13 +981,15 @@ func (e *EmbeddableSdkLibraryComponent) SdkLibraryName() *string { } // 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 @@ type SdkLibraryComponentDependency interface { // 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 } @@ -1897,6 +1893,10 @@ type sdkLibraryImportProperties struct { // If set to true, compile dex files for the stubs. Defaults to false. Compile_dex *bool + + // If not empty, classes are restricted to the specified packages and their sub-packages. + // This information is used to generate the updatable-bcp-packages.txt file. + Permitted_packages []string } type SdkLibraryImport struct { @@ -1923,8 +1923,12 @@ type SdkLibraryImport struct { // Is nil if the source module does not exist. xmlPermissionsFileModule *sdkLibraryXml - // Path to the dex implementation jar obtained from the prebuilt_apex, if any. + // Build path to the dex implementation jar obtained from the prebuilt_apex, if any. dexJarFile android.Path + + // Expected install file path of the source module(sdk_library) + // or dex implementation jar obtained from the prebuilt_apex, if any. + installFile android.Path } var _ SdkLibraryDependency = (*SdkLibraryImport)(nil) @@ -1991,6 +1995,12 @@ func sdkLibraryImportFactory() android.Module { return module } +var _ PermittedPackagesForUpdatableBootJars = (*SdkLibraryImport)(nil) + +func (module *SdkLibraryImport) PermittedPackagesForUpdatableBootJars() []string { + return module.properties.Permitted_packages +} + func (module *SdkLibraryImport) Prebuilt() *android.Prebuilt { return &module.prebuilt } @@ -2136,6 +2146,9 @@ func (module *SdkLibraryImport) GenerateAndroidBuildActions(ctx android.ModuleCo var deapexerModule android.Module + // Assume that source module(sdk_library) is installed in /<sdk_library partition>/framework + module.installFile = android.PathForModuleInstall(ctx, "framework", module.Stem()+".jar") + // Record the paths to the prebuilt stubs library and stubs source. ctx.VisitDirectDeps(func(to android.Module) { tag := ctx.OtherModuleDependencyTag(to) @@ -2195,6 +2208,7 @@ func (module *SdkLibraryImport) GenerateAndroidBuildActions(ctx android.ModuleCo di := ctx.OtherModuleProvider(deapexerModule, android.DeapexerProvider).(android.DeapexerInfo) if dexOutputPath := di.PrebuiltExportPath(apexRootRelativePathToJavaLib(module.BaseModuleName())); dexOutputPath != nil { module.dexJarFile = dexOutputPath + module.installFile = android.PathForModuleInPartitionInstall(ctx, "apex", ai.ApexVariationName, apexRootRelativePathToJavaLib(module.BaseModuleName())) module.initHiddenAPI(ctx, dexOutputPath, module.findScopePaths(apiScopePublic).stubsImplPath[0], nil) } else { // This should never happen as a variant for a prebuilt_apex is only created if the @@ -2249,11 +2263,7 @@ func (module *SdkLibraryImport) DexJarBuildPath() android.Path { // to satisfy UsesLibraryDependency interface func (module *SdkLibraryImport) DexJarInstallPath() android.Path { - if module.implLibraryModule == nil { - return nil - } else { - return module.implLibraryModule.DexJarInstallPath() - } + return module.installFile } // to satisfy UsesLibraryDependency interface @@ -2506,6 +2516,8 @@ type sdkLibrarySdkMemberProperties struct { // The paths to the doctag files to add to the prebuilt. Doctag_paths android.Paths + + Permitted_packages []string } type scopeProperties struct { @@ -2546,6 +2558,7 @@ func (s *sdkLibrarySdkMemberProperties) PopulateFromVariant(ctx android.SdkMembe s.Shared_library = proptools.BoolPtr(sdk.sharedLibrary()) s.Compile_dex = sdk.dexProperties.Compile_dex s.Doctag_paths = sdk.doctagPaths + s.Permitted_packages = sdk.PermittedPackagesForUpdatableBootJars() } func (s *sdkLibrarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) { @@ -2558,6 +2571,9 @@ func (s *sdkLibrarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberCo if s.Compile_dex != nil { propertySet.AddProperty("compile_dex", *s.Compile_dex) } + if len(s.Permitted_packages) > 0 { + propertySet.AddProperty("permitted_packages", s.Permitted_packages) + } for _, apiScope := range allApiScopes { if properties, ok := s.Scopes[apiScope]; ok { diff --git a/java/sdk_test.go b/java/sdk_test.go index bb595a54e..6d6213011 100644 --- a/java/sdk_test.go +++ b/java/sdk_test.go @@ -255,9 +255,11 @@ func TestClasspath(t *testing.T) { ` + 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 @@ func TestClasspath(t *testing.T) { } 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 @@ func TestClasspath(t *testing.T) { 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 @@ func TestClasspath(t *testing.T) { 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 11069d143..221014e5c 100644 --- a/rust/Android.bp +++ b/rust/Android.bp @@ -11,6 +11,7 @@ bootstrap_go_package { "soong-bloaty", "soong-cc", "soong-rust-config", + "soong-snapshot", ], srcs: [ "androidmk.go", diff --git a/rust/androidmk.go b/rust/androidmk.go index ea45ebd01..630805a85 100644 --- a/rust/androidmk.go +++ b/rust/androidmk.go @@ -205,24 +205,24 @@ func (fuzz *fuzzDecorator) AndroidMkEntries(ctx AndroidMkContext, entries *andro 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/benchmark.go b/rust/benchmark.go index b89f5cd9b..0e842435d 100644 --- a/rust/benchmark.go +++ b/rust/benchmark.go @@ -101,6 +101,7 @@ func (benchmark *benchmarkDecorator) compilerFlags(ctx ModuleContext, flags Flag func (benchmark *benchmarkDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps { deps = benchmark.binaryDecorator.compilerDeps(ctx, deps) + deps.Rustlibs = append(deps.Rustlibs, "libtest") deps.Rustlibs = append(deps.Rustlibs, "libcriterion") return deps diff --git a/rust/binary_test.go b/rust/binary_test.go index 86f50d3e4..968c0c1ff 100644 --- a/rust/binary_test.go +++ b/rust/binary_test.go @@ -114,6 +114,23 @@ func TestBinaryFlags(t *testing.T) { } } +// 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/bindgen.go b/rust/bindgen.go index f9e6cd0a3..3470e51fe 100644 --- a/rust/bindgen.go +++ b/rust/bindgen.go @@ -137,15 +137,15 @@ func (b *bindgenDecorator) GenerateSource(ctx ModuleContext, deps PathDeps) andr implicits = append(implicits, deps.depGeneratedHeaders...) // Default clang flags - cflags = append(cflags, "${cc_config.CommonClangGlobalCflags}") + cflags = append(cflags, "${cc_config.CommonGlobalCflags}") if ctx.Device() { - cflags = append(cflags, "${cc_config.DeviceClangGlobalCflags}") + cflags = append(cflags, "${cc_config.DeviceGlobalCflags}") } // Toolchain clang flags cflags = append(cflags, "-target "+ccToolchain.ClangTriple()) - cflags = append(cflags, strings.ReplaceAll(ccToolchain.ClangCflags(), "${config.", "${cc_config.")) - cflags = append(cflags, strings.ReplaceAll(ccToolchain.ToolchainClangCflags(), "${config.", "${cc_config.")) + cflags = append(cflags, strings.ReplaceAll(ccToolchain.Cflags(), "${config.", "${cc_config.")) + cflags = append(cflags, strings.ReplaceAll(ccToolchain.ToolchainCflags(), "${config.", "${cc_config.")) // Dependency clang flags and include paths cflags = append(cflags, deps.depClangFlags...) diff --git a/rust/builder.go b/rust/builder.go index 6db508d64..523428db2 100644 --- a/rust/builder.go +++ b/rust/builder.go @@ -220,6 +220,15 @@ func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, fl 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 0b28135ae..df77759d6 100644 --- a/rust/compiler.go +++ b/rust/compiler.go @@ -305,7 +305,7 @@ func (compiler *baseCompiler) compilerDeps(ctx DepsContext, deps Deps) Deps { 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 31ec3f12c..f568f276d 100644 --- a/rust/config/allowed_list.go +++ b/rust/config/allowed_list.go @@ -6,6 +6,7 @@ var ( // for an example. // TODO(b/160223496): enable rustfmt globally. RustAllowedPaths = []string{ + "bionic/libc", "device/google/cuttlefish", "external/adhd", "external/crosvm", diff --git a/rust/config/global.go b/rust/config/global.go index 43b49d18b..1b56237b3 100644 --- a/rust/config/global.go +++ b/rust/config/global.go @@ -29,7 +29,6 @@ var ( DefaultEdition = "2018" Stdlibs = []string{ "libstd", - "libtest", } // Mapping between Soong internal arch types and std::env constants. diff --git a/rust/config/x86_darwin_host.go b/rust/config/x86_darwin_host.go index ddd93e889..8ff0dd4be 100644 --- a/rust/config/x86_darwin_host.go +++ b/rust/config/x86_darwin_host.go @@ -78,7 +78,7 @@ func (t *toolchainDarwin) ProcMacroSuffix() string { func (t *toolchainDarwinX8664) ToolchainLinkFlags() string { // Prepend the lld flags from cc_config so we stay in sync with cc - return "${cc_config.DarwinClangLldflags} ${config.DarwinToolchainLinkFlags} ${config.DarwinToolchainX8664LinkFlags}" + return "${cc_config.DarwinLldflags} ${config.DarwinToolchainLinkFlags} ${config.DarwinToolchainX8664LinkFlags}" } func (t *toolchainDarwinX8664) ToolchainRustFlags() string { diff --git a/rust/config/x86_device.go b/rust/config/x86_device.go index aae11252f..5ae30e7d3 100644 --- a/rust/config/x86_device.go +++ b/rust/config/x86_device.go @@ -65,7 +65,7 @@ func (t *toolchainX86) RustTriple() string { func (t *toolchainX86) ToolchainLinkFlags() string { // Prepend the lld flags from cc_config so we stay in sync with cc - return "${config.DeviceGlobalLinkFlags} ${cc_config.X86ClangLldflags} ${config.X86ToolchainLinkFlags}" + return "${config.DeviceGlobalLinkFlags} ${cc_config.X86Lldflags} ${config.X86ToolchainLinkFlags}" } func (t *toolchainX86) ToolchainRustFlags() string { diff --git a/rust/config/x86_linux_host.go b/rust/config/x86_linux_host.go index b63e14d25..a9fdaed45 100644 --- a/rust/config/x86_linux_host.go +++ b/rust/config/x86_linux_host.go @@ -79,7 +79,7 @@ func (t *toolchainLinuxX8664) RustTriple() string { func (t *toolchainLinuxX8664) ToolchainLinkFlags() string { // Prepend the lld flags from cc_config so we stay in sync with cc - return "${cc_config.LinuxClangLldflags} ${cc_config.LinuxX8664ClangLldflags} " + + return "${cc_config.LinuxLldflags} ${cc_config.LinuxX8664Lldflags} " + "${config.LinuxToolchainLinkFlags} ${config.LinuxToolchainX8664LinkFlags}" } @@ -117,7 +117,7 @@ func (t *toolchainLinuxX86) RustTriple() string { func (t *toolchainLinuxX86) ToolchainLinkFlags() string { // Prepend the lld flags from cc_config so we stay in sync with cc - return "${cc_config.LinuxClangLldflags} ${cc_config.LinuxX86ClangLldflags} " + + return "${cc_config.LinuxLldflags} ${cc_config.LinuxX86Lldflags} " + "${config.LinuxToolchainLinkFlags} ${config.LinuxToolchainX86LinkFlags}" } diff --git a/rust/fuzz.go b/rust/fuzz.go index 7e1c55a50..18b25130f 100644 --- a/rust/fuzz.go +++ b/rust/fuzz.go @@ -32,13 +32,7 @@ func init() { 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) compilerDeps(ctx DepsContext, deps Deps) Deps { 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 @@ func (fuzzer *fuzzDecorator) autoDep(ctx android.BottomUpMutatorContext) autoDep // 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,20 +117,12 @@ func (s *rustFuzzPackager) GenerateBuildActions(ctx android.SingletonContext) { return } - fuzzModule, ok := rustModule.compiler.(*fuzzDecorator) - if !ok { + if ok := cc.IsValid(rustModule.FuzzModule); !ok || rustModule.Properties.PreventInstall { 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() { + fuzzModule, ok := rustModule.compiler.(*fuzzDecorator) + if !ok { return } @@ -160,126 +133,34 @@ func (s *rustFuzzPackager) GenerateBuildActions(ctx android.SingletonContext) { 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(), ""}) - - // The dictionary. - if fuzzModule.dictionary != nil { - files = append(files, fileToZip{fuzzModule.dictionary, ""}) - } + files = append(files, cc.FileToZip{rustModule.unstrippedOutputFile.Path(), ""}) - // 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 - } + archDirs[archOs], ok = s.BuildZipFile(ctx, module, fuzzModule.fuzzPackagedModule, files, builder, archDir, archString, hostOrTargetString, archOs, archDirs) + if !ok { + 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 @@ func (fuzz *fuzzDecorator) install(ctx ModuleContext) { "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 747a29d72..8c10e298b 100644 --- a/rust/library.go +++ b/rust/library.go @@ -21,6 +21,7 @@ import ( "android/soong/android" "android/soong/cc" + "android/soong/snapshot" ) var ( @@ -431,6 +432,12 @@ func (library *libraryDecorator) sharedLibFilename(ctx ModuleContext) string { 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 @@ func LibraryMutator(mctx android.BottomUpMutatorContext) { 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 54cd2a5b3..cb4ef7eec 100644 --- a/rust/library_test.go +++ b/rust/library_test.go @@ -85,6 +85,22 @@ func TestDylibPreferDynamic(t *testing.T) { } } +// 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 09d30dbde..bdd54c59b 100644 --- a/rust/project_json_test.go +++ b/rust/project_json_test.go @@ -176,6 +176,8 @@ func TestProjectJsonBinary(t *testing.T) { } func TestProjectJsonBindGen(t *testing.T) { + buildOS := android.TestConfig(t.TempDir(), nil, "", nil).BuildOS + bp := ` rust_library { name: "libd", @@ -214,9 +216,9 @@ func TestProjectJsonBindGen(t *testing.T) { 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 38f1742d4..931cb9dde 100644 --- a/rust/rust.go +++ b/rust/rust.go @@ -85,6 +85,10 @@ type BaseProperties struct { 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 BaseProperties struct { } type Module struct { - android.ModuleBase - android.DefaultableModuleBase - android.ApexModuleBase + cc.FuzzModule VendorProperties cc.VendorProperties @@ -290,7 +292,7 @@ func (mod *Module) UseVndk() bool { } 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 2f549738c..79eaab382 100644 --- a/rust/snapshot_prebuilt.go +++ b/rust/snapshot_prebuilt.go @@ -17,6 +17,7 @@ package rust import ( "android/soong/android" "android/soong/cc" + "github.com/google/blueprint/proptools" ) diff --git a/rust/test.go b/rust/test.go index 6caa7b168..e95b47cff 100644 --- a/rust/test.go +++ b/rust/test.go @@ -169,3 +169,11 @@ func RustTestHostFactory() android.Module { func (test *testDecorator) stdLinkage(ctx *depsContext) RustLinkage { return RlibLinkage } + +func (test *testDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps { + deps = test.binaryDecorator.compilerDeps(ctx, deps) + + deps.Rustlibs = append(deps.Rustlibs, "libtest") + + return deps +} diff --git a/rust/testing.go b/rust/testing.go index 72f87e136..94cdd9dcd 100644 --- a/rust/testing.go +++ b/rust/testing.go @@ -170,12 +170,10 @@ func GatherRequiredDepsForTest() string { name: "libtest", crate_name: "test", srcs: ["foo.rs"], - no_stdlibs: true, host_supported: true, vendor_available: true, vendor_ramdisk_available: true, native_coverage: false, - sysroot: true, apex_available: ["//apex_available:platform", "//apex_available:anyapex"], min_sdk_version: "29", } diff --git a/rust/vendor_snapshot_test.go b/rust/vendor_snapshot_test.go index 815f80ec7..60ddb653f 100644 --- a/rust/vendor_snapshot_test.go +++ b/rust/vendor_snapshot_test.go @@ -569,7 +569,6 @@ func TestVendorSnapshotUse(t *testing.T) { ], rlibs: [ "libstd", - "libtest", "librust_vendor_available", ], binaries: [ @@ -597,7 +596,6 @@ func TestVendorSnapshotUse(t *testing.T) { ], rlibs: [ "libstd", - "libtest", "librust_vendor_available", ], binaries: [ @@ -665,22 +663,6 @@ func TestVendorSnapshotUse(t *testing.T) { } vendor_snapshot_rlib { - name: "libtest", - version: "30", - target_arch: "arm64", - vendor: true, - sysroot: true, - arch: { - arm64: { - src: "libtest.rlib", - }, - arm: { - src: "libtest.rlib", - }, - }, - } - - vendor_snapshot_rlib { name: "librust_vendor_available", version: "30", target_arch: "arm64", @@ -917,7 +899,6 @@ func TestVendorSnapshotUse(t *testing.T) { "vendor/lib64.so": nil, "vendor/liblog.so": nil, "vendor/libstd.rlib": nil, - "vendor/libtest.rlib": nil, "vendor/librust_vendor_available.rlib": nil, "vendor/crtbegin_so.o": nil, "vendor/crtend_so.o": nil, @@ -962,7 +943,7 @@ func TestVendorSnapshotUse(t *testing.T) { } libclientAndroidMkRlibs := ctx.ModuleForTests("libclient", sharedVariant).Module().(*Module).Properties.AndroidMkRlibs - if g, w := libclientAndroidMkRlibs, []string{"librust_vendor_available.vendor_rlib.30.arm64.rlib-std", "libstd.vendor_rlib.30.arm64", "libtest.vendor_rlib.30.arm64"}; !reflect.DeepEqual(g, w) { + if g, w := libclientAndroidMkRlibs, []string{"librust_vendor_available.vendor_rlib.30.arm64.rlib-std", "libstd.vendor_rlib.30.arm64"}; !reflect.DeepEqual(g, w) { t.Errorf("wanted libclient libclientAndroidMkRlibs %q, got %q", w, g) } @@ -977,7 +958,7 @@ func TestVendorSnapshotUse(t *testing.T) { } libclientRustAndroidMkRlibs := ctx.ModuleForTests("libclient_rust", rlibVariant).Module().(*Module).Properties.AndroidMkRlibs - if g, w := libclientRustAndroidMkRlibs, []string{"librust_vendor_available.vendor_rlib.30.arm64.rlib-std", "libstd.vendor_rlib.30.arm64", "libtest.vendor_rlib.30.arm64"}; !reflect.DeepEqual(g, w) { + if g, w := libclientRustAndroidMkRlibs, []string{"librust_vendor_available.vendor_rlib.30.arm64.rlib-std", "libstd.vendor_rlib.30.arm64"}; !reflect.DeepEqual(g, w) { t.Errorf("wanted libclient libclientAndroidMkRlibs %q, got %q", w, g) } diff --git a/scripts/hiddenapi/Android.bp b/scripts/hiddenapi/Android.bp index 7472f528b..c50dc24fd 100644 --- a/scripts/hiddenapi/Android.bp +++ b/scripts/hiddenapi/Android.bp @@ -48,6 +48,27 @@ python_binary_host { }, } +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 ff3d70881..b81424b7a 100755 --- a/scripts/hiddenapi/generate_hiddenapi_lists_test.py +++ b/scripts/hiddenapi/generate_hiddenapi_lists_test.py @@ -101,4 +101,4 @@ class TestHiddenapiListGeneration(unittest.TestCase): 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 8168fbf6a..4ef4399ca 100755 --- a/scripts/manifest_check.py +++ b/scripts/manifest_check.py @@ -90,6 +90,15 @@ def enforce_uses_libraries(manifest, required, optional, relax, is_apk, path): 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 @@ def enforce_uses_libraries(manifest, required, optional, relax, is_apk, path): 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 7159bdd74..e3e8ac468 100755 --- a/scripts/manifest_check_test.py +++ b/scripts/manifest_check_test.py @@ -183,6 +183,15 @@ class EnforceUsesLibrariesTest(unittest.TestCase): 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 a458cba7d..efd2b5bd9 100644 --- a/sdk/bootclasspath_fragment_sdk_test.go +++ b/sdk/bootclasspath_fragment_sdk_test.go @@ -133,6 +133,13 @@ prebuilt_bootclasspath_fragment { 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 @@ java_import { 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 @@ prebuilt_bootclasspath_fragment { 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 @@ java_import { 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 @@ sdk_snapshot { } `), 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,8 @@ java_import { 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"], } java_sdk_library_import { @@ -336,6 +356,7 @@ java_sdk_library_import { apex_available: ["myapex"], shared_library: true, compile_dex: true, + permitted_packages: ["myothersdklibrary"], public: { jars: ["sdk_library/public/myothersdklibrary-stubs.jar"], stub_srcs: ["sdk_library/public/myothersdklibrary_stub_sources"], @@ -408,7 +429,8 @@ java_import { 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"], } java_sdk_library_import { @@ -418,6 +440,7 @@ java_sdk_library_import { apex_available: ["myapex"], shared_library: true, compile_dex: true, + permitted_packages: ["myothersdklibrary"], public: { jars: ["sdk_library/public/myothersdklibrary-stubs.jar"], stub_srcs: ["sdk_library/public/myothersdklibrary_stub_sources"], @@ -476,7 +499,7 @@ sdk_snapshot { .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 @@ -509,6 +532,12 @@ sdk_snapshot { out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv snapshot/hiddenapi/index.csv `, rule) + + // Make sure that the permitted packages from the prebuilts end up in the + // updatable-bcp-packages.txt file. + rule = module.Output("updatable-bcp-packages.txt") + expectedContents := `'mybootlib\nmyothersdklibrary\n'` + android.AssertStringEquals(t, "updatable-bcp-packages.txt", expectedContents, rule.Args["content"]) }), snapshotTestPreparer(checkSnapshotWithSourcePreferred, preparerForSnapshot), snapshotTestPreparer(checkSnapshotPreferredWithSource, preparerForSnapshot), @@ -779,6 +808,7 @@ func TestSnapshotWithBootclasspathFragment_HiddenAPI(t *testing.T) { srcs: ["Test.java"], compile_dex: true, public: {enabled: true}, + permitted_packages: ["mysdklibrary"], } `), ).RunTest(t) @@ -821,7 +851,8 @@ java_import { 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"], } java_sdk_library_import { @@ -831,6 +862,7 @@ java_sdk_library_import { apex_available: ["//apex_available:platform"], shared_library: true, compile_dex: true, + permitted_packages: ["mysdklibrary"], public: { jars: ["sdk_library/public/mysdklibrary-stubs.jar"], stub_srcs: ["sdk_library/public/mysdklibrary_stub_sources"], @@ -854,7 +886,7 @@ my-unsupported-packages.txt -> hiddenapi/my-unsupported-packages.txt .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 a2cfe6d16..9efb3a49a 100644 --- a/sdk/java_sdk_test.go +++ b/sdk/java_sdk_test.go @@ -175,6 +175,7 @@ func TestSnapshotWithJavaHeaderLibrary(t *testing.T) { sdk_version: "none", compile_dex: true, host_supported: true, + permitted_packages: ["pkg.myjavalib"], } `) @@ -188,6 +189,7 @@ java_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:platform"], jars: ["java/myjavalib.jar"], + permitted_packages: ["pkg.myjavalib"], } `), checkVersionedAndroidBpContents(` @@ -199,6 +201,7 @@ java_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:platform"], jars: ["java/myjavalib.jar"], + permitted_packages: ["pkg.myjavalib"], } sdk_snapshot { @@ -437,6 +440,7 @@ func TestSnapshotWithJavaBootLibrary(t *testing.T) { system_modules: "none", sdk_version: "none", compile_dex: true, + permitted_packages: ["pkg.myjavalib"], } `) @@ -449,7 +453,8 @@ java_import { 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"], } `), checkVersionedAndroidBpContents(` @@ -460,7 +465,8 @@ java_import { 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"], } module_exports_snapshot { @@ -468,9 +474,10 @@ module_exports_snapshot { 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 `), ) } @@ -1045,6 +1052,7 @@ func TestSnapshotWithJavaSdkLibrary(t *testing.T) { shared_library: false, stubs_library_visibility: ["//other"], stubs_source_visibility: ["//another"], + permitted_packages: ["pkg.myjavalib"], } `) @@ -1058,6 +1066,7 @@ java_sdk_library_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:anyapex"], shared_library: false, + permitted_packages: ["pkg.myjavalib"], public: { jars: ["sdk_library/public/myjavalib-stubs.jar"], stub_srcs: ["sdk_library/public/myjavalib_stub_sources"], @@ -1090,6 +1099,7 @@ java_sdk_library_import { visibility: ["//visibility:public"], apex_available: ["//apex_available:anyapex"], shared_library: false, + permitted_packages: ["pkg.myjavalib"], public: { jars: ["sdk_library/public/myjavalib-stubs.jar"], stub_srcs: ["sdk_library/public/myjavalib_stub_sources"], diff --git a/sdk/sdk_test.go b/sdk/sdk_test.go index a13b0d7d0..85e3d875e 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) } @@ -565,6 +567,49 @@ sdk_snapshot { ) }) + t.Run("SOONG_SDK_SNAPSHOT_USE_SOURCE_CONFIG_VAR=module:build_from_source", func(t *testing.T) { + result := android.GroupFixturePreparers( + preparer, + android.FixtureMergeEnv(map[string]string{ + "SOONG_SDK_SNAPSHOT_USE_SOURCE_CONFIG_VAR": "module:build_from_source", + }), + ).RunTest(t) + + checkZipFile(t, result, "out/soong/.intermediates/mysdk/common_os/mysdk-current.zip") + + CheckSnapshot(t, result, "mysdk", "", + checkAndroidBpContents(` +// This is auto-generated. DO NOT EDIT. + +java_import { + name: "mysdk_myjavalib@current", + sdk_member_name: "myjavalib", + visibility: ["//visibility:public"], + apex_available: ["//apex_available:platform"], + jars: ["java/myjavalib.jar"], +} + +java_import { + name: "myjavalib", + prefer: false, + use_source_config_var: { + config_namespace: "module", + var_name: "build_from_source", + }, + visibility: ["//visibility:public"], + apex_available: ["//apex_available:platform"], + jars: ["java/myjavalib.jar"], +} + +sdk_snapshot { + name: "mysdk@current", + visibility: ["//visibility:public"], + java_header_libs: ["mysdk_myjavalib@current"], +} + `), + ) + }) + t.Run("SOONG_SDK_SNAPSHOT_VERSION=unversioned", func(t *testing.T) { result := android.GroupFixturePreparers( preparer, diff --git a/sdk/update.go b/sdk/update.go index b146b62c8..1cd8f135a 100644 --- a/sdk/update.go +++ b/sdk/update.go @@ -22,6 +22,7 @@ import ( "android/soong/apex" "android/soong/cc" + "github.com/google/blueprint" "github.com/google/blueprint/proptools" @@ -35,6 +36,37 @@ import ( // By default every unversioned module in the generated snapshot has prefer: false. Building it // with SOONG_SDK_SNAPSHOT_PREFER=true will force them to use prefer: true. // +// SOONG_SDK_SNAPSHOT_USE_SOURCE_CONFIG_VAR +// If set this specifies the Soong config var that can be used to control whether the prebuilt +// modules from the generated snapshot or the original source modules. Values must be a colon +// separated pair of strings, the first of which is the Soong config namespace, and the second +// is the name of the variable within that namespace. +// +// The config namespace and var name are used to set the `use_source_config_var` property. That +// in turn will cause the generated prebuilts to use the soong config variable to select whether +// source or the prebuilt is used. +// e.g. If an sdk snapshot is built using: +// m SOONG_SDK_SNAPSHOT_USE_SOURCE_CONFIG_VAR=acme:build_from_source sdkextensions-sdk +// Then the resulting snapshot will include: +// use_source_config_var: { +// config_namespace: "acme", +// var_name: "build_from_source", +// } +// +// Assuming that the config variable is defined in .mk using something like: +// $(call add_soong_config_namespace,acme) +// $(call add_soong_config_var_value,acme,build_from_source,true) +// +// Then when the snapshot is unpacked in the repository it will have the following behavior: +// m droid - will use the sdkextensions-sdk prebuilts if present. Otherwise, it will use the +// sources. +// m SOONG_CONFIG_acme_build_from_source=true droid - will use the sdkextensions-sdk +// sources, if present. Otherwise, it will use the prebuilts. +// +// This is a temporary mechanism to control the prefer flags and will be removed once a more +// maintainable solution has been implemented. +// TODO(b/174997203): Remove when no longer necessary. +// // SOONG_SDK_SNAPSHOT_VERSION // This provides control over the version of the generated snapshot. // @@ -760,6 +792,8 @@ func (t unversionedToVersionedTransformation) transformModule(module *bpModule) module.insertAfter("name", "sdk_member_name", name) // Remove the prefer property if present as versioned modules never need marking with prefer. module.removeProperty("prefer") + // Ditto for use_source_config_var + module.removeProperty("use_source_config_var") return module } @@ -996,6 +1030,9 @@ type snapshotBuilder struct { filesToZip android.Paths zipsToMerge android.Paths + // The path to an empty file. + emptyFile android.WritablePath + prebuiltModules map[string]*bpModule prebuiltOrder []*bpModule @@ -1046,6 +1083,19 @@ func (s *snapshotBuilder) UnzipToSnapshot(zipPath android.Path, destDir string) 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 { @@ -1627,13 +1677,24 @@ func (s *sdk) createMemberSnapshot(ctx *memberContext, member *sdkMember, bpModu // snapshot to be created that sets prefer: true. // TODO(b/174997203): Remove once the ability to select the modules to prefer can be done // dynamically at build time not at snapshot generation time. - prefer := ctx.sdkMemberContext.Config().IsEnvTrue("SOONG_SDK_SNAPSHOT_PREFER") + config := ctx.sdkMemberContext.Config() + prefer := config.IsEnvTrue("SOONG_SDK_SNAPSHOT_PREFER") // Set prefer. Setting this to false is not strictly required as that is the default but it does // provide a convenient hook to post-process the generated Android.bp file, e.g. in tests to // check the behavior when a prebuilt is preferred. It also makes it explicit what the default // behavior is for the module. bpModule.insertAfter("name", "prefer", prefer) + + configVar := config.Getenv("SOONG_SDK_SNAPSHOT_USE_SOURCE_CONFIG_VAR") + if configVar != "" { + parts := strings.Split(configVar, ":") + cfp := android.ConfigVarProperties{ + Config_namespace: proptools.StringPtr(parts[0]), + Var_name: proptools.StringPtr(parts[1]), + } + bpModule.insertAfter("prefer", "use_source_config_var", cfp) + } } // Group the variants by os type. @@ -1714,7 +1775,7 @@ func (s *sdk) getPossibleOsTypes() []android.OsType { 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 20317d88c..865d5f3d1 100644 --- a/sh/sh_binary_test.go +++ b/sh/sh_binary_test.go @@ -115,7 +115,7 @@ func TestShTest_dataModules(t *testing.T) { } `) - 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 @@ func TestShTestHost(t *testing.T) { } `) - 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 @@ func TestShTestHost_dataDeviceModules(t *testing.T) { } `) - 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 000000000..f17ac532a --- /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 000000000..9b3919c34 --- /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 000000000..294f8b611 --- /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 000000000..de93f3eb0 --- /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 000000000..2297dfc2b --- /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 000000000..9bd26c201 --- /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) +} diff --git a/ui/build/config.go b/ui/build/config.go index 737062732..cd6d549ea 100644 --- a/ui/build/config.go +++ b/ui/build/config.go @@ -345,12 +345,7 @@ func storeConfigMetrics(ctx Context, config Config) { return } - b := &smpb.BuildConfig{ - ForceUseGoma: proto.Bool(config.ForceUseGoma()), - UseGoma: proto.Bool(config.UseGoma()), - UseRbe: proto.Bool(config.UseRBE()), - } - ctx.Metrics.BuildConfig(b) + ctx.Metrics.BuildConfig(buildConfig(config)) s := &smpb.SystemResourceInfo{ TotalPhysicalMemory: proto.Uint64(config.TotalRAM()), @@ -359,6 +354,16 @@ func storeConfigMetrics(ctx Context, config Config) { ctx.Metrics.SystemResourceInfo(s) } +func buildConfig(config Config) *smpb.BuildConfig { + return &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(config.ForceUseGoma()), + UseGoma: proto.Bool(config.UseGoma()), + UseRbe: proto.Bool(config.UseRBE()), + BazelAsNinja: proto.Bool(config.UseBazel()), + BazelMixedBuild: proto.Bool(config.bazelBuildMode() == mixedBuild), + } +} + // getConfigArgs processes the command arguments based on the build action and creates a set of new // arguments to be accepted by Config. func getConfigArgs(action BuildAction, dir string, ctx Context, args []string) []string { diff --git a/ui/build/config_test.go b/ui/build/config_test.go index 7b14c4703..7d4c76b83 100644 --- a/ui/build/config_test.go +++ b/ui/build/config_test.go @@ -26,7 +26,10 @@ import ( "testing" "android/soong/ui/logger" + smpb "android/soong/ui/metrics/metrics_proto" "android/soong/ui/status" + + "github.com/golang/protobuf/proto" ) func testContext() Context { @@ -995,3 +998,111 @@ func TestGetConfigArgsBuildModulesInDirectories(t *testing.T) { }) } } + +func TestBuildConfig(t *testing.T) { + tests := []struct { + name string + environ Environment + useBazel bool + expectedBuildConfig *smpb.BuildConfig + }{ + { + name: "none set", + environ: Environment{}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "force use goma", + environ: Environment{"FORCE_USE_GOMA=1"}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(true), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "use goma", + environ: Environment{"USE_GOMA=1"}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(true), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "use rbe", + environ: Environment{"USE_RBE=1"}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(true), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "use bazel as ninja", + environ: Environment{}, + useBazel: true, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(true), + BazelMixedBuild: proto.Bool(false), + }, + }, + { + name: "bazel mixed build", + environ: Environment{"USE_BAZEL_ANALYSIS=1"}, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(false), + UseGoma: proto.Bool(false), + UseRbe: proto.Bool(false), + BazelAsNinja: proto.Bool(false), + BazelMixedBuild: proto.Bool(true), + }, + }, + { + name: "all set", + environ: Environment{ + "FORCE_USE_GOMA=1", + "USE_GOMA=1", + "USE_RBE=1", + "USE_BAZEL_ANALYSIS=1", + }, + useBazel: true, + expectedBuildConfig: &smpb.BuildConfig{ + ForceUseGoma: proto.Bool(true), + UseGoma: proto.Bool(true), + UseRbe: proto.Bool(true), + BazelAsNinja: proto.Bool(true), + BazelMixedBuild: proto.Bool(true), + }, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + c := &configImpl{ + environ: &tc.environ, + useBazel: tc.useBazel, + } + config := Config{c} + actualBuildConfig := buildConfig(config) + if expected := tc.expectedBuildConfig; !proto.Equal(expected, actualBuildConfig) { + t.Errorf("Expected build config != actual build config: %#v != %#v", *expected, *actualBuildConfig) + } + }) + } +} diff --git a/ui/build/dumpvars.go b/ui/build/dumpvars.go index 83c8865de..f3c442ec8 100644 --- a/ui/build/dumpvars.go +++ b/ui/build/dumpvars.go @@ -163,6 +163,7 @@ var BannerVars = []string{ "AUX_OS_VARIANT_LIST", "PRODUCT_SOONG_NAMESPACES", "SOONG_SDK_SNAPSHOT_PREFER", + "SOONG_SDK_SNAPSHOT_USE_SOURCE_CONFIG_VAR", "SOONG_SDK_SNAPSHOT_VERSION", } diff --git a/ui/metrics/metrics_proto/metrics.pb.go b/ui/metrics/metrics_proto/metrics.pb.go index fc2cfa492..106333707 100644 --- a/ui/metrics/metrics_proto/metrics.pb.go +++ b/ui/metrics/metrics_proto/metrics.pb.go @@ -433,9 +433,14 @@ func (m *MetricsBase) GetBazelRuns() []*PerfInfo { } type BuildConfig struct { - UseGoma *bool `protobuf:"varint,1,opt,name=use_goma,json=useGoma" json:"use_goma,omitempty"` - UseRbe *bool `protobuf:"varint,2,opt,name=use_rbe,json=useRbe" json:"use_rbe,omitempty"` - ForceUseGoma *bool `protobuf:"varint,3,opt,name=force_use_goma,json=forceUseGoma" json:"force_use_goma,omitempty"` + UseGoma *bool `protobuf:"varint,1,opt,name=use_goma,json=useGoma" json:"use_goma,omitempty"` + UseRbe *bool `protobuf:"varint,2,opt,name=use_rbe,json=useRbe" json:"use_rbe,omitempty"` + ForceUseGoma *bool `protobuf:"varint,3,opt,name=force_use_goma,json=forceUseGoma" json:"force_use_goma,omitempty"` + // Whether the Bazel is acting as the Ninja executor for this build. + BazelAsNinja *bool `protobuf:"varint,4,opt,name=bazel_as_ninja,json=bazelAsNinja" json:"bazel_as_ninja,omitempty"` + // Whether build is occurring in a mixed build mode, where Bazel maintains the + // definition and build of some modules in cooperation with Soong. + BazelMixedBuild *bool `protobuf:"varint,5,opt,name=bazel_mixed_build,json=bazelMixedBuild" json:"bazel_mixed_build,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -487,6 +492,20 @@ func (m *BuildConfig) GetForceUseGoma() bool { return false } +func (m *BuildConfig) GetBazelAsNinja() bool { + if m != nil && m.BazelAsNinja != nil { + return *m.BazelAsNinja + } + return false +} + +func (m *BuildConfig) GetBazelMixedBuild() bool { + if m != nil && m.BazelMixedBuild != nil { + return *m.BazelMixedBuild + } + return false +} + type SystemResourceInfo struct { // The total physical memory in bytes. TotalPhysicalMemory *uint64 `protobuf:"varint,1,opt,name=total_physical_memory,json=totalPhysicalMemory" json:"total_physical_memory,omitempty"` @@ -990,92 +1009,94 @@ func init() { } var fileDescriptor_6039342a2ba47b72 = []byte{ - // 1380 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xef, 0x52, 0x1b, 0x37, - 0x10, 0x8f, 0xc1, 0x60, 0x7b, 0xfd, 0x07, 0x23, 0xa0, 0x5c, 0x48, 0xd2, 0x52, 0xb7, 0x49, 0x99, - 0x4e, 0x43, 0x32, 0x34, 0xc3, 0x64, 0x98, 0x4c, 0xa7, 0xe0, 0xd0, 0x34, 0x65, 0xc0, 0x8c, 0x08, - 0x69, 0xda, 0x7e, 0x50, 0xe5, 0xb3, 0x0c, 0x97, 0xdc, 0x9d, 0x6e, 0x24, 0x1d, 0xc5, 0x79, 0xb3, - 0x7e, 0xee, 0x4b, 0xf4, 0x05, 0xfa, 0x04, 0x7d, 0x81, 0x8e, 0x56, 0x77, 0xe6, 0x20, 0x6e, 0xc2, - 0xe4, 0xdb, 0xe9, 0xb7, 0xbf, 0xdf, 0x6a, 0xb5, 0xd2, 0xee, 0xda, 0xd0, 0x8c, 0x84, 0x51, 0x81, - 0xaf, 0xd7, 0x13, 0x25, 0x8d, 0x24, 0x0b, 0x5a, 0xca, 0xf8, 0x84, 0xf5, 0xd3, 0x20, 0x1c, 0xb0, - 0xcc, 0xd4, 0xf9, 0xbb, 0x01, 0xf5, 0x7d, 0xf7, 0xbd, 0xc3, 0xb5, 0x20, 0x0f, 0x61, 0xd1, 0x11, - 0x06, 0xdc, 0x08, 0x66, 0x82, 0x48, 0x68, 0xc3, 0xa3, 0xc4, 0x2b, 0xad, 0x96, 0xd6, 0xa6, 0x29, - 0x41, 0xdb, 0x53, 0x6e, 0xc4, 0x8b, 0xdc, 0x42, 0x6e, 0x42, 0xd5, 0x29, 0x82, 0x81, 0x37, 0xb5, - 0x5a, 0x5a, 0xab, 0xd1, 0x0a, 0xae, 0x9f, 0x0f, 0xc8, 0x16, 0xdc, 0x4c, 0x42, 0x6e, 0x86, 0x52, - 0x45, 0xec, 0x4c, 0x28, 0x1d, 0xc8, 0x98, 0xf9, 0x72, 0x20, 0x62, 0x1e, 0x09, 0x6f, 0x1a, 0xb9, - 0xcb, 0x39, 0xe1, 0xa5, 0xb3, 0x77, 0x33, 0x33, 0xb9, 0x0b, 0x2d, 0xc3, 0xd5, 0x89, 0x30, 0x2c, - 0x51, 0x72, 0x90, 0xfa, 0xc6, 0x2b, 0xa3, 0xa0, 0xe9, 0xd0, 0x43, 0x07, 0x92, 0x01, 0x2c, 0x66, - 0x34, 0x17, 0xc4, 0x19, 0x57, 0x01, 0x8f, 0x8d, 0x37, 0xb3, 0x5a, 0x5a, 0x6b, 0x6d, 0xdc, 0x5f, - 0x9f, 0x70, 0xe6, 0xf5, 0xc2, 0x79, 0xd7, 0x77, 0xac, 0xe5, 0xa5, 0x13, 0x6d, 0x4d, 0xef, 0x1e, - 0x3c, 0xa3, 0xc4, 0xf9, 0x2b, 0x1a, 0x48, 0x0f, 0xea, 0xd9, 0x2e, 0x5c, 0xf9, 0xa7, 0xde, 0x2c, - 0x3a, 0xbf, 0xfb, 0x41, 0xe7, 0xdb, 0xca, 0x3f, 0xdd, 0xaa, 0x1c, 0x1f, 0xec, 0x1d, 0xf4, 0x7e, - 0x3e, 0xa0, 0xe0, 0x5c, 0x58, 0x90, 0xac, 0xc3, 0x42, 0xc1, 0xe1, 0x38, 0xea, 0x0a, 0x1e, 0x71, - 0xfe, 0x82, 0x98, 0x07, 0xf0, 0x0d, 0x64, 0x61, 0x31, 0x3f, 0x49, 0xc7, 0xf4, 0x2a, 0xd2, 0xdb, - 0xce, 0xd2, 0x4d, 0xd2, 0x9c, 0xbd, 0x07, 0xb5, 0x53, 0xa9, 0xb3, 0x60, 0x6b, 0x1f, 0x15, 0x6c, - 0xd5, 0x3a, 0xc0, 0x50, 0x29, 0x34, 0xd1, 0xd9, 0x46, 0x3c, 0x70, 0x0e, 0xe1, 0xa3, 0x1c, 0xd6, - 0xad, 0x93, 0x8d, 0x78, 0x80, 0x3e, 0x97, 0xa1, 0x82, 0x3e, 0xa5, 0xf6, 0xea, 0x78, 0x86, 0x59, - 0xbb, 0xec, 0x69, 0xd2, 0xc9, 0x36, 0x93, 0x9a, 0x89, 0x73, 0xa3, 0xb8, 0xd7, 0x40, 0x73, 0xdd, - 0x99, 0x77, 0x2d, 0x34, 0xe6, 0xf8, 0x4a, 0x6a, 0x6d, 0x5d, 0x34, 0x2f, 0x38, 0x5d, 0x8b, 0xf5, - 0x34, 0xb9, 0x07, 0x73, 0x05, 0x0e, 0x86, 0xdd, 0x72, 0xcf, 0x67, 0xcc, 0xc2, 0x40, 0xee, 0xc3, - 0x42, 0x81, 0x37, 0x3e, 0xe2, 0x9c, 0x4b, 0xec, 0x98, 0x5b, 0x88, 0x5b, 0xa6, 0x86, 0x0d, 0x02, - 0xe5, 0xb5, 0x5d, 0xdc, 0x32, 0x35, 0x4f, 0x03, 0x45, 0xbe, 0x83, 0xba, 0x16, 0x26, 0x4d, 0x98, - 0x91, 0x32, 0xd4, 0xde, 0xfc, 0xea, 0xf4, 0x5a, 0x7d, 0xe3, 0xce, 0xc4, 0x14, 0x1d, 0x0a, 0x35, - 0x7c, 0x1e, 0x0f, 0x25, 0x05, 0x54, 0xbc, 0xb0, 0x02, 0xb2, 0x05, 0xb5, 0x37, 0xdc, 0x04, 0x4c, - 0xa5, 0xb1, 0xf6, 0xc8, 0x75, 0xd4, 0x55, 0xcb, 0xa7, 0x69, 0xac, 0xc9, 0x13, 0x00, 0xc7, 0x44, - 0xf1, 0xc2, 0x75, 0xc4, 0x35, 0xb4, 0xe6, 0xea, 0x38, 0x88, 0x5f, 0x73, 0xa7, 0x5e, 0xbc, 0x96, - 0x1a, 0x05, 0xa8, 0xfe, 0x16, 0x66, 0x8c, 0x34, 0x3c, 0xf4, 0x96, 0x56, 0x4b, 0x1f, 0x16, 0x3a, - 0x2e, 0x79, 0x09, 0x93, 0x5a, 0x91, 0xf7, 0x09, 0xba, 0xb8, 0x37, 0xd1, 0xc5, 0x91, 0xc5, 0xb0, - 0x24, 0xb3, 0x17, 0x46, 0xe7, 0xf5, 0x55, 0x88, 0x74, 0xa1, 0xe1, 0x54, 0xbe, 0x8c, 0x87, 0xc1, - 0x89, 0xb7, 0x8c, 0x0e, 0x57, 0x27, 0x3a, 0x44, 0x61, 0x17, 0x79, 0xb4, 0xde, 0xbf, 0x58, 0x90, - 0x15, 0xc0, 0xa7, 0x8f, 0x2d, 0xca, 0xc3, 0x3b, 0x1e, 0xaf, 0xc9, 0x2f, 0xb0, 0xa8, 0x47, 0xda, - 0x88, 0x88, 0x29, 0xa1, 0x65, 0xaa, 0x7c, 0xc1, 0x82, 0x78, 0x28, 0xbd, 0x9b, 0xb8, 0xd1, 0x57, - 0x93, 0x23, 0x47, 0x01, 0xcd, 0xf8, 0x98, 0x06, 0xa2, 0xdf, 0xc1, 0xc8, 0x17, 0xd0, 0xcc, 0x63, - 0x8f, 0x22, 0x1e, 0x0f, 0xbc, 0x15, 0xdc, 0xbb, 0x91, 0x85, 0x86, 0x98, 0xbd, 0xab, 0x3e, 0x7f, - 0x2b, 0x42, 0x77, 0x57, 0xb7, 0xae, 0x75, 0x57, 0x28, 0xb0, 0x77, 0xd5, 0x79, 0x08, 0x8d, 0x4b, - 0x4d, 0xad, 0x0a, 0xe5, 0xe3, 0xa3, 0x5d, 0xda, 0xbe, 0x41, 0x9a, 0x50, 0xb3, 0x5f, 0x4f, 0x77, - 0x77, 0x8e, 0x9f, 0xb5, 0x4b, 0xa4, 0x02, 0xb6, 0x11, 0xb6, 0xa7, 0x3a, 0x4f, 0xa0, 0x8c, 0xcf, - 0xbe, 0x0e, 0x79, 0x19, 0xb7, 0x6f, 0x58, 0xeb, 0x36, 0xdd, 0x6f, 0x97, 0x48, 0x0d, 0x66, 0xb6, - 0xe9, 0xfe, 0xe6, 0xa3, 0xf6, 0x94, 0xc5, 0x5e, 0x3d, 0xde, 0x6c, 0x4f, 0x13, 0x80, 0xd9, 0x57, - 0x8f, 0x37, 0xd9, 0xe6, 0xa3, 0x76, 0xb9, 0x73, 0x02, 0xf5, 0x42, 0x96, 0xed, 0x9c, 0x48, 0xb5, - 0x60, 0x27, 0x32, 0xe2, 0x38, 0x4d, 0xaa, 0xb4, 0x92, 0x6a, 0xf1, 0x4c, 0x46, 0xdc, 0x96, 0x95, - 0x35, 0xa9, 0xbe, 0xc0, 0x09, 0x52, 0xa5, 0xb3, 0xa9, 0x16, 0xb4, 0x2f, 0xc8, 0x97, 0xd0, 0x1a, - 0x4a, 0x9b, 0xe6, 0xb1, 0x72, 0x1a, 0xed, 0x0d, 0x44, 0x8f, 0x9d, 0xbc, 0x23, 0x81, 0xbc, 0x9b, - 0x65, 0xb2, 0x01, 0x4b, 0xf8, 0xdc, 0x58, 0x72, 0x3a, 0xd2, 0x81, 0xcf, 0x43, 0x16, 0x89, 0x48, - 0xaa, 0x11, 0x6e, 0x5e, 0xa6, 0x0b, 0x68, 0x3c, 0xcc, 0x6c, 0xfb, 0x68, 0xb2, 0x43, 0x87, 0x9f, - 0xf1, 0x20, 0xe4, 0xfd, 0x50, 0xd8, 0x4e, 0xab, 0x31, 0x9e, 0x19, 0xda, 0x1c, 0xa3, 0xdd, 0x24, - 0xd5, 0x9d, 0x7f, 0x4b, 0x50, 0xcd, 0x33, 0x4c, 0x08, 0x94, 0x07, 0x42, 0xfb, 0xe8, 0xb6, 0x46, - 0xf1, 0xdb, 0x62, 0xf8, 0x80, 0xdc, 0x3c, 0xc4, 0x6f, 0x72, 0x07, 0x40, 0x1b, 0xae, 0x0c, 0x0e, - 0x55, 0x3c, 0x47, 0x99, 0xd6, 0x10, 0xb1, 0xb3, 0x94, 0xdc, 0x82, 0x9a, 0x12, 0x3c, 0x74, 0xd6, - 0x32, 0x5a, 0xab, 0x16, 0x40, 0xe3, 0xe7, 0x00, 0x2e, 0x78, 0x9b, 0x08, 0x9c, 0x6d, 0xe5, 0x9d, - 0x29, 0xaf, 0x44, 0x6b, 0x0e, 0x3d, 0xd6, 0x82, 0xfc, 0x0e, 0xcb, 0x89, 0x92, 0xbe, 0xd0, 0x5a, - 0xe8, 0x2b, 0xcf, 0x73, 0x16, 0x1f, 0xca, 0xda, 0xe4, 0x87, 0xe2, 0x34, 0x97, 0xde, 0xe7, 0xd2, - 0xd8, 0x51, 0x11, 0xee, 0xfc, 0x39, 0x0d, 0x0b, 0x13, 0xe8, 0xe3, 0xc3, 0x96, 0x0a, 0x87, 0x5d, - 0x83, 0x76, 0xaa, 0x85, 0xc2, 0xd3, 0xb0, 0x28, 0xb0, 0xed, 0x15, 0x93, 0x51, 0xa6, 0x2d, 0x8b, - 0xdb, 0x43, 0xed, 0x23, 0x6a, 0x27, 0x5b, 0x56, 0x53, 0x45, 0xae, 0x4b, 0x4f, 0xdb, 0x59, 0x0a, - 0xec, 0xdb, 0x00, 0x11, 0x3f, 0x67, 0x4a, 0x6b, 0xf6, 0xa6, 0x9f, 0xa7, 0x29, 0xe2, 0xe7, 0x54, - 0xeb, 0xbd, 0x3e, 0xf9, 0x1a, 0xe6, 0xa3, 0x20, 0x96, 0x8a, 0x25, 0xfc, 0x44, 0xb0, 0x21, 0x4f, - 0x43, 0xa3, 0x5d, 0xb6, 0xe8, 0x1c, 0x1a, 0x0e, 0xf9, 0x89, 0xf8, 0x01, 0x61, 0xe4, 0xf2, 0xd7, - 0x57, 0xb8, 0xb3, 0x19, 0xd7, 0x1a, 0x0a, 0xdc, 0x4f, 0xa1, 0x1e, 0x48, 0x16, 0xc4, 0x49, 0x6a, - 0xec, 0xb6, 0x15, 0x77, 0x77, 0x81, 0x7c, 0x6e, 0x91, 0xbd, 0x3e, 0x59, 0x85, 0x46, 0x20, 0x99, - 0x4c, 0x4d, 0x46, 0xa8, 0x22, 0x01, 0x02, 0xd9, 0x43, 0x68, 0xaf, 0x4f, 0x9e, 0xc0, 0xca, 0x99, - 0x0c, 0xd3, 0xd8, 0x70, 0x35, 0xb2, 0xed, 0xc9, 0x88, 0x73, 0xc3, 0xf4, 0x1f, 0x81, 0xf1, 0x4f, - 0x85, 0xc6, 0x11, 0x5d, 0xa6, 0xde, 0x98, 0xd1, 0x75, 0x84, 0xa3, 0xcc, 0x4e, 0xbe, 0x87, 0xdb, - 0x41, 0xfc, 0x1e, 0x3d, 0xa0, 0x7e, 0xa5, 0xc0, 0xb9, 0xe2, 0xa1, 0xf3, 0x4f, 0x09, 0x5a, 0xfb, - 0x72, 0x90, 0x86, 0xe2, 0xc5, 0x28, 0x71, 0xd7, 0xf6, 0x5b, 0xde, 0x2d, 0x5d, 0x92, 0xf1, 0xfa, - 0x5a, 0x1b, 0x0f, 0x26, 0x8f, 0xf5, 0x4b, 0x52, 0xd7, 0x3c, 0x5d, 0xc9, 0x15, 0x06, 0x7c, 0xff, - 0x02, 0x25, 0x9f, 0x41, 0x3d, 0x42, 0x0d, 0x33, 0xa3, 0x24, 0xaf, 0x03, 0x88, 0xc6, 0x6e, 0x6c, - 0x65, 0xc7, 0x69, 0xc4, 0xe4, 0x90, 0x39, 0xd0, 0x5d, 0x79, 0x93, 0x36, 0xe2, 0x34, 0xea, 0x0d, - 0xdd, 0x7e, 0xba, 0xf3, 0x20, 0x6b, 0x21, 0x99, 0xd7, 0x4b, 0x7d, 0xa8, 0x06, 0x33, 0x47, 0xbd, - 0xde, 0x81, 0x6d, 0x58, 0x55, 0x28, 0xef, 0x6f, 0xef, 0xed, 0xb6, 0xa7, 0x3a, 0x21, 0xac, 0x74, - 0x55, 0x60, 0x6c, 0x49, 0x1f, 0x6b, 0xa1, 0x7e, 0x92, 0xa9, 0x8a, 0xc5, 0x28, 0x1f, 0x10, 0x93, - 0x5e, 0xea, 0x16, 0x54, 0xf2, 0x01, 0x34, 0xf5, 0x9e, 0x79, 0x51, 0xf8, 0x61, 0x43, 0x73, 0x41, - 0xa7, 0x0f, 0xb7, 0x26, 0xec, 0xa6, 0x2f, 0xe6, 0x51, 0xd9, 0x4f, 0x5f, 0x6b, 0xaf, 0x84, 0xf5, - 0x37, 0x39, 0xb3, 0xff, 0x1f, 0x2d, 0x45, 0x71, 0xe7, 0xaf, 0x12, 0xcc, 0xbf, 0x33, 0xfd, 0x88, - 0x07, 0x95, 0x3c, 0x6f, 0x25, 0xcc, 0x5b, 0xbe, 0xb4, 0xf3, 0x2b, 0xfb, 0x79, 0xe8, 0x0e, 0xd4, - 0xa4, 0xe3, 0xb5, 0x7d, 0xf3, 0xae, 0x25, 0xf2, 0x30, 0x94, 0x3e, 0xf3, 0x65, 0x1a, 0x9b, 0xac, - 0xd4, 0xe6, 0xd0, 0xb0, 0x6d, 0xf1, 0xae, 0x85, 0x6d, 0x05, 0x17, 0xb9, 0x3a, 0x78, 0x9b, 0xb7, - 0xa5, 0xd6, 0x05, 0xf5, 0x28, 0x78, 0x2b, 0xec, 0xef, 0x31, 0x5b, 0x93, 0xa7, 0x82, 0x27, 0x8e, - 0xe6, 0x2a, 0xae, 0x1e, 0xf1, 0xf3, 0x1f, 0x05, 0x4f, 0x2c, 0x67, 0x67, 0xe9, 0xd7, 0x6c, 0xe4, - 0x67, 0xe7, 0x66, 0xf8, 0x97, 0xe4, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xfb, 0x8e, 0xf5, - 0xa2, 0x0c, 0x00, 0x00, + // 1423 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xdd, 0x52, 0x1b, 0xc7, + 0x12, 0xb6, 0x40, 0x20, 0xa9, 0xf5, 0x83, 0x18, 0xe0, 0xb0, 0xc6, 0xf6, 0x39, 0x1c, 0xc5, 0x76, + 0xa8, 0x54, 0x8c, 0x5d, 0xc4, 0x45, 0xb9, 0x28, 0x57, 0x2a, 0x20, 0x13, 0xc7, 0xa1, 0x84, 0xa8, + 0xc1, 0x38, 0x4e, 0x72, 0x31, 0x19, 0xad, 0x46, 0xb0, 0xf6, 0xee, 0xce, 0xd6, 0xcc, 0x2c, 0x01, + 0xbf, 0x99, 0xaf, 0xf3, 0x12, 0x79, 0x81, 0x3c, 0x41, 0x5e, 0x20, 0x35, 0x3d, 0xbb, 0x62, 0xc1, + 0x8a, 0x4d, 0xf9, 0x4e, 0xfb, 0xf5, 0xf7, 0xf5, 0x76, 0xf7, 0xf4, 0x74, 0xaf, 0xa0, 0x19, 0x09, + 0xa3, 0x02, 0x5f, 0xaf, 0x27, 0x4a, 0x1a, 0x49, 0x16, 0xb4, 0x94, 0xf1, 0x31, 0x1b, 0xa4, 0x41, + 0x38, 0x64, 0x99, 0xa9, 0xf3, 0x67, 0x03, 0xea, 0x3d, 0xf7, 0x7b, 0x87, 0x6b, 0x41, 0x1e, 0xc1, + 0xa2, 0x23, 0x0c, 0xb9, 0x11, 0xcc, 0x04, 0x91, 0xd0, 0x86, 0x47, 0x89, 0x57, 0x5a, 0x2d, 0xad, + 0x4d, 0x53, 0x82, 0xb6, 0x67, 0xdc, 0x88, 0x97, 0xb9, 0x85, 0xdc, 0x84, 0xaa, 0x53, 0x04, 0x43, + 0x6f, 0x6a, 0xb5, 0xb4, 0x56, 0xa3, 0x15, 0x7c, 0x7e, 0x31, 0x24, 0x5b, 0x70, 0x33, 0x09, 0xb9, + 0x19, 0x49, 0x15, 0xb1, 0x53, 0xa1, 0x74, 0x20, 0x63, 0xe6, 0xcb, 0xa1, 0x88, 0x79, 0x24, 0xbc, + 0x69, 0xe4, 0x2e, 0xe7, 0x84, 0x57, 0xce, 0xde, 0xcd, 0xcc, 0xe4, 0x1e, 0xb4, 0x0c, 0x57, 0xc7, + 0xc2, 0xb0, 0x44, 0xc9, 0x61, 0xea, 0x1b, 0xaf, 0x8c, 0x82, 0xa6, 0x43, 0x0f, 0x1c, 0x48, 0x86, + 0xb0, 0x98, 0xd1, 0x5c, 0x10, 0xa7, 0x5c, 0x05, 0x3c, 0x36, 0xde, 0xcc, 0x6a, 0x69, 0xad, 0xb5, + 0xf1, 0x60, 0x7d, 0x42, 0xce, 0xeb, 0x85, 0x7c, 0xd7, 0x77, 0xac, 0xe5, 0x95, 0x13, 0x6d, 0x4d, + 0xef, 0xee, 0x3f, 0xa7, 0xc4, 0xf9, 0x2b, 0x1a, 0x48, 0x1f, 0xea, 0xd9, 0x5b, 0xb8, 0xf2, 0x4f, + 0xbc, 0x59, 0x74, 0x7e, 0xef, 0x93, 0xce, 0xb7, 0x95, 0x7f, 0xb2, 0x55, 0x39, 0xda, 0xdf, 0xdb, + 0xef, 0xff, 0xb4, 0x4f, 0xc1, 0xb9, 0xb0, 0x20, 0x59, 0x87, 0x85, 0x82, 0xc3, 0x71, 0xd4, 0x15, + 0x4c, 0x71, 0xfe, 0x82, 0x98, 0x07, 0xf0, 0x35, 0x64, 0x61, 0x31, 0x3f, 0x49, 0xc7, 0xf4, 0x2a, + 0xd2, 0xdb, 0xce, 0xd2, 0x4d, 0xd2, 0x9c, 0xbd, 0x07, 0xb5, 0x13, 0xa9, 0xb3, 0x60, 0x6b, 0x9f, + 0x15, 0x6c, 0xd5, 0x3a, 0xc0, 0x50, 0x29, 0x34, 0xd1, 0xd9, 0x46, 0x3c, 0x74, 0x0e, 0xe1, 0xb3, + 0x1c, 0xd6, 0xad, 0x93, 0x8d, 0x78, 0x88, 0x3e, 0x97, 0xa1, 0x82, 0x3e, 0xa5, 0xf6, 0xea, 0x98, + 0xc3, 0xac, 0x7d, 0xec, 0x6b, 0xd2, 0xc9, 0x5e, 0x26, 0x35, 0x13, 0x67, 0x46, 0x71, 0xaf, 0x81, + 0xe6, 0xba, 0x33, 0xef, 0x5a, 0x68, 0xcc, 0xf1, 0x95, 0xd4, 0xda, 0xba, 0x68, 0x5e, 0x70, 0xba, + 0x16, 0xeb, 0x6b, 0x72, 0x1f, 0xe6, 0x0a, 0x1c, 0x0c, 0xbb, 0xe5, 0xda, 0x67, 0xcc, 0xc2, 0x40, + 0x1e, 0xc0, 0x42, 0x81, 0x37, 0x4e, 0x71, 0xce, 0x15, 0x76, 0xcc, 0x2d, 0xc4, 0x2d, 0x53, 0xc3, + 0x86, 0x81, 0xf2, 0xda, 0x2e, 0x6e, 0x99, 0x9a, 0x67, 0x81, 0x22, 0xdf, 0x42, 0x5d, 0x0b, 0x93, + 0x26, 0xcc, 0x48, 0x19, 0x6a, 0x6f, 0x7e, 0x75, 0x7a, 0xad, 0xbe, 0x71, 0x67, 0x62, 0x89, 0x0e, + 0x84, 0x1a, 0xbd, 0x88, 0x47, 0x92, 0x02, 0x2a, 0x5e, 0x5a, 0x01, 0xd9, 0x82, 0xda, 0x5b, 0x6e, + 0x02, 0xa6, 0xd2, 0x58, 0x7b, 0xe4, 0x3a, 0xea, 0xaa, 0xe5, 0xd3, 0x34, 0xd6, 0xe4, 0x29, 0x80, + 0x63, 0xa2, 0x78, 0xe1, 0x3a, 0xe2, 0x1a, 0x5a, 0x73, 0x75, 0x1c, 0xc4, 0x6f, 0xb8, 0x53, 0x2f, + 0x5e, 0x4b, 0x8d, 0x02, 0x54, 0x7f, 0x03, 0x33, 0x46, 0x1a, 0x1e, 0x7a, 0x4b, 0xab, 0xa5, 0x4f, + 0x0b, 0x1d, 0x97, 0xbc, 0x82, 0x49, 0xa3, 0xc8, 0xfb, 0x0f, 0xba, 0xb8, 0x3f, 0xd1, 0xc5, 0xa1, + 0xc5, 0xf0, 0x4a, 0x66, 0x1d, 0x46, 0xe7, 0xf5, 0x55, 0x88, 0x74, 0xa1, 0xe1, 0x54, 0xbe, 0x8c, + 0x47, 0xc1, 0xb1, 0xb7, 0x8c, 0x0e, 0x57, 0x27, 0x3a, 0x44, 0x61, 0x17, 0x79, 0xb4, 0x3e, 0xb8, + 0x78, 0x20, 0x2b, 0x80, 0xad, 0x8f, 0x23, 0xca, 0xc3, 0x33, 0x1e, 0x3f, 0x93, 0x9f, 0x61, 0x51, + 0x9f, 0x6b, 0x23, 0x22, 0xa6, 0x84, 0x96, 0xa9, 0xf2, 0x05, 0x0b, 0xe2, 0x91, 0xf4, 0x6e, 0xe2, + 0x8b, 0xbe, 0x9c, 0x1c, 0x39, 0x0a, 0x68, 0xc6, 0xc7, 0x32, 0x10, 0xfd, 0x01, 0x46, 0xbe, 0x80, + 0x66, 0x1e, 0x7b, 0x14, 0xf1, 0x78, 0xe8, 0xad, 0xe0, 0xbb, 0x1b, 0x59, 0x68, 0x88, 0xd9, 0xb3, + 0x1a, 0xf0, 0x77, 0x22, 0x74, 0x67, 0x75, 0xeb, 0x5a, 0x67, 0x85, 0x02, 0x7b, 0x56, 0x9d, 0x47, + 0xd0, 0xb8, 0x34, 0xd4, 0xaa, 0x50, 0x3e, 0x3a, 0xdc, 0xa5, 0xed, 0x1b, 0xa4, 0x09, 0x35, 0xfb, + 0xeb, 0xd9, 0xee, 0xce, 0xd1, 0xf3, 0x76, 0x89, 0x54, 0xc0, 0x0e, 0xc2, 0xf6, 0x54, 0xe7, 0x29, + 0x94, 0xb1, 0xed, 0xeb, 0x90, 0x5f, 0xe3, 0xf6, 0x0d, 0x6b, 0xdd, 0xa6, 0xbd, 0x76, 0x89, 0xd4, + 0x60, 0x66, 0x9b, 0xf6, 0x36, 0x1f, 0xb7, 0xa7, 0x2c, 0xf6, 0xfa, 0xc9, 0x66, 0x7b, 0x9a, 0x00, + 0xcc, 0xbe, 0x7e, 0xb2, 0xc9, 0x36, 0x1f, 0xb7, 0xcb, 0x9d, 0xf7, 0x25, 0xa8, 0x17, 0xca, 0x6c, + 0x17, 0x45, 0xaa, 0x05, 0x3b, 0x96, 0x11, 0xc7, 0x75, 0x52, 0xa5, 0x95, 0x54, 0x8b, 0xe7, 0x32, + 0xe2, 0xf6, 0x5e, 0x59, 0x93, 0x1a, 0x08, 0x5c, 0x21, 0x55, 0x3a, 0x9b, 0x6a, 0x41, 0x07, 0x82, + 0xdc, 0x85, 0xd6, 0x48, 0xda, 0x3a, 0x8f, 0x95, 0xd3, 0x68, 0x6f, 0x20, 0x7a, 0x94, 0xc9, 0xef, + 0x42, 0xcb, 0xd5, 0x85, 0x6b, 0x86, 0xbd, 0x89, 0xbb, 0xa2, 0x4a, 0x1b, 0x88, 0x6e, 0xeb, 0x7d, + 0x8b, 0x91, 0xaf, 0x60, 0xde, 0xb1, 0xa2, 0xe0, 0x4c, 0x0c, 0x5d, 0xc1, 0x70, 0x4f, 0x54, 0xe9, + 0x1c, 0x1a, 0x7a, 0x16, 0xc7, 0x88, 0x3b, 0x12, 0xc8, 0x87, 0x07, 0x47, 0x36, 0x60, 0x09, 0x3b, + 0x98, 0x25, 0x27, 0xe7, 0x3a, 0xf0, 0x79, 0xc8, 0x22, 0x11, 0x49, 0x75, 0x8e, 0xe9, 0x94, 0xe9, + 0x02, 0x1a, 0x0f, 0x32, 0x5b, 0x0f, 0x4d, 0x76, 0x8f, 0xf1, 0x53, 0x1e, 0x84, 0x7c, 0x10, 0x0a, + 0x3b, 0xbc, 0x35, 0x66, 0x38, 0x43, 0x9b, 0x63, 0xb4, 0x9b, 0xa4, 0xba, 0xf3, 0x77, 0x09, 0xaa, + 0xf9, 0xa1, 0x11, 0x02, 0xe5, 0xa1, 0xd0, 0x3e, 0xba, 0xad, 0x51, 0xfc, 0x6d, 0x31, 0xec, 0x49, + 0xb7, 0x62, 0xf1, 0x37, 0xb9, 0x03, 0xa0, 0x0d, 0x57, 0x06, 0xf7, 0x34, 0x56, 0xa6, 0x4c, 0x6b, + 0x88, 0xd8, 0xf5, 0x4c, 0x6e, 0x41, 0x4d, 0x09, 0x1e, 0x3a, 0x6b, 0x19, 0xad, 0x55, 0x0b, 0xa0, + 0xf1, 0xff, 0x00, 0x2e, 0x78, 0x5b, 0x5a, 0x2c, 0x43, 0x79, 0x67, 0xca, 0x2b, 0xd1, 0x9a, 0x43, + 0x8f, 0xb4, 0x20, 0xbf, 0xc1, 0x72, 0xa2, 0xa4, 0x2f, 0xb4, 0x16, 0xfa, 0x4a, 0xc7, 0xcf, 0x62, + 0xef, 0xad, 0x4d, 0xee, 0x3d, 0xa7, 0xb9, 0xd4, 0xf2, 0x4b, 0x63, 0x47, 0x45, 0xb8, 0xf3, 0x7e, + 0x1a, 0x16, 0x26, 0xd0, 0xc7, 0xc9, 0x96, 0x0a, 0xc9, 0xae, 0x41, 0x3b, 0xd5, 0x42, 0x61, 0x36, + 0x2c, 0x0a, 0xec, 0xc4, 0xc6, 0x62, 0x94, 0x69, 0xcb, 0xe2, 0x36, 0xa9, 0x1e, 0xa2, 0x76, 0x59, + 0x66, 0xd7, 0xb4, 0xc8, 0x75, 0xe5, 0x69, 0x3b, 0x4b, 0x81, 0x7d, 0x1b, 0x20, 0xe2, 0x67, 0x4c, + 0x69, 0xcd, 0xde, 0x0e, 0xf2, 0x32, 0x45, 0xfc, 0x8c, 0x6a, 0xbd, 0x37, 0xb0, 0x4d, 0x13, 0x05, + 0xb1, 0x54, 0x2c, 0xe1, 0xc7, 0x82, 0x8d, 0x78, 0x1a, 0x1a, 0xed, 0xaa, 0x45, 0xe7, 0xd0, 0x70, + 0xc0, 0x8f, 0xc5, 0xf7, 0x08, 0x23, 0x97, 0xbf, 0xb9, 0xc2, 0x9d, 0xcd, 0xb8, 0xd6, 0x50, 0xe0, + 0xfe, 0x17, 0xea, 0x81, 0x64, 0x41, 0x9c, 0xa4, 0xc6, 0xbe, 0xb6, 0xe2, 0xce, 0x2e, 0x90, 0x2f, + 0x2c, 0xb2, 0x37, 0x20, 0xab, 0xd0, 0x08, 0x24, 0x93, 0xa9, 0xc9, 0x08, 0x55, 0x24, 0x40, 0x20, + 0xfb, 0x08, 0xed, 0x0d, 0xc8, 0x53, 0x58, 0x39, 0x95, 0x61, 0x1a, 0x1b, 0xae, 0xce, 0xed, 0xc4, + 0x33, 0xe2, 0xcc, 0x30, 0xfd, 0x7b, 0x60, 0xfc, 0x13, 0xa1, 0x71, 0xeb, 0x97, 0xa9, 0x37, 0x66, + 0x74, 0x1d, 0xe1, 0x30, 0xb3, 0x93, 0xef, 0xe0, 0x76, 0x10, 0x7f, 0x44, 0x0f, 0xa8, 0x5f, 0x29, + 0x70, 0xae, 0x78, 0xe8, 0xfc, 0x55, 0x82, 0x56, 0x4f, 0x0e, 0xd3, 0x50, 0xbc, 0x3c, 0x4f, 0xdc, + 0xb1, 0xfd, 0x9a, 0x0f, 0x60, 0x57, 0x64, 0x3c, 0xbe, 0xd6, 0xc6, 0xc3, 0xc9, 0x5f, 0x0a, 0x97, + 0xa4, 0x6e, 0x1e, 0xbb, 0x2b, 0x57, 0xf8, 0x66, 0x18, 0x5c, 0xa0, 0xe4, 0x7f, 0x50, 0x8f, 0x50, + 0xc3, 0xcc, 0x79, 0x92, 0xdf, 0x03, 0x88, 0xc6, 0x6e, 0xec, 0x14, 0x88, 0xd3, 0x88, 0xc9, 0x11, + 0x73, 0xa0, 0x3b, 0xf2, 0x26, 0x6d, 0xc4, 0x69, 0xd4, 0x1f, 0xb9, 0xf7, 0xe9, 0xce, 0xc3, 0x6c, + 0x28, 0x65, 0x5e, 0x2f, 0x8d, 0xb6, 0x1a, 0xcc, 0x1c, 0xf6, 0xfb, 0xfb, 0x76, 0x06, 0x56, 0xa1, + 0xdc, 0xdb, 0xde, 0xdb, 0x6d, 0x4f, 0x75, 0x42, 0x58, 0xe9, 0xaa, 0xc0, 0xd8, 0x2b, 0x7d, 0xa4, + 0x85, 0xfa, 0x51, 0xa6, 0x2a, 0x16, 0xe7, 0xf9, 0xce, 0x99, 0xd4, 0xa9, 0x5b, 0x50, 0xc9, 0x77, + 0xda, 0xd4, 0x47, 0x56, 0x50, 0xe1, 0x5b, 0x89, 0xe6, 0x82, 0xce, 0x00, 0x6e, 0x4d, 0x78, 0x9b, + 0xbe, 0x58, 0x71, 0x65, 0x3f, 0x7d, 0xa3, 0xbd, 0x12, 0xde, 0xbf, 0xc9, 0x95, 0xfd, 0xf7, 0x68, + 0x29, 0x8a, 0x3b, 0x7f, 0x94, 0x60, 0xfe, 0x83, 0x85, 0x4a, 0x3c, 0xa8, 0xe4, 0x75, 0x2b, 0x61, + 0xdd, 0xf2, 0x47, 0xbb, 0x12, 0xb3, 0x2f, 0x4e, 0x97, 0x50, 0x93, 0x8e, 0x9f, 0x6d, 0xcf, 0xbb, + 0x91, 0xc8, 0xc3, 0x50, 0xfa, 0xcc, 0x97, 0x69, 0x6c, 0xb2, 0xab, 0x36, 0x87, 0x86, 0x6d, 0x8b, + 0x77, 0x2d, 0x6c, 0x6f, 0x70, 0x91, 0xab, 0x83, 0x77, 0xf9, 0x58, 0x6a, 0x5d, 0x50, 0x0f, 0x83, + 0x77, 0xc2, 0x7e, 0xe2, 0xd9, 0x3b, 0x79, 0x22, 0x78, 0xe2, 0x68, 0xee, 0xc6, 0xd5, 0x23, 0x7e, + 0xf6, 0x83, 0xe0, 0x89, 0xe5, 0xec, 0x2c, 0xfd, 0x92, 0x7d, 0x45, 0x64, 0x79, 0x33, 0xfc, 0x97, + 0xf3, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe9, 0x63, 0x09, 0x14, 0xf5, 0x0c, 0x00, 0x00, } diff --git a/ui/metrics/metrics_proto/metrics.proto b/ui/metrics/metrics_proto/metrics.proto index 91d8dd9b7..b284bf982 100644 --- a/ui/metrics/metrics_proto/metrics.proto +++ b/ui/metrics/metrics_proto/metrics.proto @@ -116,6 +116,13 @@ message BuildConfig { optional bool use_rbe = 2; optional bool force_use_goma = 3; + + // Whether the Bazel is acting as the Ninja executor for this build. + optional bool bazel_as_ninja = 4; + + // Whether build is occurring in a mixed build mode, where Bazel maintains the + // definition and build of some modules in cooperation with Soong. + optional bool bazel_mixed_build = 5; } message SystemResourceInfo { |