Merge changes from topics "art-boot-image-jars", "configured-jar-location-overrides" into main
* changes:
Add a Make variable to determine ART boot image jars for testing.
Add a Make variable that overrides configured jar locations.
Refactor dexpreopt for boot jars to make it flexible to config changes.
diff --git a/android/bazel_paths.go b/android/bazel_paths.go
index 872e908..2f5ff64 100644
--- a/android/bazel_paths.go
+++ b/android/bazel_paths.go
@@ -198,7 +198,7 @@
}
labels := expandSrcsForBazel(ctx, paths, excluded)
labels.Excludes = excludeLabels.Includes
- labels = transformSubpackagePaths(ctx, labels)
+ labels = TransformSubpackagePaths(ctx.Config(), ctx.ModuleDir(), labels)
return labels
}
@@ -237,7 +237,7 @@
// if the "async_safe" directory is actually a package and not just a directory.
//
// In particular, paths that extend into packages are transformed into absolute labels beginning with //.
-func transformSubpackagePath(ctx BazelConversionPathContext, path bazel.Label) bazel.Label {
+func transformSubpackagePath(cfg Config, dir string, path bazel.Label) bazel.Label {
var newPath bazel.Label
// Don't transform OriginalModuleName
@@ -281,7 +281,7 @@
for i := len(pathComponents) - 1; i >= 0; i-- {
pathComponent := pathComponents[i]
var sep string
- if !foundPackageBoundary && isPackageBoundary(ctx.Config(), ctx.ModuleDir(), pathComponents, i) {
+ if !foundPackageBoundary && isPackageBoundary(cfg, dir, pathComponents, i) {
sep = ":"
foundPackageBoundary = true
} else {
@@ -295,7 +295,7 @@
}
if foundPackageBoundary {
// Ensure paths end up looking like //bionic/... instead of //./bionic/...
- moduleDir := ctx.ModuleDir()
+ moduleDir := dir
if strings.HasPrefix(moduleDir, ".") {
moduleDir = moduleDir[1:]
}
@@ -313,13 +313,13 @@
// Transform paths to acknowledge package boundaries
// See transformSubpackagePath() for more information
-func transformSubpackagePaths(ctx BazelConversionPathContext, paths bazel.LabelList) bazel.LabelList {
+func TransformSubpackagePaths(cfg Config, dir string, paths bazel.LabelList) bazel.LabelList {
var newPaths bazel.LabelList
for _, include := range paths.Includes {
- newPaths.Includes = append(newPaths.Includes, transformSubpackagePath(ctx, include))
+ newPaths.Includes = append(newPaths.Includes, transformSubpackagePath(cfg, dir, include))
}
for _, exclude := range paths.Excludes {
- newPaths.Excludes = append(newPaths.Excludes, transformSubpackagePath(ctx, exclude))
+ newPaths.Excludes = append(newPaths.Excludes, transformSubpackagePath(cfg, dir, exclude))
}
return newPaths
}
diff --git a/android/bazel_paths_test.go b/android/bazel_paths_test.go
index 450bf76..60c0a14 100644
--- a/android/bazel_paths_test.go
+++ b/android/bazel_paths_test.go
@@ -175,7 +175,7 @@
"./z/b.c": "z/b.c",
}
for in, out := range pairs {
- actual := transformSubpackagePath(ctx, bazel.Label{Label: in}).Label
+ actual := transformSubpackagePath(ctx.Config(), ctx.ModuleDir(), bazel.Label{Label: in}).Label
if actual != out {
t.Errorf("expected:\n%v\nactual:\n%v", out, actual)
}
diff --git a/bp2build/Android.bp b/bp2build/Android.bp
index 782a88c..f889693 100644
--- a/bp2build/Android.bp
+++ b/bp2build/Android.bp
@@ -19,6 +19,7 @@
"testing.go",
],
deps: [
+ "blueprint-bootstrap",
"soong-aidl-library",
"soong-android",
"soong-android-allowlists",
@@ -37,6 +38,7 @@
"soong-ui-metrics",
],
testSrcs: [
+ "go_conversion_test.go",
"aar_conversion_test.go",
"aidl_library_conversion_test.go",
"android_app_certificate_conversion_test.go",
diff --git a/bp2build/build_conversion.go b/bp2build/build_conversion.go
index 46a5bd8..a817386 100644
--- a/bp2build/build_conversion.go
+++ b/bp2build/build_conversion.go
@@ -30,6 +30,7 @@
"android/soong/starlark_fmt"
"android/soong/ui/metrics/bp2build_metrics_proto"
"github.com/google/blueprint"
+ "github.com/google/blueprint/bootstrap"
"github.com/google/blueprint/proptools"
)
@@ -252,6 +253,235 @@
return r.buildFileToTargets
}
+// struct to store state of go bazel targets
+// this implements bp2buildModule interface and is passed to generateBazelTargets
+type goBazelTarget struct {
+ targetName string
+ targetPackage string
+ bazelRuleClass string
+ bazelRuleLoadLocation string
+ bazelAttributes []interface{}
+}
+
+var _ bp2buildModule = (*goBazelTarget)(nil)
+
+func (g goBazelTarget) TargetName() string {
+ return g.targetName
+}
+
+func (g goBazelTarget) TargetPackage() string {
+ return g.targetPackage
+}
+
+func (g goBazelTarget) BazelRuleClass() string {
+ return g.bazelRuleClass
+}
+
+func (g goBazelTarget) BazelRuleLoadLocation() string {
+ return g.bazelRuleLoadLocation
+}
+
+func (g goBazelTarget) BazelAttributes() []interface{} {
+ return g.bazelAttributes
+}
+
+// Creates a target_compatible_with entry that is *not* compatible with android
+func targetNotCompatibleWithAndroid() bazel.LabelListAttribute {
+ ret := bazel.LabelListAttribute{}
+ ret.SetSelectValue(bazel.OsConfigurationAxis, bazel.OsAndroid,
+ bazel.MakeLabelList(
+ []bazel.Label{
+ bazel.Label{
+ Label: "@platforms//:incompatible",
+ },
+ },
+ ),
+ )
+ return ret
+}
+
+// helper function to return labels for srcs used in bootstrap_go_package and bootstrap_go_binary
+// this function has the following limitations which make it unsuitable for widespread use
+// - wildcard patterns in srcs
+// This is ok for go since build/blueprint does not support it.
+//
+// Prefer to use `BazelLabelForModuleSrc` instead
+func goSrcLabels(cfg android.Config, moduleDir string, srcs []string, linuxSrcs, darwinSrcs []string) bazel.LabelListAttribute {
+ labels := func(srcs []string) bazel.LabelList {
+ ret := []bazel.Label{}
+ for _, src := range srcs {
+ srcLabel := bazel.Label{
+ Label: src,
+ }
+ ret = append(ret, srcLabel)
+ }
+ // Respect package boundaries
+ return android.TransformSubpackagePaths(
+ cfg,
+ moduleDir,
+ bazel.MakeLabelList(ret),
+ )
+ }
+
+ ret := bazel.LabelListAttribute{}
+ // common
+ ret.SetSelectValue(bazel.NoConfigAxis, "", labels(srcs))
+ // linux
+ ret.SetSelectValue(bazel.OsConfigurationAxis, bazel.OsLinux, labels(linuxSrcs))
+ // darwin
+ ret.SetSelectValue(bazel.OsConfigurationAxis, bazel.OsDarwin, labels(darwinSrcs))
+ return ret
+}
+
+func goDepLabels(deps []string, goModulesMap nameToGoLibraryModule) bazel.LabelListAttribute {
+ labels := []bazel.Label{}
+ for _, dep := range deps {
+ moduleDir := goModulesMap[dep].Dir
+ if moduleDir == "." {
+ moduleDir = ""
+ }
+ label := bazel.Label{
+ Label: fmt.Sprintf("//%s:%s", moduleDir, dep),
+ }
+ labels = append(labels, label)
+ }
+ return bazel.MakeLabelListAttribute(bazel.MakeLabelList(labels))
+}
+
+// attributes common to blueprint_go_binary and bootstap_go_package
+type goAttributes struct {
+ Importpath bazel.StringAttribute
+ Srcs bazel.LabelListAttribute
+ Deps bazel.LabelListAttribute
+ Target_compatible_with bazel.LabelListAttribute
+}
+
+func generateBazelTargetsGoPackage(ctx *android.Context, g *bootstrap.GoPackage, goModulesMap nameToGoLibraryModule) ([]BazelTarget, []error) {
+ ca := android.CommonAttributes{
+ Name: g.Name(),
+ }
+
+ // For this bootstrap_go_package dep chain,
+ // A --> B --> C ( ---> depends on)
+ // Soong provides the convenience of only listing B as deps of A even if a src file of A imports C
+ // Bazel OTOH
+ // 1. requires C to be listed in `deps` expllicity.
+ // 2. does not require C to be listed if src of A does not import C
+ //
+ // bp2build does not have sufficient info on whether C is a direct dep of A or not, so for now collect all transitive deps and add them to deps
+ transitiveDeps := transitiveGoDeps(g.Deps(), goModulesMap)
+
+ ga := goAttributes{
+ Importpath: bazel.StringAttribute{
+ Value: proptools.StringPtr(g.GoPkgPath()),
+ },
+ Srcs: goSrcLabels(ctx.Config(), ctx.ModuleDir(g), g.Srcs(), g.LinuxSrcs(), g.DarwinSrcs()),
+ Deps: goDepLabels(
+ android.FirstUniqueStrings(transitiveDeps),
+ goModulesMap,
+ ),
+ Target_compatible_with: targetNotCompatibleWithAndroid(),
+ }
+
+ lib := goBazelTarget{
+ targetName: g.Name(),
+ targetPackage: ctx.ModuleDir(g),
+ bazelRuleClass: "go_library",
+ bazelRuleLoadLocation: "@io_bazel_rules_go//go:def.bzl",
+ bazelAttributes: []interface{}{&ca, &ga},
+ }
+ // TODO - b/284483729: Create go_test target from testSrcs
+ libTarget, err := generateBazelTarget(ctx, lib)
+ if err != nil {
+ return []BazelTarget{}, []error{err}
+ }
+ return []BazelTarget{libTarget}, nil
+}
+
+type goLibraryModule struct {
+ Dir string
+ Deps []string
+}
+
+type nameToGoLibraryModule map[string]goLibraryModule
+
+// Visit each module in the graph
+// If a module is of type `bootstrap_go_package`, return a map containing metadata like its dir and deps
+func createGoLibraryModuleMap(ctx *android.Context) nameToGoLibraryModule {
+ ret := nameToGoLibraryModule{}
+ ctx.VisitAllModules(func(m blueprint.Module) {
+ moduleType := ctx.ModuleType(m)
+ // We do not need to store information about blueprint_go_binary since it does not have any rdeps
+ if moduleType == "bootstrap_go_package" {
+ ret[m.Name()] = goLibraryModule{
+ Dir: ctx.ModuleDir(m),
+ Deps: m.(*bootstrap.GoPackage).Deps(),
+ }
+ }
+ })
+ return ret
+}
+
+// Returns the deps in the transitive closure of a go target
+func transitiveGoDeps(directDeps []string, goModulesMap nameToGoLibraryModule) []string {
+ allDeps := directDeps
+ i := 0
+ for i < len(allDeps) {
+ curr := allDeps[i]
+ allDeps = append(allDeps, goModulesMap[curr].Deps...)
+ i += 1
+ }
+ allDeps = android.SortedUniqueStrings(allDeps)
+ return allDeps
+}
+
+func generateBazelTargetsGoBinary(ctx *android.Context, g *bootstrap.GoBinary, goModulesMap nameToGoLibraryModule) ([]BazelTarget, []error) {
+ ca := android.CommonAttributes{
+ Name: g.Name(),
+ }
+
+ // For this bootstrap_go_package dep chain,
+ // A --> B --> C ( ---> depends on)
+ // Soong provides the convenience of only listing B as deps of A even if a src file of A imports C
+ // Bazel OTOH
+ // 1. requires C to be listed in `deps` expllicity.
+ // 2. does not require C to be listed if src of A does not import C
+ //
+ // bp2build does not have sufficient info on whether C is a direct dep of A or not, so for now collect all transitive deps and add them to deps
+ transitiveDeps := transitiveGoDeps(g.Deps(), goModulesMap)
+
+ ga := goAttributes{
+ Srcs: goSrcLabels(ctx.Config(), ctx.ModuleDir(g), g.Srcs(), g.LinuxSrcs(), g.DarwinSrcs()),
+ Deps: goDepLabels(transitiveDeps, goModulesMap),
+ Target_compatible_with: targetNotCompatibleWithAndroid(),
+ }
+
+ bin := goBazelTarget{
+ targetName: g.Name(),
+ targetPackage: ctx.ModuleDir(g),
+ bazelRuleClass: "go_binary",
+ bazelRuleLoadLocation: "@io_bazel_rules_go//go:def.bzl",
+ bazelAttributes: []interface{}{&ca, &ga},
+ }
+ // TODO - b/284483729: Create go_test target from testSrcs
+ binTarget, err := generateBazelTarget(ctx, bin)
+ if err != nil {
+ return []BazelTarget{}, []error{err}
+ }
+ return []BazelTarget{binTarget}, nil
+}
+
+var (
+ // TODO - b/284483729: Remove this denyilst
+ // Temporary denylist of go binaries that are currently used in mixed builds
+ // This denylist allows us to rollout bp2build converters for go targets without affecting mixed builds
+ goBinaryDenylist = []string{
+ "soong_zip",
+ "zip2zip",
+ "bazel_notice_gen",
+ }
+)
+
func GenerateBazelTargets(ctx *CodegenContext, generateFilegroups bool) (conversionResults, []error) {
buildFileToTargets := make(map[string]BazelTargets)
@@ -262,6 +492,10 @@
var errs []error
+ // Visit go libraries in a pre-run and store its state in a map
+ // The time complexity remains O(N), and this does not add significant wall time.
+ nameToGoLibMap := createGoLibraryModuleMap(ctx.Context())
+
bpCtx := ctx.Context()
bpCtx.VisitAllModules(func(m blueprint.Module) {
dir := bpCtx.ModuleDir(m)
@@ -269,6 +503,7 @@
dirs[dir] = true
var targets []BazelTarget
+ var targetErrs []error
switch ctx.Mode() {
case Bp2Build:
@@ -317,7 +552,6 @@
return
}
}
- var targetErrs []error
targets, targetErrs = generateBazelTargets(bpCtx, aModule)
errs = append(errs, targetErrs...)
for _, t := range targets {
@@ -336,6 +570,14 @@
metrics.AddUnconvertedModule(m, moduleType, dir, *reason)
}
return
+ } else if glib, ok := m.(*bootstrap.GoPackage); ok {
+ targets, targetErrs = generateBazelTargetsGoPackage(bpCtx, glib, nameToGoLibMap)
+ errs = append(errs, targetErrs...)
+ metrics.IncrementRuleClassCount("go_library")
+ } else if gbin, ok := m.(*bootstrap.GoBinary); ok && !android.InList(m.Name(), goBinaryDenylist) {
+ targets, targetErrs = generateBazelTargetsGoBinary(bpCtx, gbin, nameToGoLibMap)
+ errs = append(errs, targetErrs...)
+ metrics.IncrementRuleClassCount("go_binary")
} else {
metrics.AddUnconvertedModule(m, moduleType, dir, android.UnconvertedReason{
ReasonType: int(bp2build_metrics_proto.UnconvertedReasonType_TYPE_UNSUPPORTED),
diff --git a/bp2build/go_conversion_test.go b/bp2build/go_conversion_test.go
new file mode 100644
index 0000000..507fbf0
--- /dev/null
+++ b/bp2build/go_conversion_test.go
@@ -0,0 +1,150 @@
+// Copyright 2023 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 bp2build
+
+import (
+ "testing"
+
+ "github.com/google/blueprint/bootstrap"
+
+ "android/soong/android"
+)
+
+func runGoTests(t *testing.T, tc Bp2buildTestCase) {
+ RunBp2BuildTestCase(t, func(ctx android.RegistrationContext) {
+ tCtx := ctx.(*android.TestContext)
+ bootstrap.RegisterGoModuleTypes(tCtx.Context.Context) // android.TestContext --> android.Context --> blueprint.Context
+ }, tc)
+}
+
+func TestConvertGoPackage(t *testing.T) {
+ bp := `
+bootstrap_go_package {
+ name: "foo",
+ pkgPath: "android/foo",
+ deps: [
+ "bar",
+ ],
+ srcs: [
+ "foo1.go",
+ "foo2.go",
+ ],
+ linux: {
+ srcs: [
+ "foo_linux.go",
+ ],
+ },
+ darwin: {
+ srcs: [
+ "foo_darwin.go",
+ ],
+ },
+ testSrcs: [
+ "foo1_test.go",
+ "foo2_test.go",
+ ],
+}
+`
+ depBp := `
+bootstrap_go_package {
+ name: "bar",
+}
+`
+ t.Parallel()
+ runGoTests(t, Bp2buildTestCase{
+ Description: "Convert bootstrap_go_package to go_library",
+ ModuleTypeUnderTest: "bootrstap_go_package",
+ Blueprint: bp,
+ Filesystem: map[string]string{
+ "bar/Android.bp": depBp, // Put dep in Android.bp to reduce boilerplate in ExpectedBazelTargets
+ },
+ ExpectedBazelTargets: []string{makeBazelTargetHostOrDevice("go_library", "foo",
+ AttrNameToString{
+ "deps": `["//bar:bar"]`,
+ "importpath": `"android/foo"`,
+ "srcs": `[
+ "foo1.go",
+ "foo2.go",
+ ] + select({
+ "//build/bazel/platforms/os:darwin": ["foo_darwin.go"],
+ "//build/bazel/platforms/os:linux_glibc": ["foo_linux.go"],
+ "//conditions:default": [],
+ })`,
+ },
+ android.HostSupported,
+ )},
+ })
+}
+
+func TestConvertGoBinaryWithTransitiveDeps(t *testing.T) {
+ bp := `
+blueprint_go_binary {
+ name: "foo",
+ srcs: ["main.go"],
+ deps: ["bar"],
+}
+`
+ depBp := `
+bootstrap_go_package {
+ name: "bar",
+ deps: ["baz"],
+}
+bootstrap_go_package {
+ name: "baz",
+}
+`
+ t.Parallel()
+ runGoTests(t, Bp2buildTestCase{
+ Description: "Convert blueprint_go_binary to go_binary",
+ Blueprint: bp,
+ Filesystem: map[string]string{
+ "bar/Android.bp": depBp, // Put dep in Android.bp to reduce boilerplate in ExpectedBazelTargets
+ },
+ ExpectedBazelTargets: []string{makeBazelTargetHostOrDevice("go_binary", "foo",
+ AttrNameToString{
+ "deps": `[
+ "//bar:bar",
+ "//bar:baz",
+ ]`,
+ "srcs": `["main.go"]`,
+ },
+ android.HostSupported,
+ )},
+ })
+}
+
+func TestConvertGoBinaryWithSrcInDifferentPackage(t *testing.T) {
+ bp := `
+blueprint_go_binary {
+ name: "foo",
+ srcs: ["subdir/main.go"],
+}
+`
+ t.Parallel()
+ runGoTests(t, Bp2buildTestCase{
+ Description: "Convert blueprint_go_binary with src in different package",
+ Blueprint: bp,
+ Filesystem: map[string]string{
+ "subdir/Android.bp": "",
+ },
+ ExpectedBazelTargets: []string{makeBazelTargetHostOrDevice("go_binary", "foo",
+ AttrNameToString{
+ "deps": `[]`,
+ "srcs": `["//subdir:main.go"]`,
+ },
+ android.HostSupported,
+ )},
+ })
+}
diff --git a/cc/config/global.go b/cc/config/global.go
index 7f9a6e0..266d278 100644
--- a/cc/config/global.go
+++ b/cc/config/global.go
@@ -48,7 +48,6 @@
"-Wno-multichar",
"-O2",
- "-g",
"-fdebug-default-version=5",
"-fno-strict-aliasing",
@@ -377,6 +376,21 @@
flags = append(flags, "-Wno-error=unknown-warning-option")
}
+ switch ctx.Config().Getenv("CLANG_DEFAULT_DEBUG_LEVEL") {
+ case "debug_level_0":
+ flags = append(flags, "-g0")
+ case "debug_level_1":
+ flags = append(flags, "-g1")
+ case "debug_level_2":
+ flags = append(flags, "-g2")
+ case "debug_level_3":
+ flags = append(flags, "-g3")
+ case "debug_level_g":
+ flags = append(flags, "-g")
+ default:
+ flags = append(flags, "-g")
+ }
+
return strings.Join(flags, " ")
})
diff --git a/genrule/allowlists.go b/genrule/allowlists.go
index 22703fd..c6fa030 100644
--- a/genrule/allowlists.go
+++ b/genrule/allowlists.go
@@ -97,8 +97,6 @@
"BlueberryFacadeGeneratedStub_cc",
"BlueberryFacadeGeneratedStub_h",
"BluetoothGeneratedDumpsysDataSchema_h",
- "OpenwrtControlServerProto_cc",
- "OpenwrtControlServerProto_h",
"c2hal_test_genc++",
"c2hal_test_genc++_headers",
"hidl2aidl_test_gen_aidl",
diff --git a/java/aar.go b/java/aar.go
index 29e86e6..ed3c652 100644
--- a/java/aar.go
+++ b/java/aar.go
@@ -31,10 +31,9 @@
type AndroidLibraryDependency interface {
LibraryDependency
ExportPackage() android.Path
- ExportedRRODirs() []rroDir
- ExportedStaticPackages() android.Paths
- ExportedManifests() android.Paths
- ExportedAssets() android.OptionalPath
+ ResourcesNodeDepSet() *android.DepSet[resourcesNode]
+ RRODirsDepSet() *android.DepSet[rroDir]
+ ManifestsDepSet() *android.DepSet[android.Path]
SetRROEnforcedForDependent(enforce bool)
IsRROEnforced(ctx android.BaseModuleContext) bool
}
@@ -94,30 +93,32 @@
}
type aapt struct {
- aaptSrcJar android.Path
- exportPackage android.Path
- manifestPath android.Path
- transitiveManifestPaths android.Paths
- proguardOptionsFile android.Path
- rroDirs []rroDir
- rTxt android.Path
- extraAaptPackagesFile android.Path
- mergedManifestFile android.Path
- noticeFile android.OptionalPath
- assetPackage android.OptionalPath
- isLibrary bool
- defaultManifestVersion string
- useEmbeddedNativeLibs bool
- useEmbeddedDex bool
- usesNonSdkApis bool
- hasNoCode bool
- LoggingParent string
- resourceFiles android.Paths
+ aaptSrcJar android.Path
+ exportPackage android.Path
+ manifestPath android.Path
+ proguardOptionsFile android.Path
+ rTxt android.Path
+ extraAaptPackagesFile android.Path
+ mergedManifestFile android.Path
+ noticeFile android.OptionalPath
+ assetPackage android.OptionalPath
+ isLibrary bool
+ defaultManifestVersion string
+ useEmbeddedNativeLibs bool
+ useEmbeddedDex bool
+ usesNonSdkApis bool
+ hasNoCode bool
+ LoggingParent string
+ resourceFiles android.Paths
splitNames []string
splits []split
aaptProperties aaptProperties
+
+ resourcesNodesDepSet *android.DepSet[resourcesNode]
+ rroDirsDepSet *android.DepSet[rroDir]
+ manifestsDepSet *android.DepSet[android.Path]
}
type split struct {
@@ -141,17 +142,16 @@
func (a *aapt) ExportPackage() android.Path {
return a.exportPackage
}
-
-func (a *aapt) ExportedRRODirs() []rroDir {
- return a.rroDirs
+func (a *aapt) ResourcesNodeDepSet() *android.DepSet[resourcesNode] {
+ return a.resourcesNodesDepSet
}
-func (a *aapt) ExportedManifests() android.Paths {
- return a.transitiveManifestPaths
+func (a *aapt) RRODirsDepSet() *android.DepSet[rroDir] {
+ return a.rroDirsDepSet
}
-func (a *aapt) ExportedAssets() android.OptionalPath {
- return a.assetPackage
+func (a *aapt) ManifestsDepSet() *android.DepSet[android.Path] {
+ return a.manifestsDepSet
}
func (a *aapt) SetRROEnforcedForDependent(enforce bool) {
@@ -291,7 +291,7 @@
classLoaderContexts dexpreopt.ClassLoaderContextMap, excludedLibs []string,
enforceDefaultTargetSdkVersion bool, extraLinkFlags ...string) {
- transitiveStaticLibs, transitiveStaticLibManifests, staticRRODirs, assetPackages, libDeps, libFlags :=
+ staticResourcesNodesDepSet, staticRRODirsDepSet, staticManifestsDepSet, sharedDeps, libFlags :=
aaptLibs(ctx, sdkContext, classLoaderContexts)
// Exclude any libraries from the supplied list.
@@ -314,13 +314,20 @@
EnforceDefaultTargetSdkVersion: enforceDefaultTargetSdkVersion,
})
+ staticDeps := transitiveAarDeps(staticResourcesNodesDepSet.ToList())
+
// Add additional manifest files to transitive manifests.
additionalManifests := android.PathsForModuleSrc(ctx, a.aaptProperties.Additional_manifests)
- a.transitiveManifestPaths = append(android.Paths{manifestPath}, additionalManifests...)
- a.transitiveManifestPaths = append(a.transitiveManifestPaths, transitiveStaticLibManifests...)
+ transitiveManifestPaths := append(android.Paths{manifestPath}, additionalManifests...)
+ // TODO(b/288358614): Soong has historically not merged manifests from dependencies of android_library_import
+ // modules. Merging manifests from dependencies could remove the need for pom2bp to generate the "-nodeps" copies
+ // of androidx libraries, but doing so triggers errors due to errors introduced by existing dependencies of
+ // android_library_import modules. If this is fixed, staticManifestsDepSet can be dropped completely in favor of
+ // staticResourcesNodesDepSet.manifests()
+ transitiveManifestPaths = append(transitiveManifestPaths, staticManifestsDepSet.ToList()...)
- if len(a.transitiveManifestPaths) > 1 && !Bool(a.aaptProperties.Dont_merge_manifests) {
- a.mergedManifestFile = manifestMerger(ctx, a.transitiveManifestPaths[0], a.transitiveManifestPaths[1:], a.isLibrary)
+ if len(transitiveManifestPaths) > 1 && !Bool(a.aaptProperties.Dont_merge_manifests) {
+ a.mergedManifestFile = manifestMerger(ctx, transitiveManifestPaths[0], transitiveManifestPaths[1:], a.isLibrary)
if !a.isLibrary {
// Only use the merged manifest for applications. For libraries, the transitive closure of manifests
// will be propagated to the final application and merged there. The merged manifest for libraries is
@@ -333,9 +340,9 @@
compileFlags, linkFlags, linkDeps, resDirs, overlayDirs, rroDirs, resZips := a.aapt2Flags(ctx, sdkContext, manifestPath)
- rroDirs = append(rroDirs, staticRRODirs...)
linkFlags = append(linkFlags, libFlags...)
- linkDeps = append(linkDeps, libDeps...)
+ linkDeps = append(linkDeps, sharedDeps...)
+ linkDeps = append(linkDeps, staticDeps.resPackages()...)
linkFlags = append(linkFlags, extraLinkFlags...)
if a.isLibrary {
linkFlags = append(linkFlags, "--static-lib")
@@ -363,6 +370,10 @@
var compiledRes, compiledOverlay android.Paths
+ // AAPT2 overlays are in lowest to highest priority order, reverse the topological order
+ // of transitiveStaticLibs.
+ transitiveStaticLibs := android.ReversePaths(staticDeps.resPackages())
+
compiledOverlay = append(compiledOverlay, transitiveStaticLibs...)
if len(transitiveStaticLibs) > 0 {
@@ -404,12 +415,18 @@
})
}
+ // No need to specify assets from dependencies to aapt2Link for libraries, all transitive assets will be
+ // provided to the final app aapt2Link step.
+ var transitiveAssets android.Paths
+ if !a.isLibrary {
+ transitiveAssets = android.ReverseSliceInPlace(staticDeps.assets())
+ }
aapt2Link(ctx, packageRes, srcJar, proguardOptionsFile, rTxt, extraPackages,
- linkFlags, linkDeps, compiledRes, compiledOverlay, assetPackages, splitPackages)
+ linkFlags, linkDeps, compiledRes, compiledOverlay, transitiveAssets, splitPackages)
// Extract assets from the resource package output so that they can be used later in aapt2link
// for modules that depend on this one.
- if android.PrefixInList(linkFlags, "-A ") || len(assetPackages) > 0 {
+ if android.PrefixInList(linkFlags, "-A ") {
assets := android.PathForModuleOut(ctx, "assets.zip")
ctx.Build(pctx, android.BuildParams{
Rule: extractAssetsRule,
@@ -424,17 +441,62 @@
a.exportPackage = packageRes
a.manifestPath = manifestPath
a.proguardOptionsFile = proguardOptionsFile
- a.rroDirs = rroDirs
a.extraAaptPackagesFile = extraPackages
a.rTxt = rTxt
a.splits = splits
+ a.resourcesNodesDepSet = android.NewDepSetBuilder[resourcesNode](android.TOPOLOGICAL).
+ Direct(resourcesNode{
+ resPackage: a.exportPackage,
+ manifest: a.manifestPath,
+ assets: a.assetPackage,
+ }).
+ Transitive(staticResourcesNodesDepSet).Build()
+ a.rroDirsDepSet = android.NewDepSetBuilder[rroDir](android.TOPOLOGICAL).
+ Direct(rroDirs...).
+ Transitive(staticRRODirsDepSet).Build()
+ a.manifestsDepSet = android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).
+ Direct(a.manifestPath).
+ Transitive(staticManifestsDepSet).Build()
+}
+
+type resourcesNode struct {
+ resPackage android.Path
+ manifest android.Path
+ assets android.OptionalPath
+}
+
+type transitiveAarDeps []resourcesNode
+
+func (t transitiveAarDeps) resPackages() android.Paths {
+ var paths android.Paths
+ for _, dep := range t {
+ paths = append(paths, dep.resPackage)
+ }
+ return android.FirstUniquePaths(paths)
+}
+
+func (t transitiveAarDeps) manifests() android.Paths {
+ var paths android.Paths
+ for _, dep := range t {
+ paths = append(paths, dep.manifest)
+ }
+ return android.FirstUniquePaths(paths)
+}
+
+func (t transitiveAarDeps) assets() android.Paths {
+ var paths android.Paths
+ for _, dep := range t {
+ if dep.assets.Valid() {
+ paths = append(paths, dep.assets.Path())
+ }
+ }
+ return paths
}
// aaptLibs collects libraries from dependencies and sdk_version and converts them into paths
func aaptLibs(ctx android.ModuleContext, sdkContext android.SdkContext, classLoaderContexts dexpreopt.ClassLoaderContextMap) (
- transitiveStaticLibs, transitiveStaticLibManifests android.Paths, staticRRODirs []rroDir, assets, deps android.Paths, flags []string) {
-
- var sharedLibs android.Paths
+ staticResourcesNodes *android.DepSet[resourcesNode], staticRRODirs *android.DepSet[rroDir],
+ staticManifests *android.DepSet[android.Path], sharedLibs android.Paths, flags []string) {
if classLoaderContexts == nil {
// Not all callers need to compute class loader context, those who don't just pass nil.
@@ -447,6 +509,10 @@
sharedLibs = append(sharedLibs, sdkDep.jars...)
}
+ var resourcesNodeDepSets []*android.DepSet[resourcesNode]
+ rroDirsDepSetBuilder := android.NewDepSetBuilder[rroDir](android.TOPOLOGICAL)
+ manifestsDepSetBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
+
ctx.VisitDirectDeps(func(module android.Module) {
depTag := ctx.OtherModuleDependencyTag(module)
@@ -469,32 +535,28 @@
}
case staticLibTag:
if exportPackage != nil {
- transitiveStaticLibs = append(transitiveStaticLibs, aarDep.ExportedStaticPackages()...)
- transitiveStaticLibs = append(transitiveStaticLibs, exportPackage)
- transitiveStaticLibManifests = append(transitiveStaticLibManifests, aarDep.ExportedManifests()...)
- if aarDep.ExportedAssets().Valid() {
- assets = append(assets, aarDep.ExportedAssets().Path())
- }
-
- outer:
- for _, d := range aarDep.ExportedRRODirs() {
- for _, e := range staticRRODirs {
- if d.path == e.path {
- continue outer
- }
- }
- staticRRODirs = append(staticRRODirs, d)
- }
+ resourcesNodeDepSets = append(resourcesNodeDepSets, aarDep.ResourcesNodeDepSet())
+ rroDirsDepSetBuilder.Transitive(aarDep.RRODirsDepSet())
+ manifestsDepSetBuilder.Transitive(aarDep.ManifestsDepSet())
}
}
addCLCFromDep(ctx, module, classLoaderContexts)
})
- deps = append(deps, sharedLibs...)
- deps = append(deps, transitiveStaticLibs...)
+ // AAPT2 overlays are in lowest to highest priority order, the topological order will be reversed later.
+ // Reverse the dependency order now going into the depset so that it comes out in order after the second
+ // reverse later.
+ // NOTE: this is legacy and probably incorrect behavior, for most other cases (e.g. conflicting classes in
+ // dependencies) the highest priority dependency is listed first, but for resources the highest priority
+ // dependency has to be listed last.
+ staticResourcesNodes = android.NewDepSet(android.TOPOLOGICAL, nil,
+ android.ReverseSliceInPlace(resourcesNodeDepSets))
- if len(transitiveStaticLibs) > 0 {
+ staticRRODirs = rroDirsDepSetBuilder.Build()
+ staticManifests = manifestsDepSetBuilder.Build()
+
+ if len(staticResourcesNodes.ToList()) > 0 {
flags = append(flags, "--auto-add-overlay")
}
@@ -502,10 +564,7 @@
flags = append(flags, "-I "+sharedLib.String())
}
- transitiveStaticLibs = android.FirstUniquePaths(transitiveStaticLibs)
- transitiveStaticLibManifests = android.FirstUniquePaths(transitiveStaticLibManifests)
-
- return transitiveStaticLibs, transitiveStaticLibManifests, staticRRODirs, assets, deps, flags
+ return staticResourcesNodes, staticRRODirs, staticManifests, sharedLibs, flags
}
type AndroidLibrary struct {
@@ -516,8 +575,6 @@
androidLibraryProperties androidLibraryProperties
aarFile android.WritablePath
-
- exportedStaticPackages android.Paths
}
var _ android.OutputFileProducer = (*AndroidLibrary)(nil)
@@ -532,10 +589,6 @@
}
}
-func (a *AndroidLibrary) ExportedStaticPackages() android.Paths {
- return a.exportedStaticPackages
-}
-
var _ AndroidLibraryDependency = (*AndroidLibrary)(nil)
func (a *AndroidLibrary) DepsMutator(ctx android.BottomUpMutatorContext) {
@@ -579,19 +632,15 @@
a.exportedProguardFlagFiles = append(a.exportedProguardFlagFiles,
android.PathsForModuleSrc(ctx, a.dexProperties.Optimize.Proguard_flags_files)...)
+
ctx.VisitDirectDeps(func(m android.Module) {
if ctx.OtherModuleDependencyTag(m) == staticLibTag {
if lib, ok := m.(LibraryDependency); ok {
a.exportedProguardFlagFiles = append(a.exportedProguardFlagFiles, lib.ExportedProguardFlagFiles()...)
}
- if alib, ok := m.(AndroidLibraryDependency); ok {
- a.exportedStaticPackages = append(a.exportedStaticPackages, alib.ExportPackage())
- a.exportedStaticPackages = append(a.exportedStaticPackages, alib.ExportedStaticPackages()...)
- }
}
})
a.exportedProguardFlagFiles = android.FirstUniquePaths(a.exportedProguardFlagFiles)
- a.exportedStaticPackages = android.FirstUniquePaths(a.exportedStaticPackages)
prebuiltJniPackages := android.Paths{}
ctx.VisitDirectDeps(func(module android.Module) {
@@ -681,7 +730,8 @@
manifest android.WritablePath
assetsPackage android.WritablePath
- exportedStaticPackages android.Paths
+ resourcesNodesDepSet *android.DepSet[resourcesNode]
+ manifestsDepSet *android.DepSet[android.Path]
hideApexVariantFromMake bool
@@ -738,25 +788,20 @@
func (a *AARImport) ExportPackage() android.Path {
return a.exportPackage
}
-
func (a *AARImport) ExportedProguardFlagFiles() android.Paths {
return android.Paths{a.proguardFlags}
}
-func (a *AARImport) ExportedRRODirs() []rroDir {
- return nil
+func (a *AARImport) ResourcesNodeDepSet() *android.DepSet[resourcesNode] {
+ return a.resourcesNodesDepSet
}
-func (a *AARImport) ExportedStaticPackages() android.Paths {
- return a.exportedStaticPackages
+func (a *AARImport) RRODirsDepSet() *android.DepSet[rroDir] {
+ return android.NewDepSet[rroDir](android.TOPOLOGICAL, nil, nil)
}
-func (a *AARImport) ExportedManifests() android.Paths {
- return android.Paths{a.manifest}
-}
-
-func (a *AARImport) ExportedAssets() android.OptionalPath {
- return android.OptionalPathForPath(a.assetsPackage)
+func (a *AARImport) ManifestsDepSet() *android.DepSet[android.Path] {
+ return a.manifestsDepSet
}
// RRO enforcement is not available on aar_import since its RRO dirs are not
@@ -891,32 +936,44 @@
linkFlags = append(linkFlags, "--manifest "+a.manifest.String())
linkDeps = append(linkDeps, a.manifest)
- transitiveStaticLibs, staticLibManifests, staticRRODirs, transitiveAssets, libDeps, libFlags :=
+ staticResourcesNodesDepSet, staticRRODirsDepSet, staticManifestsDepSet, sharedLibs, libFlags :=
aaptLibs(ctx, android.SdkContext(a), nil)
- _ = staticLibManifests
- _ = staticRRODirs
+ _ = staticRRODirsDepSet
+ staticDeps := transitiveAarDeps(staticResourcesNodesDepSet.ToList())
- linkDeps = append(linkDeps, libDeps...)
+ // AAPT2 overlays are in lowest to highest priority order, reverse the topological order
+ // of transitiveStaticLibs.
+ transitiveStaticLibs := android.ReversePaths(staticDeps.resPackages())
+
+ linkDeps = append(linkDeps, sharedLibs...)
+ linkDeps = append(linkDeps, transitiveStaticLibs...)
linkFlags = append(linkFlags, libFlags...)
overlayRes := append(android.Paths{flata}, transitiveStaticLibs...)
+ transitiveAssets := android.ReverseSliceInPlace(staticDeps.assets())
aapt2Link(ctx, a.exportPackage, srcJar, proguardOptionsFile, rTxt, a.extraAaptPackagesFile,
linkFlags, linkDeps, nil, overlayRes, transitiveAssets, nil)
- // Merge this import's assets with its dependencies' assets (if there are any).
- if len(transitiveAssets) > 0 {
- mergedAssets := android.PathForModuleOut(ctx, "merged-assets.zip")
- inputZips := append(android.Paths{a.assetsPackage}, transitiveAssets...)
- ctx.Build(pctx, android.BuildParams{
- Rule: mergeAssetsRule,
- Inputs: inputZips,
- Output: mergedAssets,
- Description: "merge assets from dependencies and self",
- })
- a.assetsPackage = mergedAssets
- }
+ resourcesNodesDepSetBuilder := android.NewDepSetBuilder[resourcesNode](android.TOPOLOGICAL)
+ resourcesNodesDepSetBuilder.Direct(resourcesNode{
+ resPackage: a.exportPackage,
+ manifest: a.manifest,
+ assets: android.OptionalPathForPath(a.assetsPackage),
+ })
+ resourcesNodesDepSetBuilder.Transitive(staticResourcesNodesDepSet)
+ a.resourcesNodesDepSet = resourcesNodesDepSetBuilder.Build()
+
+ manifestDepSetBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(a.manifest)
+ // TODO(b/288358614): Soong has historically not merged manifests from dependencies of android_library_import
+ // modules. Merging manifests from dependencies could remove the need for pom2bp to generate the "-nodeps" copies
+ // of androidx libraries, but doing so triggers errors due to errors introduced by existing dependencies of
+ // android_library_import modules. If this is fixed, AndroidLibraryDependency.ManifestsDepSet can be dropped
+ // completely in favor of AndroidLibraryDependency.ResourceNodesDepSet.manifest
+ //manifestDepSetBuilder.Transitive(transitiveStaticDeps.manifests)
+ _ = staticManifestsDepSet
+ a.manifestsDepSet = manifestDepSetBuilder.Build()
a.collectTransitiveHeaderJars(ctx)
ctx.SetProvider(JavaInfoProvider, JavaInfo{
diff --git a/java/androidmk.go b/java/androidmk.go
index 9c21633..13cc96a 100644
--- a/java/androidmk.go
+++ b/java/androidmk.go
@@ -368,8 +368,13 @@
filterRRO := func(filter overlayType) android.Paths {
var paths android.Paths
- for _, d := range app.rroDirs {
+ seen := make(map[android.Path]bool)
+ for _, d := range app.rroDirsDepSet.ToList() {
if d.overlayType == filter {
+ if seen[d.path] {
+ continue
+ }
+ seen[d.path] = true
paths = append(paths, d.path)
}
}
diff --git a/java/app.go b/java/app.go
index fd626e1..10010e4 100755
--- a/java/app.go
+++ b/java/app.go
@@ -204,8 +204,8 @@
return nil
}
-func (a *AndroidApp) ExportedStaticPackages() android.Paths {
- return nil
+func (a *AndroidApp) ResourcesNodeDepSet() *android.DepSet[resourcesNode] {
+ return a.aapt.resourcesNodesDepSet
}
func (a *AndroidApp) OutputFile() android.Path {
diff --git a/java/app_test.go b/java/app_test.go
index 12c3a95..c438b6c 100644
--- a/java/app_test.go
+++ b/java/app_test.go
@@ -599,7 +599,7 @@
android_library {
name: "lib3",
sdk_version: "current",
- static_libs: ["lib4"],
+ static_libs: ["lib4", "import"],
}
android_library {
@@ -607,6 +607,12 @@
sdk_version: "current",
asset_dirs: ["assets_b"],
}
+
+ android_library_import {
+ name: "import",
+ sdk_version: "current",
+ aars: ["import.aar"],
+ }
`
testCases := []struct {
@@ -616,11 +622,12 @@
}{
{
name: "foo",
- // lib1 has its own asset. lib3 doesn't have any, but provides lib4's transitively.
+ // lib1 has its own assets. lib3 doesn't have any, but lib4 and import have assets.
assetPackages: []string{
"out/soong/.intermediates/foo/android_common/aapt2/package-res.apk",
"out/soong/.intermediates/lib1/android_common/assets.zip",
- "out/soong/.intermediates/lib3/android_common/assets.zip",
+ "out/soong/.intermediates/lib4/android_common/assets.zip",
+ "out/soong/.intermediates/import/android_common/assets.zip",
},
},
{
@@ -632,10 +639,6 @@
},
{
name: "lib3",
- assetPackages: []string{
- "out/soong/.intermediates/lib3/android_common/aapt2/package-res.apk",
- "out/soong/.intermediates/lib4/android_common/assets.zip",
- },
},
{
name: "lib4",
@@ -761,11 +764,14 @@
appResources: nil,
appOverlays: []string{
"out/soong/.intermediates/transitive/android_common/package-res.apk",
+ "out/soong/.intermediates/transitive_import_dep/android_common/package-res.apk",
"out/soong/.intermediates/transitive_import/android_common/package-res.apk",
"out/soong/.intermediates/direct/android_common/package-res.apk",
+ "out/soong/.intermediates/direct_import_dep/android_common/package-res.apk",
"out/soong/.intermediates/direct_import/android_common/package-res.apk",
"out/soong/.intermediates/app/android_common/aapt2/app/res/values_strings.arsc.flat",
},
+
appImports: []string{"out/soong/.intermediates/default/java/framework-res/android_common/package-res.apk"},
appSrcJars: []string{"out/soong/.intermediates/app/android_common/gen/android/R.srcjar"},
appClasspath: []string{
@@ -782,9 +788,11 @@
directResources: nil,
directOverlays: []string{
"out/soong/.intermediates/transitive/android_common/package-res.apk",
+ "out/soong/.intermediates/transitive_import_dep/android_common/package-res.apk",
"out/soong/.intermediates/transitive_import/android_common/package-res.apk",
"out/soong/.intermediates/direct/android_common/aapt2/direct/res/values_strings.arsc.flat",
},
+
directImports: []string{"out/soong/.intermediates/default/java/framework-res/android_common/package-res.apk"},
directSrcJars: []string{"out/soong/.intermediates/direct/android_common/gen/android/R.srcjar"},
directClasspath: []string{
@@ -1198,7 +1206,7 @@
overlayFiles = resourceListToFiles(module, android.PathsRelativeToTop(overlayList.Inputs))
}
- for _, d := range module.Module().(AndroidLibraryDependency).ExportedRRODirs() {
+ for _, d := range module.Module().(AndroidLibraryDependency).RRODirsDepSet().ToList() {
var prefix string
if d.overlayType == device {
prefix = "device:"
diff --git a/java/base.go b/java/base.go
index f2ad5c2..cb08ef3 100644
--- a/java/base.go
+++ b/java/base.go
@@ -500,6 +500,8 @@
maxSdkVersion android.ApiLevel
sourceExtensions []string
+
+ annoSrcJars android.Paths
}
func (j *Module) CheckStableSdkVersion(ctx android.BaseModuleContext) error {
@@ -1255,8 +1257,9 @@
// this module, or else we could have duplicated errorprone messages.
errorproneFlags := enableErrorproneFlags(flags)
errorprone := android.PathForModuleOut(ctx, "errorprone", jarName)
+ errorproneAnnoSrcJar := android.PathForModuleOut(ctx, "errorprone", "anno.srcjar")
- transformJavaToClasses(ctx, errorprone, -1, uniqueJavaFiles, srcJars, errorproneFlags, nil,
+ transformJavaToClasses(ctx, errorprone, -1, uniqueJavaFiles, srcJars, errorproneAnnoSrcJar, errorproneFlags, nil,
"errorprone", "errorprone")
extraJarDeps = append(extraJarDeps, errorprone)
@@ -1657,13 +1660,15 @@
srcFiles, srcJars android.Paths, flags javaBuilderFlags, extraJarDeps android.Paths) android.WritablePath {
kzipName := pathtools.ReplaceExtension(jarName, "kzip")
+ annoSrcJar := android.PathForModuleOut(ctx, "javac", "anno.srcjar")
if idx >= 0 {
kzipName = strings.TrimSuffix(jarName, filepath.Ext(jarName)) + strconv.Itoa(idx) + ".kzip"
+ annoSrcJar = android.PathForModuleOut(ctx, "javac", "anno-"+strconv.Itoa(idx)+".srcjar")
jarName += strconv.Itoa(idx)
}
classes := android.PathForModuleOut(ctx, "javac", jarName).OutputPath
- TransformJavaToClasses(ctx, classes, idx, srcFiles, srcJars, flags, extraJarDeps)
+ TransformJavaToClasses(ctx, classes, idx, srcFiles, srcJars, annoSrcJar, flags, extraJarDeps)
if ctx.Config().EmitXrefRules() {
extractionFile := android.PathForModuleOut(ctx, kzipName)
@@ -1671,6 +1676,10 @@
j.kytheFiles = append(j.kytheFiles, extractionFile)
}
+ if len(flags.processorPath) > 0 {
+ j.annoSrcJars = append(j.annoSrcJars, annoSrcJar)
+ }
+
return classes
}
@@ -1850,6 +1859,7 @@
dpInfo.Paths = append(dpInfo.Paths, j.modulePaths...)
dpInfo.Static_libs = append(dpInfo.Static_libs, j.properties.Static_libs...)
dpInfo.Libs = append(dpInfo.Libs, j.properties.Libs...)
+ dpInfo.SrcJars = append(dpInfo.SrcJars, j.annoSrcJars.Strings()...)
}
func (j *Module) CompilerDeps() []string {
diff --git a/java/builder.go b/java/builder.go
index c4395e9..be4af55 100644
--- a/java/builder.go
+++ b/java/builder.go
@@ -42,7 +42,8 @@
// TODO(b/143658984): goma can't handle the --system argument to javac.
javac, javacRE = pctx.MultiCommandRemoteStaticRules("javac",
blueprint.RuleParams{
- Command: `rm -rf "$outDir" "$annoDir" "$srcJarDir" "$out" && mkdir -p "$outDir" "$annoDir" "$srcJarDir" && ` +
+ Command: `rm -rf "$outDir" "$annoDir" "$annoSrcJar" "$srcJarDir" "$out" && ` +
+ `mkdir -p "$outDir" "$annoDir" "$srcJarDir" && ` +
`${config.ZipSyncCmd} -d $srcJarDir -l $srcJarDir/list -f "*.java" $srcJars && ` +
`(if [ -s $srcJarDir/list ] || [ -s $out.rsp ] ; then ` +
`${config.SoongJavacWrapper} $javaTemplate${config.JavacCmd} ` +
@@ -50,6 +51,7 @@
`$processorpath $processor $javacFlags $bootClasspath $classpath ` +
`-source $javaVersion -target $javaVersion ` +
`-d $outDir -s $annoDir @$out.rsp @$srcJarDir/list ; fi ) && ` +
+ `$annoSrcJarTemplate${config.SoongZipCmd} -jar -o $annoSrcJar -C $annoDir -D $annoDir && ` +
`$zipTemplate${config.SoongZipCmd} -jar -o $out -C $outDir -D $outDir && ` +
`rm -rf "$srcJarDir"`,
CommandDeps: []string{
@@ -73,8 +75,15 @@
ExecStrategy: "${config.REJavacExecStrategy}",
Platform: map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
},
+ "$annoSrcJarTemplate": &remoteexec.REParams{
+ Labels: map[string]string{"type": "tool", "name": "soong_zip"},
+ Inputs: []string{"${config.SoongZipCmd}", "$annoDir"},
+ OutputFiles: []string{"$annoSrcJar"},
+ ExecStrategy: "${config.REJavacExecStrategy}",
+ Platform: map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
+ },
}, []string{"javacFlags", "bootClasspath", "classpath", "processorpath", "processor", "srcJars", "srcJarDir",
- "outDir", "annoDir", "javaVersion"}, nil)
+ "outDir", "annoDir", "annoSrcJar", "javaVersion"}, nil)
_ = pctx.VariableFunc("kytheCorpus",
func(ctx android.PackageVarContext) string { return ctx.Config().XrefCorpusName() })
@@ -312,7 +321,7 @@
}
func TransformJavaToClasses(ctx android.ModuleContext, outputFile android.WritablePath, shardIdx int,
- srcFiles, srcJars android.Paths, flags javaBuilderFlags, deps android.Paths) {
+ srcFiles, srcJars android.Paths, annoSrcJar android.WritablePath, flags javaBuilderFlags, deps android.Paths) {
// Compile java sources into .class files
desc := "javac"
@@ -320,7 +329,7 @@
desc += strconv.Itoa(shardIdx)
}
- transformJavaToClasses(ctx, outputFile, shardIdx, srcFiles, srcJars, flags, deps, "javac", desc)
+ transformJavaToClasses(ctx, outputFile, shardIdx, srcFiles, srcJars, annoSrcJar, flags, deps, "javac", desc)
}
// Emits the rule to generate Xref input file (.kzip file) for the given set of source files and source jars
@@ -494,7 +503,7 @@
// suffix will be appended to various intermediate files and directories to avoid collisions when
// this function is called twice in the same module directory.
func transformJavaToClasses(ctx android.ModuleContext, outputFile android.WritablePath,
- shardIdx int, srcFiles, srcJars android.Paths,
+ shardIdx int, srcFiles, srcJars android.Paths, annoSrcJar android.WritablePath,
flags javaBuilderFlags, deps android.Paths,
intermediatesDir, desc string) {
@@ -541,11 +550,12 @@
rule = javacRE
}
ctx.Build(pctx, android.BuildParams{
- Rule: rule,
- Description: desc,
- Output: outputFile,
- Inputs: srcFiles,
- Implicits: deps,
+ Rule: rule,
+ Description: desc,
+ Output: outputFile,
+ ImplicitOutput: annoSrcJar,
+ Inputs: srcFiles,
+ Implicits: deps,
Args: map[string]string{
"javacFlags": flags.javacFlags,
"bootClasspath": bootClasspath,
@@ -556,6 +566,7 @@
"srcJarDir": android.PathForModuleOut(ctx, intermediatesDir, srcJarDir).String(),
"outDir": android.PathForModuleOut(ctx, intermediatesDir, outDir).String(),
"annoDir": android.PathForModuleOut(ctx, intermediatesDir, annoDir).String(),
+ "annoSrcJar": annoSrcJar.String(),
"javaVersion": flags.javaVersion.String(),
},
})
diff --git a/java/droidstubs.go b/java/droidstubs.go
index 151c94a..bb2388f 100644
--- a/java/droidstubs.go
+++ b/java/droidstubs.go
@@ -525,8 +525,7 @@
cmd.FlagWithInputList("-classpath ", classpath.Paths(), ":")
}
- cmd.Flag("--no-banner").
- Flag("--color").
+ cmd.Flag("--color").
Flag("--quiet").
Flag("--format=v2").
FlagWithArg("--repeat-errors-max ", "10").
diff --git a/java/hiddenapi_modular.go b/java/hiddenapi_modular.go
index c6b921b..f31f5d1 100644
--- a/java/hiddenapi_modular.go
+++ b/java/hiddenapi_modular.go
@@ -1236,7 +1236,6 @@
rule := android.NewRuleBuilder(pctx, ctx)
rule.Command().
BuiltTool("metalava").
- Flag("--no-banner").
Inputs(removedTxtFiles).
FlagWithOutput("--dex-api ", output)
rule.Build("modular-hiddenapi-removed-dex-signatures"+suffix, "modular hiddenapi removed dex signatures"+suffix)
diff --git a/java/java.go b/java/java.go
index 50d48ab..d3762f6 100644
--- a/java/java.go
+++ b/java/java.go
@@ -1716,8 +1716,7 @@
FlagWithArg("-encoding ", "UTF-8").
FlagWithInputList("--source-files ", srcs, " ")
- cmd.Flag("--no-banner").
- Flag("--color").
+ cmd.Flag("--color").
Flag("--quiet").
Flag("--format=v2").
Flag("--include-annotations").
@@ -1878,8 +1877,10 @@
flags.javacFlags = strings.Join(al.properties.Javacflags, " ")
flags.classpath = classpath(classPaths)
+ annoSrcJar := android.PathForModuleOut(ctx, ctx.ModuleName(), "anno.srcjar")
+
TransformJavaToClasses(ctx, al.stubsJarWithoutStaticLibs, 0, android.Paths{},
- android.Paths{al.stubsSrcJar}, flags, android.Paths{})
+ android.Paths{al.stubsSrcJar}, annoSrcJar, flags, android.Paths{})
}
builder := android.NewRuleBuilder(pctx, ctx)
diff --git a/tests/sbom_test.sh b/tests/sbom_test.sh
index 30a1d37..1241e89 100755
--- a/tests/sbom_test.sh
+++ b/tests/sbom_test.sh
@@ -111,6 +111,14 @@
-I /system/lib64/android.hardware.security.rkp-V3-ndk.so \
-I /system/lib64/android.hardware.security.sharedsecret-V1-ndk.so \
-I /system/lib64/android.security.compat-ndk.so \
+ -I /system/lib64/libcuttlefish_allocd_utils.so \
+ -I /system/lib64/libcuttlefish_device_config_proto.so \
+ -I /system/lib64/libcuttlefish_device_config.so \
+ -I /system/lib64/libcuttlefish_fs.so \
+ -I /system/lib64/libcuttlefish_kernel_log_monitor_utils.so \
+ -I /system/lib64/libcuttlefish_utils.so \
+ -I /system/lib64/libfruit.so \
+ -I /system/lib64/libgflags.so \
-I /system/lib64/libkeymaster4_1support.so \
-I /system/lib64/libkeymaster4support.so \
-I /system/lib64/libkeymint.so \
diff --git a/ui/metrics/bp2build_progress_metrics_proto/bp2build.proto b/ui/metrics/bp2build_progress_metrics_proto/bp2build.proto
index 4aee88b..5b44002 100644
--- a/ui/metrics/bp2build_progress_metrics_proto/bp2build.proto
+++ b/ui/metrics/bp2build_progress_metrics_proto/bp2build.proto
@@ -38,6 +38,9 @@
// Total number of transitive dependencies.
int32 num_deps = 5;
+
+ // Unconverted reasons from heuristics
+ repeated string unconverted_reasons_from_heuristics = 6;
}
// Modules that the transitive dependencies were identified for.
diff --git a/zip/cmd/main.go b/zip/cmd/main.go
index a2ccc20..5231fae 100644
--- a/zip/cmd/main.go
+++ b/zip/cmd/main.go
@@ -173,6 +173,7 @@
cpuProfile := flags.String("cpuprofile", "", "write cpu profile to file")
traceFile := flags.String("trace", "", "write trace to file")
sha256Checksum := flags.Bool("sha256", false, "add a zip header to each file containing its SHA256 digest")
+ doNotWrite := flags.Bool("n", false, "Nothing is written to disk -- all other work happens")
flags.Var(&rootPrefix{}, "P", "path prefix within the zip at which to place files")
flags.Var(&listFiles{}, "l", "file containing list of files to zip")
@@ -236,6 +237,7 @@
StoreSymlinks: *symlinks,
IgnoreMissingFiles: *ignoreMissingFiles,
Sha256Checksum: *sha256Checksum,
+ DoNotWrite: *doNotWrite,
})
if err != nil {
fmt.Fprintln(os.Stderr, "error:", err.Error())
diff --git a/zip/zip.go b/zip/zip.go
index 5e1a104..30a2ee7 100644
--- a/zip/zip.go
+++ b/zip/zip.go
@@ -282,6 +282,7 @@
StoreSymlinks bool
IgnoreMissingFiles bool
Sha256Checksum bool
+ DoNotWrite bool
Stderr io.Writer
Filesystem pathtools.FileSystem
@@ -400,7 +401,9 @@
var zipErr error
- if !args.WriteIfChanged {
+ if args.DoNotWrite {
+ out = io.Discard
+ } else if !args.WriteIfChanged {
f, err := os.Create(args.OutputFilePath)
if err != nil {
return err
@@ -421,7 +424,7 @@
return zipErr
}
- if args.WriteIfChanged {
+ if args.WriteIfChanged && !args.DoNotWrite {
err := pathtools.WriteFileIfChanged(args.OutputFilePath, buf.Bytes(), 0666)
if err != nil {
return err