Merge "Remove cts renderscript modules from sandboxing denylist"
diff --git a/aconfig/Android.bp b/aconfig/Android.bp
new file mode 100644
index 0000000..ae8276f
--- /dev/null
+++ b/aconfig/Android.bp
@@ -0,0 +1,33 @@
+package {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+bootstrap_go_package {
+ name: "soong-aconfig",
+ pkgPath: "android/soong/aconfig",
+ deps: [
+ "blueprint",
+ "blueprint-pathtools",
+ "sbox_proto",
+ "soong",
+ "soong-android",
+ "soong-bazel",
+ "soong-android",
+ "soong-java",
+ ],
+ srcs: [
+ "aconfig_declarations.go",
+ "aconfig_values.go",
+ "aconfig_value_set.go",
+ "all_aconfig_declarations.go",
+ "init.go",
+ "java_aconfig_library.go",
+ "testing.go",
+ ],
+ testSrcs: [
+ "aconfig_declarations_test.go",
+ "aconfig_values_test.go",
+ "aconfig_value_set_test.go",
+ ],
+ pluginFor: ["soong_build"],
+}
diff --git a/device_config/device_config_definitions.go b/aconfig/aconfig_declarations.go
similarity index 62%
rename from device_config/device_config_definitions.go
rename to aconfig/aconfig_declarations.go
index ab2e4f7..007d529 100644
--- a/device_config/device_config_definitions.go
+++ b/aconfig/aconfig_declarations.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"android/soong/android"
@@ -21,27 +21,27 @@
"strings"
)
-type DefinitionsModule struct {
+type DeclarationsModule struct {
android.ModuleBase
android.DefaultableModuleBase
- // Properties for "device_config_definitions"
+ // Properties for "aconfig_declarations"
properties struct {
// aconfig files, relative to this Android.bp file
Srcs []string `android:"path"`
- // Release config flag namespace
- Namespace string
+ // Release config flag package
+ Package string
- // Values from TARGET_RELEASE / RELEASE_DEVICE_CONFIG_VALUE_SETS
+ // Values from TARGET_RELEASE / RELEASE_ACONFIG_VALUE_SETS
Values []string `blueprint:"mutated"`
}
intermediatePath android.WritablePath
}
-func DefinitionsFactory() android.Module {
- module := &DefinitionsModule{}
+func DeclarationsFactory() android.Module {
+ module := &DeclarationsModule{}
android.InitAndroidModule(module)
android.InitDefaultableModule(module)
@@ -58,24 +58,24 @@
var implicitValuesTag = implicitValuesTagType{}
-func (module *DefinitionsModule) DepsMutator(ctx android.BottomUpMutatorContext) {
+func (module *DeclarationsModule) DepsMutator(ctx android.BottomUpMutatorContext) {
// Validate Properties
if len(module.properties.Srcs) == 0 {
ctx.PropertyErrorf("srcs", "missing source files")
return
}
- if len(module.properties.Namespace) == 0 {
- ctx.PropertyErrorf("namespace", "missing namespace property")
+ if len(module.properties.Package) == 0 {
+ ctx.PropertyErrorf("package", "missing package property")
}
- // Add a dependency on the device_config_value_sets defined in
- // RELEASE_DEVICE_CONFIG_VALUE_SETS, and add any device_config_values that
- // match our namespace.
- valuesFromConfig := ctx.Config().ReleaseDeviceConfigValueSets()
+ // Add a dependency on the aconfig_value_sets defined in
+ // RELEASE_ACONFIG_VALUE_SETS, and add any aconfig_values that
+ // match our package.
+ valuesFromConfig := ctx.Config().ReleaseAconfigValueSets()
ctx.AddDependency(ctx.Module(), implicitValuesTag, valuesFromConfig...)
}
-func (module *DefinitionsModule) OutputFiles(tag string) (android.Paths, error) {
+func (module *DeclarationsModule) OutputFiles(tag string) (android.Paths, error) {
switch tag {
case "":
// The default output of this module is the intermediates format, which is
@@ -83,7 +83,7 @@
// correctly.
return []android.Path{module.intermediatePath}, nil
default:
- return nil, fmt.Errorf("unsupported device_config_definitions module reference tag %q", tag)
+ return nil, fmt.Errorf("unsupported aconfig_declarations module reference tag %q", tag)
}
}
@@ -96,23 +96,23 @@
return sb.String()
}
-// Provider published by device_config_value_set
-type definitionsProviderData struct {
- namespace string
- intermediatePath android.WritablePath
+// Provider published by aconfig_value_set
+type declarationsProviderData struct {
+ Package string
+ IntermediatePath android.WritablePath
}
-var definitionsProviderKey = blueprint.NewProvider(definitionsProviderData{})
+var declarationsProviderKey = blueprint.NewProvider(declarationsProviderData{})
-func (module *DefinitionsModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
- // Get the values that came from the global RELEASE_DEVICE_CONFIG_VALUE_SETS flag
+func (module *DeclarationsModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+ // Get the values that came from the global RELEASE_ACONFIG_VALUE_SETS flag
ctx.VisitDirectDeps(func(dep android.Module) {
if !ctx.OtherModuleHasProvider(dep, valueSetProviderKey) {
// Other modules get injected as dependencies too, for example the license modules
return
}
depData := ctx.OtherModuleProvider(dep, valueSetProviderKey).(valueSetProviderData)
- valuesFiles, ok := depData.AvailableNamespaces[module.properties.Namespace]
+ valuesFiles, ok := depData.AvailablePackages[module.properties.Package]
if ok {
for _, path := range valuesFiles {
module.properties.Values = append(module.properties.Values, path.String())
@@ -127,17 +127,17 @@
Rule: aconfigRule,
Inputs: inputFiles,
Output: intermediatePath,
- Description: "device_config_definitions",
+ Description: "aconfig_declarations",
Args: map[string]string{
"release_version": ctx.Config().ReleaseVersion(),
- "namespace": module.properties.Namespace,
+ "package": module.properties.Package,
"values": joinAndPrefix(" --values ", module.properties.Values),
},
})
- ctx.SetProvider(definitionsProviderKey, definitionsProviderData{
- namespace: module.properties.Namespace,
- intermediatePath: intermediatePath,
+ ctx.SetProvider(declarationsProviderKey, declarationsProviderData{
+ Package: module.properties.Package,
+ IntermediatePath: intermediatePath,
})
}
diff --git a/device_config/device_config_definitions_test.go b/aconfig/aconfig_declarations_test.go
similarity index 69%
rename from device_config/device_config_definitions_test.go
rename to aconfig/aconfig_declarations_test.go
index 6bc6eaa..e14ca38 100644
--- a/device_config/device_config_definitions_test.go
+++ b/aconfig/aconfig_declarations_test.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"strings"
@@ -21,22 +21,22 @@
"android/soong/android"
)
-func TestDeviceConfigDefinitions(t *testing.T) {
+func TestAconfigDeclarations(t *testing.T) {
bp := `
- device_config_definitions {
+ aconfig_declarations {
name: "module_name",
- namespace: "com.example.package",
+ package: "com.example.package",
srcs: ["foo.aconfig"],
}
`
result := runTest(t, android.FixtureExpectsNoErrors, bp)
- module := result.ModuleForTests("module_name", "").Module().(*DefinitionsModule)
+ module := result.ModuleForTests("module_name", "").Module().(*DeclarationsModule)
// Check that the provider has the right contents
- depData := result.ModuleProvider(module, definitionsProviderKey).(definitionsProviderData)
- android.AssertStringEquals(t, "namespace", depData.namespace, "com.example.package")
- if !strings.HasSuffix(depData.intermediatePath.String(), "/intermediate.pb") {
- t.Errorf("Missing intermediates path in provider: %s", depData.intermediatePath.String())
+ depData := result.ModuleProvider(module, declarationsProviderKey).(declarationsProviderData)
+ android.AssertStringEquals(t, "package", depData.Package, "com.example.package")
+ if !strings.HasSuffix(depData.IntermediatePath.String(), "/intermediate.pb") {
+ t.Errorf("Missing intermediates path in provider: %s", depData.IntermediatePath.String())
}
}
diff --git a/device_config/device_config_value_set.go b/aconfig/aconfig_value_set.go
similarity index 76%
rename from device_config/device_config_value_set.go
rename to aconfig/aconfig_value_set.go
index e406d20..252908f 100644
--- a/device_config/device_config_value_set.go
+++ b/aconfig/aconfig_value_set.go
@@ -12,20 +12,20 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"android/soong/android"
"github.com/google/blueprint"
)
-// Properties for "device_config_value_set"
+// Properties for "aconfig_value_set"
type ValueSetModule struct {
android.ModuleBase
android.DefaultableModuleBase
properties struct {
- // device_config_values modules
+ // aconfig_values modules
Values []string
}
}
@@ -49,11 +49,11 @@
var valueSetTag = valueSetType{}
-// Provider published by device_config_value_set
+// Provider published by aconfig_value_set
type valueSetProviderData struct {
- // The namespace of each of the
- // (map of namespace --> device_config_module)
- AvailableNamespaces map[string]android.Paths
+ // The package of each of the
+ // (map of package --> aconfig_module)
+ AvailablePackages map[string]android.Paths
}
var valueSetProviderKey = blueprint.NewProvider(valueSetProviderData{})
@@ -63,17 +63,17 @@
for _, dep := range deps {
_, ok := dep.(*ValuesModule)
if !ok {
- ctx.PropertyErrorf("values", "values must be a device_config_values module")
+ ctx.PropertyErrorf("values", "values must be a aconfig_values module")
return
}
}
}
func (module *ValueSetModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
- // Accumulate the namespaces of the values modules listed, and set that as an
- // valueSetProviderKey provider that device_config modules can read and use
+ // Accumulate the packages of the values modules listed, and set that as an
+ // valueSetProviderKey provider that aconfig modules can read and use
// to append values to their aconfig actions.
- namespaces := make(map[string]android.Paths)
+ packages := make(map[string]android.Paths)
ctx.VisitDirectDeps(func(dep android.Module) {
if !ctx.OtherModuleHasProvider(dep, valuesProviderKey) {
// Other modules get injected as dependencies too, for example the license modules
@@ -83,10 +83,10 @@
srcs := make([]android.Path, len(depData.Values))
copy(srcs, depData.Values)
- namespaces[depData.Namespace] = srcs
+ packages[depData.Package] = srcs
})
ctx.SetProvider(valueSetProviderKey, valueSetProviderData{
- AvailableNamespaces: namespaces,
+ AvailablePackages: packages,
})
}
diff --git a/device_config/device_config_value_set_test.go b/aconfig/aconfig_value_set_test.go
similarity index 78%
rename from device_config/device_config_value_set_test.go
rename to aconfig/aconfig_value_set_test.go
index f9e7c38..9127872 100644
--- a/device_config/device_config_value_set_test.go
+++ b/aconfig/aconfig_value_set_test.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"testing"
@@ -20,15 +20,15 @@
"android/soong/android"
)
-func TestDeviceConfigValueSet(t *testing.T) {
+func TestAconfigValueSet(t *testing.T) {
bp := `
- device_config_values {
+ aconfig_values {
name: "one",
srcs: [ "blah.aconfig_values" ],
- namespace: "foo.namespace"
+ package: "foo.package"
}
- device_config_value_set {
+ aconfig_value_set {
name: "module_name",
values: [ "one" ],
}
@@ -39,5 +39,5 @@
// Check that the provider has the right contents
depData := result.ModuleProvider(module, valueSetProviderKey).(valueSetProviderData)
- android.AssertStringEquals(t, "AvailableNamespaces", "blah.aconfig_values", depData.AvailableNamespaces["foo.namespace"][0].String())
+ android.AssertStringEquals(t, "AvailablePackages", "blah.aconfig_values", depData.AvailablePackages["foo.package"][0].String())
}
diff --git a/device_config/device_config_values.go b/aconfig/aconfig_values.go
similarity index 73%
rename from device_config/device_config_values.go
rename to aconfig/aconfig_values.go
index 110f12a..91f1c90 100644
--- a/device_config/device_config_values.go
+++ b/aconfig/aconfig_values.go
@@ -12,14 +12,14 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"android/soong/android"
"github.com/google/blueprint"
)
-// Properties for "device_config_value"
+// Properties for "aconfig_value"
type ValuesModule struct {
android.ModuleBase
android.DefaultableModuleBase
@@ -28,8 +28,8 @@
// aconfig files, relative to this Android.bp file
Srcs []string `android:"path"`
- // Release config flag namespace
- Namespace string
+ // Release config flag package
+ Package string
}
}
@@ -45,10 +45,10 @@
return module
}
-// Provider published by device_config_value_set
+// Provider published by aconfig_value_set
type valuesProviderData struct {
- // The namespace that this values module values
- Namespace string
+ // The package that this values module values
+ Package string
// The values aconfig files, relative to the root of the tree
Values android.Paths
@@ -57,14 +57,14 @@
var valuesProviderKey = blueprint.NewProvider(valuesProviderData{})
func (module *ValuesModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
- if len(module.properties.Namespace) == 0 {
- ctx.PropertyErrorf("namespace", "missing namespace property")
+ if len(module.properties.Package) == 0 {
+ ctx.PropertyErrorf("package", "missing package property")
}
- // Provide the our source files list to the device_config_value_set as a list of files
+ // Provide the our source files list to the aconfig_value_set as a list of files
providerData := valuesProviderData{
- Namespace: module.properties.Namespace,
- Values: android.PathsForModuleSrc(ctx, module.properties.Srcs),
+ Package: module.properties.Package,
+ Values: android.PathsForModuleSrc(ctx, module.properties.Srcs),
}
ctx.SetProvider(valuesProviderKey, providerData)
}
diff --git a/device_config/device_config_values_test.go b/aconfig/aconfig_values_test.go
similarity index 83%
rename from device_config/device_config_values_test.go
rename to aconfig/aconfig_values_test.go
index 64c57eb..ab457f0 100644
--- a/device_config/device_config_values_test.go
+++ b/aconfig/aconfig_values_test.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"testing"
@@ -20,12 +20,12 @@
"android/soong/android"
)
-func TestDeviceConfigValues(t *testing.T) {
+func TestAconfigValues(t *testing.T) {
bp := `
- device_config_values {
+ aconfig_values {
name: "module_name",
srcs: [ "blah.aconfig_values" ],
- namespace: "foo.namespace"
+ package: "foo.package"
}
`
result := runTest(t, android.FixtureExpectsNoErrors, bp)
@@ -34,6 +34,6 @@
// Check that the provider has the right contents
depData := result.ModuleProvider(module, valuesProviderKey).(valuesProviderData)
- android.AssertStringEquals(t, "namespace", "foo.namespace", depData.Namespace)
+ android.AssertStringEquals(t, "package", "foo.package", depData.Package)
android.AssertPathsEndWith(t, "srcs", []string{"blah.aconfig_values"}, depData.Values)
}
diff --git a/aconfig/all_aconfig_declarations.go b/aconfig/all_aconfig_declarations.go
new file mode 100644
index 0000000..6096c6c
--- /dev/null
+++ b/aconfig/all_aconfig_declarations.go
@@ -0,0 +1,63 @@
+// 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 aconfig
+
+import (
+ "android/soong/android"
+)
+
+// A singleton module that collects all of the aconfig flags declared in the
+// tree into a single combined file for export to the external flag setting
+// server (inside Google it's Gantry).
+//
+// Note that this is ALL aconfig_declarations modules present in the tree, not just
+// ones that are relevant to the product currently being built, so that that infra
+// doesn't need to pull from multiple builds and merge them.
+func AllAconfigDeclarationsFactory() android.Singleton {
+ return &allAconfigDeclarationsSingleton{}
+}
+
+type allAconfigDeclarationsSingleton struct {
+ intermediatePath android.OutputPath
+}
+
+func (this *allAconfigDeclarationsSingleton) GenerateBuildActions(ctx android.SingletonContext) {
+ // Find all of the aconfig_declarations modules
+ var cacheFiles android.Paths
+ ctx.VisitAllModules(func(module android.Module) {
+ if !ctx.ModuleHasProvider(module, declarationsProviderKey) {
+ return
+ }
+ decl := ctx.ModuleProvider(module, declarationsProviderKey).(declarationsProviderData)
+ cacheFiles = append(cacheFiles, decl.IntermediatePath)
+ })
+
+ // Generate build action for aconfig
+ this.intermediatePath = android.PathForIntermediates(ctx, "all_aconfig_declarations.pb")
+ ctx.Build(pctx, android.BuildParams{
+ Rule: allDeclarationsRule,
+ Inputs: cacheFiles,
+ Output: this.intermediatePath,
+ Description: "all_aconfig_declarations",
+ Args: map[string]string{
+ "cache_files": android.JoinPathsWithPrefix(cacheFiles, "--cache "),
+ },
+ })
+ ctx.Phony("all_aconfig_declarations", this.intermediatePath)
+}
+
+func (this *allAconfigDeclarationsSingleton) MakeVars(ctx android.MakeVarsContext) {
+ ctx.DistForGoal("droid", this.intermediatePath)
+}
diff --git a/device_config/init.go b/aconfig/init.go
similarity index 66%
rename from device_config/init.go
rename to aconfig/init.go
index 04bbab6..161fd42 100644
--- a/device_config/init.go
+++ b/aconfig/init.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"android/soong/android"
@@ -20,13 +20,13 @@
)
var (
- pctx = android.NewPackageContext("android/soong/device_config")
+ pctx = android.NewPackageContext("android/soong/aconfig")
- // For device_config_definitions: Generate cache file
+ // For aconfig_declarations: Generate cache file
aconfigRule = pctx.AndroidStaticRule("aconfig",
blueprint.RuleParams{
Command: `${aconfig} create-cache` +
- ` --package ${namespace}` +
+ ` --package ${package}` +
` --declarations ${in}` +
` ${values}` +
` --cache ${out}.tmp` +
@@ -36,9 +36,9 @@
"${aconfig}",
},
Restat: true,
- }, "release_version", "namespace", "values")
+ }, "release_version", "package", "values")
- // For java_device_config_definitions_library: Generate java file
+ // For java_aconfig_library: Generate java file
srcJarRule = pctx.AndroidStaticRule("aconfig_srcjar",
blueprint.RuleParams{
Command: `rm -rf ${out}.tmp` +
@@ -54,6 +54,15 @@
},
Restat: true,
})
+
+ // For all_aconfig_declarations
+ allDeclarationsRule = pctx.AndroidStaticRule("all_aconfig_declarations_dump",
+ blueprint.RuleParams{
+ Command: `${aconfig} dump --format protobuf --out ${out} ${cache_files}`,
+ CommandDeps: []string{
+ "${aconfig}",
+ },
+ }, "cache_files")
)
func init() {
@@ -63,8 +72,9 @@
}
func registerBuildComponents(ctx android.RegistrationContext) {
- ctx.RegisterModuleType("device_config_definitions", DefinitionsFactory)
- ctx.RegisterModuleType("device_config_values", ValuesFactory)
- ctx.RegisterModuleType("device_config_value_set", ValueSetFactory)
- ctx.RegisterModuleType("java_device_config_definitions_library", JavaDefinitionsLibraryFactory)
+ ctx.RegisterModuleType("aconfig_declarations", DeclarationsFactory)
+ ctx.RegisterModuleType("aconfig_values", ValuesFactory)
+ ctx.RegisterModuleType("aconfig_value_set", ValueSetFactory)
+ ctx.RegisterModuleType("java_aconfig_library", JavaDeclarationsLibraryFactory)
+ ctx.RegisterParallelSingletonType("all_aconfig_declarations", AllAconfigDeclarationsFactory)
}
diff --git a/aconfig/java_aconfig_library.go b/aconfig/java_aconfig_library.go
new file mode 100644
index 0000000..0eeb14f
--- /dev/null
+++ b/aconfig/java_aconfig_library.go
@@ -0,0 +1,71 @@
+// 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 aconfig
+
+import (
+ "android/soong/android"
+ "android/soong/java"
+ "fmt"
+ "github.com/google/blueprint"
+)
+
+type declarationsTagType struct {
+ blueprint.BaseDependencyTag
+}
+
+var declarationsTag = declarationsTagType{}
+
+type JavaAconfigDeclarationsLibraryProperties struct {
+ // name of the aconfig_declarations module to generate a library for
+ Aconfig_declarations string
+}
+
+type JavaAconfigDeclarationsLibraryCallbacks struct {
+ properties JavaAconfigDeclarationsLibraryProperties
+}
+
+func JavaDeclarationsLibraryFactory() android.Module {
+ callbacks := &JavaAconfigDeclarationsLibraryCallbacks{}
+ return java.GeneratedJavaLibraryModuleFactory("java_aconfig_library", callbacks, &callbacks.properties)
+}
+
+func (callbacks *JavaAconfigDeclarationsLibraryCallbacks) DepsMutator(module *java.GeneratedJavaLibraryModule, ctx android.BottomUpMutatorContext) {
+ declarations := callbacks.properties.Aconfig_declarations
+ if len(declarations) == 0 {
+ // TODO: Add test for this case
+ ctx.PropertyErrorf("aconfig_declarations", "aconfig_declarations property required")
+ } else {
+ ctx.AddDependency(ctx.Module(), declarationsTag, declarations)
+ }
+}
+
+func (callbacks *JavaAconfigDeclarationsLibraryCallbacks) GenerateSourceJarBuildActions(ctx android.ModuleContext) android.Path {
+ // Get the values that came from the global RELEASE_ACONFIG_VALUE_SETS flag
+ declarationsModules := ctx.GetDirectDepsWithTag(declarationsTag)
+ if len(declarationsModules) != 1 {
+ panic(fmt.Errorf("Exactly one aconfig_declarations property required"))
+ }
+ declarations := ctx.OtherModuleProvider(declarationsModules[0], declarationsProviderKey).(declarationsProviderData)
+
+ srcJarPath := android.PathForModuleGen(ctx, ctx.ModuleName()+".srcjar")
+ ctx.Build(pctx, android.BuildParams{
+ Rule: srcJarRule,
+ Input: declarations.IntermediatePath,
+ Output: srcJarPath,
+ Description: "aconfig.srcjar",
+ })
+
+ return srcJarPath
+}
diff --git a/device_config/testing.go b/aconfig/testing.go
similarity index 78%
rename from device_config/testing.go
rename to aconfig/testing.go
index 284a7fa..60cefeb 100644
--- a/device_config/testing.go
+++ b/aconfig/testing.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package device_config
+package aconfig
import (
"testing"
@@ -20,10 +20,10 @@
"android/soong/android"
)
-var PrepareForTestWithDeviceConfigBuildComponents = android.FixtureRegisterWithContext(registerBuildComponents)
+var PrepareForTestWithAconfigBuildComponents = android.FixtureRegisterWithContext(registerBuildComponents)
func runTest(t *testing.T, errorHandler android.FixtureErrorHandler, bp string) *android.TestResult {
- return android.GroupFixturePreparers(PrepareForTestWithDeviceConfigBuildComponents).
+ return android.GroupFixturePreparers(PrepareForTestWithAconfigBuildComponents).
ExtendWithErrorHandler(errorHandler).
RunTestWithBp(t, bp)
}
diff --git a/aidl_library/aidl_library.go b/aidl_library/aidl_library.go
index 5985103..7449d67 100644
--- a/aidl_library/aidl_library.go
+++ b/aidl_library/aidl_library.go
@@ -108,17 +108,17 @@
// The direct aidl files of the module
Srcs android.Paths
// The include dirs to the direct aidl files and those provided from transitive aidl_library deps
- IncludeDirs android.DepSet
+ IncludeDirs android.DepSet[android.Path]
// The direct hdrs and hdrs from transitive deps
- Hdrs android.DepSet
+ Hdrs android.DepSet[android.Path]
}
// AidlLibraryProvider provides the srcs and the transitive include dirs
var AidlLibraryProvider = blueprint.NewProvider(AidlLibraryInfo{})
func (lib *AidlLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
- includeDirsDepSetBuilder := android.NewDepSetBuilder(android.PREORDER)
- hdrsDepSetBuilder := android.NewDepSetBuilder(android.PREORDER)
+ includeDirsDepSetBuilder := android.NewDepSetBuilder[android.Path](android.PREORDER)
+ hdrsDepSetBuilder := android.NewDepSetBuilder[android.Path](android.PREORDER)
if len(lib.properties.Srcs) == 0 && len(lib.properties.Hdrs) == 0 {
ctx.ModuleErrorf("at least srcs or hdrs prop must be non-empty")
diff --git a/aidl_library/aidl_library_test.go b/aidl_library/aidl_library_test.go
index d9dd245..0205629 100644
--- a/aidl_library/aidl_library_test.go
+++ b/aidl_library/aidl_library_test.go
@@ -52,7 +52,7 @@
t,
"aidl include dirs",
[]string{"package_foo/a", "package_bar/x"},
- actualInfo.IncludeDirs.ToList().Strings(),
+ android.Paths(actualInfo.IncludeDirs.ToList()).Strings(),
)
android.AssertPathsRelativeToTopEquals(
@@ -101,7 +101,7 @@
t,
"aidl include dirs",
[]string{"package_foo", "package_bar"},
- actualInfo.IncludeDirs.ToList().Strings(),
+ android.Paths(actualInfo.IncludeDirs.ToList()).Strings(),
)
android.AssertPathsRelativeToTopEquals(
diff --git a/android/Android.bp b/android/Android.bp
index 2ccccf0..fc5198f 100644
--- a/android/Android.bp
+++ b/android/Android.bp
@@ -49,7 +49,6 @@
"defaults.go",
"defs.go",
"depset_generic.go",
- "depset_paths.go",
"deptag.go",
"expand.go",
"filegroup.go",
diff --git a/android/allowlists/allowlists.go b/android/allowlists/allowlists.go
index 34a6860..d320599 100644
--- a/android/allowlists/allowlists.go
+++ b/android/allowlists/allowlists.go
@@ -131,6 +131,7 @@
"external/brotli": Bp2BuildDefaultTrue,
"external/bsdiff": Bp2BuildDefaultTrueRecursively,
"external/bzip2": Bp2BuildDefaultTrueRecursively,
+ "external/clang/lib": Bp2BuildDefaultTrue,
"external/conscrypt": Bp2BuildDefaultTrue,
"external/e2fsprogs": Bp2BuildDefaultTrueRecursively,
"external/eigen": Bp2BuildDefaultTrueRecursively,
@@ -429,6 +430,7 @@
// e.g. ERROR: Analysis of target '@soong_injection//mixed_builds:buildroot' failed
"external/bazelbuild-rules_android":/* recursive = */ true,
"external/bazelbuild-rules_license":/* recursive = */ true,
+ "external/bazelbuild-rules_go":/* recursive = */ true,
"external/bazelbuild-kotlin-rules":/* recursive = */ true,
"external/bazel-skylib":/* recursive = */ true,
"external/protobuf":/* recursive = */ false,
@@ -796,6 +798,13 @@
// for platform_compat_config
"process-compat-config",
+
+ // cc_* modules with rscript srcs
+ "rstest-latency",
+ "libRScpp_static",
+ "rs-headers",
+ "rs_script_api",
+ "libRSDispatch",
}
Bp2buildModuleTypeAlwaysConvertList = []string{
@@ -940,12 +949,8 @@
//system/libvintf
// depends on apex-info-list-tinyxml, unconverted xsd_config Soong module type.
- "libvintf",
- "vintf",
"libassemblevintf",
"assemble_vintf",
- "libvintffm",
- "vintffm",
"checkvintf",
// depends on audio_policy_configuration_aidl_default, xsd_config module.
diff --git a/android/bazel_handler.go b/android/bazel_handler.go
index f4b368b..4b1a8f4 100644
--- a/android/bazel_handler.go
+++ b/android/bazel_handler.go
@@ -92,10 +92,11 @@
type ApexConfigKey struct {
WithinApex bool
ApexSdkVersion string
+ ApiDomain string
}
func (c ApexConfigKey) String() string {
- return fmt.Sprintf("%s_%s", withinApexToString(c.WithinApex), c.ApexSdkVersion)
+ return fmt.Sprintf("%s_%s_%s", withinApexToString(c.WithinApex), c.ApexSdkVersion, c.ApiDomain)
}
func withinApexToString(withinApex bool) string {
@@ -737,6 +738,7 @@
"@//build/bazel/rules/apex:within_apex": attr.within_apex,
"@//build/bazel/rules/apex:min_sdk_version": attr.apex_sdk_version,
"@//build/bazel/rules/apex:apex_name": apex_name,
+ "@//build/bazel/rules/apex:api_domain": attr.api_domain,
}
return outputs
@@ -749,6 +751,7 @@
"@//build/bazel/rules/apex:within_apex",
"@//build/bazel/rules/apex:min_sdk_version",
"@//build/bazel/rules/apex:apex_name",
+ "@//build/bazel/rules/apex:api_domain",
],
)
@@ -762,6 +765,7 @@
"os" : attr.string(mandatory = True),
"within_apex" : attr.bool(default = False),
"apex_sdk_version" : attr.string(mandatory = True),
+ "api_domain" : attr.string(mandatory = True),
"deps" : attr.label_list(cfg = _config_node_transition, allow_files = True),
"_allowlist_function_transition": attr.label(default = "@bazel_tools//tools/allowlists/function_transition_allowlist"),
},
@@ -823,6 +827,7 @@
os = "%s",
within_apex = %s,
apex_sdk_version = "%s",
+ api_domain = "%s",
deps = [%s],
testonly = True, # Unblocks testonly deps.
)
@@ -856,6 +861,11 @@
osString := configTokens[1]
withinApex := "False"
apexSdkVerString := ""
+ apiDomainString := ""
+ if osString == "android" {
+ // api domains are meaningful only for device variants
+ apiDomainString = "system"
+ }
targetString := fmt.Sprintf("%s_%s", osString, archString)
if len(configTokens) > 2 {
targetString += "_" + configTokens[2]
@@ -867,9 +877,13 @@
targetString += "_" + configTokens[3]
apexSdkVerString = configTokens[3]
}
+ if len(configTokens) > 4 {
+ apiDomainString = configTokens[4]
+ targetString += "_" + apiDomainString
+ }
allLabels = append(allLabels, fmt.Sprintf("\":%s\"", targetString))
labelsString := strings.Join(labels, ",\n ")
- configNodesSection += fmt.Sprintf(configNodeFormatString, targetString, archString, osString, withinApex, apexSdkVerString,
+ configNodesSection += fmt.Sprintf(configNodeFormatString, targetString, archString, osString, withinApex, apexSdkVerString, apiDomainString,
labelsString)
}
@@ -974,11 +988,14 @@
within_apex = buildoptions.get("//build/bazel/rules/apex:within_apex")
apex_sdk_version = buildoptions.get("//build/bazel/rules/apex:min_sdk_version")
+ api_domain = buildoptions.get("//build/bazel/rules/apex:api_domain")
if within_apex:
config_key += "|within_apex"
if apex_sdk_version != None and len(apex_sdk_version) > 0:
config_key += "|" + apex_sdk_version
+ if api_domain != None and len(api_domain) > 0:
+ config_key += "|" + api_domain
return config_key
@@ -1385,6 +1402,10 @@
keyString += "|" + key.configKey.apexKey.ApexSdkVersion
}
+ if len(key.configKey.apexKey.ApiDomain) > 0 {
+ keyString += "|" + key.configKey.apexKey.ApiDomain
+ }
+
return keyString
}
@@ -1403,6 +1424,7 @@
configKey.apexKey = ApexConfigKey{
WithinApex: apexKey.WithinApex,
ApexSdkVersion: apexKey.ApexSdkVersion,
+ ApiDomain: apexKey.ApiDomain,
}
}
diff --git a/android/bazel_handler_test.go b/android/bazel_handler_test.go
index a81a878..65cd5a8 100644
--- a/android/bazel_handler_test.go
+++ b/android/bazel_handler_test.go
@@ -58,11 +58,12 @@
apexKey := ApexConfigKey{
WithinApex: true,
ApexSdkVersion: "29",
+ ApiDomain: "myapex",
}
cfg_foo := configKey{"arm64_armv8-a", Android, apexKey}
cfg_bar := configKey{arch: "arm64_armv8-a", osType: Android}
cmd_results := []string{
- `@//foo:foo|arm64_armv8-a|android|within_apex|29>>out/foo/foo.txt`,
+ `@//foo:foo|arm64_armv8-a|android|within_apex|29|myapex>>out/foo/foo.txt`,
`@//foo:bar|arm64_armv8-a|android>>out/foo/bar.txt`,
}
bazelContext, _ := testBazelContext(t, map[bazelCommand]string{cqueryCmd: strings.Join(cmd_results, "\n")})
diff --git a/android/config.go b/android/config.go
index 242be18..839ff05 100644
--- a/android/config.go
+++ b/android/config.go
@@ -184,8 +184,8 @@
}
// The flag values files passed to aconfig, derived from RELEASE_VERSION
-func (c Config) ReleaseDeviceConfigValueSets() []string {
- return c.config.productVariables.ReleaseDeviceConfigValueSets
+func (c Config) ReleaseAconfigValueSets() []string {
+ return c.config.productVariables.ReleaseAconfigValueSets
}
// A DeviceConfig object represents the configuration for a particular device
@@ -1645,10 +1645,6 @@
return Bool(c.productVariables.Aml_abis)
}
-func (c *config) FlattenApex() bool {
- return Bool(c.productVariables.Flatten_apex)
-}
-
func (c *config) ForceApexSymlinkOptimization() bool {
return Bool(c.productVariables.ForceApexSymlinkOptimization)
}
diff --git a/android/depset_generic.go b/android/depset_generic.go
index f00e462..ae14d32 100644
--- a/android/depset_generic.go
+++ b/android/depset_generic.go
@@ -16,10 +16,9 @@
import (
"fmt"
- "reflect"
)
-// depSet is designed to be conceptually compatible with Bazel's depsets:
+// DepSet is designed to be conceptually compatible with Bazel's depsets:
// https://docs.bazel.build/versions/master/skylark/depsets.html
type DepSetOrder int
@@ -43,142 +42,114 @@
}
}
-// A depSet efficiently stores a slice of an arbitrary type from transitive dependencies without
-// copying. It is stored as a DAG of depSet nodes, each of which has some direct contents and a list
-// of dependency depSet nodes.
+type depSettableType comparable
+
+// A DepSet efficiently stores a slice of an arbitrary type from transitive dependencies without
+// copying. It is stored as a DAG of DepSet nodes, each of which has some direct contents and a list
+// of dependency DepSet nodes.
//
-// A depSet has an order that will be used to walk the DAG when ToList() is called. The order
+// A DepSet has an order that will be used to walk the DAG when ToList() is called. The order
// can be POSTORDER, PREORDER, or TOPOLOGICAL. POSTORDER and PREORDER orders return a postordered
// or preordered left to right flattened list. TOPOLOGICAL returns a list that guarantees that
// elements of children are listed after all of their parents (unless there are duplicate direct
-// elements in the depSet or any of its transitive dependencies, in which case the ordering of the
+// elements in the DepSet or any of its transitive dependencies, in which case the ordering of the
// duplicated element is not guaranteed).
//
-// A depSet is created by newDepSet or newDepSetBuilder.Build from the slice for direct contents
-// and the *depSets of dependencies. A depSet is immutable once created.
-//
-// This object uses reflection to remain agnostic to the type it contains. It should be replaced
-// with generics once those exist in Go. Callers should generally use a thin wrapper around depSet
-// that provides type-safe methods like DepSet for Paths.
-type depSet struct {
+// A DepSet is created by NewDepSet or NewDepSetBuilder.Build from the slice for direct contents
+// and the *DepSets of dependencies. A DepSet is immutable once created.
+type DepSet[T depSettableType] struct {
preorder bool
reverse bool
order DepSetOrder
- direct interface{}
- transitive []*depSet
+ direct []T
+ transitive []*DepSet[T]
}
-type depSetInterface interface {
- embeddedDepSet() *depSet
-}
-
-func (d *depSet) embeddedDepSet() *depSet {
- return d
-}
-
-var _ depSetInterface = (*depSet)(nil)
-
-// newDepSet returns an immutable depSet with the given order, direct and transitive contents.
-// direct must be a slice, but is not type-safe due to the lack of generics in Go. It can be a
-// nil slice, but not a nil interface{}, i.e. []string(nil) but not nil.
-func newDepSet(order DepSetOrder, direct interface{}, transitive interface{}) *depSet {
- var directCopy interface{}
- transitiveDepSet := sliceToDepSets(transitive, order)
-
- if order == TOPOLOGICAL {
- directCopy = reverseSlice(direct)
- reverseSliceInPlace(transitiveDepSet)
- } else {
- directCopy = copySlice(direct)
+// NewDepSet returns an immutable DepSet with the given order, direct and transitive contents.
+func NewDepSet[T depSettableType](order DepSetOrder, direct []T, transitive []*DepSet[T]) *DepSet[T] {
+ var directCopy []T
+ var transitiveCopy []*DepSet[T]
+ for _, t := range transitive {
+ if t.order != order {
+ panic(fmt.Errorf("incompatible order, new DepSet is %s but transitive DepSet is %s",
+ order, t.order))
+ }
}
- return &depSet{
+ if order == TOPOLOGICAL {
+ // TOPOLOGICAL is implemented as a postorder traversal followed by reversing the output.
+ // Pre-reverse the inputs here so their order is maintained in the output.
+ directCopy = reverseSlice(direct)
+ transitiveCopy = reverseSlice(transitive)
+ } else {
+ directCopy = append([]T(nil), direct...)
+ transitiveCopy = append([]*DepSet[T](nil), transitive...)
+ }
+
+ return &DepSet[T]{
preorder: order == PREORDER,
reverse: order == TOPOLOGICAL,
order: order,
direct: directCopy,
- transitive: transitiveDepSet,
+ transitive: transitiveCopy,
}
}
-// depSetBuilder is used to create an immutable depSet.
-type depSetBuilder struct {
+// DepSetBuilder is used to create an immutable DepSet.
+type DepSetBuilder[T depSettableType] struct {
order DepSetOrder
- direct reflect.Value
- transitive []*depSet
+ direct []T
+ transitive []*DepSet[T]
}
-// newDepSetBuilder returns a depSetBuilder to create an immutable depSet with the given order and
-// type, represented by a slice of type that will be in the depSet.
-func newDepSetBuilder(order DepSetOrder, typ interface{}) *depSetBuilder {
- empty := reflect.Zero(reflect.TypeOf(typ))
- return &depSetBuilder{
- order: order,
- direct: empty,
+// NewDepSetBuilder returns a DepSetBuilder to create an immutable DepSet with the given order and
+// type, represented by a slice of type that will be in the DepSet.
+func NewDepSetBuilder[T depSettableType](order DepSetOrder) *DepSetBuilder[T] {
+ return &DepSetBuilder[T]{
+ order: order,
}
}
-// sliceToDepSets converts a slice of any type that implements depSetInterface (by having a depSet
-// embedded in it) into a []*depSet.
-func sliceToDepSets(in interface{}, order DepSetOrder) []*depSet {
- slice := reflect.ValueOf(in)
- length := slice.Len()
- out := make([]*depSet, length)
- for i := 0; i < length; i++ {
- vi := slice.Index(i)
- depSetIntf, ok := vi.Interface().(depSetInterface)
- if !ok {
- panic(fmt.Errorf("element %d is a %s, not a depSetInterface", i, vi.Type()))
- }
- depSet := depSetIntf.embeddedDepSet()
- if depSet.order != order {
- panic(fmt.Errorf("incompatible order, new depSet is %s but transitive depSet is %s",
- order, depSet.order))
- }
- out[i] = depSet
- }
- return out
-}
-
-// DirectSlice adds direct contents to the depSet being built by a depSetBuilder. Newly added direct
-// contents are to the right of any existing direct contents. The argument must be a slice, but
-// is not type-safe due to the lack of generics in Go.
-func (b *depSetBuilder) DirectSlice(direct interface{}) *depSetBuilder {
- b.direct = reflect.AppendSlice(b.direct, reflect.ValueOf(direct))
+// DirectSlice adds direct contents to the DepSet being built by a DepSetBuilder. Newly added direct
+// contents are to the right of any existing direct contents.
+func (b *DepSetBuilder[T]) DirectSlice(direct []T) *DepSetBuilder[T] {
+ b.direct = append(b.direct, direct...)
return b
}
-// Direct adds direct contents to the depSet being built by a depSetBuilder. Newly added direct
-// contents are to the right of any existing direct contents. The argument must be the same type
-// as the element of the slice passed to newDepSetBuilder, but is not type-safe due to the lack of
-// generics in Go.
-func (b *depSetBuilder) Direct(direct interface{}) *depSetBuilder {
- b.direct = reflect.Append(b.direct, reflect.ValueOf(direct))
+// Direct adds direct contents to the DepSet being built by a DepSetBuilder. Newly added direct
+// contents are to the right of any existing direct contents.
+func (b *DepSetBuilder[T]) Direct(direct ...T) *DepSetBuilder[T] {
+ b.direct = append(b.direct, direct...)
return b
}
// Transitive adds transitive contents to the DepSet being built by a DepSetBuilder. Newly added
-// transitive contents are to the right of any existing transitive contents. The argument can
-// be any slice of type that has depSet embedded in it.
-func (b *depSetBuilder) Transitive(transitive interface{}) *depSetBuilder {
- depSets := sliceToDepSets(transitive, b.order)
- b.transitive = append(b.transitive, depSets...)
+// transitive contents are to the right of any existing transitive contents.
+func (b *DepSetBuilder[T]) Transitive(transitive ...*DepSet[T]) *DepSetBuilder[T] {
+ for _, t := range transitive {
+ if t.order != b.order {
+ panic(fmt.Errorf("incompatible order, new DepSet is %s but transitive DepSet is %s",
+ b.order, t.order))
+ }
+ }
+ b.transitive = append(b.transitive, transitive...)
return b
}
-// Returns the depSet being built by this depSetBuilder. The depSetBuilder retains its contents
+// Returns the DepSet being built by this DepSetBuilder. The DepSetBuilder retains its contents
// for creating more depSets.
-func (b *depSetBuilder) Build() *depSet {
- return newDepSet(b.order, b.direct.Interface(), b.transitive)
+func (b *DepSetBuilder[T]) Build() *DepSet[T] {
+ return NewDepSet(b.order, b.direct, b.transitive)
}
// walk calls the visit method in depth-first order on a DepSet, preordered if d.preorder is set,
// otherwise postordered.
-func (d *depSet) walk(visit func(interface{})) {
- visited := make(map[*depSet]bool)
+func (d *DepSet[T]) walk(visit func([]T)) {
+ visited := make(map[*DepSet[T]]bool)
- var dfs func(d *depSet)
- dfs = func(d *depSet) {
+ var dfs func(d *DepSet[T])
+ dfs = func(d *DepSet[T]) {
visited[d] = true
if d.preorder {
visit(d.direct)
@@ -197,155 +168,33 @@
dfs(d)
}
-// ToList returns the depSet flattened to a list. The order in the list is based on the order
-// of the depSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
+// ToList returns the DepSet flattened to a list. The order in the list is based on the order
+// of the DepSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
// flattened list. TOPOLOGICAL returns a list that guarantees that elements of children are listed
// after all of their parents (unless there are duplicate direct elements in the DepSet or any of
// its transitive dependencies, in which case the ordering of the duplicated element is not
// guaranteed).
-//
-// This method uses a reflection-based implementation to find the unique elements in slice, which
-// is around 3x slower than a concrete implementation. Type-safe wrappers around depSet can
-// provide their own implementation of ToList that calls depSet.toList with a method that
-// uses a concrete implementation.
-func (d *depSet) ToList() interface{} {
- return d.toList(firstUnique)
+func (d *DepSet[T]) ToList() []T {
+ return d.toList(firstUnique[T])
}
-// toList returns the depSet flattened to a list. The order in the list is based on the order
-// of the depSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
+// toList returns the DepSet flattened to a list. The order in the list is based on the order
+// of the DepSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
// flattened list. TOPOLOGICAL returns a list that guarantees that elements of children are listed
// after all of their parents (unless there are duplicate direct elements in the DepSet or any of
// its transitive dependencies, in which case the ordering of the duplicated element is not
// guaranteed). The firstUniqueFunc is used to remove duplicates from the list.
-func (d *depSet) toList(firstUniqueFunc func(interface{}) interface{}) interface{} {
+func (d *DepSet[T]) toList(firstUniqueFunc func([]T) []T) []T {
if d == nil {
return nil
}
- slice := reflect.Zero(reflect.TypeOf(d.direct))
- d.walk(func(paths interface{}) {
- slice = reflect.AppendSlice(slice, reflect.ValueOf(paths))
+ var list []T
+ d.walk(func(paths []T) {
+ list = append(list, paths...)
})
- list := slice.Interface()
list = firstUniqueFunc(list)
if d.reverse {
reverseSliceInPlace(list)
}
return list
}
-
-// firstUnique returns all unique elements of a slice, keeping the first copy of each. It
-// modifies the slice contents in place, and returns a subslice of the original slice. The
-// argument must be a slice, but is not type-safe due to the lack of reflection in Go.
-//
-// Performance of the reflection-based firstUnique is up to 3x slower than a concrete type
-// version such as FirstUniqueStrings.
-func firstUnique(slice interface{}) interface{} {
- // 4 was chosen based on Benchmark_firstUnique results.
- if reflect.ValueOf(slice).Len() > 4 {
- return firstUniqueMap(slice)
- }
- return firstUniqueList(slice)
-}
-
-// firstUniqueList is an implementation of firstUnique using an O(N^2) list comparison to look for
-// duplicates.
-func firstUniqueList(in interface{}) interface{} {
- writeIndex := 0
- slice := reflect.ValueOf(in)
- length := slice.Len()
-outer:
- for readIndex := 0; readIndex < length; readIndex++ {
- readValue := slice.Index(readIndex)
- for compareIndex := 0; compareIndex < writeIndex; compareIndex++ {
- compareValue := slice.Index(compareIndex)
- // These two Interface() calls seem to cause an allocation and significantly
- // slow down this list-based implementation. The map implementation below doesn't
- // have this issue because reflect.Value.MapIndex takes a Value and appears to be
- // able to do the map lookup without an allocation.
- if readValue.Interface() == compareValue.Interface() {
- // The value at readIndex already exists somewhere in the output region
- // of the slice before writeIndex, skip it.
- continue outer
- }
- }
- if readIndex != writeIndex {
- writeValue := slice.Index(writeIndex)
- writeValue.Set(readValue)
- }
- writeIndex++
- }
- return slice.Slice(0, writeIndex).Interface()
-}
-
-var trueValue = reflect.ValueOf(true)
-
-// firstUniqueList is an implementation of firstUnique using an O(N) hash set lookup to look for
-// duplicates.
-func firstUniqueMap(in interface{}) interface{} {
- writeIndex := 0
- slice := reflect.ValueOf(in)
- length := slice.Len()
- seen := reflect.MakeMapWithSize(reflect.MapOf(slice.Type().Elem(), trueValue.Type()), slice.Len())
- for readIndex := 0; readIndex < length; readIndex++ {
- readValue := slice.Index(readIndex)
- if seen.MapIndex(readValue).IsValid() {
- continue
- }
- seen.SetMapIndex(readValue, trueValue)
- if readIndex != writeIndex {
- writeValue := slice.Index(writeIndex)
- writeValue.Set(readValue)
- }
- writeIndex++
- }
- return slice.Slice(0, writeIndex).Interface()
-}
-
-// reverseSliceInPlace reverses the elements of a slice in place. The argument must be a slice, but
-// is not type-safe due to the lack of reflection in Go.
-func reverseSliceInPlace(in interface{}) {
- swapper := reflect.Swapper(in)
- slice := reflect.ValueOf(in)
- length := slice.Len()
- for i, j := 0, length-1; i < j; i, j = i+1, j-1 {
- swapper(i, j)
- }
-}
-
-// reverseSlice returns a copy of a slice in reverse order. The argument must be a slice, but is
-// not type-safe due to the lack of reflection in Go.
-func reverseSlice(in interface{}) interface{} {
- slice := reflect.ValueOf(in)
- if !slice.IsValid() || slice.IsNil() {
- return in
- }
- if slice.Kind() != reflect.Slice {
- panic(fmt.Errorf("%t is not a slice", in))
- }
- length := slice.Len()
- if length == 0 {
- return in
- }
- out := reflect.MakeSlice(slice.Type(), length, length)
- for i := 0; i < length; i++ {
- out.Index(i).Set(slice.Index(length - 1 - i))
- }
- return out.Interface()
-}
-
-// copySlice returns a copy of a slice. The argument must be a slice, but is not type-safe due to
-// the lack of reflection in Go.
-func copySlice(in interface{}) interface{} {
- slice := reflect.ValueOf(in)
- if !slice.IsValid() || slice.IsNil() {
- return in
- }
- length := slice.Len()
- if length == 0 {
- return in
- }
- out := reflect.MakeSlice(slice.Type(), length, length)
- reflect.Copy(out, slice)
- return out.Interface()
-}
diff --git a/android/depset_paths.go b/android/depset_paths.go
deleted file mode 100644
index ed561ba..0000000
--- a/android/depset_paths.go
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2020 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 android
-
-// This file implements DepSet, a thin type-safe wrapper around depSet that contains Paths.
-
-// A DepSet efficiently stores Paths from transitive dependencies without copying. It is stored
-// as a DAG of DepSet nodes, each of which has some direct contents and a list of dependency
-// DepSet nodes.
-//
-// A DepSet has an order that will be used to walk the DAG when ToList() is called. The order
-// can be POSTORDER, PREORDER, or TOPOLOGICAL. POSTORDER and PREORDER orders return a postordered
-// or preordered left to right flattened list. TOPOLOGICAL returns a list that guarantees that
-// elements of children are listed after all of their parents (unless there are duplicate direct
-// elements in the DepSet or any of its transitive dependencies, in which case the ordering of the
-// duplicated element is not guaranteed).
-//
-// A DepSet is created by NewDepSet or NewDepSetBuilder.Build from the Paths for direct contents
-// and the *DepSets of dependencies. A DepSet is immutable once created.
-type DepSet struct {
- depSet
-}
-
-// DepSetBuilder is used to create an immutable DepSet.
-type DepSetBuilder struct {
- depSetBuilder
-}
-
-// NewDepSet returns an immutable DepSet with the given order, direct and transitive contents.
-func NewDepSet(order DepSetOrder, direct Paths, transitive []*DepSet) *DepSet {
- return &DepSet{*newDepSet(order, direct, transitive)}
-}
-
-// NewDepSetBuilder returns a DepSetBuilder to create an immutable DepSet with the given order.
-func NewDepSetBuilder(order DepSetOrder) *DepSetBuilder {
- return &DepSetBuilder{*newDepSetBuilder(order, Paths(nil))}
-}
-
-// Direct adds direct contents to the DepSet being built by a DepSetBuilder. Newly added direct
-// contents are to the right of any existing direct contents.
-func (b *DepSetBuilder) Direct(direct ...Path) *DepSetBuilder {
- b.depSetBuilder.DirectSlice(direct)
- return b
-}
-
-// Transitive adds transitive contents to the DepSet being built by a DepSetBuilder. Newly added
-// transitive contents are to the right of any existing transitive contents.
-func (b *DepSetBuilder) Transitive(transitive ...*DepSet) *DepSetBuilder {
- b.depSetBuilder.Transitive(transitive)
- return b
-}
-
-// Returns the DepSet being built by this DepSetBuilder. The DepSetBuilder retains its contents
-// for creating more DepSets.
-func (b *DepSetBuilder) Build() *DepSet {
- return &DepSet{*b.depSetBuilder.Build()}
-}
-
-// ToList returns the DepSet flattened to a list. The order in the list is based on the order
-// of the DepSet. POSTORDER and PREORDER orders return a postordered or preordered left to right
-// flattened list. TOPOLOGICAL returns a list that guarantees that elements of children are listed
-// after all of their parents (unless there are duplicate direct elements in the DepSet or any of
-// its transitive dependencies, in which case the ordering of the duplicated element is not
-// guaranteed).
-func (d *DepSet) ToList() Paths {
- if d == nil {
- return nil
- }
- return d.toList(func(paths interface{}) interface{} {
- return FirstUniquePaths(paths.(Paths))
- }).(Paths)
-}
-
-// ToSortedList returns the direct and transitive contents of a DepSet in lexically sorted order
-// with duplicates removed.
-func (d *DepSet) ToSortedList() Paths {
- if d == nil {
- return nil
- }
- paths := d.ToList()
- return SortedUniquePaths(paths)
-}
diff --git a/android/depset_test.go b/android/depset_test.go
index 955ccb0..376dffa 100644
--- a/android/depset_test.go
+++ b/android/depset_test.go
@@ -17,51 +17,40 @@
import (
"fmt"
"reflect"
- "strconv"
"strings"
"testing"
)
func ExampleDepSet_ToList_postordered() {
- a := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("a")).Build()
- b := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("b")).Transitive(a).Build()
- c := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("c")).Transitive(a).Build()
- d := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
+ a := NewDepSetBuilder[Path](POSTORDER).Direct(PathForTesting("a")).Build()
+ b := NewDepSetBuilder[Path](POSTORDER).Direct(PathForTesting("b")).Transitive(a).Build()
+ c := NewDepSetBuilder[Path](POSTORDER).Direct(PathForTesting("c")).Transitive(a).Build()
+ d := NewDepSetBuilder[Path](POSTORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
- fmt.Println(d.ToList().Strings())
+ fmt.Println(Paths(d.ToList()).Strings())
// Output: [a b c d]
}
func ExampleDepSet_ToList_preordered() {
- a := NewDepSetBuilder(PREORDER).Direct(PathForTesting("a")).Build()
- b := NewDepSetBuilder(PREORDER).Direct(PathForTesting("b")).Transitive(a).Build()
- c := NewDepSetBuilder(PREORDER).Direct(PathForTesting("c")).Transitive(a).Build()
- d := NewDepSetBuilder(PREORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
+ a := NewDepSetBuilder[Path](PREORDER).Direct(PathForTesting("a")).Build()
+ b := NewDepSetBuilder[Path](PREORDER).Direct(PathForTesting("b")).Transitive(a).Build()
+ c := NewDepSetBuilder[Path](PREORDER).Direct(PathForTesting("c")).Transitive(a).Build()
+ d := NewDepSetBuilder[Path](PREORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
- fmt.Println(d.ToList().Strings())
+ fmt.Println(Paths(d.ToList()).Strings())
// Output: [d b a c]
}
func ExampleDepSet_ToList_topological() {
- a := NewDepSetBuilder(TOPOLOGICAL).Direct(PathForTesting("a")).Build()
- b := NewDepSetBuilder(TOPOLOGICAL).Direct(PathForTesting("b")).Transitive(a).Build()
- c := NewDepSetBuilder(TOPOLOGICAL).Direct(PathForTesting("c")).Transitive(a).Build()
- d := NewDepSetBuilder(TOPOLOGICAL).Direct(PathForTesting("d")).Transitive(b, c).Build()
+ a := NewDepSetBuilder[Path](TOPOLOGICAL).Direct(PathForTesting("a")).Build()
+ b := NewDepSetBuilder[Path](TOPOLOGICAL).Direct(PathForTesting("b")).Transitive(a).Build()
+ c := NewDepSetBuilder[Path](TOPOLOGICAL).Direct(PathForTesting("c")).Transitive(a).Build()
+ d := NewDepSetBuilder[Path](TOPOLOGICAL).Direct(PathForTesting("d")).Transitive(b, c).Build()
- fmt.Println(d.ToList().Strings())
+ fmt.Println(Paths(d.ToList()).Strings())
// Output: [d b c a]
}
-func ExampleDepSet_ToSortedList() {
- a := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("a")).Build()
- b := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("b")).Transitive(a).Build()
- c := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("c")).Transitive(a).Build()
- d := NewDepSetBuilder(POSTORDER).Direct(PathForTesting("d")).Transitive(b, c).Build()
-
- fmt.Println(d.ToSortedList().Strings())
- // Output: [a b c d]
-}
-
// Tests based on Bazel's ExpanderTestBase.java to ensure compatibility
// https://github.com/bazelbuild/bazel/blob/master/src/test/java/com/google/devtools/build/lib/collect/nestedset/ExpanderTestBase.java
func TestDepSet(t *testing.T) {
@@ -74,13 +63,13 @@
tests := []struct {
name string
- depSet func(t *testing.T, order DepSetOrder) *DepSet
+ depSet func(t *testing.T, order DepSetOrder) *DepSet[Path]
postorder, preorder, topological []string
}{
{
name: "simple",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- return NewDepSet(order, Paths{c, a, b}, nil)
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ return NewDepSet[Path](order, Paths{c, a, b}, nil)
},
postorder: []string{"c", "a", "b"},
preorder: []string{"c", "a", "b"},
@@ -88,8 +77,8 @@
},
{
name: "simpleNoDuplicates",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- return NewDepSet(order, Paths{c, a, a, a, b}, nil)
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ return NewDepSet[Path](order, Paths{c, a, a, a, b}, nil)
},
postorder: []string{"c", "a", "b"},
preorder: []string{"c", "a", "b"},
@@ -97,9 +86,9 @@
},
{
name: "nesting",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- subset := NewDepSet(order, Paths{c, a, e}, nil)
- return NewDepSet(order, Paths{b, d}, []*DepSet{subset})
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ subset := NewDepSet[Path](order, Paths{c, a, e}, nil)
+ return NewDepSet[Path](order, Paths{b, d}, []*DepSet[Path]{subset})
},
postorder: []string{"c", "a", "e", "b", "d"},
preorder: []string{"b", "d", "c", "a", "e"},
@@ -107,14 +96,14 @@
},
{
name: "builderReuse",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
assertEquals := func(t *testing.T, w, g Paths) {
t.Helper()
if !reflect.DeepEqual(w, g) {
t.Errorf("want %q, got %q", w, g)
}
}
- builder := NewDepSetBuilder(order)
+ builder := NewDepSetBuilder[Path](order)
assertEquals(t, nil, builder.Build().ToList())
builder.Direct(b)
@@ -123,7 +112,7 @@
builder.Direct(d)
assertEquals(t, Paths{b, d}, builder.Build().ToList())
- child := NewDepSetBuilder(order).Direct(c, a, e).Build()
+ child := NewDepSetBuilder[Path](order).Direct(c, a, e).Build()
builder.Transitive(child)
return builder.Build()
},
@@ -133,9 +122,9 @@
},
{
name: "builderChaining",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- return NewDepSetBuilder(order).Direct(b).Direct(d).
- Transitive(NewDepSetBuilder(order).Direct(c, a, e).Build()).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ return NewDepSetBuilder[Path](order).Direct(b).Direct(d).
+ Transitive(NewDepSetBuilder[Path](order).Direct(c, a, e).Build()).Build()
},
postorder: []string{"c", "a", "e", "b", "d"},
preorder: []string{"b", "d", "c", "a", "e"},
@@ -143,9 +132,9 @@
},
{
name: "transitiveDepsHandledSeparately",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- subset := NewDepSetBuilder(order).Direct(c, a, e).Build()
- builder := NewDepSetBuilder(order)
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ subset := NewDepSetBuilder[Path](order).Direct(c, a, e).Build()
+ builder := NewDepSetBuilder[Path](order)
// The fact that we add the transitive subset between the Direct(b) and Direct(d)
// calls should not change the result.
builder.Direct(b)
@@ -159,9 +148,9 @@
},
{
name: "nestingNoDuplicates",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- subset := NewDepSetBuilder(order).Direct(c, a, e).Build()
- return NewDepSetBuilder(order).Direct(b, d, e).Transitive(subset).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ subset := NewDepSetBuilder[Path](order).Direct(c, a, e).Build()
+ return NewDepSetBuilder[Path](order).Direct(b, d, e).Transitive(subset).Build()
},
postorder: []string{"c", "a", "e", "b", "d"},
preorder: []string{"b", "d", "e", "c", "a"},
@@ -169,10 +158,10 @@
},
{
name: "chain",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- c := NewDepSetBuilder(order).Direct(c).Build()
- b := NewDepSetBuilder(order).Direct(b).Transitive(c).Build()
- a := NewDepSetBuilder(order).Direct(a).Transitive(b).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ c := NewDepSetBuilder[Path](order).Direct(c).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Transitive(c).Build()
+ a := NewDepSetBuilder[Path](order).Direct(a).Transitive(b).Build()
return a
},
@@ -182,11 +171,11 @@
},
{
name: "diamond",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- d := NewDepSetBuilder(order).Direct(d).Build()
- c := NewDepSetBuilder(order).Direct(c).Transitive(d).Build()
- b := NewDepSetBuilder(order).Direct(b).Transitive(d).Build()
- a := NewDepSetBuilder(order).Direct(a).Transitive(b).Transitive(c).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ d := NewDepSetBuilder[Path](order).Direct(d).Build()
+ c := NewDepSetBuilder[Path](order).Direct(c).Transitive(d).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Transitive(d).Build()
+ a := NewDepSetBuilder[Path](order).Direct(a).Transitive(b).Transitive(c).Build()
return a
},
@@ -196,12 +185,12 @@
},
{
name: "extendedDiamond",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- d := NewDepSetBuilder(order).Direct(d).Build()
- e := NewDepSetBuilder(order).Direct(e).Build()
- b := NewDepSetBuilder(order).Direct(b).Transitive(d).Transitive(e).Build()
- c := NewDepSetBuilder(order).Direct(c).Transitive(e).Transitive(d).Build()
- a := NewDepSetBuilder(order).Direct(a).Transitive(b).Transitive(c).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ d := NewDepSetBuilder[Path](order).Direct(d).Build()
+ e := NewDepSetBuilder[Path](order).Direct(e).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Transitive(d).Transitive(e).Build()
+ c := NewDepSetBuilder[Path](order).Direct(c).Transitive(e).Transitive(d).Build()
+ a := NewDepSetBuilder[Path](order).Direct(a).Transitive(b).Transitive(c).Build()
return a
},
postorder: []string{"d", "e", "b", "c", "a"},
@@ -210,13 +199,13 @@
},
{
name: "extendedDiamondRightArm",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- d := NewDepSetBuilder(order).Direct(d).Build()
- e := NewDepSetBuilder(order).Direct(e).Build()
- b := NewDepSetBuilder(order).Direct(b).Transitive(d).Transitive(e).Build()
- c2 := NewDepSetBuilder(order).Direct(c2).Transitive(e).Transitive(d).Build()
- c := NewDepSetBuilder(order).Direct(c).Transitive(c2).Build()
- a := NewDepSetBuilder(order).Direct(a).Transitive(b).Transitive(c).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ d := NewDepSetBuilder[Path](order).Direct(d).Build()
+ e := NewDepSetBuilder[Path](order).Direct(e).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Transitive(d).Transitive(e).Build()
+ c2 := NewDepSetBuilder[Path](order).Direct(c2).Transitive(e).Transitive(d).Build()
+ c := NewDepSetBuilder[Path](order).Direct(c).Transitive(c2).Build()
+ a := NewDepSetBuilder[Path](order).Direct(a).Transitive(b).Transitive(c).Build()
return a
},
postorder: []string{"d", "e", "b", "c2", "c", "a"},
@@ -225,10 +214,10 @@
},
{
name: "orderConflict",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- child1 := NewDepSetBuilder(order).Direct(a, b).Build()
- child2 := NewDepSetBuilder(order).Direct(b, a).Build()
- parent := NewDepSetBuilder(order).Transitive(child1).Transitive(child2).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ child1 := NewDepSetBuilder[Path](order).Direct(a, b).Build()
+ child2 := NewDepSetBuilder[Path](order).Direct(b, a).Build()
+ parent := NewDepSetBuilder[Path](order).Transitive(child1).Transitive(child2).Build()
return parent
},
postorder: []string{"a", "b"},
@@ -237,12 +226,12 @@
},
{
name: "orderConflictNested",
- depSet: func(t *testing.T, order DepSetOrder) *DepSet {
- a := NewDepSetBuilder(order).Direct(a).Build()
- b := NewDepSetBuilder(order).Direct(b).Build()
- child1 := NewDepSetBuilder(order).Transitive(a).Transitive(b).Build()
- child2 := NewDepSetBuilder(order).Transitive(b).Transitive(a).Build()
- parent := NewDepSetBuilder(order).Transitive(child1).Transitive(child2).Build()
+ depSet: func(t *testing.T, order DepSetOrder) *DepSet[Path] {
+ a := NewDepSetBuilder[Path](order).Direct(a).Build()
+ b := NewDepSetBuilder[Path](order).Direct(b).Build()
+ child1 := NewDepSetBuilder[Path](order).Transitive(a).Transitive(b).Build()
+ child2 := NewDepSetBuilder[Path](order).Transitive(b).Transitive(a).Build()
+ parent := NewDepSetBuilder[Path](order).Transitive(child1).Transitive(child2).Build()
return parent
},
postorder: []string{"a", "b"},
@@ -255,19 +244,19 @@
t.Run(tt.name, func(t *testing.T) {
t.Run("postorder", func(t *testing.T) {
depSet := tt.depSet(t, POSTORDER)
- if g, w := depSet.ToList().Strings(), tt.postorder; !reflect.DeepEqual(g, w) {
+ if g, w := Paths(depSet.ToList()).Strings(), tt.postorder; !reflect.DeepEqual(g, w) {
t.Errorf("expected ToList() = %q, got %q", w, g)
}
})
t.Run("preorder", func(t *testing.T) {
depSet := tt.depSet(t, PREORDER)
- if g, w := depSet.ToList().Strings(), tt.preorder; !reflect.DeepEqual(g, w) {
+ if g, w := Paths(depSet.ToList()).Strings(), tt.preorder; !reflect.DeepEqual(g, w) {
t.Errorf("expected ToList() = %q, got %q", w, g)
}
})
t.Run("topological", func(t *testing.T) {
depSet := tt.depSet(t, TOPOLOGICAL)
- if g, w := depSet.ToList().Strings(), tt.topological; !reflect.DeepEqual(g, w) {
+ if g, w := Paths(depSet.ToList()).Strings(), tt.topological; !reflect.DeepEqual(g, w) {
t.Errorf("expected ToList() = %q, got %q", w, g)
}
})
@@ -288,7 +277,7 @@
}
}
}()
- NewDepSet(order1, nil, []*DepSet{NewDepSet(order2, nil, nil)})
+ NewDepSet(order1, nil, []*DepSet[Path]{NewDepSet[Path](order2, nil, nil)})
t.Fatal("expected panic")
}
@@ -304,87 +293,3 @@
})
}
}
-
-func Test_firstUnique(t *testing.T) {
- f := func(t *testing.T, imp func([]string) []string, in, want []string) {
- t.Helper()
- out := imp(in)
- if !reflect.DeepEqual(out, want) {
- t.Errorf("incorrect output:")
- t.Errorf(" input: %#v", in)
- t.Errorf(" expected: %#v", want)
- t.Errorf(" got: %#v", out)
- }
- }
-
- for _, testCase := range firstUniqueStringsTestCases {
- t.Run("list", func(t *testing.T) {
- f(t, func(s []string) []string {
- return firstUniqueList(s).([]string)
- }, testCase.in, testCase.out)
- })
- t.Run("map", func(t *testing.T) {
- f(t, func(s []string) []string {
- return firstUniqueMap(s).([]string)
- }, testCase.in, testCase.out)
- })
- }
-}
-
-func Benchmark_firstUnique(b *testing.B) {
- implementations := []struct {
- name string
- f func([]string) []string
- }{
- {
- name: "list",
- f: func(slice []string) []string {
- return firstUniqueList(slice).([]string)
- },
- },
- {
- name: "map",
- f: func(slice []string) []string {
- return firstUniqueMap(slice).([]string)
- },
- },
- {
- name: "optimal",
- f: func(slice []string) []string {
- return firstUnique(slice).([]string)
- },
- },
- }
- const maxSize = 1024
- uniqueStrings := make([]string, maxSize)
- for i := range uniqueStrings {
- uniqueStrings[i] = strconv.Itoa(i)
- }
- sameString := make([]string, maxSize)
- for i := range sameString {
- sameString[i] = uniqueStrings[0]
- }
-
- f := func(b *testing.B, imp func([]string) []string, s []string) {
- for i := 0; i < b.N; i++ {
- b.ReportAllocs()
- s = append([]string(nil), s...)
- imp(s)
- }
- }
-
- for n := 1; n <= maxSize; n <<= 1 {
- b.Run(strconv.Itoa(n), func(b *testing.B) {
- for _, implementation := range implementations {
- b.Run(implementation.name, func(b *testing.B) {
- b.Run("same", func(b *testing.B) {
- f(b, implementation.f, sameString[:n])
- })
- b.Run("unique", func(b *testing.B) {
- f(b, implementation.f, uniqueStrings[:n])
- })
- })
- }
- })
- }
-}
diff --git a/android/fixture.go b/android/fixture.go
index dbc3bc5..03abb7f 100644
--- a/android/fixture.go
+++ b/android/fixture.go
@@ -275,6 +275,15 @@
})
}
+// Sync the mock filesystem with the current config, then modify the context,
+// This allows context modification that requires filesystem access.
+func FixtureModifyContextWithMockFs(mutator func(ctx *TestContext)) FixturePreparer {
+ return newSimpleFixturePreparer(func(f *fixture) {
+ f.config.mockFileSystem("", f.mockFS)
+ mutator(f.ctx)
+ })
+}
+
func FixtureRegisterWithContext(registeringFunc func(ctx RegistrationContext)) FixturePreparer {
return FixtureModifyContext(func(ctx *TestContext) { registeringFunc(ctx) })
}
diff --git a/android/license_metadata.go b/android/license_metadata.go
index 73000a9..8933bd5 100644
--- a/android/license_metadata.go
+++ b/android/license_metadata.go
@@ -55,7 +55,7 @@
var allDepMetadataFiles Paths
var allDepMetadataArgs []string
var allDepOutputFiles Paths
- var allDepMetadataDepSets []*PathsDepSet
+ var allDepMetadataDepSets []*DepSet[Path]
ctx.VisitDirectDepsBlueprint(func(bpdep blueprint.Module) {
dep, _ := bpdep.(Module)
@@ -127,7 +127,7 @@
JoinWithPrefix(proptools.NinjaAndShellEscapeListIncludingSpaces(base.commonProperties.Effective_license_text.Strings()), "-n "))
if isContainer {
- transitiveDeps := newPathsDepSet(nil, allDepMetadataDepSets).ToList()
+ transitiveDeps := Paths(NewDepSet[Path](TOPOLOGICAL, nil, allDepMetadataDepSets).ToList())
args = append(args,
JoinWithPrefix(proptools.NinjaAndShellEscapeListIncludingSpaces(transitiveDeps.Strings()), "-d "))
orderOnlyDeps = append(orderOnlyDeps, transitiveDeps...)
@@ -170,7 +170,7 @@
ctx.SetProvider(LicenseMetadataProvider, &LicenseMetadataInfo{
LicenseMetadataPath: licenseMetadataFile,
- LicenseMetadataDepSet: newPathsDepSet(Paths{licenseMetadataFile}, allDepMetadataDepSets),
+ LicenseMetadataDepSet: NewDepSet(TOPOLOGICAL, Paths{licenseMetadataFile}, allDepMetadataDepSets),
})
}
@@ -198,7 +198,7 @@
// LicenseMetadataInfo stores the license metadata path for a module.
type LicenseMetadataInfo struct {
LicenseMetadataPath Path
- LicenseMetadataDepSet *PathsDepSet
+ LicenseMetadataDepSet *DepSet[Path]
}
// licenseAnnotationsFromTag returns the LicenseAnnotations for a tag (if any) converted into
diff --git a/android/module.go b/android/module.go
index 726fa85..384776a 100644
--- a/android/module.go
+++ b/android/module.go
@@ -1525,10 +1525,10 @@
noAddressSanitizer bool
installFiles InstallPaths
- installFilesDepSet *installPathsDepSet
+ installFilesDepSet *DepSet[InstallPath]
checkbuildFiles Paths
packagingSpecs []PackagingSpec
- packagingSpecsDepSet *packagingSpecsDepSet
+ packagingSpecsDepSet *DepSet[PackagingSpec]
// katiInstalls tracks the install rules that were created by Soong but are being exported
// to Make to convert to ninja rules so that Make can add additional dependencies.
katiInstalls katiInstalls
@@ -2108,9 +2108,9 @@
// computeInstallDeps finds the installed paths of all dependencies that have a dependency
// tag that is annotated as needing installation via the isInstallDepNeeded method.
-func (m *ModuleBase) computeInstallDeps(ctx ModuleContext) ([]*installPathsDepSet, []*packagingSpecsDepSet) {
- var installDeps []*installPathsDepSet
- var packagingSpecs []*packagingSpecsDepSet
+func (m *ModuleBase) computeInstallDeps(ctx ModuleContext) ([]*DepSet[InstallPath], []*DepSet[PackagingSpec]) {
+ var installDeps []*DepSet[InstallPath]
+ var packagingSpecs []*DepSet[PackagingSpec]
ctx.VisitDirectDeps(func(dep Module) {
if isInstallDepNeeded(dep, ctx.OtherModuleDependencyTag(dep)) {
// Installation is still handled by Make, so anything hidden from Make is not
@@ -2405,7 +2405,7 @@
// set m.installFilesDepSet to only the transitive dependencies to be used as the dependencies
// of installed files of this module. It will be replaced by a depset including the installed
// files of this module at the end for use by modules that depend on this one.
- m.installFilesDepSet = newInstallPathsDepSet(nil, dependencyInstallFiles)
+ m.installFilesDepSet = NewDepSet[InstallPath](TOPOLOGICAL, nil, dependencyInstallFiles)
// Temporarily continue to call blueprintCtx.GetMissingDependencies() to maintain the previous behavior of never
// reporting missing dependency errors in Blueprint when AllowMissingDependencies == true.
@@ -2512,8 +2512,8 @@
}
}
- m.installFilesDepSet = newInstallPathsDepSet(m.installFiles, dependencyInstallFiles)
- m.packagingSpecsDepSet = newPackagingSpecsDepSet(m.packagingSpecs, dependencyPackagingSpecs)
+ m.installFilesDepSet = NewDepSet[InstallPath](TOPOLOGICAL, m.installFiles, dependencyInstallFiles)
+ m.packagingSpecsDepSet = NewDepSet[PackagingSpec](TOPOLOGICAL, m.packagingSpecs, dependencyPackagingSpecs)
buildLicenseMetadata(ctx, m.licenseMetadataFile)
@@ -3394,7 +3394,7 @@
m.module.base().hooks.runInstallHooks(m, srcPath, fullInstallPath, false)
if !m.skipInstall() {
- deps = append(deps, m.module.base().installFilesDepSet.ToList().Paths()...)
+ deps = append(deps, InstallPaths(m.module.base().installFilesDepSet.ToList()).Paths()...)
var implicitDeps, orderOnlyDeps Paths
@@ -3969,26 +3969,6 @@
return blueprint.CheckBlueprintSyntax(bpctx.ModuleFactories(), filename, contents)
}
-// installPathsDepSet is a thin type-safe wrapper around the generic depSet. It always uses
-// topological order.
-type installPathsDepSet struct {
- depSet
-}
-
-// newInstallPathsDepSet returns an immutable packagingSpecsDepSet with the given direct and
-// transitive contents.
-func newInstallPathsDepSet(direct InstallPaths, transitive []*installPathsDepSet) *installPathsDepSet {
- return &installPathsDepSet{*newDepSet(TOPOLOGICAL, direct, transitive)}
-}
-
-// ToList returns the installPathsDepSet flattened to a list in topological order.
-func (d *installPathsDepSet) ToList() InstallPaths {
- if d == nil {
- return nil
- }
- return d.depSet.ToList().(InstallPaths)
-}
-
func registerSoongConfigTraceMutator(ctx RegisterMutatorsContext) {
ctx.BottomUp("soongconfigtrace", soongConfigTraceMutator).Parallel()
}
diff --git a/android/neverallow.go b/android/neverallow.go
index f2e8c85..24031ba 100644
--- a/android/neverallow.go
+++ b/android/neverallow.go
@@ -239,7 +239,9 @@
func createInitFirstStageRules() []Rule {
return []Rule{
NeverAllow().
+ Without("name", "init_first_stage_defaults").
Without("name", "init_first_stage").
+ Without("name", "init_first_stage.microdroid").
With("install_in_root", "true").
Because("install_in_root is only for init_first_stage."),
}
@@ -256,10 +258,10 @@
func createJavaExcludeStaticLibsRule() Rule {
return NeverAllow().
- NotIn("build/soong").
+ NotIn("build/soong", "libcore", "frameworks/base/api").
ModuleType("java_library").
WithMatcher("exclude_static_libs", isSetMatcherInstance).
- Because("exclude_static_libs property is only allowed for java modules defined in build/soong")
+ Because("exclude_static_libs property is only allowed for java modules defined in build/soong, libcore, and frameworks/base/api")
}
func neverallowMutator(ctx BottomUpMutatorContext) {
diff --git a/android/neverallow_test.go b/android/neverallow_test.go
index 1639bbf..2a938b8 100644
--- a/android/neverallow_test.go
+++ b/android/neverallow_test.go
@@ -358,7 +358,7 @@
`),
},
expectedErrors: []string{
- `exclude_static_libs property is only allowed for java modules defined in build/soong`,
+ `exclude_static_libs property is only allowed for java modules defined in build/soong, libcore, and frameworks/base/api`,
},
},
}
diff --git a/android/packaging.go b/android/packaging.go
index c764a6d..503bb97 100644
--- a/android/packaging.go
+++ b/android/packaging.go
@@ -282,23 +282,3 @@
builder.Build("zip_deps", fmt.Sprintf("Zipping deps for %s", ctx.ModuleName()))
return entries
}
-
-// packagingSpecsDepSet is a thin type-safe wrapper around the generic depSet. It always uses
-// topological order.
-type packagingSpecsDepSet struct {
- depSet
-}
-
-// newPackagingSpecsDepSet returns an immutable packagingSpecsDepSet with the given direct and
-// transitive contents.
-func newPackagingSpecsDepSet(direct []PackagingSpec, transitive []*packagingSpecsDepSet) *packagingSpecsDepSet {
- return &packagingSpecsDepSet{*newDepSet(TOPOLOGICAL, direct, transitive)}
-}
-
-// ToList returns the packagingSpecsDepSet flattened to a list in topological order.
-func (d *packagingSpecsDepSet) ToList() []PackagingSpec {
- if d == nil {
- return nil
- }
- return d.depSet.ToList().([]PackagingSpec)
-}
diff --git a/android/paths.go b/android/paths.go
index 94fa89c..fda4d2f 100644
--- a/android/paths.go
+++ b/android/paths.go
@@ -2196,23 +2196,3 @@
}
return false
}
-
-// PathsDepSet is a thin type-safe wrapper around the generic depSet. It always uses
-// topological order.
-type PathsDepSet struct {
- depSet
-}
-
-// newPathsDepSet returns an immutable PathsDepSet with the given direct and
-// transitive contents.
-func newPathsDepSet(direct Paths, transitive []*PathsDepSet) *PathsDepSet {
- return &PathsDepSet{*newDepSet(TOPOLOGICAL, direct, transitive)}
-}
-
-// ToList returns the PathsDepSet flattened to a list in topological order.
-func (d *PathsDepSet) ToList() Paths {
- if d == nil {
- return nil
- }
- return d.depSet.ToList().(Paths)
-}
diff --git a/android/register.go b/android/register.go
index 64b0207..5d277e1 100644
--- a/android/register.go
+++ b/android/register.go
@@ -15,9 +15,13 @@
package android
import (
+ "bufio"
"fmt"
+ "path/filepath"
"reflect"
+ "regexp"
+ "android/soong/shared"
"github.com/google/blueprint"
)
@@ -197,6 +201,49 @@
RegisterMutatorsForBazelConversion(ctx, bp2buildPreArchMutators)
}
+func (c *Context) ParseBuildFiles(topDir string, existingBazelFiles []string) error {
+ result := map[string][]string{}
+
+ // Search for instances of `name = "$NAME"` (with arbitrary spacing).
+ targetNameRegex := regexp.MustCompile(`(?m)^\s*name\s*=\s*\"([^\"]+)\"`)
+
+ parseBuildFile := func(path string) error {
+ fullPath := shared.JoinPath(topDir, path)
+ sourceDir := filepath.Dir(path)
+
+ fileInfo, err := c.Config().fs.Stat(fullPath)
+ if err != nil {
+ return fmt.Errorf("Error accessing Bazel file '%s': %s", path, err)
+ }
+ if !fileInfo.IsDir() &&
+ (fileInfo.Name() == "BUILD" || fileInfo.Name() == "BUILD.bazel") {
+ f, err := c.Config().fs.Open(fullPath)
+ if err != nil {
+ return fmt.Errorf("Error reading Bazel file '%s': %s", path, err)
+ }
+ defer f.Close()
+ scanner := bufio.NewScanner(f)
+ for scanner.Scan() {
+ line := scanner.Text()
+ matches := targetNameRegex.FindAllStringSubmatch(line, -1)
+ for _, match := range matches {
+ result[sourceDir] = append(result[sourceDir], match[1])
+ }
+ }
+ }
+ return nil
+ }
+
+ for _, path := range existingBazelFiles {
+ err := parseBuildFile(path)
+ if err != nil {
+ return err
+ }
+ }
+ c.Config().SetBazelBuildFileTargets(result)
+ return nil
+}
+
// RegisterForApiBazelConversion is similar to RegisterForBazelConversion except that
// it only generates API targets in the generated workspace
func (ctx *Context) RegisterForApiBazelConversion() {
diff --git a/android/sdk_version.go b/android/sdk_version.go
index 80aeb2e..1fadda0 100644
--- a/android/sdk_version.go
+++ b/android/sdk_version.go
@@ -84,25 +84,6 @@
}
}
-// JavaApiLibraryName returns the name of .txt equivalent of a java_library, but does
-// not check if either module exists.
-// TODO: Return .txt (single-tree or multi-tree equivalents) based on config
-func JavaApiLibraryName(c Config, name string) string {
- if c.BuildFromTextStub() {
- return name + ".from-text"
- }
- return name
-}
-
-// JavaApiLibraryNames applies JavaApiLibraryName to the list of java_library names.
-func JavaApiLibraryNames(c Config, names []string) []string {
- apiLibs := make([]string, len(names))
- for i, name := range names {
- apiLibs[i] = JavaApiLibraryName(c, name)
- }
- return apiLibs
-}
-
func (k SdkKind) DefaultJavaLibraryName() string {
switch k {
case SdkPublic:
diff --git a/android/util.go b/android/util.go
index 08a3521..9695454 100644
--- a/android/util.go
+++ b/android/util.go
@@ -42,6 +42,16 @@
return res
}
+// JoinPathsWithPrefix converts the paths to strings, prefixes them
+// with prefix and then joins them separated by " ".
+func JoinPathsWithPrefix(paths []Path, prefix string) string {
+ strs := make([]string, len(paths))
+ for i := range paths {
+ strs[i] = paths[i].String()
+ }
+ return JoinWithPrefixAndSeparator(strs, prefix, " ")
+}
+
// JoinWithPrefix prepends the prefix to each string in the list and
// returns them joined together with " " as separator.
func JoinWithPrefix(strs []string, prefix string) string {
@@ -284,38 +294,74 @@
list = CopyOf(list)
// 128 was chosen based on BenchmarkFirstUniqueStrings results.
if len(list) > 128 {
- return firstUniqueStringsMap(list)
+ return firstUnique(list)
}
- return firstUniqueStringsList(list)
+ return firstUnique(list)
}
-func firstUniqueStringsList(list []string) []string {
- k := 0
+// firstUnique returns all unique elements of a slice, keeping the first copy of each. It
+// modifies the slice contents in place, and returns a subslice of the original slice.
+func firstUnique[T comparable](slice []T) []T {
+ // 4 was chosen based on Benchmark_firstUnique results.
+ if len(slice) > 4 {
+ return firstUniqueMap(slice)
+ }
+ return firstUniqueList(slice)
+}
+
+// firstUniqueList is an implementation of firstUnique using an O(N^2) list comparison to look for
+// duplicates.
+func firstUniqueList[T any](in []T) []T {
+ writeIndex := 0
outer:
- for i := 0; i < len(list); i++ {
- for j := 0; j < k; j++ {
- if list[i] == list[j] {
+ for readIndex := 0; readIndex < len(in); readIndex++ {
+ for compareIndex := 0; compareIndex < writeIndex; compareIndex++ {
+ if interface{}(in[readIndex]) == interface{}(in[compareIndex]) {
+ // The value at readIndex already exists somewhere in the output region
+ // of the slice before writeIndex, skip it.
continue outer
}
}
- list[k] = list[i]
- k++
+ if readIndex != writeIndex {
+ in[writeIndex] = in[readIndex]
+ }
+ writeIndex++
}
- return list[:k]
+ return in[0:writeIndex]
}
-func firstUniqueStringsMap(list []string) []string {
- k := 0
- seen := make(map[string]bool, len(list))
- for i := 0; i < len(list); i++ {
- if seen[list[i]] {
+// firstUniqueMap is an implementation of firstUnique using an O(N) hash set lookup to look for
+// duplicates.
+func firstUniqueMap[T comparable](in []T) []T {
+ writeIndex := 0
+ seen := make(map[T]bool, len(in))
+ for readIndex := 0; readIndex < len(in); readIndex++ {
+ if _, exists := seen[in[readIndex]]; exists {
continue
}
- seen[list[i]] = true
- list[k] = list[i]
- k++
+ seen[in[readIndex]] = true
+ if readIndex != writeIndex {
+ in[writeIndex] = in[readIndex]
+ }
+ writeIndex++
}
- return list[:k]
+ return in[0:writeIndex]
+}
+
+// reverseSliceInPlace reverses the elements of a slice in place.
+func reverseSliceInPlace[T any](in []T) {
+ for i, j := 0, len(in)-1; i < j; i, j = i+1, j-1 {
+ in[i], in[j] = in[j], in[i]
+ }
+}
+
+// reverseSlice returns a copy of a slice in reverse order.
+func reverseSlice[T any](in []T) []T {
+ out := make([]T, len(in))
+ for i := 0; i < len(in); i++ {
+ out[i] = in[len(in)-1-i]
+ }
+ return out
}
// LastUniqueStrings returns all unique elements of a slice of strings, keeping the last copy of
diff --git a/android/util_test.go b/android/util_test.go
index a2ef589..bee31a9 100644
--- a/android/util_test.go
+++ b/android/util_test.go
@@ -74,10 +74,10 @@
for _, testCase := range firstUniqueStringsTestCases {
t.Run("list", func(t *testing.T) {
- f(t, firstUniqueStringsList, testCase.in, testCase.out)
+ f(t, firstUniqueList[string], testCase.in, testCase.out)
})
t.Run("map", func(t *testing.T) {
- f(t, firstUniqueStringsMap, testCase.in, testCase.out)
+ f(t, firstUniqueMap[string], testCase.in, testCase.out)
})
}
}
@@ -604,11 +604,11 @@
}{
{
name: "list",
- f: firstUniqueStringsList,
+ f: firstUniqueList[string],
},
{
name: "map",
- f: firstUniqueStringsMap,
+ f: firstUniqueMap[string],
},
{
name: "optimal",
diff --git a/android/variable.go b/android/variable.go
index c5f1823..3bec854 100644
--- a/android/variable.go
+++ b/android/variable.go
@@ -175,10 +175,6 @@
Whole_static_libs []string `android:"arch_variant"`
} `android:"arch_variant"`
- Flatten_apex struct {
- Enabled *bool
- }
-
Native_coverage struct {
Src *string `android:"arch_variant"`
Srcs []string `android:"arch_variant"`
@@ -397,7 +393,6 @@
Ndk_abis *bool `json:",omitempty"`
TrimmedApex *bool `json:",omitempty"`
- Flatten_apex *bool `json:",omitempty"`
ForceApexSymlinkOptimization *bool `json:",omitempty"`
CompressedApex *bool `json:",omitempty"`
Aml_abis *bool `json:",omitempty"`
@@ -477,8 +472,8 @@
ProductBrand string `json:",omitempty"`
BuildVersionTags []string `json:",omitempty"`
- ReleaseVersion string `json:",omitempty"`
- ReleaseDeviceConfigValueSets []string `json:",omitempty"`
+ ReleaseVersion string `json:",omitempty"`
+ ReleaseAconfigValueSets []string `json:",omitempty"`
}
func boolPtr(v bool) *bool {
diff --git a/apex/androidmk.go b/apex/androidmk.go
index 684833d..f469062 100644
--- a/apex/androidmk.go
+++ b/apex/androidmk.go
@@ -85,16 +85,12 @@
// conflicts between two apexes with the same apexName.
moduleNames := []string{}
- apexType := a.properties.ApexType
// To avoid creating duplicate build rules, run this function only when primaryApexType is true
// to install symbol files in $(PRODUCT_OUT}/apex.
- // And if apexType is flattened, run this function to install files in $(PRODUCT_OUT}/system/apex.
- if !a.primaryApexType && apexType != flattenedApex {
+ if !a.primaryApexType {
return moduleNames
}
- seenDataOutPaths := make(map[string]bool)
-
for _, fi := range a.filesInfo {
linkToSystemLib := a.linkToSystemLib && fi.transitiveDep && fi.availableToPlatform()
moduleName := a.fullModuleName(apexBundleName, linkToSystemLib, &fi)
@@ -131,33 +127,13 @@
}
// /apex/<apexBundleName>/{lib|framework|...}
pathForSymbol := filepath.Join("$(PRODUCT_OUT)", "apex", apexBundleName, fi.installDir)
- var modulePath string
- if apexType == flattenedApex {
- // /system/apex/<apexBundleName>/{lib|framework|...}
- modulePath = filepath.Join(a.installDir.String(), apexBundleName, fi.installDir)
- fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", modulePath)
- if a.primaryApexType {
- fmt.Fprintln(w, "LOCAL_SOONG_SYMBOL_PATH :=", pathForSymbol)
- }
- android.AndroidMkEmitAssignList(w, "LOCAL_MODULE_SYMLINKS", fi.symlinks)
- newDataPaths := []android.DataPath{}
- for _, path := range fi.dataPaths {
- dataOutPath := modulePath + ":" + path.SrcPath.Rel()
- if ok := seenDataOutPaths[dataOutPath]; !ok {
- newDataPaths = append(newDataPaths, path)
- seenDataOutPaths[dataOutPath] = true
- }
- }
- android.AndroidMkEmitAssignList(w, "LOCAL_TEST_DATA", android.AndroidMkDataPaths(newDataPaths))
- } else {
- modulePath = pathForSymbol
- fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", modulePath)
+ modulePath := pathForSymbol
+ fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", modulePath)
- // For non-flattend APEXes, the merged notice file is attached to the APEX itself.
- // We don't need to have notice file for the individual modules in it. Otherwise,
- // we will have duplicated notice entries.
- fmt.Fprintln(w, "LOCAL_NO_NOTICE_FILE := true")
- }
+ // For non-flattend APEXes, the merged notice file is attached to the APEX itself.
+ // We don't need to have notice file for the individual modules in it. Otherwise,
+ // we will have duplicated notice entries.
+ fmt.Fprintln(w, "LOCAL_NO_NOTICE_FILE := true")
fmt.Fprintln(w, "LOCAL_SOONG_INSTALLED_MODULE :=", filepath.Join(modulePath, fi.stem()))
fmt.Fprintln(w, "LOCAL_SOONG_INSTALL_PAIRS :=", fi.builtFile.String()+":"+filepath.Join(modulePath, fi.stem()))
fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", fi.builtFile.String())
@@ -257,31 +233,6 @@
fmt.Fprintln(w, "include $(BUILD_SYSTEM)/soong_cc_rust_prebuilt.mk")
default:
fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.stem())
- if fi.builtFile == a.manifestPbOut && apexType == flattenedApex {
- if a.primaryApexType {
- // To install companion files (init_rc, vintf_fragments)
- // Copy some common properties of apexBundle to apex_manifest
- commonProperties := []string{
- "LOCAL_FULL_INIT_RC", "LOCAL_FULL_VINTF_FRAGMENTS",
- }
- for _, name := range commonProperties {
- if value, ok := apexAndroidMkData.Entries.EntryMap[name]; ok {
- android.AndroidMkEmitAssignList(w, name, value)
- }
- }
-
- // Make apex_manifest.pb module for this APEX to override all other
- // modules in the APEXes being overridden by this APEX
- var patterns []string
- for _, o := range a.overridableProperties.Overrides {
- patterns = append(patterns, "%."+o+a.suffix)
- }
- android.AndroidMkEmitAssignList(w, "LOCAL_OVERRIDES_MODULES", patterns)
- }
-
- // File_contexts of flattened APEXes should be merged into file_contexts.bin
- fmt.Fprintln(w, "LOCAL_FILE_CONTEXTS :=", a.fileContexts)
- }
fmt.Fprintln(w, "include $(BUILD_PREBUILT)")
}
@@ -320,73 +271,62 @@
moduleNames = a.androidMkForFiles(w, name, moduleDir, data)
}
- if apexType == flattenedApex {
- // Only image APEXes can be flattened.
- fmt.Fprintln(w, "\ninclude $(CLEAR_VARS) # apex.apexBundle.flat")
- fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
- fmt.Fprintln(w, "LOCAL_MODULE :=", name+a.suffix)
- data.Entries.WriteLicenseVariables(w)
- a.writeRequiredModules(w, moduleNames)
- fmt.Fprintln(w, "include $(BUILD_PHONY_PACKAGE)")
-
- } else {
- fmt.Fprintln(w, "\ninclude $(CLEAR_VARS) # apex.apexBundle")
- fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
- fmt.Fprintln(w, "LOCAL_MODULE :=", name+a.suffix)
- data.Entries.WriteLicenseVariables(w)
- fmt.Fprintln(w, "LOCAL_MODULE_CLASS := ETC") // do we need a new class?
- fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", a.outputFile.String())
- fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", a.installDir.String())
- stemSuffix := apexType.suffix()
- if a.isCompressed {
- stemSuffix = imageCapexSuffix
- }
- fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", name+stemSuffix)
- fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE :=", !a.installable())
- if a.installable() {
- fmt.Fprintln(w, "LOCAL_SOONG_INSTALLED_MODULE :=", a.installedFile.String())
- fmt.Fprintln(w, "LOCAL_SOONG_INSTALL_PAIRS :=", a.outputFile.String()+":"+a.installedFile.String())
- }
-
- // Because apex writes .mk with Custom(), we need to write manually some common properties
- // which are available via data.Entries
- commonProperties := []string{
- "LOCAL_FULL_INIT_RC", "LOCAL_FULL_VINTF_FRAGMENTS",
- "LOCAL_PROPRIETARY_MODULE", "LOCAL_VENDOR_MODULE", "LOCAL_ODM_MODULE", "LOCAL_PRODUCT_MODULE", "LOCAL_SYSTEM_EXT_MODULE",
- "LOCAL_MODULE_OWNER",
- }
- for _, name := range commonProperties {
- if value, ok := data.Entries.EntryMap[name]; ok {
- android.AndroidMkEmitAssignList(w, name, value)
- }
- }
-
- android.AndroidMkEmitAssignList(w, "LOCAL_OVERRIDES_MODULES", a.overridableProperties.Overrides)
- a.writeRequiredModules(w, moduleNames)
-
- fmt.Fprintln(w, "include $(BUILD_PREBUILT)")
-
- if apexType == imageApex {
- fmt.Fprintln(w, "ALL_MODULES.$(my_register_name).BUNDLE :=", a.bundleModuleFile.String())
- }
- android.AndroidMkEmitAssignList(w, "ALL_MODULES.$(my_register_name).LINT_REPORTS", a.lintReports.Strings())
-
- if a.installedFilesFile != nil {
- goal := "checkbuild"
- distFile := name + "-installed-files.txt"
- fmt.Fprintln(w, ".PHONY:", goal)
- fmt.Fprintf(w, "$(call dist-for-goals,%s,%s:%s)\n",
- goal, a.installedFilesFile.String(), distFile)
- fmt.Fprintf(w, "$(call declare-0p-target,%s)\n", a.installedFilesFile.String())
- }
- for _, dist := range data.Entries.GetDistForGoals(a) {
- fmt.Fprintf(w, dist)
- }
-
- distCoverageFiles(w, "ndk_apis_usedby_apex", a.nativeApisUsedByModuleFile.String())
- distCoverageFiles(w, "ndk_apis_backedby_apex", a.nativeApisBackedByModuleFile.String())
- distCoverageFiles(w, "java_apis_used_by_apex", a.javaApisUsedByModuleFile.String())
+ fmt.Fprintln(w, "\ninclude $(CLEAR_VARS) # apex.apexBundle")
+ fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
+ fmt.Fprintln(w, "LOCAL_MODULE :=", name+a.suffix)
+ data.Entries.WriteLicenseVariables(w)
+ fmt.Fprintln(w, "LOCAL_MODULE_CLASS := ETC") // do we need a new class?
+ fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", a.outputFile.String())
+ fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", a.installDir.String())
+ stemSuffix := apexType.suffix()
+ if a.isCompressed {
+ stemSuffix = imageCapexSuffix
}
+ fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", name+stemSuffix)
+ fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE :=", !a.installable())
+ if a.installable() {
+ fmt.Fprintln(w, "LOCAL_SOONG_INSTALLED_MODULE :=", a.installedFile.String())
+ fmt.Fprintln(w, "LOCAL_SOONG_INSTALL_PAIRS :=", a.outputFile.String()+":"+a.installedFile.String())
+ }
+
+ // Because apex writes .mk with Custom(), we need to write manually some common properties
+ // which are available via data.Entries
+ commonProperties := []string{
+ "LOCAL_FULL_INIT_RC", "LOCAL_FULL_VINTF_FRAGMENTS",
+ "LOCAL_PROPRIETARY_MODULE", "LOCAL_VENDOR_MODULE", "LOCAL_ODM_MODULE", "LOCAL_PRODUCT_MODULE", "LOCAL_SYSTEM_EXT_MODULE",
+ "LOCAL_MODULE_OWNER",
+ }
+ for _, name := range commonProperties {
+ if value, ok := data.Entries.EntryMap[name]; ok {
+ android.AndroidMkEmitAssignList(w, name, value)
+ }
+ }
+
+ android.AndroidMkEmitAssignList(w, "LOCAL_OVERRIDES_MODULES", a.overridableProperties.Overrides)
+ a.writeRequiredModules(w, moduleNames)
+
+ fmt.Fprintln(w, "include $(BUILD_PREBUILT)")
+
+ if apexType == imageApex {
+ fmt.Fprintln(w, "ALL_MODULES.$(my_register_name).BUNDLE :=", a.bundleModuleFile.String())
+ }
+ android.AndroidMkEmitAssignList(w, "ALL_MODULES.$(my_register_name).LINT_REPORTS", a.lintReports.Strings())
+
+ if a.installedFilesFile != nil {
+ goal := "checkbuild"
+ distFile := name + "-installed-files.txt"
+ fmt.Fprintln(w, ".PHONY:", goal)
+ fmt.Fprintf(w, "$(call dist-for-goals,%s,%s:%s)\n",
+ goal, a.installedFilesFile.String(), distFile)
+ fmt.Fprintf(w, "$(call declare-0p-target,%s)\n", a.installedFilesFile.String())
+ }
+ for _, dist := range data.Entries.GetDistForGoals(a) {
+ fmt.Fprintf(w, dist)
+ }
+
+ distCoverageFiles(w, "ndk_apis_usedby_apex", a.nativeApisUsedByModuleFile.String())
+ distCoverageFiles(w, "ndk_apis_backedby_apex", a.nativeApisBackedByModuleFile.String())
+ distCoverageFiles(w, "java_apis_used_by_apex", a.javaApisUsedByModuleFile.String())
}}
}
diff --git a/apex/apex.go b/apex/apex.go
index 51c67d0..1d094eb 100644
--- a/apex/apex.go
+++ b/apex/apex.go
@@ -79,7 +79,7 @@
ctx.BottomUp("mark_platform_availability", markPlatformAvailability).Parallel()
ctx.BottomUp("apex", apexMutator).Parallel()
ctx.BottomUp("apex_directly_in_any", apexDirectlyInAnyMutator).Parallel()
- ctx.BottomUp("apex_flattened", apexFlattenedMutator).Parallel()
+ ctx.BottomUp("apex_packaging", apexPackagingMutator).Parallel()
ctx.BottomUp("apex_dcla_deps", apexDCLADepsMutator).Parallel()
// Register after apex_info mutator so that it can use ApexVariationName
ctx.TopDown("apex_strict_updatability_lint", apexStrictUpdatibilityLintMutator).Parallel()
@@ -216,9 +216,7 @@
HideFromMake bool `blueprint:"mutated"`
- // Internal package method for this APEX. When payload_type is image, this can be either
- // imageApex or flattenedApex depending on Config.FlattenApex(). When payload_type is zip,
- // this becomes zipApex.
+ // Internal package method for this APEX.
ApexType apexPackaging `blueprint:"mutated"`
// Name that dependencies can specify in their apex_available properties to refer to this module.
@@ -427,7 +425,7 @@
// one gets installed to the device.
primaryApexType bool
- // Suffix of module name in Android.mk ".flattened", ".apex", ".zipapex", or ""
+ // Suffix of module name in Android.mk ".apex", ".zipapex", or ""
suffix string
// File system type of apex_payload.img
@@ -535,8 +533,7 @@
// apexFile represents a file in an APEX bundle. This is created during the first half of
// GenerateAndroidBuildActions by traversing the dependencies of the APEX. Then in the second half
// of the function, this is used to create commands that copies the files into a staging directory,
-// where they are packaged into the APEX file. This struct is also used for creating Make modules
-// for each of the files in case when the APEX is flattened.
+// where they are packaged into the APEX file.
type apexFile struct {
// buildFile is put in the installDir inside the APEX.
builtFile android.Path
@@ -1367,12 +1364,8 @@
// zipApex is a packaging method where contents are directly included in the zip container.
// This is used for host-side testing - because the contents are easily accessible by
// unzipping the container.
+ // TODO(b/279835185) deprecate zipApex
zipApex
-
- // flattendApex is a packaging method where contents are not included in the APEX file, but
- // installed to /apex/<apexname> directory on the device. This packaging method is used for
- // old devices where the filesystem-based APEX file can't be supported.
- flattenedApex
)
const (
@@ -1380,12 +1373,10 @@
imageApexSuffix = ".apex"
imageCapexSuffix = ".capex"
zipApexSuffix = ".zipapex"
- flattenedSuffix = ".flattened"
// variant names each of which is for a packaging method
- imageApexType = "image"
- zipApexType = "zip"
- flattenedApexType = "flattened"
+ imageApexType = "image"
+ zipApexType = "zip"
ext4FsType = "ext4"
f2fsFsType = "f2fs"
@@ -1415,9 +1406,8 @@
}
}
-// apexFlattenedMutator creates one or more variations each of which is for a packaging method.
-// TODO(jiyong): give a better name to this mutator
-func apexFlattenedMutator(mctx android.BottomUpMutatorContext) {
+// apexPackagingMutator creates one or more variations each of which is for a packaging method.
+func apexPackagingMutator(mctx android.BottomUpMutatorContext) {
if !mctx.Module().Enabled() {
return
}
@@ -1425,19 +1415,11 @@
var variants []string
switch proptools.StringDefault(ab.properties.Payload_type, "image") {
case "image":
- // This is the normal case. Note that both image and flattend APEXes are
- // created. The image type is installed to the system partition, while the
- // flattened APEX is (optionally) installed to the system_ext partition.
- // This is mostly for GSI which has to support wide range of devices. If GSI
- // is installed on a newer (APEX-capable) device, the image APEX in the
- // system will be used. However, if the same GSI is installed on an old
- // device which can't support image APEX, the flattened APEX in the
- // system_ext partion (which still is part of GSI) is used instead.
- variants = append(variants, imageApexType, flattenedApexType)
+ variants = append(variants, imageApexType)
case "zip":
variants = append(variants, zipApexType)
case "both":
- variants = append(variants, imageApexType, zipApexType, flattenedApexType)
+ variants = append(variants, imageApexType, zipApexType)
default:
mctx.PropertyErrorf("payload_type", "%q is not one of \"image\", \"zip\", or \"both\".", *ab.properties.Payload_type)
return
@@ -1451,18 +1433,12 @@
modules[i].(*apexBundle).properties.ApexType = imageApex
case zipApexType:
modules[i].(*apexBundle).properties.ApexType = zipApex
- case flattenedApexType:
- modules[i].(*apexBundle).properties.ApexType = flattenedApex
- // See the comment above for why system_ext.
- if !mctx.Config().FlattenApex() && ab.Platform() {
- modules[i].(*apexBundle).MakeAsSystemExt()
- }
}
}
} else if _, ok := mctx.Module().(*OverrideApex); ok {
// payload_type is forcibly overridden to "image"
// TODO(jiyong): is this the right decision?
- mctx.CreateVariations(imageApexType, flattenedApexType)
+ mctx.CreateVariations(imageApexType)
}
}
@@ -1497,9 +1473,6 @@
var _ multitree.Exportable = (*apexBundle)(nil)
func (a *apexBundle) Exportable() bool {
- if a.properties.ApexType == flattenedApex {
- return false
- }
return true
}
@@ -2143,15 +2116,10 @@
func (a *apexBundle) setApexTypeAndSuffix(ctx android.ModuleContext) {
// Set suffix and primaryApexType depending on the ApexType
- buildFlattenedAsDefault := ctx.Config().FlattenApex()
switch a.properties.ApexType {
case imageApex:
- if buildFlattenedAsDefault {
- a.suffix = imageApexSuffix
- } else {
- a.suffix = ""
- a.primaryApexType = true
- }
+ a.suffix = ""
+ a.primaryApexType = true
case zipApex:
if proptools.String(a.properties.Payload_type) == "zip" {
a.suffix = ""
@@ -2159,17 +2127,10 @@
} else {
a.suffix = zipApexSuffix
}
- case flattenedApex:
- if buildFlattenedAsDefault {
- a.suffix = ""
- a.primaryApexType = true
- } else {
- a.suffix = flattenedSuffix
- }
}
}
-func (a apexBundle) isCompressable() bool {
+func (a *apexBundle) isCompressable() bool {
return proptools.BoolDefault(a.overridableProperties.Compressible, false) && !a.testApex
}
@@ -2668,32 +2629,9 @@
////////////////////////////////////////////////////////////////////////////////////////////
// 4) generate the build rules to create the APEX. This is done in builder.go.
a.buildManifest(ctx, vctx.provideNativeLibs, vctx.requireNativeLibs)
- if a.properties.ApexType == flattenedApex {
- a.buildFlattenedApex(ctx)
- } else {
- a.buildUnflattenedApex(ctx)
- }
+ a.buildApex(ctx)
a.buildApexDependencyInfo(ctx)
a.buildLintReports(ctx)
-
- // Append meta-files to the filesInfo list so that they are reflected in Android.mk as well.
- if a.installable() {
- // For flattened APEX, make sure that APEX manifest and apex_pubkey are also copied
- // along with other ordinary files. (Note that this is done by apexer for
- // non-flattened APEXes)
- a.filesInfo = append(a.filesInfo, newApexFile(ctx, a.manifestPbOut, "apex_manifest.pb", ".", etc, nil))
-
- // Place the public key as apex_pubkey. This is also done by apexer for
- // non-flattened APEXes case.
- // TODO(jiyong): Why do we need this CP rule?
- copiedPubkey := android.PathForModuleOut(ctx, "apex_pubkey")
- ctx.Build(pctx, android.BuildParams{
- Rule: android.Cp,
- Input: a.publicKeyFile,
- Output: copiedPubkey,
- })
- a.filesInfo = append(a.filesInfo, newApexFile(ctx, copiedPubkey, "apex_pubkey", ".", etc, nil))
- }
}
// apexBootclasspathFragmentFiles returns the list of apexFile structures defining the files that
diff --git a/apex/apex_test.go b/apex/apex_test.go
index 984ca41..b67535a 100644
--- a/apex/apex_test.go
+++ b/apex/apex_test.go
@@ -3206,7 +3206,7 @@
var builder strings.Builder
data.Custom(&builder, name, prefix, "", data)
androidMk := builder.String()
- ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := libc++.vendor.myapex:64 mylib.vendor.myapex:64 apex_manifest.pb.myapex apex_pubkey.myapex libc.vendor libm.vendor libdl.vendor\n")
+ ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := libc++.vendor.myapex:64 mylib.vendor.myapex:64 libc.vendor libm.vendor libdl.vendor\n")
}
func TestAndroidMkWritesCommonProperties(t *testing.T) {
@@ -4934,17 +4934,17 @@
func TestApexInVariousPartition(t *testing.T) {
testcases := []struct {
- propName, parition, flattenedPartition string
+ propName, partition string
}{
- {"", "system", "system_ext"},
- {"product_specific: true", "product", "product"},
- {"soc_specific: true", "vendor", "vendor"},
- {"proprietary: true", "vendor", "vendor"},
- {"vendor: true", "vendor", "vendor"},
- {"system_ext_specific: true", "system_ext", "system_ext"},
+ {"", "system"},
+ {"product_specific: true", "product"},
+ {"soc_specific: true", "vendor"},
+ {"proprietary: true", "vendor"},
+ {"vendor: true", "vendor"},
+ {"system_ext_specific: true", "system_ext"},
}
for _, tc := range testcases {
- t.Run(tc.propName+":"+tc.parition, func(t *testing.T) {
+ t.Run(tc.propName+":"+tc.partition, func(t *testing.T) {
ctx := testApex(t, `
apex {
name: "myapex",
@@ -4961,18 +4961,11 @@
`)
apex := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
- expected := "out/soong/target/product/test_device/" + tc.parition + "/apex"
+ expected := "out/soong/target/product/test_device/" + tc.partition + "/apex"
actual := apex.installDir.RelativeToTop().String()
if actual != expected {
t.Errorf("wrong install path. expected %q. actual %q", expected, actual)
}
-
- flattened := ctx.ModuleForTests("myapex", "android_common_myapex_flattened").Module().(*apexBundle)
- expected = "out/soong/target/product/test_device/" + tc.flattenedPartition + "/apex"
- actual = flattened.installDir.RelativeToTop().String()
- if actual != expected {
- t.Errorf("wrong install path. expected %q. actual %q", expected, actual)
- }
})
}
}
@@ -6110,16 +6103,7 @@
ensureContains(t, androidMk, "LOCAL_MODULE := mytest1.myapex\n")
ensureContains(t, androidMk, "LOCAL_MODULE := mytest2.myapex\n")
ensureContains(t, androidMk, "LOCAL_MODULE := mytest3.myapex\n")
- ensureContains(t, androidMk, "LOCAL_MODULE := apex_manifest.pb.myapex\n")
- ensureContains(t, androidMk, "LOCAL_MODULE := apex_pubkey.myapex\n")
ensureContains(t, androidMk, "LOCAL_MODULE := myapex\n")
-
- flatBundle := ctx.ModuleForTests("myapex", "android_common_myapex_flattened").Module().(*apexBundle)
- data = android.AndroidMkDataForTest(t, ctx, flatBundle)
- data.Custom(&builder, name, prefix, "", data)
- flatAndroidMk := builder.String()
- ensureContainsOnce(t, flatAndroidMk, "LOCAL_TEST_DATA := :baz :bar/baz\n")
- ensureContainsOnce(t, flatAndroidMk, "LOCAL_TEST_DATA := :testdata/baz\n")
}
func TestErrorsIfDepsAreNotEnabled(t *testing.T) {
@@ -7169,13 +7153,11 @@
androidMk := builder.String()
ensureContains(t, androidMk, "LOCAL_MODULE := override_app.override_myapex")
ensureContains(t, androidMk, "LOCAL_MODULE := overrideBpf.o.override_myapex")
- ensureContains(t, androidMk, "LOCAL_MODULE := apex_manifest.pb.override_myapex")
ensureContains(t, androidMk, "LOCAL_MODULE_STEM := override_myapex.apex")
ensureContains(t, androidMk, "LOCAL_OVERRIDES_MODULES := unknownapex myapex")
ensureNotContains(t, androidMk, "LOCAL_MODULE := app.myapex")
ensureNotContains(t, androidMk, "LOCAL_MODULE := bpf.myapex")
ensureNotContains(t, androidMk, "LOCAL_MODULE := override_app.myapex")
- ensureNotContains(t, androidMk, "LOCAL_MODULE := apex_manifest.pb.myapex")
ensureNotContains(t, androidMk, "LOCAL_MODULE_STEM := myapex.apex")
}
@@ -7758,7 +7740,7 @@
var builder strings.Builder
data.Custom(&builder, name, prefix, "", data)
androidMk := builder.String()
- ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := mylib.myapex:64 apex_manifest.pb.myapex apex_pubkey.myapex a b\n")
+ ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := mylib.myapex:64 a b\n")
ensureContains(t, androidMk, "LOCAL_HOST_REQUIRED_MODULES := c d\n")
ensureContains(t, androidMk, "LOCAL_TARGET_REQUIRED_MODULES := e f\n")
}
@@ -7966,7 +7948,7 @@
ensureNotContains(t, androidMk, "LOCAL_MODULE := prebuilt_myotherlib.myapex\n")
ensureNotContains(t, androidMk, "LOCAL_MODULE := myotherlib.myapex\n")
// `myapex` should have `myotherlib` in its required line, not `prebuilt_myotherlib`
- ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := mylib.myapex:64 myotherlib:64 apex_manifest.pb.myapex apex_pubkey.myapex\n")
+ ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := mylib.myapex:64 myotherlib:64\n")
}
func TestApexWithJniLibs(t *testing.T) {
@@ -9295,7 +9277,7 @@
apexKeysText := ctx.SingletonForTests("apex_keys_text")
content := apexKeysText.MaybeDescription("apexkeys.txt").BuildParams.Args["content"]
- ensureContains(t, content, `name="myapex.apex" public_key="vendor/foo/devkeys/testkey.avbpubkey" private_key="vendor/foo/devkeys/testkey.pem" container_certificate="vendor/foo/devkeys/test.x509.pem" container_private_key="vendor/foo/devkeys/test.pk8" partition="system_ext" sign_tool="sign_myapex"`)
+ ensureContains(t, content, `name="myapex.apex" public_key="vendor/foo/devkeys/testkey.avbpubkey" private_key="vendor/foo/devkeys/testkey.pem" container_certificate="vendor/foo/devkeys/test.x509.pem" container_private_key="vendor/foo/devkeys/test.pk8" partition="system" sign_tool="sign_myapex"`)
}
func TestApexKeysTxtOverrides(t *testing.T) {
@@ -9518,7 +9500,7 @@
// The make level dependency needs to be on otherlib - prebuilt_otherlib isn't
// a thing there.
- ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := libc++:64 mylib.myapex:64 apex_manifest.pb.myapex apex_pubkey.myapex otherlib\n")
+ ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := libc++:64 mylib.myapex:64 otherlib\n")
}
func TestExcludeDependency(t *testing.T) {
@@ -9912,7 +9894,7 @@
var builder strings.Builder
data.Custom(&builder, apexBundle.BaseModuleName(), "TARGET_", "", data)
androidMk := builder.String()
- ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := foo.myapex apex_manifest.pb.myapex apex_pubkey.myapex foo-dexpreopt-arm64-apex@myapex@javalib@foo.jar@classes.odex foo-dexpreopt-arm64-apex@myapex@javalib@foo.jar@classes.vdex\n")
+ ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := foo.myapex foo-dexpreopt-arm64-apex@myapex@javalib@foo.jar@classes.odex foo-dexpreopt-arm64-apex@myapex@javalib@foo.jar@classes.vdex\n")
}
func TestAndroidMk_DexpreoptBuiltInstalledForApex_Prebuilt(t *testing.T) {
@@ -9988,7 +9970,7 @@
var builder strings.Builder
data.Custom(&builder, apexBundle.BaseModuleName(), "TARGET_", "", data)
androidMk := builder.String()
- ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := foo.myapex apex_manifest.pb.myapex apex_pubkey.myapex otherapex")
+ ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := foo.myapex otherapex")
}
func TestAndroidMk_RequiredDeps(t *testing.T) {
@@ -10012,15 +9994,7 @@
var builder strings.Builder
data.Custom(&builder, bundle.BaseModuleName(), "TARGET_", "", data)
androidMk := builder.String()
- ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := apex_manifest.pb.myapex apex_pubkey.myapex foo\n")
-
- flattenedBundle := ctx.ModuleForTests("myapex", "android_common_myapex_flattened").Module().(*apexBundle)
- flattenedBundle.makeModulesToInstall = append(flattenedBundle.makeModulesToInstall, "foo")
- flattenedData := android.AndroidMkDataForTest(t, ctx, flattenedBundle)
- var flattenedBuilder strings.Builder
- flattenedData.Custom(&flattenedBuilder, flattenedBundle.BaseModuleName(), "TARGET_", "", flattenedData)
- flattenedAndroidMk := flattenedBuilder.String()
- ensureContains(t, flattenedAndroidMk, "LOCAL_REQUIRED_MODULES := apex_manifest.pb.myapex.flattened apex_pubkey.myapex.flattened foo\n")
+ ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES := foo\n")
}
func TestApexOutputFileProducer(t *testing.T) {
diff --git a/apex/builder.go b/apex/builder.go
index a2fe2a0..db66a72 100644
--- a/apex/builder.go
+++ b/apex/builder.go
@@ -382,23 +382,6 @@
rule.Command().Text("echo").Text("/apex_manifest\\\\.pb").Text(forceLabel).Text(">>").Output(output)
rule.Command().Text("echo").Text("/").Text(forceLabel).Text(">>").Output(output)
}
- case flattenedApex:
- // For flattened apexes, install path should be prepended.
- // File_contexts file should be emiited to make via LOCAL_FILE_CONTEXTS
- // so that it can be merged into file_contexts.bin
- apexPath := android.InstallPathToOnDevicePath(ctx, a.installDir.Join(ctx, a.Name()))
- apexPath = strings.ReplaceAll(apexPath, ".", `\\.`)
- // remove old file
- rule.Command().Text("rm").FlagWithOutput("-f ", output)
- // copy file_contexts
- rule.Command().Text("awk").Text(`'/object_r/{printf("` + apexPath + `%s\n", $0)}'`).Input(fileContexts).Text(">").Output(output)
- // new line
- rule.Command().Text("echo").Text(">>").Output(output)
- if !useFileContextsAsIs {
- // force-label /apex_manifest.pb and /
- rule.Command().Text("echo").Text(apexPath + "/apex_manifest\\\\.pb").Text(forceLabel).Text(">>").Output(output)
- rule.Command().Text("echo").Text(apexPath + "/").Text(forceLabel).Text(">>").Output(output)
- }
default:
panic(fmt.Errorf("unsupported type %v", a.properties.ApexType))
}
@@ -479,8 +462,8 @@
})
}
-// buildUnflattendApex creates build rules to build an APEX using apexer.
-func (a *apexBundle) buildUnflattenedApex(ctx android.ModuleContext) {
+// buildApex creates build rules to build an APEX using apexer.
+func (a *apexBundle) buildApex(ctx android.ModuleContext) {
apexType := a.properties.ApexType
suffix := apexType.suffix()
apexName := a.BaseModuleName()
@@ -963,49 +946,6 @@
a.installedFilesFile = a.buildInstalledFilesFile(ctx, a.outputFile, imageDir)
}
-// buildFlattenedApex creates rules for a flattened APEX. Flattened APEX actually doesn't have a
-// single output file. It is a phony target for all the files under /system/apex/<name> directory.
-// This function creates the installation rules for the files.
-func (a *apexBundle) buildFlattenedApex(ctx android.ModuleContext) {
- bundleName := a.Name()
- installedSymlinks := append(android.InstallPaths(nil), a.compatSymlinks...)
- if a.installable() {
- for _, fi := range a.filesInfo {
- dir := filepath.Join("apex", bundleName, fi.installDir)
- installDir := android.PathForModuleInstall(ctx, dir)
- if a.linkToSystemLib && fi.transitiveDep && fi.availableToPlatform() {
- pathOnDevice := filepath.Join("/", fi.partition, fi.path())
- installedSymlinks = append(installedSymlinks,
- ctx.InstallAbsoluteSymlink(installDir, fi.stem(), pathOnDevice))
- } else {
- if fi.class == appSet {
- as := fi.module.(*java.AndroidAppSet)
- ctx.InstallFileWithExtraFilesZip(installDir, as.BaseModuleName()+".apk",
- as.OutputFile(), as.PackedAdditionalOutputs())
- } else {
- target := ctx.InstallFile(installDir, fi.stem(), fi.builtFile)
- for _, sym := range fi.symlinks {
- installedSymlinks = append(installedSymlinks,
- ctx.InstallSymlink(installDir, sym, target))
- }
- }
- }
- }
-
- // Create install rules for the files added in GenerateAndroidBuildActions after
- // buildFlattenedApex is called. Add the links to system libs (if any) as dependencies
- // of the apex_manifest.pb file since it is always present.
- dir := filepath.Join("apex", bundleName)
- installDir := android.PathForModuleInstall(ctx, dir)
- ctx.InstallFile(installDir, "apex_manifest.pb", a.manifestPbOut, installedSymlinks.Paths()...)
- ctx.InstallFile(installDir, "apex_pubkey", a.publicKeyFile)
- }
-
- a.fileContexts = a.buildFileContexts(ctx)
-
- a.outputFile = android.PathForModuleInstall(ctx, "apex", bundleName)
-}
-
// getCertificateAndPrivateKey retrieves the cert and the private key that will be used to sign
// the zip container of this APEX. See the description of the 'certificate' property for how
// the cert and the private key are found.
diff --git a/apex/prebuilt.go b/apex/prebuilt.go
index 0d83830..3509e6c 100644
--- a/apex/prebuilt.go
+++ b/apex/prebuilt.go
@@ -133,9 +133,7 @@
}
func (p *prebuiltCommon) checkForceDisable(ctx android.ModuleContext) bool {
- // If the device is configured to use flattened APEX, force disable the prebuilt because
- // the prebuilt is a non-flattened one.
- forceDisable := ctx.Config().FlattenApex()
+ forceDisable := false
// Force disable the prebuilts when we are doing unbundled build. We do unbundled build
// to build the prebuilts themselves.
diff --git a/bazel/aquery.go b/bazel/aquery.go
index 4d39e8f..95e52ae 100644
--- a/bazel/aquery.go
+++ b/bazel/aquery.go
@@ -453,8 +453,32 @@
return hashes, nil
}
+// escapes the args received from aquery and creates a command string
+func commandString(actionEntry *analysis_v2_proto.Action) string {
+ switch actionEntry.Mnemonic {
+ case "GoCompilePkg":
+ argsEscaped := []string{}
+ for _, arg := range actionEntry.Arguments {
+ if arg == "" {
+ // If this is an empty string, add ''
+ // And not
+ // 1. (literal empty)
+ // 2. `''\'''\'''` (escaped version of '')
+ //
+ // If we had used (1), then this would appear as a whitespace when we strings.Join
+ argsEscaped = append(argsEscaped, "''")
+ } else {
+ argsEscaped = append(argsEscaped, proptools.ShellEscapeIncludingSpaces(arg))
+ }
+ }
+ return strings.Join(argsEscaped, " ")
+ default:
+ return strings.Join(proptools.ShellEscapeListIncludingSpaces(actionEntry.Arguments), " ")
+ }
+}
+
func (a *aqueryArtifactHandler) normalActionBuildStatement(actionEntry *analysis_v2_proto.Action) (*BuildStatement, error) {
- command := strings.Join(proptools.ShellEscapeListIncludingSpaces(actionEntry.Arguments), " ")
+ command := commandString(actionEntry)
inputDepsetHashes, err := a.depsetContentHashes(actionEntry.InputDepSetIds)
if err != nil {
return nil, err
diff --git a/bp2build/build_conversion_test.go b/bp2build/build_conversion_test.go
index e127fd5..1a35743 100644
--- a/bp2build/build_conversion_test.go
+++ b/bp2build/build_conversion_test.go
@@ -1946,3 +1946,36 @@
actual, _ := prettyPrintAttribute(lla, 0)
android.AssertStringEquals(t, "Print the common value if all keys in an axis have the same value", `[":libfoo.impl"]`, actual)
}
+
+func TestAlreadyPresentBuildTarget(t *testing.T) {
+ bp := `
+ custom {
+ name: "foo",
+ }
+ custom {
+ name: "bar",
+ }
+ `
+ alreadyPresentBuildFile :=
+ MakeBazelTarget(
+ "custom",
+ "foo",
+ AttrNameToString{},
+ )
+ expectedBazelTargets := []string{
+ MakeBazelTarget(
+ "custom",
+ "bar",
+ AttrNameToString{},
+ ),
+ }
+ registerCustomModule := func(ctx android.RegistrationContext) {
+ ctx.RegisterModuleType("custom", customModuleFactoryHostAndDevice)
+ }
+ RunBp2BuildTestCase(t, registerCustomModule, Bp2buildTestCase{
+ AlreadyExistingBuildContents: alreadyPresentBuildFile,
+ Blueprint: bp,
+ ExpectedBazelTargets: expectedBazelTargets,
+ Description: "Not duplicating work for an already-present BUILD target.",
+ })
+}
diff --git a/bp2build/cc_binary_conversion_test.go b/bp2build/cc_binary_conversion_test.go
index ab6e4a5..18cb9e1 100644
--- a/bp2build/cc_binary_conversion_test.go
+++ b/bp2build/cc_binary_conversion_test.go
@@ -1182,3 +1182,35 @@
},
})
}
+
+func TestCCBinaryRscriptSrc(t *testing.T) {
+ runCcBinaryTests(t, ccBinaryBp2buildTestCase{
+ description: `cc_binary with rscript files in sources`,
+ blueprint: `
+{rule_name} {
+ name : "foo",
+ srcs : [
+ "ccSrc.cc",
+ "rsSrc.rscript",
+ ],
+ include_build_directory: false,
+}
+`,
+ targets: []testBazelTarget{
+ {"rscript_to_cpp", "foo_renderscript", AttrNameToString{
+ "srcs": `["rsSrc.rscript"]`,
+ }},
+ {"cc_binary", "foo", AttrNameToString{
+ "absolute_includes": `[
+ "frameworks/rs",
+ "frameworks/rs/cpp",
+ ]`,
+ "local_includes": `["."]`,
+ "srcs": `[
+ "ccSrc.cc",
+ "foo_renderscript",
+ ]`,
+ }},
+ },
+ })
+}
diff --git a/bp2build/cc_library_shared_conversion_test.go b/bp2build/cc_library_shared_conversion_test.go
index a16cfb3..2d61d53 100644
--- a/bp2build/cc_library_shared_conversion_test.go
+++ b/bp2build/cc_library_shared_conversion_test.go
@@ -1555,3 +1555,33 @@
},
})
}
+
+func TestCCLibrarySharedRscriptSrc(t *testing.T) {
+ runCcLibrarySharedTestCase(t, Bp2buildTestCase{
+ Description: ``,
+ Blueprint: `
+cc_library_shared{
+ name : "foo",
+ srcs : [
+ "ccSrc.cc",
+ "rsSrc.rscript",
+ ],
+ include_build_directory: false,
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("rscript_to_cpp", "foo_renderscript", AttrNameToString{
+ "srcs": `["rsSrc.rscript"]`,
+ }),
+ MakeBazelTarget("cc_library_shared", "foo", AttrNameToString{
+ "absolute_includes": `[
+ "frameworks/rs",
+ "frameworks/rs/cpp",
+ ]`,
+ "local_includes": `["."]`,
+ "srcs": `[
+ "ccSrc.cc",
+ "foo_renderscript",
+ ]`,
+ })}})
+}
diff --git a/bp2build/cc_library_static_conversion_test.go b/bp2build/cc_library_static_conversion_test.go
index b473f27..18225df 100644
--- a/bp2build/cc_library_static_conversion_test.go
+++ b/bp2build/cc_library_static_conversion_test.go
@@ -2185,3 +2185,33 @@
},
})
}
+
+func TestCCLibraryStaticRscriptSrc(t *testing.T) {
+ runCcLibraryStaticTestCase(t, Bp2buildTestCase{
+ Description: `cc_library_static with rscript files in sources`,
+ Blueprint: `
+cc_library_static{
+ name : "foo",
+ srcs : [
+ "ccSrc.cc",
+ "rsSrc.rscript",
+ ],
+ include_build_directory: false,
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("rscript_to_cpp", "foo_renderscript", AttrNameToString{
+ "srcs": `["rsSrc.rscript"]`,
+ }),
+ MakeBazelTarget("cc_library_static", "foo", AttrNameToString{
+ "absolute_includes": `[
+ "frameworks/rs",
+ "frameworks/rs/cpp",
+ ]`,
+ "local_includes": `["."]`,
+ "srcs": `[
+ "ccSrc.cc",
+ "foo_renderscript",
+ ]`,
+ })}})
+}
diff --git a/bp2build/testing.go b/bp2build/testing.go
index 140b214..89ef07b 100644
--- a/bp2build/testing.go
+++ b/bp2build/testing.go
@@ -21,6 +21,7 @@
import (
"fmt"
+ "path/filepath"
"sort"
"strings"
"testing"
@@ -82,7 +83,12 @@
// ExpectedBazelTargets compares the BazelTargets generated in `Dir` (if not empty).
// Otherwise, it checks the BazelTargets generated by `Blueprint` in the root directory.
ExpectedBazelTargets []string
- Filesystem map[string]string
+ // AlreadyExistingBuildContents, if non-empty, simulates an already-present source BUILD file
+ // in the directory under test. The BUILD file has the given contents. This BUILD file
+ // will also be treated as "BUILD file to keep" by the simulated bp2build environment.
+ AlreadyExistingBuildContents string
+
+ Filesystem map[string]string
// Dir sets the directory which will be compared against the targets in ExpectedBazelTargets.
// This should used in conjunction with the Filesystem property to check for targets
// generated from a directory that is not the root.
@@ -119,11 +125,22 @@
func runBp2BuildTestCaseWithSetup(t *testing.T, extraPreparer android.FixturePreparer, tc Bp2buildTestCase) {
t.Helper()
- dir := "."
+ checkDir := "."
+ if tc.Dir != "" {
+ checkDir = tc.Dir
+ }
+ keepExistingBuildDirs := tc.KeepBuildFileForDirs
+ buildFilesToParse := []string{}
filesystem := make(map[string][]byte)
for f, content := range tc.Filesystem {
filesystem[f] = []byte(content)
}
+ if len(tc.AlreadyExistingBuildContents) > 0 {
+ buildFilePath := filepath.Join(checkDir, "BUILD")
+ filesystem[buildFilePath] = []byte(tc.AlreadyExistingBuildContents)
+ keepExistingBuildDirs = append(keepExistingBuildDirs, checkDir)
+ buildFilesToParse = append(buildFilesToParse, buildFilePath)
+ }
preparers := []android.FixturePreparer{
extraPreparer,
@@ -132,7 +149,7 @@
android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
ctx.RegisterModuleType(tc.ModuleTypeUnderTest, tc.ModuleTypeUnderTestFactory)
}),
- android.FixtureModifyContext(func(ctx *android.TestContext) {
+ android.FixtureModifyContextWithMockFs(func(ctx *android.TestContext) {
// A default configuration for tests to not have to specify bp2build_available on top level
// targets.
bp2buildConfig := android.NewBp2BuildAllowlist().SetDefaultConfig(
@@ -140,7 +157,7 @@
android.Bp2BuildTopLevel: allowlists.Bp2BuildDefaultTrueRecursively,
},
)
- for _, f := range tc.KeepBuildFileForDirs {
+ for _, f := range keepExistingBuildDirs {
bp2buildConfig.SetKeepExistingBuildFile(map[string]bool{
f: /*recursive=*/ false,
})
@@ -150,6 +167,10 @@
// from cloning modules to their original state after mutators run. This
// would lose some data intentionally set by these mutators.
ctx.SkipCloneModulesAfterMutators = true
+ err := ctx.ParseBuildFiles(".", buildFilesToParse)
+ if err != nil {
+ t.Errorf("error parsing build files in test setup: %s", err)
+ }
}),
android.FixtureModifyEnv(func(env map[string]string) {
if tc.UnconvertedDepsMode == errorModulesUnconvertedDeps {
@@ -168,10 +189,6 @@
return
}
- checkDir := dir
- if tc.Dir != "" {
- checkDir = tc.Dir
- }
expectedTargets := map[string][]string{
checkDir: tc.ExpectedBazelTargets,
}
diff --git a/cc/bp2build.go b/cc/bp2build.go
index d09cdcd..5459595 100644
--- a/cc/bp2build.go
+++ b/cc/bp2build.go
@@ -38,7 +38,10 @@
protoSrcPartition = "proto"
aidlSrcPartition = "aidl"
syspropSrcPartition = "sysprop"
- yaccSrcPartition = "yacc"
+
+ yaccSrcPartition = "yacc"
+
+ rScriptSrcPartition = "renderScript"
stubsSuffix = "_stub_libs_current"
)
@@ -149,8 +152,9 @@
// contains .l or .ll files we will need to find a way to add a
// LabelMapper for these that identifies these filegroups and
// converts them appropriately
- lSrcPartition: bazel.LabelPartition{Extensions: []string{".l"}},
- llSrcPartition: bazel.LabelPartition{Extensions: []string{".ll"}},
+ lSrcPartition: bazel.LabelPartition{Extensions: []string{".l"}},
+ llSrcPartition: bazel.LabelPartition{Extensions: []string{".ll"}},
+ rScriptSrcPartition: bazel.LabelPartition{Extensions: []string{".fs", ".rscript"}},
// C++ is the "catch-all" group, and comprises generated sources because we don't
// know the language of these sources until the genrule is executed.
cppSrcPartition: bazel.LabelPartition{Extensions: []string{".cpp", ".cc", ".cxx", ".mm"}, LabelMapper: addSuffixForFilegroup("_cpp_srcs"), Keep_remainder: true},
@@ -398,6 +402,9 @@
cppFlags bazel.StringListAttribute
srcs bazel.LabelListAttribute
+ // xsd config sources
+ xsdInSrcs bazel.StringListAttribute
+
// Lex sources and options
lSrcs bazel.LabelListAttribute
llSrcs bazel.LabelListAttribute
@@ -412,6 +419,8 @@
yaccGenLocationHeader bazel.BoolAttribute
yaccGenPositionHeader bazel.BoolAttribute
+ rsSrcs bazel.LabelListAttribute
+
hdrs bazel.LabelListAttribute
rtti bazel.BoolAttribute
@@ -426,8 +435,9 @@
includes BazelIncludes
- protoSrcs bazel.LabelListAttribute
- aidlSrcs bazel.LabelListAttribute
+ protoSrcs bazel.LabelListAttribute
+ aidlSrcs bazel.LabelListAttribute
+ rscriptSrcs bazel.LabelListAttribute
stubsSymbolFile *string
stubsVersions bazel.StringListAttribute
@@ -484,9 +494,14 @@
func (ca *compilerAttributes) bp2buildForAxisAndConfig(ctx android.BazelConversionPathContext, axis bazel.ConfigurationAxis, config string, props *BaseCompilerProperties) {
// If there's arch specific srcs or exclude_srcs, generate a select entry for it.
// TODO(b/186153868): do this for OS specific srcs and exclude_srcs too.
- if srcsList, ok := parseSrcs(ctx, props); ok {
+ srcsList, xsdList, ok := parseSrcs(ctx, props)
+
+ if ok {
ca.srcs.SetSelectValue(axis, config, srcsList)
}
+ if len(xsdList) > 0 {
+ ca.xsdInSrcs.SetSelectValue(axis, config, xsdList)
+ }
localIncludeDirs := props.Local_include_dirs
if axis == bazel.NoConfigAxis {
@@ -582,17 +597,18 @@
ca.yaccSrc = bazel.MakeLabelAttribute(yacc.Value.Includes[0].Label)
}
ca.syspropSrcs = partitionedSrcs[syspropSrcPartition]
+ ca.rscriptSrcs = partitionedSrcs[rScriptSrcPartition]
ca.absoluteIncludes.DeduplicateAxesFromBase()
ca.localIncludes.DeduplicateAxesFromBase()
}
// Parse srcs from an arch or OS's props value.
-func parseSrcs(ctx android.BazelConversionPathContext, props *BaseCompilerProperties) (bazel.LabelList, bool) {
+func parseSrcs(ctx android.BazelConversionPathContext, props *BaseCompilerProperties) (bazel.LabelList, []string, bool) {
anySrcs := false
// Add srcs-like dependencies such as generated files.
// First create a LabelList containing these dependencies, then merge the values with srcs.
- genSrcs, _ := android.PartitionXsdSrcs(ctx, props.Generated_sources)
+ genSrcs, xsd := android.PartitionXsdSrcs(ctx, props.Generated_sources)
generatedSrcsLabelList := android.BazelLabelForModuleDepsExcludes(ctx, genSrcs, props.Exclude_generated_sources)
if len(props.Generated_sources) > 0 || len(props.Exclude_generated_sources) > 0 {
anySrcs = true
@@ -604,7 +620,7 @@
anySrcs = true
}
- return bazel.AppendBazelLabelLists(allSrcsLabelList, generatedSrcsLabelList), anySrcs
+ return bazel.AppendBazelLabelLists(allSrcsLabelList, generatedSrcsLabelList), xsd, anySrcs
}
func bp2buildStdVal(std *string, prefix string, useGnu bool) *string {
@@ -718,14 +734,6 @@
return ret
}
-// Replaces //a/b/my_xsd_config with //a/b/my_xsd_config-cpp
-func xsdConfigCppTarget(ctx android.BazelConversionPathContext, mod blueprint.Module) string {
- callback := func(xsd android.XsdConfigBp2buildTargets) string {
- return xsd.CppBp2buildTargetName()
- }
- return android.XsdConfigBp2buildTarget(ctx, mod, callback)
-}
-
// bp2BuildParseBaseProps returns all compiler, linker, library attributes of a cc module..
func bp2BuildParseBaseProps(ctx android.Bp2buildMutatorContext, module *Module) baseAttributes {
archVariantCompilerProps := module.GetArchVariantProperties(ctx, &BaseCompilerProperties{})
@@ -762,15 +770,9 @@
for _, axis := range bazel.SortedConfigurationAxes(axisToConfigs) {
configs := axisToConfigs[axis]
for cfg := range configs {
- var allHdrs []string
+ var allHdrs, allHdrsXsd []string
if baseCompilerProps, ok := archVariantCompilerProps[axis][cfg].(*BaseCompilerProperties); ok {
- ah, allHdrsXsd := android.PartitionXsdSrcs(ctx, baseCompilerProps.Generated_headers)
- allHdrs = ah
- // in the synthetic bp2build workspace, xsd sources are compiled to a static library
- xsdCppConfigLibraryLabels := android.BazelLabelForModuleDepsWithFn(ctx, allHdrsXsd, xsdConfigCppTarget)
- iwad := linkerAttrs.implementationWholeArchiveDeps.SelectValue(axis, cfg)
- (&iwad).Append(xsdCppConfigLibraryLabels)
- linkerAttrs.implementationWholeArchiveDeps.SetSelectValue(axis, cfg, bazel.FirstUniqueBazelLabelList(iwad))
+ allHdrs, allHdrsXsd = android.PartitionXsdSrcs(ctx, baseCompilerProps.Generated_headers)
if baseCompilerProps.Lex != nil {
compilerAttrs.lexopts.SetSelectValue(axis, cfg, baseCompilerProps.Lex.Flags)
@@ -784,14 +786,19 @@
aidlLibs.Append(android.BazelLabelForModuleDeps(ctx, baseCompilerProps.Aidl.Libs))
}
- var exportHdrs []string
+ var exportHdrs, exportHdrsXsd []string
if baseLinkerProps, ok := archVariantLinkerProps[axis][cfg].(*BaseLinkerProperties); ok {
- exportHdrs = baseLinkerProps.Export_generated_headers
-
+ exportHdrs, exportHdrsXsd = android.PartitionXsdSrcs(ctx, baseLinkerProps.Export_generated_headers)
(&linkerAttrs).bp2buildForAxisAndConfig(ctx, module, axis, cfg, baseLinkerProps)
}
+
+ // in the synthetic bp2build workspace, xsd sources are compiled to a static library
+ xsdList := compilerAttrs.xsdInSrcs.SelectValue(axis, cfg)
+ allHdrsXsd = android.FirstUniqueStrings(append(xsdList, allHdrsXsd...))
headers := maybePartitionExportedAndImplementationsDeps(ctx, !module.Binary(), allHdrs, exportHdrs, android.BazelLabelForModuleDeps)
+ xsdConfigLibs := maybePartitionExportedAndImplementationsDeps(ctx, !module.Binary(), allHdrsXsd, exportHdrsXsd, bazelLabelForXsdConfig)
+
implementationHdrs.SetSelectValue(axis, cfg, headers.implementation)
compilerAttrs.hdrs.SetSelectValue(axis, cfg, headers.export)
@@ -827,6 +834,15 @@
compilerAttrs.suffix.SetSelectValue(axis, cfg, suffix)
}
}
+
+ if len(allHdrsXsd) > 0 {
+ wholeStaticLibs := linkerAttrs.implementationWholeArchiveDeps.SelectValue(axis, cfg)
+ (&wholeStaticLibs).Append(xsdConfigLibs.implementation)
+ linkerAttrs.implementationWholeArchiveDeps.SetSelectValue(axis, cfg, wholeStaticLibs)
+ wholeStaticLibs = linkerAttrs.wholeArchiveDeps.SelectValue(axis, cfg)
+ (&wholeStaticLibs).Append(xsdConfigLibs.export)
+ linkerAttrs.wholeArchiveDeps.SetSelectValue(axis, cfg, wholeStaticLibs)
+ }
}
}
@@ -903,6 +919,12 @@
compilerAttrs.absoluteIncludes.Prepend = true
compilerAttrs.hdrs.Prepend = true
+ convertedRsSrcs, rsAbsIncludes, rsLocalIncludes := bp2buildRScript(ctx, module, compilerAttrs)
+ (&compilerAttrs).srcs.Add(&convertedRsSrcs)
+ (&compilerAttrs).absoluteIncludes.Append(rsAbsIncludes)
+ (&compilerAttrs).localIncludes.Append(rsLocalIncludes)
+ (&compilerAttrs).localIncludes.Value = android.FirstUniqueStrings(compilerAttrs.localIncludes.Value)
+
features := compilerAttrs.features.Clone().Append(linkerAttrs.features).Append(bp2buildSanitizerFeatures(ctx, module))
features = features.Append(bp2buildLtoFeatures(ctx, module))
features = features.Append(convertHiddenVisibilityToFeatureBase(ctx, module))
@@ -1703,6 +1725,18 @@
return label
}
+// Replaces //a/b/my_xsd_config with //a/b/my_xsd_config-cpp
+func xsdConfigCppTarget(ctx android.BazelConversionPathContext, mod blueprint.Module) string {
+ callback := func(xsd android.XsdConfigBp2buildTargets) string {
+ return xsd.CppBp2buildTargetName()
+ }
+ return android.XsdConfigBp2buildTarget(ctx, mod, callback)
+}
+
+func bazelLabelForXsdConfig(ctx android.BazelConversionPathContext, modules []string) bazel.LabelList {
+ return android.BazelLabelForModuleDepsWithFn(ctx, modules, xsdConfigCppTarget)
+}
+
func bazelLabelForWholeDeps(ctx android.BazelConversionPathContext, modules []string) bazel.LabelList {
return android.BazelLabelForModuleDepsWithFn(ctx, modules, bazelLabelForStaticWholeModuleDeps)
}
diff --git a/cc/cc.go b/cc/cc.go
index d67f3ad..52a30d7 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -25,6 +25,7 @@
"strings"
"android/soong/ui/metrics/bp2build_metrics_proto"
+
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
@@ -151,7 +152,7 @@
StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
// Transitive static library dependencies of static libraries for use in ordering.
- TranstiveStaticLibrariesForOrdering *android.DepSet
+ TranstiveStaticLibrariesForOrdering *android.DepSet[android.Path]
// Paths to .o files
Objs Objects
@@ -1922,9 +1923,37 @@
//TODO(b/278772861) support sanitizers in Bazel rules
return false
}
+ if !imageVariantSupportedByBazel(c) {
+ return false
+ }
+ if c.IsSdkVariant() {
+ return false
+ }
return c.bazelHandler != nil
}
+func imageVariantSupportedByBazel(c *Module) bool {
+ if c.IsLlndk() {
+ return false
+ }
+ if c.InVendor() {
+ return false
+ }
+ if c.InProduct() {
+ return false
+ }
+ if c.InRamdisk() {
+ return false
+ }
+ if c.InVendorRamdisk() {
+ return false
+ }
+ if c.InRecovery() {
+ return false
+ }
+ return true
+}
+
func allEnabledSanitizersSupportedByBazel(ctx android.BaseModuleContext, c *Module) bool {
if c.sanitize == nil {
return true
@@ -1974,6 +2003,7 @@
apexKey := android.ApexConfigKey{
WithinApex: true,
ApexSdkVersion: findApexSdkVersion(ctx, apexInfo).String(),
+ ApiDomain: findApiDomain(apexInfo),
}
return &apexKey
}
@@ -1981,6 +2011,30 @@
return nil
}
+// Returns the api domain of a module for an apexInfo group
+// Input:
+// ai.InApexModules: [com.android.foo, test_com.android.foo, com.google.android.foo]
+// Return:
+// com.android.foo
+
+// If a module is included in multiple api domains (collated by min_sdk_version), it will return
+// the first match. The other matches have the same build actions since they share a min_sdk_version, so returning
+// the first match is fine.
+func findApiDomain(ai android.ApexInfo) string {
+ // Remove any test apexes
+ matches, _ := android.FilterList(ai.InApexModules, ai.TestApexes)
+ // Remove any google apexes. Rely on naming convention.
+ pred := func(s string) bool { return !strings.HasPrefix(s, "com.google") }
+ matches = android.FilterListPred(matches, pred)
+ if len(matches) > 0 {
+ // Return the first match
+ return android.SortedUniqueStrings(matches)[0]
+ } else {
+ // No apex in the tree has a dependency on this module
+ return ""
+ }
+}
+
func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
bazelModuleLabel := c.getBazelModuleLabel(ctx)
c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
@@ -3550,8 +3604,8 @@
// to match the topological order of the dependency tree, including any static analogues of
// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
// of the transitive dependencies.
-func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
- transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
+func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet[android.Path]) {
+ transitiveStaticLibsBuilder := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL)
var staticPaths android.Paths
for _, staticDep := range staticDeps {
staticPaths = append(staticPaths, staticDep.StaticLibrary)
diff --git a/cc/cc_test.go b/cc/cc_test.go
index 859059e..7534db2 100644
--- a/cc/cc_test.go
+++ b/cc/cc_test.go
@@ -2700,8 +2700,8 @@
variant := "android_arm64_armv8-a_static"
moduleA := ctx.ModuleForTests("a", variant).Module().(*Module)
- actual := ctx.ModuleProvider(moduleA, StaticLibraryInfoProvider).(StaticLibraryInfo).
- TransitiveStaticLibrariesForOrdering.ToList().RelativeToTop()
+ actual := android.Paths(ctx.ModuleProvider(moduleA, StaticLibraryInfoProvider).(StaticLibraryInfo).
+ TransitiveStaticLibrariesForOrdering.ToList()).RelativeToTop()
expected := GetOutputPaths(ctx, variant, []string{"a", "c", "b", "d"})
if !reflect.DeepEqual(actual, expected) {
@@ -2736,8 +2736,8 @@
variant := "android_arm64_armv8-a_static"
moduleA := ctx.ModuleForTests("a", variant).Module().(*Module)
- actual := ctx.ModuleProvider(moduleA, StaticLibraryInfoProvider).(StaticLibraryInfo).
- TransitiveStaticLibrariesForOrdering.ToList().RelativeToTop()
+ actual := android.Paths(ctx.ModuleProvider(moduleA, StaticLibraryInfoProvider).(StaticLibraryInfo).
+ TransitiveStaticLibrariesForOrdering.ToList()).RelativeToTop()
expected := GetOutputPaths(ctx, variant, []string{"a", "c", "b"})
if !reflect.DeepEqual(actual, expected) {
diff --git a/cc/config/global.go b/cc/config/global.go
index 8ff5f55..e450ba7 100644
--- a/cc/config/global.go
+++ b/cc/config/global.go
@@ -448,11 +448,12 @@
pctx.StaticVariable("RSLLVMPrebuiltsPath", "${RSClangBase}/${HostPrebuiltTag}/${RSClangVersion}/bin")
pctx.StaticVariable("RSIncludePath", "${RSLLVMPrebuiltsPath}/../lib64/clang/${RSReleaseVersion}/include")
- pctx.PrefixedExistentPathsForSourcesVariable("RsGlobalIncludes", "-I",
- []string{
- "external/clang/lib/Headers",
- "frameworks/rs/script_api/include",
- })
+ rsGlobalIncludes := []string{
+ "external/clang/lib/Headers",
+ "frameworks/rs/script_api/include",
+ }
+ pctx.PrefixedExistentPathsForSourcesVariable("RsGlobalIncludes", "-I", rsGlobalIncludes)
+ exportedVars.ExportStringList("RsGlobalIncludes", rsGlobalIncludes)
pctx.VariableFunc("CcWrapper", func(ctx android.PackageVarContext) string {
if override := ctx.Config().Getenv("CC_WRAPPER"); override != "" {
diff --git a/cc/library.go b/cc/library.go
index 47df53e..aec6433 100644
--- a/cc/library.go
+++ b/cc/library.go
@@ -892,7 +892,7 @@
// TODO(b/190524881): Include transitive static libraries in this provider to support
// static libraries with deps.
- TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
+ TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).
Direct(outputFilePath).
Build(),
})
@@ -1649,7 +1649,7 @@
Objects: library.objects,
WholeStaticLibsFromPrebuilts: library.wholeStaticLibsFromPrebuilts,
- TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder(android.TOPOLOGICAL).
+ TransitiveStaticLibrariesForOrdering: android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).
Direct(outputFile).
Transitive(deps.TranstiveStaticLibrariesForOrdering).
Build(),
@@ -1794,7 +1794,7 @@
library.coverageOutputFile = transformCoverageFilesToZip(ctx, objs, library.getLibName(ctx))
library.linkSAbiDumpFiles(ctx, objs, fileName, unstrippedOutputFile)
- var transitiveStaticLibrariesForOrdering *android.DepSet
+ var transitiveStaticLibrariesForOrdering *android.DepSet[android.Path]
if static := ctx.GetDirectDepsWithTag(staticVariantTag); len(static) > 0 {
s := ctx.OtherModuleProvider(static[0], StaticLibraryInfoProvider).(StaticLibraryInfo)
transitiveStaticLibrariesForOrdering = s.TransitiveStaticLibrariesForOrdering
diff --git a/cc/linkable.go b/cc/linkable.go
index 976a382..19e6501 100644
--- a/cc/linkable.go
+++ b/cc/linkable.go
@@ -345,7 +345,7 @@
TableOfContents android.OptionalPath
// should be obtained from static analogue
- TransitiveStaticLibrariesForOrdering *android.DepSet
+ TransitiveStaticLibrariesForOrdering *android.DepSet[android.Path]
}
var SharedLibraryInfoProvider = blueprint.NewProvider(SharedLibraryInfo{})
@@ -387,7 +387,7 @@
// This isn't the actual transitive DepSet, shared library dependencies have been
// converted into static library analogues. It is only used to order the static
// library dependencies that were specified for the current module.
- TransitiveStaticLibrariesForOrdering *android.DepSet
+ TransitiveStaticLibrariesForOrdering *android.DepSet[android.Path]
}
var StaticLibraryInfoProvider = blueprint.NewProvider(StaticLibraryInfo{})
diff --git a/cc/ndk_prebuilt.go b/cc/ndk_prebuilt.go
index 1d15cf8..d3a0a00 100644
--- a/cc/ndk_prebuilt.go
+++ b/cc/ndk_prebuilt.go
@@ -113,7 +113,7 @@
ndk.libraryDecorator.flagExporter.setProvider(ctx)
if ndk.static() {
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(lib).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(lib).Build()
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
StaticLibrary: lib,
diff --git a/cc/prebuilt.go b/cc/prebuilt.go
index 44cd0d7..a4ca590 100644
--- a/cc/prebuilt.go
+++ b/cc/prebuilt.go
@@ -140,7 +140,7 @@
}
if p.static() {
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(in).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(in).Build()
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
StaticLibrary: in,
@@ -508,7 +508,7 @@
h.module.outputFile = android.OptionalPathForPath(outputPath)
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(outputPath).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(outputPath).Build()
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
StaticLibrary: outputPath,
TransitiveStaticLibrariesForOrdering: depSet,
diff --git a/cc/rs.go b/cc/rs.go
index fbc86e2..6507259 100644
--- a/cc/rs.go
+++ b/cc/rs.go
@@ -15,11 +15,12 @@
package cc
import (
- "android/soong/android"
"path/filepath"
"runtime"
"strings"
+ "android/soong/android"
+ "android/soong/bazel"
"github.com/google/blueprint"
)
@@ -132,3 +133,35 @@
return flags
}
+
+type rscriptAttributes struct {
+ // Renderscript source files
+ Srcs bazel.LabelListAttribute
+}
+
+func bp2buildRScript(ctx android.Bp2buildMutatorContext, m *Module, ca compilerAttributes) (bazel.LabelAttribute, bazel.StringListAttribute, bazel.StringListAttribute) {
+ var rscriptAttrs rscriptAttributes
+ var rsAbsIncludes bazel.StringListAttribute
+ var localIncludes bazel.StringListAttribute
+ var rsModuleName string
+ var convertedRsSrcsLabel bazel.LabelAttribute
+
+ if !ca.rscriptSrcs.IsEmpty() {
+ rscriptAttrs.Srcs = ca.rscriptSrcs
+ rsModuleName = m.Name() + "_renderscript"
+
+ localIncludes.Value = []string{"."}
+ rsAbsIncludes.Value = []string{"frameworks/rs", "frameworks/rs/cpp"}
+ convertedRsSrcsLabel = bazel.LabelAttribute{Value: &bazel.Label{Label: rsModuleName}}
+
+ ctx.CreateBazelTargetModule(
+ bazel.BazelTargetModuleProperties{
+ Rule_class: "rscript_to_cpp",
+ Bzl_load_location: "//build/bazel/rules/cc:rscript_to_cpp.bzl",
+ },
+ android.CommonAttributes{Name: rsModuleName},
+ &rscriptAttrs)
+ }
+
+ return convertedRsSrcsLabel, rsAbsIncludes, localIncludes
+}
diff --git a/cc/sanitize.go b/cc/sanitize.go
index eab6d25..62e31d1 100644
--- a/cc/sanitize.go
+++ b/cc/sanitize.go
@@ -104,6 +104,7 @@
Fuzzer
Memtag_heap
Memtag_stack
+ Memtag_globals
cfi // cfi is last to prevent it running before incompatible mutators
)
@@ -116,6 +117,7 @@
Fuzzer,
Memtag_heap,
Memtag_stack,
+ Memtag_globals,
cfi, // cfi is last to prevent it running before incompatible mutators
}
@@ -138,6 +140,8 @@
return "memtag_heap"
case Memtag_stack:
return "memtag_stack"
+ case Memtag_globals:
+ return "memtag_globals"
case Fuzzer:
return "fuzzer"
default:
@@ -156,6 +160,8 @@
return "memtag_heap"
case Memtag_stack:
return "memtag_stack"
+ case Memtag_globals:
+ return "memtag_globals"
case tsan:
return "thread"
case intOverflow:
@@ -177,7 +183,7 @@
sanitizer := &sanitizerSplitMutator{t}
ctx.TopDown(t.variationName()+"_markapexes", sanitizer.markSanitizableApexesMutator)
ctx.Transition(t.variationName(), sanitizer)
- case Memtag_heap, Memtag_stack, intOverflow:
+ case Memtag_heap, Memtag_stack, Memtag_globals, intOverflow:
// do nothing
default:
panic(fmt.Errorf("unknown SanitizerType %d", t))
@@ -218,6 +224,8 @@
return true
case Memtag_stack:
return true
+ case Memtag_globals:
+ return true
default:
return false
}
@@ -272,6 +280,9 @@
// Memory-tagging stack instrumentation, only available on arm64
// Adds instrumentation to detect stack buffer overflows and use-after-scope using MTE.
Memtag_stack *bool `android:"arch_variant"`
+ // Memory-tagging globals instrumentation, only available on arm64
+ // Adds instrumentation to detect global buffer overflows using MTE.
+ Memtag_globals *bool `android:"arch_variant"`
// A modifier for ASAN and HWASAN for write only instrumentation
Writeonly *bool `android:"arch_variant"`
@@ -347,6 +358,8 @@
Memtag_heap *bool `blueprint:"mutated"`
// Whether Memory-tagging stack instrumentation is enabled for this module
Memtag_stack *bool `blueprint:"mutated"`
+ // Whether Memory-tagging globals instrumentation is enabled for this module
+ Memtag_globals *bool `android:"arch_variant"`
// Whether a modifier for ASAN and HWASAN for write only instrumentation is enabled for this
// module
@@ -431,6 +444,7 @@
p.Integer_overflow = userProps.Integer_overflow
p.Memtag_heap = userProps.Memtag_heap
p.Memtag_stack = userProps.Memtag_stack
+ p.Memtag_globals = userProps.Memtag_globals
p.Safestack = userProps.Safestack
p.Scs = userProps.Scs
p.Scudo = userProps.Scudo
@@ -558,6 +572,10 @@
s.Memtag_stack = proptools.BoolPtr(true)
}
+ if found, globalSanitizers = removeFromList("memtag_globals", globalSanitizers); found && s.Memtag_globals == nil {
+ s.Memtag_globals = proptools.BoolPtr(true)
+ }
+
if len(globalSanitizers) > 0 {
ctx.ModuleErrorf("unknown global sanitizer option %s", globalSanitizers[0])
}
@@ -638,6 +656,7 @@
if ctx.Arch().ArchType != android.Arm64 || !ctx.toolchain().Bionic() || ctx.Host() {
s.Memtag_heap = nil
s.Memtag_stack = nil
+ s.Memtag_globals = nil
}
// Also disable CFI if ASAN is enabled.
@@ -647,6 +666,7 @@
// HWASAN and ASAN win against MTE.
s.Memtag_heap = nil
s.Memtag_stack = nil
+ s.Memtag_globals = nil
}
// Disable sanitizers that depend on the UBSan runtime for windows/darwin builds.
@@ -717,7 +737,8 @@
if ctx.Os() != android.Windows && (Bool(s.All_undefined) || Bool(s.Undefined) || Bool(s.Address) || Bool(s.Thread) ||
Bool(s.Fuzzer) || Bool(s.Safestack) || Bool(s.Cfi) || Bool(s.Integer_overflow) || len(s.Misc_undefined) > 0 ||
- Bool(s.Scudo) || Bool(s.Hwaddress) || Bool(s.Scs) || Bool(s.Memtag_heap) || Bool(s.Memtag_stack)) {
+ Bool(s.Scudo) || Bool(s.Hwaddress) || Bool(s.Scs) || Bool(s.Memtag_heap) || Bool(s.Memtag_stack) ||
+ Bool(s.Memtag_globals)) {
sanitize.Properties.SanitizerEnabled = true
}
@@ -884,16 +905,11 @@
if Bool(sanProps.Memtag_stack) {
flags.Local.CFlags = append(flags.Local.CFlags, memtagStackCommonFlags...)
- // TODO(fmayer): remove -Wno-error once https://reviews.llvm.org/D127917 is in Android toolchain.
- flags.Local.CFlags = append(flags.Local.CFlags, "-Wno-error=frame-larger-than")
flags.Local.AsFlags = append(flags.Local.AsFlags, memtagStackCommonFlags...)
flags.Local.LdFlags = append(flags.Local.LdFlags, memtagStackCommonFlags...)
- // This works around LLD complaining about the stack frame size.
- // TODO(fmayer): remove once https://reviews.llvm.org/D127917 is in Android toolchain.
- flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--no-fatal-warnings")
}
- if (Bool(sanProps.Memtag_heap) || Bool(sanProps.Memtag_stack)) && ctx.binary() {
+ if (Bool(sanProps.Memtag_heap) || Bool(sanProps.Memtag_stack) || Bool(sanProps.Memtag_globals)) && ctx.binary() {
if Bool(sanProps.Diag.Memtag_heap) {
flags.Local.LdFlags = append(flags.Local.LdFlags, "-fsanitize-memtag-mode=sync")
} else {
@@ -1016,6 +1032,8 @@
return s.Properties.SanitizeMutated.Memtag_heap
case Memtag_stack:
return s.Properties.SanitizeMutated.Memtag_stack
+ case Memtag_globals:
+ return s.Properties.SanitizeMutated.Memtag_globals
case Fuzzer:
return s.Properties.SanitizeMutated.Fuzzer
default:
@@ -1032,6 +1050,7 @@
!sanitize.isSanitizerEnabled(scs) &&
!sanitize.isSanitizerEnabled(Memtag_heap) &&
!sanitize.isSanitizerEnabled(Memtag_stack) &&
+ !sanitize.isSanitizerEnabled(Memtag_globals) &&
!sanitize.isSanitizerEnabled(Fuzzer)
}
@@ -1053,10 +1072,12 @@
sanitize.Properties.SanitizeMutated.Address = bPtr
// For ASAN variant, we need to disable Memtag_stack
sanitize.Properties.SanitizeMutated.Memtag_stack = nil
+ sanitize.Properties.SanitizeMutated.Memtag_globals = nil
case Hwasan:
sanitize.Properties.SanitizeMutated.Hwaddress = bPtr
// For HWAsan variant, we need to disable Memtag_stack
sanitize.Properties.SanitizeMutated.Memtag_stack = nil
+ sanitize.Properties.SanitizeMutated.Memtag_globals = nil
case tsan:
sanitize.Properties.SanitizeMutated.Thread = bPtr
case intOverflow:
@@ -1070,6 +1091,8 @@
case Memtag_stack:
sanitize.Properties.SanitizeMutated.Memtag_stack = bPtr
// We do not need to disable ASAN or HWASan here, as there is no Memtag_stack variant.
+ case Memtag_globals:
+ sanitize.Properties.Sanitize.Memtag_globals = bPtr
case Fuzzer:
sanitize.Properties.SanitizeMutated.Fuzzer = bPtr
default:
@@ -1557,6 +1580,13 @@
sanitizers = append(sanitizers, "memtag-stack")
}
+ if Bool(sanProps.Memtag_globals) {
+ sanitizers = append(sanitizers, "memtag-globals")
+ // TODO(mitchp): For now, enable memtag-heap with memtag-globals because the linker
+ // isn't new enough (https://reviews.llvm.org/differential/changeset/?ref=4243566).
+ sanitizers = append(sanitizers, "memtag-heap")
+ }
+
if Bool(sanProps.Fuzzer) {
sanitizers = append(sanitizers, "fuzzer-no-link")
}
diff --git a/cc/snapshot_prebuilt.go b/cc/snapshot_prebuilt.go
index bb6e257..a5729df 100644
--- a/cc/snapshot_prebuilt.go
+++ b/cc/snapshot_prebuilt.go
@@ -499,7 +499,7 @@
}
if p.static() {
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(in).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(in).Build()
ctx.SetProvider(StaticLibraryInfoProvider, StaticLibraryInfo{
StaticLibrary: in,
diff --git a/cmd/multiproduct_kati/main.go b/cmd/multiproduct_kati/main.go
index b897bb5..c3b0381 100644
--- a/cmd/multiproduct_kati/main.go
+++ b/cmd/multiproduct_kati/main.go
@@ -399,6 +399,9 @@
var wg sync.WaitGroup
for i := 0; i < jobs; i++ {
wg.Add(1)
+ // To smooth out the spikes in memory usage, skew the
+ // initial starting time of the jobs by a small amount.
+ time.Sleep(15 * time.Second)
go func() {
defer wg.Done()
for {
diff --git a/cmd/soong_build/main.go b/cmd/soong_build/main.go
index 10a5762..bf5af2c 100644
--- a/cmd/soong_build/main.go
+++ b/cmd/soong_build/main.go
@@ -21,7 +21,6 @@
"fmt"
"os"
"path/filepath"
- "regexp"
"strings"
"time"
@@ -741,43 +740,6 @@
return excluded
}
-// buildTargetsByPackage parses Bazel BUILD.bazel and BUILD files under
-// the workspace, and returns a map containing names of Bazel targets defined in
-// these BUILD files.
-// For example, maps "//foo/bar" to ["baz", "qux"] if `//foo/bar:{baz,qux}` exist.
-func buildTargetsByPackage(ctx *android.Context) map[string][]string {
- existingBazelFiles, err := getExistingBazelRelatedFiles(topDir)
- maybeQuit(err, "Error determining existing Bazel-related files")
-
- result := map[string][]string{}
-
- // Search for instances of `name = "$NAME"` (with arbitrary spacing).
- targetNameRegex := regexp.MustCompile(`(?m)^\s*name\s*=\s*\"([^\"]+)\"`)
-
- for _, path := range existingBazelFiles {
- if !ctx.Config().Bp2buildPackageConfig.ShouldKeepExistingBuildFileForDir(filepath.Dir(path)) {
- continue
- }
- fullPath := shared.JoinPath(topDir, path)
- sourceDir := filepath.Dir(path)
- fileInfo, err := os.Stat(fullPath)
- maybeQuit(err, "Error accessing Bazel file '%s'", fullPath)
-
- if !fileInfo.IsDir() &&
- (fileInfo.Name() == "BUILD" || fileInfo.Name() == "BUILD.bazel") {
- // Process this BUILD file.
- buildFileContent, err := os.ReadFile(fullPath)
- maybeQuit(err, "Error reading Bazel file '%s'", fullPath)
-
- matches := targetNameRegex.FindAllStringSubmatch(string(buildFileContent), -1)
- for _, match := range matches {
- result[sourceDir] = append(result[sourceDir], match[1])
- }
- }
- }
- return result
-}
-
// Run Soong in the bp2build mode. This creates a standalone context that registers
// an alternate pipeline of mutators and singletons specifically for generating
// Bazel BUILD files instead of Ninja files.
@@ -786,7 +748,11 @@
ctx.EventHandler.Do("bp2build", func() {
ctx.EventHandler.Do("read_build", func() {
- ctx.Config().SetBazelBuildFileTargets(buildTargetsByPackage(ctx))
+ existingBazelFiles, err := getExistingBazelRelatedFiles(topDir)
+ maybeQuit(err, "Error determining existing Bazel-related files")
+
+ err = ctx.ParseBuildFiles(topDir, existingBazelFiles)
+ maybeQuit(err, "Error parsing existing Bazel-related files")
})
// Propagate "allow misssing dependencies" bit. This is normally set in
diff --git a/device_config/Android.bp b/device_config/Android.bp
deleted file mode 100644
index 6c44454..0000000
--- a/device_config/Android.bp
+++ /dev/null
@@ -1,32 +0,0 @@
-package {
- default_applicable_licenses: ["Android-Apache-2.0"],
-}
-
-bootstrap_go_package {
- name: "soong-device_config",
- pkgPath: "android/soong/device_config",
- deps: [
- "blueprint",
- "blueprint-pathtools",
- "sbox_proto",
- "soong",
- "soong-android",
- "soong-bazel",
- "soong-android",
- "soong-java",
- ],
- srcs: [
- "device_config_definitions.go",
- "device_config_values.go",
- "device_config_value_set.go",
- "init.go",
- "java_device_config_definitions_library.go",
- "testing.go",
- ],
- testSrcs: [
- "device_config_definitions_test.go",
- "device_config_values_test.go",
- "device_config_value_set_test.go",
- ],
- pluginFor: ["soong_build"],
-}
diff --git a/device_config/java_device_config_definitions_library.go b/device_config/java_device_config_definitions_library.go
deleted file mode 100644
index 6e48ece..0000000
--- a/device_config/java_device_config_definitions_library.go
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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 device_config
-
-import (
- "android/soong/android"
- "android/soong/java"
- "fmt"
- "github.com/google/blueprint"
-)
-
-type definitionsTagType struct {
- blueprint.BaseDependencyTag
-}
-
-var definitionsTag = definitionsTagType{}
-
-type JavaDeviceConfigDefinitionsLibraryProperties struct {
- // name of the device_config_definitions module to generate a library for
- Device_config_definitions string
-}
-
-type JavaDeviceConfigDefinitionsLibraryCallbacks struct {
- properties JavaDeviceConfigDefinitionsLibraryProperties
-}
-
-func JavaDefinitionsLibraryFactory() android.Module {
- callbacks := &JavaDeviceConfigDefinitionsLibraryCallbacks{}
- return java.GeneratedJavaLibraryModuleFactory("java_device_config_definitions_library", callbacks, &callbacks.properties)
-}
-
-func (callbacks *JavaDeviceConfigDefinitionsLibraryCallbacks) DepsMutator(module *java.GeneratedJavaLibraryModule, ctx android.BottomUpMutatorContext) {
- definitions := callbacks.properties.Device_config_definitions
- if len(definitions) == 0 {
- // TODO: Add test for this case
- ctx.PropertyErrorf("device_config_definitions", "device_config_definitions property required")
- } else {
- ctx.AddDependency(ctx.Module(), definitionsTag, definitions)
- }
-}
-
-func (callbacks *JavaDeviceConfigDefinitionsLibraryCallbacks) GenerateSourceJarBuildActions(ctx android.ModuleContext) android.Path {
- // Get the values that came from the global RELEASE_DEVICE_CONFIG_VALUE_SETS flag
- definitionsModules := ctx.GetDirectDepsWithTag(definitionsTag)
- if len(definitionsModules) != 1 {
- panic(fmt.Errorf("Exactly one device_config_definitions property required"))
- }
- definitions := ctx.OtherModuleProvider(definitionsModules[0], definitionsProviderKey).(definitionsProviderData)
-
- srcJarPath := android.PathForModuleGen(ctx, ctx.ModuleName()+".srcjar")
- ctx.Build(pctx, android.BuildParams{
- Rule: srcJarRule,
- Input: definitions.intermediatePath,
- Output: srcJarPath,
- Description: "device_config.srcjar",
- })
-
- return srcJarPath
-}
diff --git a/dexpreopt/config.go b/dexpreopt/config.go
index e61ebe6..bb83dc8 100644
--- a/dexpreopt/config.go
+++ b/dexpreopt/config.go
@@ -321,7 +321,7 @@
missingDepsCtx.AddMissingDependencies([]string{err.Error()})
}
} else {
- android.ReportPathErrorf(ctx, "%w", err)
+ android.ReportPathErrorf(ctx, "%s", err)
}
}
diff --git a/go.mod b/go.mod
index 4a511c5..0a11bd2 100644
--- a/go.mod
+++ b/go.mod
@@ -1,6 +1,6 @@
module android/soong
-go 1.19
+go 1.20
require (
github.com/google/blueprint v0.0.0
diff --git a/java/base.go b/java/base.go
index f9c9e1e..75e25e3 100644
--- a/java/base.go
+++ b/java/base.go
@@ -1756,24 +1756,24 @@
type providesTransitiveHeaderJars struct {
// set of header jars for all transitive libs deps
- transitiveLibsHeaderJars *android.DepSet
+ transitiveLibsHeaderJars *android.DepSet[android.Path]
// set of header jars for all transitive static libs deps
- transitiveStaticLibsHeaderJars *android.DepSet
+ transitiveStaticLibsHeaderJars *android.DepSet[android.Path]
}
-func (j *providesTransitiveHeaderJars) TransitiveLibsHeaderJars() *android.DepSet {
+func (j *providesTransitiveHeaderJars) TransitiveLibsHeaderJars() *android.DepSet[android.Path] {
return j.transitiveLibsHeaderJars
}
-func (j *providesTransitiveHeaderJars) TransitiveStaticLibsHeaderJars() *android.DepSet {
+func (j *providesTransitiveHeaderJars) TransitiveStaticLibsHeaderJars() *android.DepSet[android.Path] {
return j.transitiveStaticLibsHeaderJars
}
func (j *providesTransitiveHeaderJars) collectTransitiveHeaderJars(ctx android.ModuleContext) {
directLibs := android.Paths{}
directStaticLibs := android.Paths{}
- transitiveLibs := []*android.DepSet{}
- transitiveStaticLibs := []*android.DepSet{}
+ transitiveLibs := []*android.DepSet[android.Path]{}
+ transitiveStaticLibs := []*android.DepSet[android.Path]{}
ctx.VisitDirectDeps(func(module android.Module) {
// don't add deps of the prebuilt version of the same library
if ctx.ModuleName() == android.RemoveOptionalPrebuiltPrefix(module.Name()) {
diff --git a/java/bootclasspath_fragment.go b/java/bootclasspath_fragment.go
index 108fdd4..50429b0 100644
--- a/java/bootclasspath_fragment.go
+++ b/java/bootclasspath_fragment.go
@@ -479,8 +479,6 @@
for _, apiScope := range hiddenAPISdkLibrarySupportedScopes {
// Add a dependency onto a possibly scope specific stub library.
scopeSpecificDependency := apiScope.scopeSpecificStubModule(ctx, additionalStubModule)
- // Use JavaApiLibraryName function to be redirected to stubs generated from .txt if applicable
- scopeSpecificDependency = android.JavaApiLibraryName(ctx.Config(), scopeSpecificDependency)
tag := hiddenAPIStubsDependencyTag{apiScope: apiScope, fromAdditionalDependency: true}
ctx.AddVariationDependencies(nil, tag, scopeSpecificDependency)
}
diff --git a/java/bootclasspath_fragment_test.go b/java/bootclasspath_fragment_test.go
index 9bdef74..2541f14 100644
--- a/java/bootclasspath_fragment_test.go
+++ b/java/bootclasspath_fragment_test.go
@@ -432,39 +432,3 @@
fragment = result.Module("a_test_fragment", "android_common").(*BootclasspathFragmentModule)
android.AssertBoolEquals(t, "is a test fragment by type", true, fragment.isTestFragment())
}
-
-func TestBootclassFragment_LinkTextStub(t *testing.T) {
- result := android.GroupFixturePreparers(
- prepareForJavaTest,
- prepareForTestWithBootclasspathFragment,
- PrepareForTestWithJavaSdkLibraryFiles,
- FixtureWithLastReleaseApis("mysdklibrary"),
- android.FixtureModifyConfig(func(config android.Config) {
- config.SetBuildFromTextStub(true)
- }),
- ).RunTestWithBp(t, `
- bootclasspath_fragment {
- name: "myfragment",
- contents: ["mysdklibrary"],
- hidden_api: {split_packages: ["*"]},
- additional_stubs: [
- "android-non-updatable",
- ],
- }
- java_sdk_library {
- name: "mysdklibrary",
- srcs: ["a.java"],
- shared_library: false,
- public: {enabled: true},
- system: {enabled: true},
- }
- `)
-
- fragment := result.ModuleForTests("myfragment", "android_common")
- ruleCommand := fragment.Rule("modularHiddenAPIStubFlagsFile").RuleParams.Command
- android.AssertStringDoesContain(t, "Command expected to contain library as dependency stub dex",
- ruleCommand, "--dependency-stub-dex=out/soong/.intermediates/default/java/android-non-updatable.stubs.module_lib.from-text/android_common/dex/android-non-updatable.stubs.module_lib.from-text.jar")
- android.AssertStringDoesNotContain(t,
- "Command not expected to contain multiple api_library as dependency stub dex", ruleCommand,
- "--dependency-stub-dex=out/soong/.intermediates/default/java/android-non-updatable.stubs.from-text/android_common/dex/android-non-updatable.stubs.from-text.jar")
-}
diff --git a/java/config/makevars.go b/java/config/makevars.go
index d383d98..4e09195 100644
--- a/java/config/makevars.go
+++ b/java/config/makevars.go
@@ -29,10 +29,8 @@
// These are used by make when LOCAL_PRIVATE_PLATFORM_APIS is set (equivalent to platform_apis in blueprint):
ctx.Strict("LEGACY_CORE_PLATFORM_BOOTCLASSPATH_LIBRARIES",
- strings.Join(android.JavaApiLibraryNames(ctx.Config(), LegacyCorePlatformBootclasspathLibraries), " "))
- ctx.Strict("LEGACY_CORE_PLATFORM_SYSTEM_MODULES",
- android.JavaApiLibraryName(ctx.Config(), LegacyCorePlatformSystemModules),
- )
+ strings.Join(LegacyCorePlatformBootclasspathLibraries, " "))
+ ctx.Strict("LEGACY_CORE_PLATFORM_SYSTEM_MODULES", LegacyCorePlatformSystemModules)
ctx.Strict("ANDROID_JAVA_HOME", "${JavaHome}")
ctx.Strict("ANDROID_JAVA8_HOME", "prebuilts/jdk/jdk8/${hostPrebuiltTag}")
diff --git a/java/hiddenapi_modular.go b/java/hiddenapi_modular.go
index da9c997..c6b921b 100644
--- a/java/hiddenapi_modular.go
+++ b/java/hiddenapi_modular.go
@@ -647,7 +647,7 @@
// public version is provided by the art.module.public.api module. In those cases it is necessary
// to treat all those modules as they were the same name, otherwise it will result in multiple
// definitions of a single class being passed to hidden API processing which will cause an error.
- if name == scope.nonUpdatablePrebuiltModule || name == android.JavaApiLibraryName(ctx.Config(), scope.nonUpdatableSourceModule) {
+ if name == scope.nonUpdatablePrebuiltModule || name == scope.nonUpdatableSourceModule {
// Treat all *android-non-updatable* modules as if they were part of an android-non-updatable
// java_sdk_library.
// TODO(b/192067200): Remove once android-non-updatable is a java_sdk_library or equivalent.
diff --git a/java/java.go b/java/java.go
index a026610..caafaa2 100644
--- a/java/java.go
+++ b/java/java.go
@@ -231,10 +231,10 @@
HeaderJars android.Paths
// set of header jars for all transitive libs deps
- TransitiveLibsHeaderJars *android.DepSet
+ TransitiveLibsHeaderJars *android.DepSet[android.Path]
// set of header jars for all transitive static libs deps
- TransitiveStaticLibsHeaderJars *android.DepSet
+ TransitiveStaticLibsHeaderJars *android.DepSet[android.Path]
// ImplementationAndResourceJars is a list of jars that contain the implementations of classes
// in the module as well as any resources included in the module.
@@ -459,7 +459,7 @@
ctx.AddVariationDependencies(nil, sdkLibTag, sdkDep.classpath...)
if d.effectiveOptimizeEnabled() && sdkDep.hasStandardLibs() {
ctx.AddVariationDependencies(nil, proguardRaiseTag,
- android.JavaApiLibraryNames(ctx.Config(), config.LegacyCorePlatformBootclasspathLibraries)...,
+ config.LegacyCorePlatformBootclasspathLibraries...,
)
}
if d.effectiveOptimizeEnabled() && sdkDep.hasFrameworkLibs() {
diff --git a/java/legacy_core_platform_api_usage.go b/java/legacy_core_platform_api_usage.go
index 04c6d05..6cb549e 100644
--- a/java/legacy_core_platform_api_usage.go
+++ b/java/legacy_core_platform_api_usage.go
@@ -93,16 +93,16 @@
func corePlatformSystemModules(ctx android.EarlyModuleContext) string {
if useLegacyCorePlatformApi(ctx, ctx.ModuleName()) {
- return android.JavaApiLibraryName(ctx.Config(), config.LegacyCorePlatformSystemModules)
+ return config.LegacyCorePlatformSystemModules
} else {
- return android.JavaApiLibraryName(ctx.Config(), config.StableCorePlatformSystemModules)
+ return config.StableCorePlatformSystemModules
}
}
func corePlatformBootclasspathLibraries(ctx android.EarlyModuleContext) []string {
if useLegacyCorePlatformApi(ctx, ctx.ModuleName()) {
- return android.JavaApiLibraryNames(ctx.Config(), config.LegacyCorePlatformBootclasspathLibraries)
+ return config.LegacyCorePlatformBootclasspathLibraries
} else {
- return android.JavaApiLibraryNames(ctx.Config(), config.StableCorePlatformBootclasspathLibraries)
+ return config.StableCorePlatformBootclasspathLibraries
}
}
diff --git a/java/lint.go b/java/lint.go
index a0f9970..f84f1c0 100644
--- a/java/lint.go
+++ b/java/lint.go
@@ -117,18 +117,18 @@
}
type LintDepSets struct {
- HTML, Text, XML *android.DepSet
+ HTML, Text, XML *android.DepSet[android.Path]
}
type LintDepSetsBuilder struct {
- HTML, Text, XML *android.DepSetBuilder
+ HTML, Text, XML *android.DepSetBuilder[android.Path]
}
func NewLintDepSetBuilder() LintDepSetsBuilder {
return LintDepSetsBuilder{
- HTML: android.NewDepSetBuilder(android.POSTORDER),
- Text: android.NewDepSetBuilder(android.POSTORDER),
- XML: android.NewDepSetBuilder(android.POSTORDER),
+ HTML: android.NewDepSetBuilder[android.Path](android.POSTORDER),
+ Text: android.NewDepSetBuilder[android.Path](android.POSTORDER),
+ XML: android.NewDepSetBuilder[android.Path](android.POSTORDER),
}
}
@@ -553,9 +553,9 @@
}
func BuildModuleLintReportZips(ctx android.ModuleContext, depSets LintDepSets) android.Paths {
- htmlList := depSets.HTML.ToSortedList()
- textList := depSets.Text.ToSortedList()
- xmlList := depSets.XML.ToSortedList()
+ htmlList := android.SortedUniquePaths(depSets.HTML.ToList())
+ textList := android.SortedUniquePaths(depSets.Text.ToList())
+ xmlList := android.SortedUniquePaths(depSets.XML.ToList())
if len(htmlList) == 0 && len(textList) == 0 && len(xmlList) == 0 {
return nil
diff --git a/java/sdk.go b/java/sdk.go
index 7699aab..7c702c4 100644
--- a/java/sdk.go
+++ b/java/sdk.go
@@ -148,7 +148,7 @@
toModule := func(module string, aidl android.Path) sdkDep {
// Select the kind of system modules needed for the sdk version.
systemModulesKind := systemModuleKind(sdkVersion.Kind, android.FutureApiLevel)
- systemModules := android.JavaApiLibraryName(ctx.Config(), fmt.Sprintf("core-%s-stubs-system-modules", systemModulesKind))
+ systemModules := fmt.Sprintf("core-%s-stubs-system-modules", systemModulesKind)
return sdkDep{
useModule: true,
bootclasspath: []string{module, config.DefaultLambdaStubsLibrary},
@@ -198,7 +198,7 @@
return sdkDep{
useModule: true,
bootclasspath: []string{android.SdkCore.DefaultJavaLibraryName(), config.DefaultLambdaStubsLibrary},
- systemModules: android.JavaApiLibraryName(ctx.Config(), "core-public-stubs-system-modules"),
+ systemModules: "core-public-stubs-system-modules",
noFrameworksLibs: true,
}
case android.SdkModule:
diff --git a/java/sdk_library.go b/java/sdk_library.go
index 3de8238..a3d81ce 100644
--- a/java/sdk_library.go
+++ b/java/sdk_library.go
@@ -25,6 +25,7 @@
"sync"
"android/soong/ui/metrics/bp2build_metrics_proto"
+
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
@@ -1698,7 +1699,6 @@
"MissingPermission",
"SdkConstant",
"Todo",
- "Typo",
"UnavailableSymbol",
}
droidstubsArgs = append(droidstubsArgs, android.JoinWithPrefix(disabledWarnings, "--hide "))
diff --git a/rust/builder.go b/rust/builder.go
index bf009a5..c31bc88 100644
--- a/rust/builder.go
+++ b/rust/builder.go
@@ -217,6 +217,22 @@
envVars = append(envVars, "OUT_DIR=out")
}
+ envVars = append(envVars, "ANDROID_RUST_VERSION="+config.GetRustVersion(ctx))
+
+ if ctx.RustModule().compiler.CargoEnvCompat() {
+ if bin, ok := ctx.RustModule().compiler.(*binaryDecorator); ok {
+ envVars = append(envVars, "CARGO_BIN_NAME="+bin.getStem(ctx))
+ }
+ envVars = append(envVars, "CARGO_CRATE_NAME="+ctx.RustModule().CrateName())
+ envVars = append(envVars, "CARGO_PKG_NAME="+ctx.RustModule().CrateName())
+ pkgVersion := ctx.RustModule().compiler.CargoPkgVersion()
+ if pkgVersion != "" {
+ envVars = append(envVars, "CARGO_PKG_VERSION="+pkgVersion)
+ }
+ }
+
+ envVars = append(envVars, "AR=${cc_config.ClangBin}/llvm-ar")
+
return envVars
}
@@ -317,22 +333,6 @@
implicits = append(implicits, outputs.Paths()...)
}
- envVars = append(envVars, "ANDROID_RUST_VERSION="+config.GetRustVersion(ctx))
-
- if ctx.RustModule().compiler.CargoEnvCompat() {
- if _, ok := ctx.RustModule().compiler.(*binaryDecorator); ok {
- envVars = append(envVars, "CARGO_BIN_NAME="+strings.TrimSuffix(outputFile.Base(), outputFile.Ext()))
- }
- envVars = append(envVars, "CARGO_CRATE_NAME="+ctx.RustModule().CrateName())
- envVars = append(envVars, "CARGO_PKG_NAME="+ctx.RustModule().CrateName())
- pkgVersion := ctx.RustModule().compiler.CargoPkgVersion()
- if pkgVersion != "" {
- envVars = append(envVars, "CARGO_PKG_VERSION="+pkgVersion)
- }
- }
-
- envVars = append(envVars, "AR=${cc_config.ClangBin}/llvm-ar")
-
if flags.Clippy {
clippyFile := android.PathForModuleOut(ctx, outputFile.Base()+".clippy")
ctx.Build(pctx, android.BuildParams{
diff --git a/rust/config/global.go b/rust/config/global.go
index f838d0e..d844a25 100644
--- a/rust/config/global.go
+++ b/rust/config/global.go
@@ -41,6 +41,7 @@
}
GlobalRustFlags = []string{
+ "-Z stack-protector=strong",
"-Z remap-cwd-prefix=.",
"-C codegen-units=1",
"-C debuginfo=2",
diff --git a/rust/library.go b/rust/library.go
index ca5ad14..331763a 100644
--- a/rust/library.go
+++ b/rust/library.go
@@ -566,7 +566,7 @@
}
if library.static() {
- depSet := android.NewDepSetBuilder(android.TOPOLOGICAL).Direct(outputFile).Build()
+ depSet := android.NewDepSetBuilder[android.Path](android.TOPOLOGICAL).Direct(outputFile).Build()
ctx.SetProvider(cc.StaticLibraryInfoProvider, cc.StaticLibraryInfo{
StaticLibrary: outputFile,
diff --git a/tests/lib.sh b/tests/lib.sh
index b5dea99..4aaf272 100644
--- a/tests/lib.sh
+++ b/tests/lib.sh
@@ -144,6 +144,7 @@
symlink_directory prebuilts/jdk
symlink_directory external/bazel-skylib
symlink_directory external/bazelbuild-rules_android
+ symlink_directory external/bazelbuild-rules_go
symlink_directory external/bazelbuild-rules_license
symlink_directory external/bazelbuild-kotlin-rules
diff --git a/tests/sbom_test.sh b/tests/sbom_test.sh
index 94fe51d..19987f2 100755
--- a/tests/sbom_test.sh
+++ b/tests/sbom_test.sh
@@ -23,194 +23,204 @@
exit 1
fi
-tmp_dir="$(mktemp -d tmp.XXXXXX)"
+function setup {
+ tmp_dir="$(mktemp -d tmp.XXXXXX)"
+ trap 'cleanup "${tmp_dir}"' EXIT
+ echo "${tmp_dir}"
+}
+
function cleanup {
+ tmp_dir="$1"; shift
rm -rf "${tmp_dir}"
}
-trap cleanup EXIT
-
-out_dir=$tmp_dir
-droid_target=droid
-
-debug=false
-if [ $debug = "true" ]; then
- out_dir=out
- droid_target=
-fi
function run_soong {
- TARGET_PRODUCT="aosp_cf_x86_64_phone" TARGET_BUILD_VARIANT=userdebug OUT_DIR=$out_dir \
- build/soong/soong_ui.bash --make-mode "$@"
+ target_product="$1";shift
+ out_dir="$1"; shift
+ targets="$1"; shift
+ if [ "$#" -ge 1 ]; then
+ apps=$1; shift
+ TARGET_PRODUCT="${target_product}" TARGET_BUILD_VARIANT=userdebug OUT_DIR="${out_dir}" TARGET_BUILD_UNBUNDLED=true TARGET_BUILD_APPS=$apps build/soong/soong_ui.bash --make-mode ${targets}
+ else
+ TARGET_PRODUCT="${target_product}" TARGET_BUILD_VARIANT=userdebug OUT_DIR="${out_dir}" build/soong/soong_ui.bash --make-mode ${targets}
+ fi
}
-# m droid, build sbom later in case additional dependencies might be built and included in partition images.
-run_soong $droid_target dump.erofs lz4
-
-product_out=$out_dir/target/product/vsoc_x86_64
-sbom_test=$product_out/sbom_test
-mkdir $sbom_test
-cp $product_out/*.img $sbom_test
-
-# m sbom
-run_soong sbom
-
-# Generate installed file list from .img files in PRODUCT_OUT
-dump_erofs=$out_dir/host/linux-x86/bin/dump.erofs
-lz4=$out_dir/host/linux-x86/bin/lz4
-
-declare -A diff_excludes
-diff_excludes[odm]="-I /odm/lib/modules"
-diff_excludes[vendor]=\
-"-I /vendor/lib64/libkeystore2_crypto.so \
- -I /vendor/lib/modules \
- -I /vendor/odm"
-diff_excludes[system]=\
-"-I /bin \
- -I /bugreports \
- -I /cache \
- -I /d \
- -I /etc \
- -I /init \
- -I /odm/app \
- -I /odm/bin \
- -I /odm_dlkm/etc \
- -I /odm/etc \
- -I /odm/firmware \
- -I /odm/framework \
- -I /odm/lib \
- -I /odm/lib64 \
- -I /odm/overlay \
- -I /odm/priv-app \
- -I /odm/usr \
- -I /sdcard \
- -I /system/lib64/android.hardware.confirmationui@1.0.so \
- -I /system/lib64/android.hardware.confirmationui-V1-ndk.so \
- -I /system/lib64/android.hardware.keymaster@4.1.so \
- -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/libkeymaster4_1support.so \
- -I /system/lib64/libkeymaster4support.so \
- -I /system/lib64/libkeymint.so \
- -I /system/lib64/libkeystore2_aaid.so \
- -I /system/lib64/libkeystore2_apc_compat.so \
- -I /system/lib64/libkeystore2_crypto.so \
- -I /system/lib64/libkeystore-attestation-application-id.so \
- -I /system/lib64/libkm_compat_service.so \
- -I /system/lib64/libkm_compat.so \
- -I /system/lib64/vndk-29 \
- -I /system/lib64/vndk-sp-29 \
- -I /system/lib/vndk-29 \
- -I /system/lib/vndk-sp-29 \
- -I /system/usr/icu \
- -I /vendor_dlkm/etc"
-
function diff_files {
- file_list_file="$1"; shift
- files_in_spdx_file="$1"; shift
- partition_name="$1"; shift
- exclude=
- if [ -v 'diff_excludes[$partition_name]' ]; then
- exclude=${diff_excludes[$partition_name]}
- fi
-
- diff "$file_list_file" "$files_in_spdx_file" $exclude
- if [ $? != "0" ]; then
- echo Found diffs in $f and SBOM.
- exit 1
- else
- echo No diffs.
- fi
- }
-
-# Example output of dump.erofs is as below, and the data used in the test start
-# at line 11. Column 1 is inode id, column 2 is inode type and column 3 is name.
-# Each line is captured in variable "entry", awk is used to get type and name.
-# Output of dump.erofs:
-# File : /
-# Size: 160 On-disk size: 160 directory
-# NID: 39 Links: 10 Layout: 2 Compression ratio: 100.00%
-# Inode size: 64 Extent size: 0 Xattr size: 16
-# Uid: 0 Gid: 0 Access: 0755/rwxr-xr-x
-# Timestamp: 2023-02-14 01:15:54.000000000
-#
-# NID TYPE FILENAME
-# 39 2 .
-# 39 2 ..
-# 47 2 app
-# 1286748 2 bin
-# 1286754 2 etc
-# 5304814 2 lib
-# 5309056 2 lib64
-# 5309130 2 media
-# 5388910 2 overlay
-# 5479537 2 priv-app
-EROFS_IMAGES="\
- $sbom_test/product.img \
- $sbom_test/system.img \
- $sbom_test/system_ext.img \
- $sbom_test/system_dlkm.img \
- $sbom_test/system_other.img \
- $sbom_test/odm.img \
- $sbom_test/odm_dlkm.img \
- $sbom_test/vendor.img \
- $sbom_test/vendor_dlkm.img"
-for f in $EROFS_IMAGES; do
- partition_name=$(basename $f | cut -d. -f1)
- file_list_file="${sbom_test}/sbom-${partition_name}-files.txt"
- files_in_spdx_file="${sbom_test}/sbom-${partition_name}-files-in-spdx.txt"
- rm "$file_list_file" > /dev/null 2>&1
- all_dirs="/"
- while [ ! -z "$all_dirs" ]; do
- dir=$(echo "$all_dirs" | cut -d ' ' -f1)
- all_dirs=$(echo "$all_dirs" | cut -d ' ' -f1 --complement -s)
- entries=$($dump_erofs --ls --path "$dir" $f | tail -n +11)
- while read -r entry; do
- inode_type=$(echo $entry | awk -F ' ' '{print $2}')
- name=$(echo $entry | awk -F ' ' '{print $3}')
- case $inode_type in
- "2") # directory
- all_dirs=$(echo "$all_dirs $dir/$name" | sed 's/^\s*//')
- ;;
- "1"|"7") # 1: file, 7: symlink
- (
- if [ "$partition_name" != "system" ]; then
- # system partition is mounted to /, not to prepend partition name.
- printf %s "/$partition_name"
- fi
- echo "$dir/$name" | sed 's#^//#/#'
- ) >> "$file_list_file"
- ;;
- esac
- done <<< "$entries"
- done
- sort -n -o "$file_list_file" "$file_list_file"
-
- grep "FileName: /${partition_name}/" $product_out/sbom.spdx | sed 's/^FileName: //' > "$files_in_spdx_file"
- if [ "$partition_name" = "system" ]; then
- # system partition is mounted to /, so include FileName starts with /root/ too.
- grep "FileName: /root/" $product_out/sbom.spdx | sed 's/^FileName: \/root//' >> "$files_in_spdx_file"
+ file_list_file="$1"; shift
+ files_in_spdx_file="$1"; shift
+ partition_name="$1"; shift
+ exclude=
+ if [ -v 'diff_excludes[$partition_name]' ]; then
+ exclude=${diff_excludes[$partition_name]}
fi
- sort -n -o "$files_in_spdx_file" "$files_in_spdx_file"
- echo ============ Diffing files in $f and SBOM
- diff_files "$file_list_file" "$files_in_spdx_file" "$partition_name"
-done
+ diff "$file_list_file" "$files_in_spdx_file" $exclude
+ if [ $? != "0" ]; then
+ echo Found diffs in $f and SBOM.
+ exit 1
+ else
+ echo No diffs.
+ fi
+}
-RAMDISK_IMAGES="$product_out/ramdisk.img"
-for f in $RAMDISK_IMAGES; do
- partition_name=$(basename $f | cut -d. -f1)
- file_list_file="${sbom_test}/sbom-${partition_name}-files.txt"
- files_in_spdx_file="${sbom_test}/sbom-${partition_name}-files-in-spdx.txt"
- # lz4 decompress $f to stdout
- # cpio list all entries like ls -l
- # grep filter normal files and symlinks
- # awk get entry names
- # sed remove partition name from entry names
- $lz4 -c -d $f | cpio -tv 2>/dev/null | grep '^[-l]' | awk -F ' ' '{print $9}' | sed "s:^:/$partition_name/:" | sort -n > "$file_list_file"
+function test_sbom_aosp_cf_x86_64_phone {
+ # Setup
+ out_dir="$(setup)"
- grep "FileName: /${partition_name}/" $product_out/sbom.spdx | sed 's/^FileName: //' | sort -n > "$files_in_spdx_file"
+ # Test
+ # m droid, build sbom later in case additional dependencies might be built and included in partition images.
+ run_soong "aosp_cf_x86_64_phone" "${out_dir}" "droid dump.erofs lz4"
- echo ============ Diffing files in $f and SBOM
- diff_files "$file_list_file" "$files_in_spdx_file" "$partition_name"
-done
\ No newline at end of file
+ product_out=$out_dir/target/product/vsoc_x86_64
+ sbom_test=$product_out/sbom_test
+ mkdir -p $sbom_test
+ cp $product_out/*.img $sbom_test
+
+ # m sbom
+ run_soong "aosp_cf_x86_64_phone" "${out_dir}" sbom
+
+ # Generate installed file list from .img files in PRODUCT_OUT
+ dump_erofs=$out_dir/host/linux-x86/bin/dump.erofs
+ lz4=$out_dir/host/linux-x86/bin/lz4
+
+ declare -A diff_excludes
+ diff_excludes[vendor]="-I /vendor/lib64/libkeystore2_crypto.so"
+ diff_excludes[system]="\
+ -I /bin \
+ -I /bugreports \
+ -I /cache \
+ -I /d \
+ -I /etc \
+ -I /init \
+ -I /odm/app \
+ -I /odm/bin \
+ -I /odm_dlkm/etc \
+ -I /odm/etc \
+ -I /odm/firmware \
+ -I /odm/framework \
+ -I /odm/lib \
+ -I /odm/lib64 \
+ -I /odm/overlay \
+ -I /odm/priv-app \
+ -I /odm/usr \
+ -I /sdcard \
+ -I /system/lib64/android.hardware.confirmationui@1.0.so \
+ -I /system/lib64/android.hardware.confirmationui-V1-ndk.so \
+ -I /system/lib64/android.hardware.keymaster@4.1.so \
+ -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/libkeymaster4_1support.so \
+ -I /system/lib64/libkeymaster4support.so \
+ -I /system/lib64/libkeymint.so \
+ -I /system/lib64/libkeystore2_aaid.so \
+ -I /system/lib64/libkeystore2_apc_compat.so \
+ -I /system/lib64/libkeystore2_crypto.so \
+ -I /system/lib64/libkeystore-attestation-application-id.so \
+ -I /system/lib64/libkm_compat_service.so \
+ -I /system/lib64/libkm_compat.so \
+ -I /system/lib64/vndk-29 \
+ -I /system/lib64/vndk-sp-29 \
+ -I /system/lib/vndk-29 \
+ -I /system/lib/vndk-sp-29 \
+ -I /system/usr/icu \
+ -I /vendor_dlkm/etc"
+
+ # Example output of dump.erofs is as below, and the data used in the test start
+ # at line 11. Column 1 is inode id, column 2 is inode type and column 3 is name.
+ # Each line is captured in variable "entry", awk is used to get type and name.
+ # Output of dump.erofs:
+ # File : /
+ # Size: 160 On-disk size: 160 directory
+ # NID: 39 Links: 10 Layout: 2 Compression ratio: 100.00%
+ # Inode size: 64 Extent size: 0 Xattr size: 16
+ # Uid: 0 Gid: 0 Access: 0755/rwxr-xr-x
+ # Timestamp: 2023-02-14 01:15:54.000000000
+ #
+ # NID TYPE FILENAME
+ # 39 2 .
+ # 39 2 ..
+ # 47 2 app
+ # 1286748 2 bin
+ # 1286754 2 etc
+ # 5304814 2 lib
+ # 5309056 2 lib64
+ # 5309130 2 media
+ # 5388910 2 overlay
+ # 5479537 2 priv-app
+ EROFS_IMAGES="\
+ $sbom_test/product.img \
+ $sbom_test/system.img \
+ $sbom_test/system_ext.img \
+ $sbom_test/system_dlkm.img \
+ $sbom_test/system_other.img \
+ $sbom_test/odm.img \
+ $sbom_test/odm_dlkm.img \
+ $sbom_test/vendor.img \
+ $sbom_test/vendor_dlkm.img"
+ for f in $EROFS_IMAGES; do
+ partition_name=$(basename $f | cut -d. -f1)
+ file_list_file="${sbom_test}/sbom-${partition_name}-files.txt"
+ files_in_spdx_file="${sbom_test}/sbom-${partition_name}-files-in-spdx.txt"
+ rm "$file_list_file" > /dev/null 2>&1 || true
+ all_dirs="/"
+ while [ ! -z "$all_dirs" ]; do
+ dir=$(echo "$all_dirs" | cut -d ' ' -f1)
+ all_dirs=$(echo "$all_dirs" | cut -d ' ' -f1 --complement -s)
+ entries=$($dump_erofs --ls --path "$dir" $f | tail -n +11)
+ while read -r entry; do
+ inode_type=$(echo $entry | awk -F ' ' '{print $2}')
+ name=$(echo $entry | awk -F ' ' '{print $3}')
+ case $inode_type in
+ "2") # directory
+ all_dirs=$(echo "$all_dirs $dir/$name" | sed 's/^\s*//')
+ ;;
+ "1"|"7") # 1: file, 7: symlink
+ (
+ if [ "$partition_name" != "system" ]; then
+ # system partition is mounted to /, not to prepend partition name.
+ printf %s "/$partition_name"
+ fi
+ echo "$dir/$name" | sed 's#^//#/#'
+ ) >> "$file_list_file"
+ ;;
+ esac
+ done <<< "$entries"
+ done
+ sort -n -o "$file_list_file" "$file_list_file"
+
+ grep "FileName: /${partition_name}/" $product_out/sbom.spdx | sed 's/^FileName: //' > "$files_in_spdx_file"
+ if [ "$partition_name" = "system" ]; then
+ # system partition is mounted to /, so include FileName starts with /root/ too.
+ grep "FileName: /root/" $product_out/sbom.spdx | sed 's/^FileName: \/root//' >> "$files_in_spdx_file"
+ fi
+ sort -n -o "$files_in_spdx_file" "$files_in_spdx_file"
+
+ echo ============ Diffing files in $f and SBOM
+ diff_files "$file_list_file" "$files_in_spdx_file" "$partition_name"
+ done
+
+ RAMDISK_IMAGES="$product_out/ramdisk.img"
+ for f in $RAMDISK_IMAGES; do
+ partition_name=$(basename $f | cut -d. -f1)
+ file_list_file="${sbom_test}/sbom-${partition_name}-files.txt"
+ files_in_spdx_file="${sbom_test}/sbom-${partition_name}-files-in-spdx.txt"
+ # lz4 decompress $f to stdout
+ # cpio list all entries like ls -l
+ # grep filter normal files and symlinks
+ # awk get entry names
+ # sed remove partition name from entry names
+ $lz4 -c -d $f | cpio -tv 2>/dev/null | grep '^[-l]' | awk -F ' ' '{print $9}' | sed "s:^:/$partition_name/:" | sort -n > "$file_list_file"
+
+ grep "FileName: /${partition_name}/" $product_out/sbom.spdx | sed 's/^FileName: //' | sort -n > "$files_in_spdx_file"
+
+ echo ============ Diffing files in $f and SBOM
+ diff_files "$file_list_file" "$files_in_spdx_file" "$partition_name"
+ done
+
+ # Teardown
+ cleanup "${out_dir}"
+}
+
+test_sbom_aosp_cf_x86_64_phone
\ No newline at end of file
diff --git a/third_party/zip/android_test.go b/third_party/zip/android_test.go
index 46588d4..3911dd4 100644
--- a/third_party/zip/android_test.go
+++ b/third_party/zip/android_test.go
@@ -190,7 +190,9 @@
t.Errorf("wanted directoryRecords %d, got %d", w, g)
}
- if g, w := d.directorySize, uint64(uint32max); g != w {
+ zip64ExtraBuf := 48 // 4x uint16 + 5x uint64
+ expectedDirSize := directoryHeaderLen + zip64ExtraBuf + len("large") // name of header
+ if g, w := d.directorySize, uint64(expectedDirSize); g != w {
t.Errorf("wanted directorySize %d, got %d", w, g)
}
diff --git a/ui/build/config.go b/ui/build/config.go
index 80038f5..e642772 100644
--- a/ui/build/config.go
+++ b/ui/build/config.go
@@ -1375,6 +1375,12 @@
}
func (c *configImpl) UseRBE() bool {
+ authType, _ := c.rbeAuth()
+ // Do not use RBE with prod credentials in scenarios when stubby doesn't exist, since
+ // its unlikely that we will be able to obtain necessary creds without stubby.
+ if !c.StubbyExists() && strings.Contains(authType, "use_google_prod_creds"){
+ return false
+ }
if v, ok := c.Environment().Get("USE_RBE"); ok {
v = strings.TrimSpace(v)
if v != "" && v != "false" {
@@ -1514,7 +1520,7 @@
if googleProdCredsExistCache {
return googleProdCredsExistCache
}
- if _, err := exec.Command("/usr/bin/gcertstatus").Output(); err != nil {
+ if _, err := exec.Command("/usr/bin/gcertstatus", "-nocheck_ssh").Output(); err != nil {
return false
}
googleProdCredsExistCache = true
diff --git a/ui/build/soong.go b/ui/build/soong.go
index 07d6188..a4cf7fb 100644
--- a/ui/build/soong.go
+++ b/ui/build/soong.go
@@ -532,13 +532,15 @@
runMicrofactory(ctx, config, "bpglob", "github.com/google/blueprint/bootstrap/bpglob",
map[string]string{"github.com/google/blueprint": "build/blueprint"})
- ninja := func(name, ninjaFile string, targets ...string) {
- ctx.BeginTrace(metrics.RunSoong, name)
+ ninja := func(targets ...string) {
+ ctx.BeginTrace(metrics.RunSoong, "bootstrap")
defer ctx.EndTrace()
if config.IsPersistentBazelEnabled() {
bazelProxy := bazel.NewProxyServer(ctx.Logger, config.OutDir(), filepath.Join(config.SoongOutDir(), "workspace"), config.GetBazeliskBazelVersion())
- bazelProxy.Start()
+ if err := bazelProxy.Start(); err != nil {
+ ctx.Fatalf("Failed to create bazel proxy")
+ }
defer bazelProxy.Close()
}
@@ -556,7 +558,7 @@
"-w", "missingoutfile=err",
"-j", strconv.Itoa(config.Parallel()),
"--frontend_file", fifo,
- "-f", filepath.Join(config.SoongOutDir(), ninjaFile),
+ "-f", filepath.Join(config.SoongOutDir(), "bootstrap.ninja"),
}
if extra, ok := config.Environment().Get("SOONG_UI_NINJA_ARGS"); ok {
@@ -565,7 +567,7 @@
}
ninjaArgs = append(ninjaArgs, targets...)
- cmd := Command(ctx, config, "soong "+name,
+ cmd := Command(ctx, config, "soong bootstrap",
config.PrebuiltBuildTool("ninja"), ninjaArgs...)
var ninjaEnv Environment
@@ -606,7 +608,7 @@
targets = append(targets, config.SoongNinjaFile())
}
- ninja("bootstrap", "bootstrap.ninja", targets...)
+ ninja(targets...)
distGzipFile(ctx, config, config.SoongNinjaFile(), "soong")
distFile(ctx, config, config.SoongVarsFile(), "soong")
diff --git a/ui/metrics/metrics.go b/ui/metrics/metrics.go
index 6d60316..d68ced8 100644
--- a/ui/metrics/metrics.go
+++ b/ui/metrics/metrics.go
@@ -230,7 +230,7 @@
func (m *Metrics) UpdateTotalRealTimeAndNonZeroExit(data []byte, bazelExitCode int32) error {
if err := proto.Unmarshal(data, &m.metrics); err != nil {
- return fmt.Errorf("Failed to unmarshal proto", err)
+ return fmt.Errorf("Failed to unmarshal proto: %w", err)
}
startTime := *m.metrics.Total.StartTime
endTime := uint64(time.Now().UnixNano())
diff --git a/ui/status/kati.go b/ui/status/kati.go
index 1485c8d..dbb0ce3 100644
--- a/ui/status/kati.go
+++ b/ui/status/kati.go
@@ -24,7 +24,7 @@
)
var katiError = regexp.MustCompile(`^(\033\[1m)?[^ ]+:[0-9]+: (\033\[31m)?error:`)
-var katiIncludeRe = regexp.MustCompile(`^(\[(\d+)/(\d+)] )?((including [^ ]+|initializing (build|packaging) system|finishing (build|packaging) rules|writing (build|packaging) rules) ...)$`)
+var katiIncludeRe = regexp.MustCompile(`^(\[(\d+)/(\d+)] )?((including [^ ]+|initializing (legacy Make module parser|packaging system)|finishing (legacy Make module parsing|packaging rules)|writing (legacy Make module|packaging) rules) ...)$`)
var katiLogRe = regexp.MustCompile(`^\*kati\*: `)
var katiNinjaMissing = regexp.MustCompile("^[^ ]+ is missing, regenerating...$")
diff --git a/ui/status/kati_test.go b/ui/status/kati_test.go
index f2cb813..fd1b4b5 100644
--- a/ui/status/kati_test.go
+++ b/ui/status/kati_test.go
@@ -65,7 +65,7 @@
parser.parseLine("out/build-aosp_arm.ninja is missing, regenerating...")
output.Expect(t, Counts{})
- parser.parseLine("[1/1] initializing build system ...")
+ parser.parseLine("[1/1] initializing legacy Make module parser ...")
output.Expect(t, Counts{
TotalActions: 1,
RunningActions: 1,
@@ -86,14 +86,14 @@
parser.parseLine(msg)
// Start the next line to flush the previous result
- parser.parseLine("[4/5] finishing build rules ...")
+ parser.parseLine("[4/5] finishing legacy Make module parsing ...")
msg += "\n"
if output.result.Output != msg {
t.Errorf("output for action did not match:\nwant: %q\n got: %q\n", msg, output.result.Output)
}
- parser.parseLine("[5/5] writing build rules ...")
+ parser.parseLine("[5/5] writing legacy Make module rules ...")
parser.parseLine("*kati*: verbose msg")
parser.flushAction()
@@ -118,7 +118,7 @@
st: status.StartTool(),
}
- parser.parseLine("[1/1] initializing build system ...")
+ parser.parseLine("[1/1] initializing legacy Make module parser ...")
parser.parseLine("[2/5] including out/soong/Android-aosp_arm.mk ...")
output.Expect(t, Counts{
TotalActions: 5,
@@ -145,7 +145,7 @@
FinishedActions: 3,
})
- parser.parseLine("[3/5] finishing build rules ...")
+ parser.parseLine("[3/5] finishing legacy Make module parsing ...")
output.Expect(t, Counts{
TotalActions: 7,
@@ -164,7 +164,7 @@
st: status.StartTool(),
}
- parser.parseLine("[1/1] initializing build system ...")
+ parser.parseLine("[1/1] initializing legacy Make module parser ...")
parser.parseLine("[2/5] inclduing out/soong/Android-aosp_arm.mk ...")
parser.parseLine("build/make/tools/Android.mk:19: error: testing")
parser.flushAction()
diff --git a/ui/status/ninja.go b/ui/status/ninja.go
index fc0e21a..fb760ac 100644
--- a/ui/status/ninja.go
+++ b/ui/status/ninja.go
@@ -174,6 +174,7 @@
IOOutputKB: msg.EdgeFinished.GetIoOutputKb(),
VoluntaryContextSwitches: msg.EdgeFinished.GetVoluntaryContextSwitches(),
InvoluntaryContextSwitches: msg.EdgeFinished.GetInvoluntaryContextSwitches(),
+ Tags: msg.EdgeFinished.GetTags(),
},
})
}
diff --git a/ui/status/ninja_frontend/frontend.pb.go b/ui/status/ninja_frontend/frontend.pb.go
index bcadc67..d0c4953 100644
--- a/ui/status/ninja_frontend/frontend.pb.go
+++ b/ui/status/ninja_frontend/frontend.pb.go
@@ -14,8 +14,8 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
-// protoc-gen-go v1.26.0
-// protoc v3.9.1
+// protoc-gen-go v1.28.1
+// protoc v3.21.12
// source: frontend.proto
package ninja_frontend
@@ -459,6 +459,9 @@
VoluntaryContextSwitches *uint64 `protobuf:"varint,12,opt,name=voluntary_context_switches,json=voluntaryContextSwitches" json:"voluntary_context_switches,omitempty"`
// Involuntary context switches
InvoluntaryContextSwitches *uint64 `protobuf:"varint,13,opt,name=involuntary_context_switches,json=involuntaryContextSwitches" json:"involuntary_context_switches,omitempty"`
+ // Arbitrary tags for build system profiling (module names and types, rule
+ // names, etc). Format of the string is implementation defined.
+ Tags *string `protobuf:"bytes,14,opt,name=tags" json:"tags,omitempty"`
}
func (x *Status_EdgeFinished) Reset() {
@@ -584,6 +587,13 @@
return 0
}
+func (x *Status_EdgeFinished) GetTags() string {
+ if x != nil && x.Tags != nil {
+ return *x.Tags
+ }
+ return ""
+}
+
type Status_Message struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
@@ -650,7 +660,7 @@
var file_frontend_proto_rawDesc = []byte{
0x0a, 0x0e, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x64, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
- 0x12, 0x05, 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x22, 0xb4, 0x0a, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74,
+ 0x12, 0x05, 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x22, 0xc8, 0x0a, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74,
0x75, 0x73, 0x12, 0x39, 0x0a, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x65, 0x64, 0x67, 0x65,
0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x2e,
0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x45, 0x64, 0x67, 0x65,
@@ -694,7 +704,7 @@
0x65, 0x73, 0x63, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x18, 0x06,
0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x12, 0x18, 0x0a,
0x07, 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07,
- 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x1a, 0xdf, 0x03, 0x0a, 0x0c, 0x45, 0x64, 0x67, 0x65,
+ 0x63, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x1a, 0xf3, 0x03, 0x0a, 0x0c, 0x45, 0x64, 0x67, 0x65,
0x46, 0x69, 0x6e, 0x69, 0x73, 0x68, 0x65, 0x64, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
0x20, 0x01, 0x28, 0x0d, 0x52, 0x02, 0x69, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x65, 0x6e, 0x64, 0x5f,
0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x07, 0x65, 0x6e, 0x64, 0x54,
@@ -724,19 +734,20 @@
0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x5f, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x73,
0x77, 0x69, 0x74, 0x63, 0x68, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x04, 0x52, 0x1a, 0x69,
0x6e, 0x76, 0x6f, 0x6c, 0x75, 0x6e, 0x74, 0x61, 0x72, 0x79, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78,
- 0x74, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x65, 0x73, 0x1a, 0x92, 0x01, 0x0a, 0x07, 0x4d, 0x65,
- 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x01,
- 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x2e, 0x53, 0x74, 0x61,
- 0x74, 0x75, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x4c, 0x65, 0x76, 0x65,
- 0x6c, 0x3a, 0x04, 0x49, 0x4e, 0x46, 0x4f, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x18,
- 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52,
- 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x34, 0x0a, 0x05, 0x4c, 0x65, 0x76, 0x65,
- 0x6c, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x4e, 0x46, 0x4f, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x57,
- 0x41, 0x52, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x52, 0x52, 0x4f,
- 0x52, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x44, 0x45, 0x42, 0x55, 0x47, 0x10, 0x03, 0x42, 0x2a,
- 0x48, 0x03, 0x5a, 0x26, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2f, 0x73, 0x6f, 0x6f, 0x6e,
- 0x67, 0x2f, 0x75, 0x69, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2f, 0x6e, 0x69, 0x6e, 0x6a,
- 0x61, 0x5f, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x64,
+ 0x74, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x61, 0x67,
+ 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x61, 0x67, 0x73, 0x1a, 0x92, 0x01,
+ 0x0a, 0x07, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x05, 0x6c, 0x65, 0x76,
+ 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6e, 0x69, 0x6e, 0x6a, 0x61,
+ 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e,
+ 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x3a, 0x04, 0x49, 0x4e, 0x46, 0x4f, 0x52, 0x05, 0x6c, 0x65, 0x76,
+ 0x65, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20,
+ 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x34, 0x0a, 0x05,
+ 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x4e, 0x46, 0x4f, 0x10, 0x00, 0x12,
+ 0x0b, 0x0a, 0x07, 0x57, 0x41, 0x52, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05,
+ 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x44, 0x45, 0x42, 0x55, 0x47,
+ 0x10, 0x03, 0x42, 0x2a, 0x48, 0x03, 0x5a, 0x26, 0x61, 0x6e, 0x64, 0x72, 0x6f, 0x69, 0x64, 0x2f,
+ 0x73, 0x6f, 0x6f, 0x6e, 0x67, 0x2f, 0x75, 0x69, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2f,
+ 0x6e, 0x69, 0x6e, 0x6a, 0x61, 0x5f, 0x66, 0x72, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x64,
}
var (
diff --git a/ui/status/ninja_frontend/frontend.proto b/ui/status/ninja_frontend/frontend.proto
index 5730388..6cb4a0d 100644
--- a/ui/status/ninja_frontend/frontend.proto
+++ b/ui/status/ninja_frontend/frontend.proto
@@ -79,6 +79,9 @@
optional uint64 voluntary_context_switches = 12;
// Involuntary context switches
optional uint64 involuntary_context_switches = 13;
+ // Arbitrary tags for build system profiling (module names and types, rule
+ // names, etc). Format of the string is implementation defined.
+ optional string tags = 14;
}
message Message {
diff --git a/ui/status/status.go b/ui/status/status.go
index a5b4a28..f3e58b6 100644
--- a/ui/status/status.go
+++ b/ui/status/status.go
@@ -85,6 +85,8 @@
// Involuntary context switches
InvoluntaryContextSwitches uint64
+
+ Tags string
}
// Counts describes the number of actions in each state
diff --git a/ui/terminal/smart_status.go b/ui/terminal/smart_status.go
index 06a4064..3880b04 100644
--- a/ui/terminal/smart_status.go
+++ b/ui/terminal/smart_status.go
@@ -53,6 +53,13 @@
done chan bool
sigwinch chan os.Signal
sigwinchHandled chan bool
+
+ // Once there is a failure, we stop printing command output so the error
+ // is easier to find
+ haveFailures bool
+ // If we are dropping errors, then at the end, we report a message to go
+ // look in the verbose log if you want that command output.
+ postFailureActionCount int
}
// NewSmartStatusOutput returns a StatusOutput that represents the
@@ -165,12 +172,20 @@
}
}
+ s.statusLine(progress)
+
+ // Stop printing when there are failures, but don't skip actions that also have their own errors.
if output != "" {
- s.statusLine(progress)
- s.requestLine()
- s.print(output)
- } else {
- s.statusLine(progress)
+ if !s.haveFailures || result.Error != nil {
+ s.requestLine()
+ s.print(output)
+ } else {
+ s.postFailureActionCount++
+ }
+ }
+
+ if result.Error != nil {
+ s.haveFailures = true
}
}
@@ -187,6 +202,15 @@
s.stopSigwinch()
+ if s.postFailureActionCount > 0 {
+ s.requestLine()
+ if s.postFailureActionCount == 1 {
+ s.print(fmt.Sprintf("There was 1 action that completed after the action that failed. See verbose.log.gz for its output."))
+ } else {
+ s.print(fmt.Sprintf("There were %d actions that completed after the action that failed. See verbose.log.gz for their output.", s.postFailureActionCount))
+ }
+ }
+
s.requestLine()
s.runningActions = nil
diff --git a/ui/terminal/status_test.go b/ui/terminal/status_test.go
index b9057d2..8dd1809 100644
--- a/ui/terminal/status_test.go
+++ b/ui/terminal/status_test.go
@@ -295,3 +295,159 @@
t.Errorf("want:\n%q\ngot:\n%q", w, g)
}
}
+
+func TestSmartStatusDoesntHideAfterSucecss(t *testing.T) {
+ os.Setenv(tableHeightEnVar, "")
+
+ smart := &fakeSmartTerminal{termWidth: 40}
+ stat := NewStatusOutput(smart, "", false, false, false)
+ smartStat := stat.(*smartStatusOutput)
+ smartStat.sigwinchHandled = make(chan bool)
+
+ runner := newRunner(stat, 2)
+
+ action1 := &status.Action{Description: "action1"}
+ result1 := status.ActionResult{
+ Action: action1,
+ Output: "Output1",
+ }
+
+ action2 := &status.Action{Description: "action2"}
+ result2 := status.ActionResult{
+ Action: action2,
+ Output: "Output2",
+ }
+
+ runner.startAction(action1)
+ runner.startAction(action2)
+ runner.finishAction(result1)
+ runner.finishAction(result2)
+
+ stat.Flush()
+
+ w := "\r\x1b[1m[ 0% 0/2] action1\x1b[0m\x1b[K\r\x1b[1m[ 0% 0/2] action2\x1b[0m\x1b[K\r\x1b[1m[ 50% 1/2] action1\x1b[0m\x1b[K\nOutput1\n\r\x1b[1m[100% 2/2] action2\x1b[0m\x1b[K\nOutput2\n"
+
+ if g := smart.String(); g != w {
+ t.Errorf("want:\n%q\ngot:\n%q", w, g)
+ }
+}
+
+func TestSmartStatusHideAfterFailure(t *testing.T) {
+ os.Setenv(tableHeightEnVar, "")
+
+ smart := &fakeSmartTerminal{termWidth: 40}
+ stat := NewStatusOutput(smart, "", false, false, false)
+ smartStat := stat.(*smartStatusOutput)
+ smartStat.sigwinchHandled = make(chan bool)
+
+ runner := newRunner(stat, 2)
+
+ action1 := &status.Action{Description: "action1"}
+ result1 := status.ActionResult{
+ Action: action1,
+ Output: "Output1",
+ Error: fmt.Errorf("Error1"),
+ }
+
+ action2 := &status.Action{Description: "action2"}
+ result2 := status.ActionResult{
+ Action: action2,
+ Output: "Output2",
+ }
+
+ runner.startAction(action1)
+ runner.startAction(action2)
+ runner.finishAction(result1)
+ runner.finishAction(result2)
+
+ stat.Flush()
+
+ w := "\r\x1b[1m[ 0% 0/2] action1\x1b[0m\x1b[K\r\x1b[1m[ 0% 0/2] action2\x1b[0m\x1b[K\r\x1b[1m[ 50% 1/2] action1\x1b[0m\x1b[K\nFAILED: \nOutput1\n\r\x1b[1m[100% 2/2] action2\x1b[0m\x1b[K\nThere was 1 action that completed after the action that failed. See verbose.log.gz for its output.\n"
+
+ if g := smart.String(); g != w {
+ t.Errorf("want:\n%q\ngot:\n%q", w, g)
+ }
+}
+
+func TestSmartStatusHideAfterFailurePlural(t *testing.T) {
+ os.Setenv(tableHeightEnVar, "")
+
+ smart := &fakeSmartTerminal{termWidth: 40}
+ stat := NewStatusOutput(smart, "", false, false, false)
+ smartStat := stat.(*smartStatusOutput)
+ smartStat.sigwinchHandled = make(chan bool)
+
+ runner := newRunner(stat, 2)
+
+ action1 := &status.Action{Description: "action1"}
+ result1 := status.ActionResult{
+ Action: action1,
+ Output: "Output1",
+ Error: fmt.Errorf("Error1"),
+ }
+
+ action2 := &status.Action{Description: "action2"}
+ result2 := status.ActionResult{
+ Action: action2,
+ Output: "Output2",
+ }
+
+ action3 := &status.Action{Description: "action3"}
+ result3 := status.ActionResult{
+ Action: action3,
+ Output: "Output3",
+ }
+
+ runner.startAction(action1)
+ runner.startAction(action2)
+ runner.startAction(action3)
+ runner.finishAction(result1)
+ runner.finishAction(result2)
+ runner.finishAction(result3)
+
+ stat.Flush()
+
+ w := "\r\x1b[1m[ 0% 0/2] action1\x1b[0m\x1b[K\r\x1b[1m[ 0% 0/2] action2\x1b[0m\x1b[K\r\x1b[1m[ 0% 0/2] action3\x1b[0m\x1b[K\r\x1b[1m[ 50% 1/2] action1\x1b[0m\x1b[K\nFAILED: \nOutput1\n\r\x1b[1m[100% 2/2] action2\x1b[0m\x1b[K\r\x1b[1m[150% 3/2] action3\x1b[0m\x1b[K\nThere were 2 actions that completed after the action that failed. See verbose.log.gz for their output.\n"
+
+ if g := smart.String(); g != w {
+ t.Errorf("want:\n%q\ngot:\n%q", w, g)
+ }
+}
+
+func TestSmartStatusDontHideErrorAfterFailure(t *testing.T) {
+ os.Setenv(tableHeightEnVar, "")
+
+ smart := &fakeSmartTerminal{termWidth: 40}
+ stat := NewStatusOutput(smart, "", false, false, false)
+ smartStat := stat.(*smartStatusOutput)
+ smartStat.sigwinchHandled = make(chan bool)
+
+ runner := newRunner(stat, 2)
+
+ action1 := &status.Action{Description: "action1"}
+ result1 := status.ActionResult{
+ Action: action1,
+ Output: "Output1",
+ Error: fmt.Errorf("Error1"),
+ }
+
+ action2 := &status.Action{Description: "action2"}
+ result2 := status.ActionResult{
+ Action: action2,
+ Output: "Output2",
+ Error: fmt.Errorf("Error1"),
+ }
+
+ runner.startAction(action1)
+ runner.startAction(action2)
+ runner.finishAction(result1)
+ runner.finishAction(result2)
+
+ stat.Flush()
+
+ w := "\r\x1b[1m[ 0% 0/2] action1\x1b[0m\x1b[K\r\x1b[1m[ 0% 0/2] action2\x1b[0m\x1b[K\r\x1b[1m[ 50% 1/2] action1\x1b[0m\x1b[K\nFAILED: \nOutput1\n\r\x1b[1m[100% 2/2] action2\x1b[0m\x1b[K\nFAILED: \nOutput2\n"
+
+ if g := smart.String(); g != w {
+ t.Errorf("want:\n%q\ngot:\n%q", w, g)
+ }
+}
diff --git a/ui/tracer/status.go b/ui/tracer/status.go
index a8b4e62..f973613 100644
--- a/ui/tracer/status.go
+++ b/ui/tracer/status.go
@@ -16,6 +16,7 @@
import (
"android/soong/ui/status"
+ "strings"
"time"
)
@@ -60,6 +61,24 @@
}
}
+func (s *statusOutput) parseTags(rawTags string) map[string]string {
+ if rawTags == "" {
+ return nil
+ }
+
+ tags := map[string]string{}
+ for _, pair := range strings.Split(rawTags, ";") {
+ if pair == "" {
+ // Ignore empty tag pairs. It's hard to generate these cleanly from
+ // make so some tag strings might be something like ";key=value".
+ continue
+ }
+ parts := strings.SplitN(pair, "=", 2)
+ tags[parts[0]] = parts[1]
+ }
+ return tags
+}
+
func (s *statusOutput) FinishAction(result status.ActionResult, counts status.Counts) {
start, ok := s.running[result.Action]
if !ok {
@@ -90,20 +109,22 @@
IOOutputKB: result.Stats.IOOutputKB,
VoluntaryContextSwitches: result.Stats.VoluntaryContextSwitches,
InvoluntaryContextSwitches: result.Stats.InvoluntaryContextSwitches,
+ Tags: s.parseTags(result.Stats.Tags),
},
})
}
type statsArg struct {
- UserTime uint32 `json:"user_time"`
- SystemTime uint32 `json:"system_time_ms"`
- MaxRssKB uint64 `json:"max_rss_kb"`
- MinorPageFaults uint64 `json:"minor_page_faults"`
- MajorPageFaults uint64 `json:"major_page_faults"`
- IOInputKB uint64 `json:"io_input_kb"`
- IOOutputKB uint64 `json:"io_output_kb"`
- VoluntaryContextSwitches uint64 `json:"voluntary_context_switches"`
- InvoluntaryContextSwitches uint64 `json:"involuntary_context_switches"`
+ UserTime uint32 `json:"user_time"`
+ SystemTime uint32 `json:"system_time_ms"`
+ MaxRssKB uint64 `json:"max_rss_kb"`
+ MinorPageFaults uint64 `json:"minor_page_faults"`
+ MajorPageFaults uint64 `json:"major_page_faults"`
+ IOInputKB uint64 `json:"io_input_kb"`
+ IOOutputKB uint64 `json:"io_output_kb"`
+ VoluntaryContextSwitches uint64 `json:"voluntary_context_switches"`
+ InvoluntaryContextSwitches uint64 `json:"involuntary_context_switches"`
+ Tags map[string]string `json:"tags"`
}
func (s *statusOutput) Flush() {}