Merge "Add upload-only mode and manual build-started-time flag."
diff --git a/android/api_domain.go b/android/api_domain.go
index 3265148..bdd4e6f 100644
--- a/android/api_domain.go
+++ b/android/api_domain.go
@@ -59,8 +59,14 @@
type apiDomainProperties struct {
// cc library contributions (.h files/.map.txt) of this API domain
- // This dependency is a no-op in Soong, but the corresponding Bazel target in the bp2build workspace will provide a `CcApiContributionInfo` provider
+ // This dependency is a no-op in Soong, but the corresponding Bazel target in the api_bp2build workspace
+ // will provide a `CcApiContributionInfo` provider
Cc_api_contributions []string
+
+ // java library contributions (as .txt) of this API domain
+ // This dependency is a no-op in Soong, but the corresponding Bazel target in the api_bp2build workspace
+ // will provide a `JavaApiContributionInfo` provider
+ Java_api_contributions []string
}
func ApiDomainFactory() Module {
@@ -102,7 +108,8 @@
}
type bazelApiDomainAttributes struct {
- Cc_api_contributions bazel.LabelListAttribute
+ Cc_api_contributions bazel.LabelListAttribute
+ Java_api_contributions bazel.LabelListAttribute
}
var _ ApiProvider = (*apiDomain)(nil)
@@ -113,7 +120,8 @@
Bzl_load_location: "//build/bazel/rules/apis:api_domain.bzl",
}
attrs := &bazelApiDomainAttributes{
- Cc_api_contributions: contributionBazelAttributes(ctx, a.properties.Cc_api_contributions),
+ Cc_api_contributions: contributionBazelAttributes(ctx, a.properties.Cc_api_contributions),
+ Java_api_contributions: contributionBazelAttributes(ctx, a.properties.Java_api_contributions),
}
ctx.CreateBazelTargetModule(props, CommonAttributes{
Name: ctx.ModuleName(),
diff --git a/android/arch_test.go b/android/arch_test.go
index 46c018a..e445ec6 100644
--- a/android/arch_test.go
+++ b/android/arch_test.go
@@ -584,6 +584,8 @@
func (testArchPropertiesModule) GenerateAndroidBuildActions(ctx ModuleContext) {}
+// Module property "a" does not have "variant_prepend" tag.
+// Expected variant property orders are based on this fact.
func TestArchProperties(t *testing.T) {
bp := `
module {
diff --git a/android/config.go b/android/config.go
index 9c1a484..4ebb00f 100644
--- a/android/config.go
+++ b/android/config.go
@@ -595,10 +595,6 @@
fmt.Fprintln(os.Stderr, "unsupported env var GLOBAL_THINLTO for Bazel: falling back to non-mixed build")
return false
}
- if c.IsEnvTrue("CLANG_COVERAGE") {
- fmt.Fprintln(os.Stderr, "unsupported env var CLANG_COVERAGE for Bazel: falling back to non-mixed build")
- return false
- }
if len(c.productVariables.SanitizeHost) > 0 {
fmt.Fprintln(os.Stderr, "unsupported product var SanitizeHost for Bazel: falling back to non-mixed build")
return false
diff --git a/android/sdk_version.go b/android/sdk_version.go
index c188c48..d73c912 100644
--- a/android/sdk_version.go
+++ b/android/sdk_version.go
@@ -44,6 +44,7 @@
SdkNone
SdkCore
SdkCorePlatform
+ SdkIntraCore // API surface provided by one core module to another
SdkPublic
SdkSystem
SdkTest
@@ -69,6 +70,8 @@
return "core"
case SdkCorePlatform:
return "core_platform"
+ case SdkIntraCore:
+ return "intracore"
case SdkModule:
return "module-lib"
case SdkSystemServer:
diff --git a/android/soong_config_modules.go b/android/soong_config_modules.go
index c0f4523..c1e92b8 100644
--- a/android/soong_config_modules.go
+++ b/android/soong_config_modules.go
@@ -382,15 +382,15 @@
defer r.Close()
mtDef, errs := soongconfig.Parse(r, from)
- if ctx.Config().BuildMode == Bp2build {
- ctx.Config().Bp2buildSoongConfigDefinitions.AddVars(*mtDef)
- }
-
if len(errs) > 0 {
reportErrors(ctx, from, errs...)
return (map[string]blueprint.ModuleFactory)(nil)
}
+ if ctx.Config().BuildMode == Bp2build {
+ ctx.Config().Bp2buildSoongConfigDefinitions.AddVars(*mtDef)
+ }
+
globalModuleTypes := ctx.moduleFactories()
factories := make(map[string]blueprint.ModuleFactory)
diff --git a/apex/apex.go b/apex/apex.go
index fcac3ab..a07576a 100644
--- a/apex/apex.go
+++ b/apex/apex.go
@@ -2066,15 +2066,23 @@
requireNativeLibs []string
handleSpecialLibs bool
+
+ // if true, raise error on duplicate apexFile
+ checkDuplicate bool
}
-func (vctx *visitorContext) normalizeFileInfo() {
+func (vctx *visitorContext) normalizeFileInfo(mctx android.ModuleContext) {
encountered := make(map[string]apexFile)
for _, f := range vctx.filesInfo {
dest := filepath.Join(f.installDir, f.builtFile.Base())
if e, ok := encountered[dest]; !ok {
encountered[dest] = f
} else {
+ if vctx.checkDuplicate && f.builtFile.String() != e.builtFile.String() {
+ mctx.ModuleErrorf("apex file %v is provided by two different files %v and %v",
+ dest, e.builtFile, f.builtFile)
+ return
+ }
// If a module is directly included and also transitively depended on
// consider it as directly included.
e.transitiveDep = e.transitiveDep && f.transitiveDep
@@ -2433,6 +2441,25 @@
return false
}
+func (a *apexBundle) shouldCheckDuplicate(ctx android.ModuleContext) bool {
+ // TODO(b/263308293) remove this
+ if a.properties.IsCoverageVariant {
+ return false
+ }
+ // TODO(b/263308515) remove this
+ if a.testApex {
+ return false
+ }
+ // TODO(b/263309864) remove this
+ if a.Host() {
+ return false
+ }
+ if a.Device() && ctx.DeviceConfig().DeviceArch() == "" {
+ return false
+ }
+ return true
+}
+
// Creates build rules for an APEX. It consists of the following major steps:
//
// 1) do some validity checks such as apex_available, min_sdk_version, etc.
@@ -2453,9 +2480,12 @@
// TODO(jiyong): do this using WalkPayloadDeps
// TODO(jiyong): make this clean!!!
- vctx := visitorContext{handleSpecialLibs: !android.Bool(a.properties.Ignore_system_library_special_case)}
+ vctx := visitorContext{
+ handleSpecialLibs: !android.Bool(a.properties.Ignore_system_library_special_case),
+ checkDuplicate: a.shouldCheckDuplicate(ctx),
+ }
ctx.WalkDepsBlueprint(func(child, parent blueprint.Module) bool { return a.depVisitor(&vctx, ctx, child, parent) })
- vctx.normalizeFileInfo()
+ vctx.normalizeFileInfo(ctx)
if a.privateKeyFile == nil {
ctx.PropertyErrorf("key", "private_key for %q could not be found", String(a.overridableProperties.Key))
return
diff --git a/apex/apex_test.go b/apex/apex_test.go
index 499d753..33fce7c 100644
--- a/apex/apex_test.go
+++ b/apex/apex_test.go
@@ -3420,11 +3420,34 @@
isLink bool
}
+func (f fileInApex) String() string {
+ return f.src + ":" + f.path
+}
+
+func (f fileInApex) match(expectation string) bool {
+ parts := strings.Split(expectation, ":")
+ if len(parts) == 1 {
+ match, _ := path.Match(parts[0], f.path)
+ return match
+ }
+ if len(parts) == 2 {
+ matchSrc, _ := path.Match(parts[0], f.src)
+ matchDst, _ := path.Match(parts[1], f.path)
+ return matchSrc && matchDst
+ }
+ panic("invalid expected file specification: " + expectation)
+}
+
func getFiles(t *testing.T, ctx *android.TestContext, moduleName, variant string) []fileInApex {
t.Helper()
- apexRule := ctx.ModuleForTests(moduleName, variant).Rule("apexRule")
+ module := ctx.ModuleForTests(moduleName, variant)
+ apexRule := module.MaybeRule("apexRule")
+ apexDir := "/image.apex/"
+ if apexRule.Rule == nil {
+ apexRule = module.Rule("zipApexRule")
+ apexDir = "/image.zipapex/"
+ }
copyCmds := apexRule.Args["copy_commands"]
- imageApexDir := "/image.apex/"
var ret []fileInApex
for _, cmd := range strings.Split(copyCmds, "&&") {
cmd = strings.TrimSpace(cmd)
@@ -3455,11 +3478,11 @@
t.Fatalf("copyCmds should contain mkdir/cp commands only: %q", cmd)
}
if dst != "" {
- index := strings.Index(dst, imageApexDir)
+ index := strings.Index(dst, apexDir)
if index == -1 {
- t.Fatal("copyCmds should copy a file to image.apex/", cmd)
+ t.Fatal("copyCmds should copy a file to "+apexDir, cmd)
}
- dstFile := dst[index+len(imageApexDir):]
+ dstFile := dst[index+len(apexDir):]
ret = append(ret, fileInApex{path: dstFile, src: src, isLink: isLink})
}
}
@@ -3472,16 +3495,16 @@
var surplus []string
filesMatched := make(map[string]bool)
for _, file := range getFiles(t, ctx, moduleName, variant) {
- mactchFound := false
+ matchFound := false
for _, expected := range files {
- if matched, _ := path.Match(expected, file.path); matched {
+ if file.match(expected) {
+ matchFound = true
filesMatched[expected] = true
- mactchFound = true
break
}
}
- if !mactchFound {
- surplus = append(surplus, file.path)
+ if !matchFound {
+ surplus = append(surplus, file.String())
}
}
@@ -3974,6 +3997,11 @@
apexManifestRule := ctx.ModuleForTests("com.android.vndk.current", "android_common_image").Rule("apexManifestRule")
provideNativeLibs := names(apexManifestRule.Args["provideNativeLibs"])
ensureListEmpty(t, provideNativeLibs)
+ ensureExactContents(t, ctx, "com.android.vndk.current", "android_common_image", []string{
+ "out/soong/.intermediates/libz/android_vendor.29_arm64_armv8-a_shared/libz.so:lib64/libz.so",
+ "out/soong/.intermediates/libz/android_vendor.29_arm_armv7-a-neon_shared/libz.so:lib/libz.so",
+ "*/*",
+ })
}
func TestDependenciesInApexManifest(t *testing.T) {
@@ -6992,6 +7020,42 @@
})
}
+func TestNoDupeApexFiles(t *testing.T) {
+ android.GroupFixturePreparers(
+ android.PrepareForTestWithAndroidBuildComponents,
+ PrepareForTestWithApexBuildComponents,
+ prepareForTestWithMyapex,
+ prebuilt_etc.PrepareForTestWithPrebuiltEtc,
+ ).
+ ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern("is provided by two different files")).
+ RunTestWithBp(t, `
+ apex {
+ name: "myapex",
+ key: "myapex.key",
+ prebuilts: ["foo", "bar"],
+ updatable: false,
+ }
+
+ apex_key {
+ name: "myapex.key",
+ public_key: "testkey.avbpubkey",
+ private_key: "testkey.pem",
+ }
+
+ prebuilt_etc {
+ name: "foo",
+ src: "myprebuilt",
+ filename_from_src: true,
+ }
+
+ prebuilt_etc {
+ name: "bar",
+ src: "myprebuilt",
+ filename_from_src: true,
+ }
+ `)
+}
+
func TestRejectNonInstallableJavaLibrary(t *testing.T) {
testApexError(t, `"myjar" is not configured to be compiled into dex`, `
apex {
diff --git a/apex/bootclasspath_fragment_test.go b/apex/bootclasspath_fragment_test.go
index b298dac..af4fd9f 100644
--- a/apex/bootclasspath_fragment_test.go
+++ b/apex/bootclasspath_fragment_test.go
@@ -71,10 +71,6 @@
name: "com.android.art",
key: "com.android.art.key",
bootclasspath_fragments: ["art-bootclasspath-fragment"],
- java_libs: [
- "baz",
- "quuz",
- ],
updatable: false,
}
@@ -301,11 +297,7 @@
"mybootclasspathfragment",
],
// bar (like foo) should be transitively included in this apex because it is part of the
- // mybootclasspathfragment bootclasspath_fragment. However, it is kept here to ensure that the
- // apex dedups the files correctly.
- java_libs: [
- "bar",
- ],
+ // mybootclasspathfragment bootclasspath_fragment.
updatable: false,
}
@@ -445,7 +437,6 @@
})
java.CheckModuleDependencies(t, result.TestContext, "com.android.art", "android_common_com.android.art_image", []string{
- `bar`,
`com.android.art.key`,
`mybootclasspathfragment`,
})
@@ -559,7 +550,6 @@
})
java.CheckModuleDependencies(t, result.TestContext, "com.android.art", "android_common_com.android.art_image", []string{
- `bar`,
`com.android.art.key`,
`mybootclasspathfragment`,
`prebuilt_com.android.art`,
@@ -1105,10 +1095,6 @@
name: "com.android.art",
key: "com.android.art.key",
bootclasspath_fragments: ["art-bootclasspath-fragment"],
- java_libs: [
- "baz",
- "quuz",
- ],
updatable: false,
}
@@ -1270,10 +1256,6 @@
name: "com.android.art",
key: "com.android.art.key",
bootclasspath_fragments: ["art-bootclasspath-fragment"],
- java_libs: [
- "baz",
- "quuz",
- ],
updatable: false,
}
diff --git a/bazel/properties.go b/bazel/properties.go
index 6921984..f9cabf2 100644
--- a/bazel/properties.go
+++ b/bazel/properties.go
@@ -1278,9 +1278,6 @@
// Append appends all values, including os and arch specific ones, from another
// StringListAttribute to this StringListAttribute
func (sla *StringListAttribute) Append(other StringListAttribute) *StringListAttribute {
- if sla.Prepend != other.Prepend {
- panic(fmt.Errorf("StringListAttribute could not be appended because it has different prepend value"))
- }
sla.Value = append(sla.Value, other.Value...)
if sla.ConfigurableValues == nil {
sla.ConfigurableValues = make(configurableStringLists)
diff --git a/bp2build/Android.bp b/bp2build/Android.bp
index 2e01789..72d16fa 100644
--- a/bp2build/Android.bp
+++ b/bp2build/Android.bp
@@ -55,6 +55,7 @@
"cc_test_conversion_test.go",
"cc_yasm_conversion_test.go",
"conversion_test.go",
+ "droidstubs_conversion_test.go",
"filegroup_conversion_test.go",
"genrule_conversion_test.go",
"gensrcs_conversion_test.go",
diff --git a/bp2build/cc_binary_conversion_test.go b/bp2build/cc_binary_conversion_test.go
index 8aa2c3e..fe156df 100644
--- a/bp2build/cc_binary_conversion_test.go
+++ b/bp2build/cc_binary_conversion_test.go
@@ -789,3 +789,82 @@
},
})
}
+
+func TestCcBinaryWithIntegerOverflowProperty(t *testing.T) {
+ runCcBinaryTestCase(t, ccBinaryBp2buildTestCase{
+ description: "cc_binary with integer overflow property specified",
+ blueprint: `
+{rule_name} {
+ name: "foo",
+ sanitize: {
+ integer_overflow: true,
+ },
+}`,
+ targets: []testBazelTarget{
+ {"cc_binary", "foo", AttrNameToString{
+ "local_includes": `["."]`,
+ "features": `["ubsan_integer_overflow"]`,
+ }},
+ },
+ })
+}
+
+func TestCcBinaryWithMiscUndefinedProperty(t *testing.T) {
+ runCcBinaryTestCase(t, ccBinaryBp2buildTestCase{
+ description: "cc_binary with miscellaneous properties specified",
+ blueprint: `
+{rule_name} {
+ name: "foo",
+ sanitize: {
+ misc_undefined: ["undefined", "nullability"],
+ },
+}`,
+ targets: []testBazelTarget{
+ {"cc_binary", "foo", AttrNameToString{
+ "local_includes": `["."]`,
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ]`,
+ }},
+ },
+ })
+}
+
+func TestCcBinaryWithUBSanPropertiesArchSpecific(t *testing.T) {
+ runCcBinaryTestCase(t, ccBinaryBp2buildTestCase{
+ description: "cc_binary has correct feature select when UBSan props are specified in arch specific blocks",
+ blueprint: `
+{rule_name} {
+ name: "foo",
+ sanitize: {
+ misc_undefined: ["undefined", "nullability"],
+ },
+ target: {
+ android: {
+ sanitize: {
+ misc_undefined: ["alignment"],
+ },
+ },
+ linux_glibc: {
+ sanitize: {
+ integer_overflow: true,
+ },
+ },
+ },
+}`,
+ targets: []testBazelTarget{
+ {"cc_binary", "foo", AttrNameToString{
+ "local_includes": `["."]`,
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ] + select({
+ "//build/bazel/platforms/os:android": ["ubsan_alignment"],
+ "//build/bazel/platforms/os:linux_glibc": ["ubsan_integer_overflow"],
+ "//conditions:default": [],
+ })`,
+ }},
+ },
+ })
+}
diff --git a/bp2build/cc_library_conversion_test.go b/bp2build/cc_library_conversion_test.go
index cfd1a8c..f924d00 100644
--- a/bp2build/cc_library_conversion_test.go
+++ b/bp2build/cc_library_conversion_test.go
@@ -3773,3 +3773,248 @@
},
)
}
+
+// Export_include_dirs and Export_system_include_dirs have "variant_prepend" tag.
+// In bp2build output, variant info(select) should go before general info.
+// Internal order of the property should be unchanged. (e.g. ["eid1", "eid2"])
+func TestCcLibraryVariantPrependPropOrder(t *testing.T) {
+ runCcLibraryTestCase(t, Bp2buildTestCase{
+ Description: "cc_library variant prepend properties order",
+ ModuleTypeUnderTest: "cc_library",
+ ModuleTypeUnderTestFactory: cc.LibraryFactory,
+ Blueprint: soongCcLibraryPreamble + `
+cc_library {
+ name: "a",
+ srcs: ["a.cpp"],
+ export_include_dirs: ["eid1", "eid2"],
+ export_system_include_dirs: ["esid1", "esid2"],
+ target: {
+ android: {
+ export_include_dirs: ["android_eid1", "android_eid2"],
+ export_system_include_dirs: ["android_esid1", "android_esid2"],
+ },
+ android_arm: {
+ export_include_dirs: ["android_arm_eid1", "android_arm_eid2"],
+ export_system_include_dirs: ["android_arm_esid1", "android_arm_esid2"],
+ },
+ linux: {
+ export_include_dirs: ["linux_eid1", "linux_eid2"],
+ export_system_include_dirs: ["linux_esid1", "linux_esid2"],
+ },
+ },
+ multilib: {
+ lib32: {
+ export_include_dirs: ["lib32_eid1", "lib32_eid2"],
+ export_system_include_dirs: ["lib32_esid1", "lib32_esid2"],
+ },
+ },
+ arch: {
+ arm: {
+ export_include_dirs: ["arm_eid1", "arm_eid2"],
+ export_system_include_dirs: ["arm_esid1", "arm_esid2"],
+ },
+ }
+}
+`,
+ ExpectedBazelTargets: makeCcLibraryTargets("a", AttrNameToString{
+ "export_includes": `select({
+ "//build/bazel/platforms/os_arch:android_arm": [
+ "android_arm_eid1",
+ "android_arm_eid2",
+ ],
+ "//conditions:default": [],
+ }) + select({
+ "//build/bazel/platforms/os:android": [
+ "android_eid1",
+ "android_eid2",
+ "linux_eid1",
+ "linux_eid2",
+ ],
+ "//build/bazel/platforms/os:linux_bionic": [
+ "linux_eid1",
+ "linux_eid2",
+ ],
+ "//build/bazel/platforms/os:linux_glibc": [
+ "linux_eid1",
+ "linux_eid2",
+ ],
+ "//build/bazel/platforms/os:linux_musl": [
+ "linux_eid1",
+ "linux_eid2",
+ ],
+ "//conditions:default": [],
+ }) + select({
+ "//build/bazel/platforms/arch:arm": [
+ "lib32_eid1",
+ "lib32_eid2",
+ "arm_eid1",
+ "arm_eid2",
+ ],
+ "//build/bazel/platforms/arch:x86": [
+ "lib32_eid1",
+ "lib32_eid2",
+ ],
+ "//conditions:default": [],
+ }) + [
+ "eid1",
+ "eid2",
+ ]`,
+ "export_system_includes": `select({
+ "//build/bazel/platforms/os_arch:android_arm": [
+ "android_arm_esid1",
+ "android_arm_esid2",
+ ],
+ "//conditions:default": [],
+ }) + select({
+ "//build/bazel/platforms/os:android": [
+ "android_esid1",
+ "android_esid2",
+ "linux_esid1",
+ "linux_esid2",
+ ],
+ "//build/bazel/platforms/os:linux_bionic": [
+ "linux_esid1",
+ "linux_esid2",
+ ],
+ "//build/bazel/platforms/os:linux_glibc": [
+ "linux_esid1",
+ "linux_esid2",
+ ],
+ "//build/bazel/platforms/os:linux_musl": [
+ "linux_esid1",
+ "linux_esid2",
+ ],
+ "//conditions:default": [],
+ }) + select({
+ "//build/bazel/platforms/arch:arm": [
+ "lib32_esid1",
+ "lib32_esid2",
+ "arm_esid1",
+ "arm_esid2",
+ ],
+ "//build/bazel/platforms/arch:x86": [
+ "lib32_esid1",
+ "lib32_esid2",
+ ],
+ "//conditions:default": [],
+ }) + [
+ "esid1",
+ "esid2",
+ ]`,
+ "srcs": `["a.cpp"]`,
+ "local_includes": `["."]`,
+ "target_compatible_with": `["//build/bazel/platforms/os:android"]`,
+ }),
+ },
+ )
+}
+
+func TestCcLibraryWithIntegerOverflowProperty(t *testing.T) {
+ runCcLibraryTestCase(t, Bp2buildTestCase{
+ Description: "cc_library has correct features when integer_overflow property is provided",
+ ModuleTypeUnderTest: "cc_library",
+ ModuleTypeUnderTestFactory: cc.LibraryFactory,
+ Blueprint: `
+cc_library {
+ name: "foo",
+ sanitize: {
+ integer_overflow: true,
+ },
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("cc_library_static", "foo_bp2build_cc_library_static", AttrNameToString{
+ "features": `["ubsan_integer_overflow"]`,
+ "local_includes": `["."]`,
+ }),
+ MakeBazelTarget("cc_library_shared", "foo", AttrNameToString{
+ "features": `["ubsan_integer_overflow"]`,
+ "local_includes": `["."]`,
+ }),
+ },
+ })
+}
+
+func TestCcLibraryWithMiscUndefinedProperty(t *testing.T) {
+ runCcLibraryTestCase(t, Bp2buildTestCase{
+ Description: "cc_library has correct features when misc_undefined property is provided",
+ ModuleTypeUnderTest: "cc_library",
+ ModuleTypeUnderTestFactory: cc.LibraryFactory,
+ Blueprint: `
+cc_library {
+ name: "foo",
+ sanitize: {
+ misc_undefined: ["undefined", "nullability"],
+ },
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("cc_library_static", "foo_bp2build_cc_library_static", AttrNameToString{
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ]`,
+ "local_includes": `["."]`,
+ }),
+ MakeBazelTarget("cc_library_shared", "foo", AttrNameToString{
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ]`,
+ "local_includes": `["."]`,
+ }),
+ },
+ })
+}
+
+func TestCcLibraryWithUBSanPropertiesArchSpecific(t *testing.T) {
+ runCcLibraryTestCase(t, Bp2buildTestCase{
+ Description: "cc_library has correct feature select when UBSan props are specified in arch specific blocks",
+ ModuleTypeUnderTest: "cc_library",
+ ModuleTypeUnderTestFactory: cc.LibraryFactory,
+ Blueprint: `
+cc_library {
+ name: "foo",
+ sanitize: {
+ misc_undefined: ["undefined", "nullability"],
+ },
+ target: {
+ android: {
+ sanitize: {
+ misc_undefined: ["alignment"],
+ },
+ },
+ linux_glibc: {
+ sanitize: {
+ integer_overflow: true,
+ },
+ },
+ },
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("cc_library_static", "foo_bp2build_cc_library_static", AttrNameToString{
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ] + select({
+ "//build/bazel/platforms/os:android": ["ubsan_alignment"],
+ "//build/bazel/platforms/os:linux_glibc": ["ubsan_integer_overflow"],
+ "//conditions:default": [],
+ })`,
+ "local_includes": `["."]`,
+ }),
+ MakeBazelTarget("cc_library_shared", "foo", AttrNameToString{
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ] + select({
+ "//build/bazel/platforms/os:android": ["ubsan_alignment"],
+ "//build/bazel/platforms/os:linux_glibc": ["ubsan_integer_overflow"],
+ "//conditions:default": [],
+ })`,
+ "local_includes": `["."]`,
+ }),
+ },
+ })
+}
diff --git a/bp2build/cc_library_shared_conversion_test.go b/bp2build/cc_library_shared_conversion_test.go
index 14b6f0d..017df6f 100644
--- a/bp2build/cc_library_shared_conversion_test.go
+++ b/bp2build/cc_library_shared_conversion_test.go
@@ -885,3 +885,85 @@
},
})
}
+
+func TestCcLibrarySharedWithIntegerOverflowProperty(t *testing.T) {
+ runCcLibrarySharedTestCase(t, Bp2buildTestCase{
+ Description: "cc_library_shared has correct features when integer_overflow property is provided",
+ Blueprint: `
+cc_library_shared {
+ name: "foo",
+ sanitize: {
+ integer_overflow: true,
+ },
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("cc_library_shared", "foo", AttrNameToString{
+ "features": `["ubsan_integer_overflow"]`,
+ "local_includes": `["."]`,
+ }),
+ },
+ })
+}
+
+func TestCcLibrarySharedWithMiscUndefinedProperty(t *testing.T) {
+ runCcLibrarySharedTestCase(t, Bp2buildTestCase{
+ Description: "cc_library_shared has correct features when misc_undefined property is provided",
+ Blueprint: `
+cc_library_shared {
+ name: "foo",
+ sanitize: {
+ misc_undefined: ["undefined", "nullability"],
+ },
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("cc_library_shared", "foo", AttrNameToString{
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ]`,
+ "local_includes": `["."]`,
+ }),
+ },
+ })
+}
+
+func TestCcLibrarySharedWithUBSanPropertiesArchSpecific(t *testing.T) {
+ runCcLibrarySharedTestCase(t, Bp2buildTestCase{
+ Description: "cc_library_shared has correct feature select when UBSan props are specified in arch specific blocks",
+ Blueprint: `
+cc_library_shared {
+ name: "foo",
+ sanitize: {
+ misc_undefined: ["undefined", "nullability"],
+ },
+ target: {
+ android: {
+ sanitize: {
+ misc_undefined: ["alignment"],
+ },
+ },
+ linux_glibc: {
+ sanitize: {
+ integer_overflow: true,
+ },
+ },
+ },
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("cc_library_shared", "foo", AttrNameToString{
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ] + select({
+ "//build/bazel/platforms/os:android": ["ubsan_alignment"],
+ "//build/bazel/platforms/os:linux_glibc": ["ubsan_integer_overflow"],
+ "//conditions:default": [],
+ })`,
+ "local_includes": `["."]`,
+ }),
+ },
+ })
+}
diff --git a/bp2build/cc_library_static_conversion_test.go b/bp2build/cc_library_static_conversion_test.go
index b47d1f1..5a1260f 100644
--- a/bp2build/cc_library_static_conversion_test.go
+++ b/bp2build/cc_library_static_conversion_test.go
@@ -1723,3 +1723,85 @@
},
})
}
+
+func TestCcLibraryStaticWithIntegerOverflowProperty(t *testing.T) {
+ runCcLibraryStaticTestCase(t, Bp2buildTestCase{
+ Description: "cc_library_static has correct features when integer_overflow property is provided",
+ Blueprint: `
+cc_library_static {
+ name: "foo",
+ sanitize: {
+ integer_overflow: true,
+ },
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("cc_library_static", "foo", AttrNameToString{
+ "features": `["ubsan_integer_overflow"]`,
+ "local_includes": `["."]`,
+ }),
+ },
+ })
+}
+
+func TestCcLibraryStaticWithMiscUndefinedProperty(t *testing.T) {
+ runCcLibraryStaticTestCase(t, Bp2buildTestCase{
+ Description: "cc_library_static has correct features when misc_undefined property is provided",
+ Blueprint: `
+cc_library_static {
+ name: "foo",
+ sanitize: {
+ misc_undefined: ["undefined", "nullability"],
+ },
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("cc_library_static", "foo", AttrNameToString{
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ]`,
+ "local_includes": `["."]`,
+ }),
+ },
+ })
+}
+
+func TestCcLibraryStaticWithUBSanPropertiesArchSpecific(t *testing.T) {
+ runCcLibraryStaticTestCase(t, Bp2buildTestCase{
+ Description: "cc_library_static has correct feature select when UBSan props are specified in arch specific blocks",
+ Blueprint: `
+cc_library_static {
+ name: "foo",
+ sanitize: {
+ misc_undefined: ["undefined", "nullability"],
+ },
+ target: {
+ android: {
+ sanitize: {
+ misc_undefined: ["alignment"],
+ },
+ },
+ linux_glibc: {
+ sanitize: {
+ integer_overflow: true,
+ },
+ },
+ },
+}
+`,
+ ExpectedBazelTargets: []string{
+ MakeBazelTarget("cc_library_static", "foo", AttrNameToString{
+ "features": `[
+ "ubsan_undefined",
+ "ubsan_nullability",
+ ] + select({
+ "//build/bazel/platforms/os:android": ["ubsan_alignment"],
+ "//build/bazel/platforms/os:linux_glibc": ["ubsan_integer_overflow"],
+ "//conditions:default": [],
+ })`,
+ "local_includes": `["."]`,
+ }),
+ },
+ })
+}
diff --git a/bp2build/configurability.go b/bp2build/configurability.go
index 112755b..c630965 100644
--- a/bp2build/configurability.go
+++ b/bp2build/configurability.go
@@ -39,7 +39,7 @@
func getStringListValues(list bazel.StringListAttribute) (reflect.Value, []selects, bool) {
value := reflect.ValueOf(list.Value)
- prepend := reflect.ValueOf(list.Prepend).Bool()
+ prepend := list.Prepend
if !list.HasConfigurableValues() {
return value, []selects{}, prepend
}
diff --git a/bp2build/droidstubs_conversion_test.go b/bp2build/droidstubs_conversion_test.go
new file mode 100644
index 0000000..12c1cfe
--- /dev/null
+++ b/bp2build/droidstubs_conversion_test.go
@@ -0,0 +1,104 @@
+// Copyright 2022 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package bp2build
+
+import (
+ "testing"
+
+ "android/soong/android"
+ "android/soong/java"
+)
+
+func registerJavaApiModules(ctx android.RegistrationContext) {
+ java.RegisterSdkLibraryBuildComponents(ctx)
+ java.RegisterStubsBuildComponents(ctx)
+}
+
+func TestDroidstubsApiContributions(t *testing.T) {
+ bp := `
+ droidstubs {
+ name: "framework-stubs",
+ check_api: {
+ current: {
+ api_file: "framework.current.txt",
+ },
+ },
+ }
+
+ // Modules without check_api should not generate a Bazel API target
+ droidstubs {
+ name: "framework-docs",
+ }
+
+ // java_sdk_library is a macro that creates droidstubs
+ java_sdk_library {
+ name: "module-stubs",
+ srcs: ["A.java"],
+
+ // These api surfaces are added by default, but add them explicitly to make
+ // this test hermetic
+ public: {
+ enabled: true,
+ },
+ system: {
+ enabled: true,
+ },
+
+ // Disable other api surfaces to keep unit test scope limited
+ module_lib: {
+ enabled: false,
+ },
+ test: {
+ enabled: false,
+ },
+ }
+ `
+ expectedBazelTargets := []string{
+ MakeBazelTargetNoRestrictions(
+ "java_api_contribution",
+ "framework-stubs.contribution",
+ AttrNameToString{
+ "api": `"framework.current.txt"`,
+ "api_surface": `"publicapi"`,
+ "target_compatible_with": `["//build/bazel/platforms/os:android"]`,
+ }),
+ MakeBazelTargetNoRestrictions(
+ "java_api_contribution",
+ "module-stubs.stubs.source.contribution",
+ AttrNameToString{
+ "api": `"api/current.txt"`,
+ "api_surface": `"publicapi"`,
+ "target_compatible_with": `["//build/bazel/platforms/os:android"]`,
+ }),
+ MakeBazelTargetNoRestrictions(
+ "java_api_contribution",
+ "module-stubs.stubs.source.system.contribution",
+ AttrNameToString{
+ "api": `"api/system-current.txt"`,
+ "api_surface": `"systemapi"`,
+ "target_compatible_with": `["//build/bazel/platforms/os:android"]`,
+ }),
+ }
+ RunApiBp2BuildTestCase(t, registerJavaApiModules, Bp2buildTestCase{
+ Blueprint: bp,
+ ExpectedBazelTargets: expectedBazelTargets,
+ Filesystem: map[string]string{
+ "api/current.txt": "",
+ "api/removed.txt": "",
+ "api/system-current.txt": "",
+ "api/system-removed.txt": "",
+ },
+ })
+}
diff --git a/bp2build/soong_config_module_type_conversion_test.go b/bp2build/soong_config_module_type_conversion_test.go
index a94b2b9..7029b93 100644
--- a/bp2build/soong_config_module_type_conversion_test.go
+++ b/bp2build/soong_config_module_type_conversion_test.go
@@ -17,6 +17,7 @@
import (
"android/soong/android"
"android/soong/cc"
+ "fmt"
"testing"
)
@@ -36,6 +37,29 @@
ctx.RegisterModuleType("cc_library", cc.LibraryFactory)
}
+func TestErrorInBpFileDoesNotPanic(t *testing.T) {
+ bp := `
+soong_config_module_type {
+ name: "library_linking_strategy_cc_defaults",
+ module_type: "cc_defaults",
+ config_namespace: "ANDROID",
+ variables: ["library_linking_strategy"],
+ properties: [
+ "shared_libs",
+ "static_libs",
+ ],
+}
+`
+
+ runSoongConfigModuleTypeTest(t, Bp2buildTestCase{
+ Description: "soong config variables - generates selects for library_linking_strategy",
+ ModuleTypeUnderTest: "cc_binary",
+ ModuleTypeUnderTestFactory: cc.BinaryFactory,
+ Blueprint: bp,
+ ExpectedErr: fmt.Errorf(`unknown variable "library_linking_strategy" in module type "library_linking_strategy_cc_defaults`),
+ })
+}
+
func TestSoongConfigModuleType(t *testing.T) {
bp := `
soong_config_module_type {
diff --git a/cc/bp2build.go b/cc/bp2build.go
index 66157ae..a7ee5d1 100644
--- a/cc/bp2build.go
+++ b/cc/bp2build.go
@@ -354,7 +354,7 @@
compilerAttributes
linkerAttributes
- // A combination of compilerAttributes.features and linkerAttributes.features
+ // A combination of compilerAttributes.features and linkerAttributes.features, as well as sanitizer features
features bazel.StringListAttribute
protoDependency *bazel.LabelAttribute
aidlDependency *bazel.LabelAttribute
@@ -804,7 +804,7 @@
(&linkerAttrs).wholeArchiveDeps.Add(bp2buildCcSysprop(ctx, module.Name(), module.Properties.Min_sdk_version, compilerAttrs.syspropSrcs))
}
- features := compilerAttrs.features.Clone().Append(linkerAttrs.features)
+ features := compilerAttrs.features.Clone().Append(linkerAttrs.features).Append(bp2buildSanitizerFeatures(ctx, module))
features.DeduplicateAxesFromBase()
return baseAttributes{
@@ -1430,3 +1430,20 @@
return attrs
}
+
+func bp2buildSanitizerFeatures(ctx android.BazelConversionPathContext, m *Module) bazel.StringListAttribute {
+ sanitizerFeatures := bazel.StringListAttribute{}
+ bp2BuildPropParseHelper(ctx, m, &SanitizeProperties{}, func(axis bazel.ConfigurationAxis, config string, props interface{}) {
+ var features []string
+ if sanitizerProps, ok := props.(*SanitizeProperties); ok {
+ if sanitizerProps.Sanitize.Integer_overflow != nil && *sanitizerProps.Sanitize.Integer_overflow {
+ features = append(features, "ubsan_integer_overflow")
+ }
+ for _, sanitizer := range sanitizerProps.Sanitize.Misc_undefined {
+ features = append(features, "ubsan_"+sanitizer)
+ }
+ sanitizerFeatures.SetSelectValue(axis, config, features)
+ }
+ })
+ return sanitizerFeatures
+}
diff --git a/cc/cc.go b/cc/cc.go
index 6ca2575..1611b7d 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -1873,8 +1873,11 @@
return false
}
- // Enable mixed builds as long as the cc_* module type has a bazel handler.
- return c.bazelHandler != nil
+ // TODO(b/261058727): Remove this (enable mixed builds for modules with UBSan)
+ ubsanEnabled := c.sanitize != nil &&
+ ((c.sanitize.Properties.Sanitize.Integer_overflow != nil && *c.sanitize.Properties.Sanitize.Integer_overflow) ||
+ c.sanitize.Properties.Sanitize.Misc_undefined != nil)
+ return c.bazelHandler != nil && !ubsanEnabled
}
func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
diff --git a/cc/config/global.go b/cc/config/global.go
index a4e2975..e78839b 100644
--- a/cc/config/global.go
+++ b/cc/config/global.go
@@ -294,8 +294,8 @@
}
llvmNextExtraCommonGlobalCflags = []string{
- // New warnings to be fixed after clang-r475365
- "-Wno-error=single-bit-bitfield-constant-conversion", // http://b/243965903
+ // Do not report warnings when testing with the top of trunk LLVM.
+ "-Wno-error",
}
IllegalFlags = []string{
@@ -344,16 +344,7 @@
exportedVars.ExportStringListStaticVariable("HostGlobalLldflags", hostGlobalLldflags)
// Export the static default CommonGlobalCflags to Bazel.
- // TODO(187086342): handle cflags that are set in VariableFuncs.
- bazelCommonGlobalCflags := append(
- commonGlobalCflags,
- []string{
- // Default to zero initialization.
- "-ftrivial-auto-var-init=zero",
- "-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang",
- "-Wno-unused-command-line-argument",
- }...)
- exportedVars.ExportStringList("CommonGlobalCflags", bazelCommonGlobalCflags)
+ exportedVars.ExportStringList("CommonGlobalCflags", commonGlobalCflags)
pctx.VariableFunc("CommonGlobalCflags", func(ctx android.PackageVarContext) string {
flags := commonGlobalCflags
diff --git a/cc/sanitize.go b/cc/sanitize.go
index eba709b..8e2d161 100644
--- a/cc/sanitize.go
+++ b/cc/sanitize.go
@@ -630,15 +630,8 @@
// Also disable CFI for VNDK variants of components
if ctx.isVndk() && ctx.useVndk() {
- if ctx.static() {
- // Cfi variant for static vndk should be captured as vendor snapshot,
- // so don't strictly disable Cfi.
- s.Cfi = nil
- s.Diag.Cfi = nil
- } else {
- s.Cfi = nil
- s.Diag.Cfi = nil
- }
+ s.Cfi = nil
+ s.Diag.Cfi = nil
}
// HWASan ramdisk (which is built from recovery) goes over some bootloader limit.
@@ -1067,6 +1060,11 @@
// as vendor snapshot. Such modules must create both cfi and non-cfi variants,
// except for ones which explicitly disable cfi.
func needsCfiForVendorSnapshot(mctx android.BaseModuleContext) bool {
+ if inList("hwaddress", mctx.Config().SanitizeDevice()) {
+ // cfi will not be built if SANITIZE_TARGET=hwaddress is set
+ return false
+ }
+
if snapshot.IsVendorProprietaryModule(mctx) {
return false
}
@@ -1163,10 +1161,12 @@
//TODO: When Rust modules have vendor support, enable this path for PlatformSanitizeable
// Check if it's a snapshot module supporting sanitizer
- if ss, ok := c.linker.(snapshotSanitizer); ok && ss.isSanitizerAvailable(s.sanitizer) {
- return []string{"", s.sanitizer.variationName()}
- } else {
- return []string{""}
+ if ss, ok := c.linker.(snapshotSanitizer); ok {
+ if ss.isSanitizerAvailable(s.sanitizer) {
+ return []string{"", s.sanitizer.variationName()}
+ } else {
+ return []string{""}
+ }
}
}
diff --git a/cc/snapshot_prebuilt.go b/cc/snapshot_prebuilt.go
index 570300b..32878ca 100644
--- a/cc/snapshot_prebuilt.go
+++ b/cc/snapshot_prebuilt.go
@@ -801,6 +801,10 @@
prebuilt.Init(module, VendorSnapshotImageSingleton, snapshotObjectSuffix)
module.AddProperties(&prebuilt.properties)
+
+ // vendor_snapshot_object module does not provide sanitizer variants
+ module.sanitize.Properties.Sanitize.Never = BoolPtr(true)
+
return module.Init()
}
diff --git a/cc/vendor_snapshot.go b/cc/vendor_snapshot.go
index 2dcf26e..9b12bfa 100644
--- a/cc/vendor_snapshot.go
+++ b/cc/vendor_snapshot.go
@@ -93,17 +93,18 @@
// Libraries
if sanitizable, ok := m.(PlatformSanitizeable); ok && sanitizable.IsSnapshotLibrary() {
if sanitizable.SanitizePropDefined() {
- // scs and hwasan export both sanitized and unsanitized variants for static and header
- // Always use unsanitized variants of them.
- for _, t := range []SanitizerType{scs, Hwasan} {
- if !sanitizable.Shared() && sanitizable.IsSanitizerEnabled(t) {
- return false
- }
+ // scs exports both sanitized and unsanitized variants for static and header
+ // Always use unsanitized variant of it.
+ if !sanitizable.Shared() && sanitizable.IsSanitizerEnabled(scs) {
+ return false
}
- // cfi also exports both variants. But for static, we capture both.
+ // cfi and hwasan also export both variants. But for static, we capture both.
// This is because cfi static libraries can't be linked from non-cfi modules,
- // and vice versa. This isn't the case for scs and hwasan sanitizers.
- if !sanitizable.Static() && !sanitizable.Shared() && sanitizable.IsSanitizerEnabled(cfi) {
+ // and vice versa.
+ // hwasan is captured as well to support hwasan build.
+ if !sanitizable.Static() &&
+ !sanitizable.Shared() &&
+ (sanitizable.IsSanitizerEnabled(cfi) || sanitizable.IsSanitizerEnabled(Hwasan)) {
return false
}
}
@@ -303,14 +304,22 @@
libPath := m.OutputFile().Path()
stem = libPath.Base()
if sanitizable, ok := m.(PlatformSanitizeable); ok {
- if (sanitizable.Static() || sanitizable.Rlib()) && sanitizable.SanitizePropDefined() && sanitizable.IsSanitizerEnabled(cfi) {
- // both cfi and non-cfi variant for static libraries can exist.
- // attach .cfi to distinguish between cfi and non-cfi.
- // e.g. libbase.a -> libbase.cfi.a
- ext := filepath.Ext(stem)
- stem = strings.TrimSuffix(stem, ext) + ".cfi" + ext
- prop.Sanitize = "cfi"
- prop.ModuleName += ".cfi"
+ if (sanitizable.Static() || sanitizable.Rlib()) && sanitizable.SanitizePropDefined() {
+ if sanitizable.IsSanitizerEnabled(cfi) {
+ // both cfi and non-cfi variant for static libraries can exist.
+ // attach .cfi to distinguish between cfi and non-cfi.
+ // e.g. libbase.a -> libbase.cfi.a
+ ext := filepath.Ext(stem)
+ stem = strings.TrimSuffix(stem, ext) + ".cfi" + ext
+ prop.Sanitize = "cfi"
+ prop.ModuleName += ".cfi"
+ } else if sanitizable.IsSanitizerEnabled(Hwasan) {
+ // Same for the hwasan
+ ext := filepath.Ext(stem)
+ stem = strings.TrimSuffix(stem, ext) + ".hwasan" + ext
+ prop.Sanitize = "hwasan"
+ prop.ModuleName += ".hwasan"
+ }
}
}
snapshotLibOut := filepath.Join(snapshotArchDir, targetArch, libType, stem)
diff --git a/cc/vendor_snapshot_test.go b/cc/vendor_snapshot_test.go
index 79405e9..619500e 100644
--- a/cc/vendor_snapshot_test.go
+++ b/cc/vendor_snapshot_test.go
@@ -1050,6 +1050,12 @@
"libsnapshot",
"note_memtag_heap_sync",
],
+ objects: [
+ "snapshot_object",
+ ],
+ vndk_libs: [
+ "libclang_rt.hwasan",
+ ],
},
},
}
@@ -1084,6 +1090,35 @@
},
}
+ vndk_prebuilt_shared {
+ name: "libclang_rt.hwasan",
+ version: "28",
+ target_arch: "arm64",
+ vendor_available: true,
+ product_available: true,
+ vndk: {
+ enabled: true,
+ },
+ arch: {
+ arm64: {
+ srcs: ["libclang_rt.hwasan.so"],
+ },
+ },
+ }
+
+ vendor_snapshot_object {
+ name: "snapshot_object",
+ vendor: true,
+ target_arch: "arm64",
+ version: "28",
+ arch: {
+ arm64: {
+ src: "snapshot_object.o",
+ },
+ },
+ stl: "none",
+ }
+
cc_test {
name: "vstest",
gtest: false,
@@ -1100,15 +1135,18 @@
mockFS := map[string][]byte{
"vendor/Android.bp": []byte(bp),
"vendor/libc++demangle.a": nil,
+ "vendor/libclang_rt.hwasan.so": nil,
"vendor/libsnapshot.a": nil,
"vendor/libsnapshot.cfi.a": nil,
"vendor/libsnapshot.hwasan.a": nil,
"vendor/note_memtag_heap_sync.a": nil,
+ "vendor/snapshot_object.o": nil,
}
config := TestConfig(t.TempDir(), android.Android, nil, "", mockFS)
config.TestProductVariables.DeviceVndkVersion = StringPtr("28")
config.TestProductVariables.Platform_vndk_version = StringPtr("29")
+ config.TestProductVariables.SanitizeDevice = []string{"hwaddress"}
ctx := testCcWithConfig(t, config)
// Check non-cfi, cfi and hwasan variant.
@@ -1130,6 +1168,11 @@
if !staticHwasanCfiModule.HiddenFromMake() || !staticHwasanCfiModule.PreventInstall() {
t.Errorf("Hwasan and Cfi cannot enabled at the same time.")
}
+
+ snapshotObjModule := ctx.ModuleForTests("snapshot_object.vendor_object.28.arm64", "android_vendor.28_arm64_armv8-a").Module()
+ snapshotObjMkEntries := android.AndroidMkEntriesForTest(t, ctx, snapshotObjModule)
+ // snapshot object must not add ".hwasan" suffix
+ assertString(t, snapshotObjMkEntries[0].EntryMap["LOCAL_MODULE"][0], "snapshot_object")
}
func TestVendorSnapshotExclude(t *testing.T) {
diff --git a/cc/vndk.go b/cc/vndk.go
index 4cd4d42..6ab4734 100644
--- a/cc/vndk.go
+++ b/cc/vndk.go
@@ -368,7 +368,10 @@
}
return m.ImageVariation().Variation == android.CoreVariation && lib.shared() && m.IsVndkSp() && !m.IsVndkExt()
}
-
+ // VNDK APEX doesn't need stub variants
+ if lib.buildStubs() {
+ return false
+ }
useCoreVariant := m.VndkVersion() == mctx.DeviceConfig().PlatformVndkVersion() &&
mctx.DeviceConfig().VndkUseCoreVariant() && !m.MustUseVendorVariant()
return lib.shared() && m.InVendor() && m.IsVndk() && !m.IsVndkExt() && !useCoreVariant
diff --git a/etc/prebuilt_etc.go b/etc/prebuilt_etc.go
index baad58e..b0660df 100644
--- a/etc/prebuilt_etc.go
+++ b/etc/prebuilt_etc.go
@@ -54,6 +54,7 @@
func RegisterPrebuiltEtcBuildComponents(ctx android.RegistrationContext) {
ctx.RegisterModuleType("prebuilt_etc", PrebuiltEtcFactory)
ctx.RegisterModuleType("prebuilt_etc_host", PrebuiltEtcHostFactory)
+ ctx.RegisterModuleType("prebuilt_etc_cacerts", PrebuiltEtcCaCertsFactory)
ctx.RegisterModuleType("prebuilt_root", PrebuiltRootFactory)
ctx.RegisterModuleType("prebuilt_root_host", PrebuiltRootHostFactory)
ctx.RegisterModuleType("prebuilt_usr_share", PrebuiltUserShareFactory)
@@ -455,6 +456,17 @@
return module
}
+// prebuilt_etc_host is for a host prebuilt artifact that is installed in
+// <partition>/etc/<sub_dir> directory.
+func PrebuiltEtcCaCertsFactory() android.Module {
+ module := &PrebuiltEtc{}
+ InitPrebuiltEtcModule(module, "cacerts")
+ // This module is device-only
+ android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibFirst)
+ android.InitBazelModule(module)
+ return module
+}
+
// prebuilt_root is for a prebuilt artifact that is installed in
// <partition>/ directory. Can't have any sub directories.
func PrebuiltRootFactory() android.Module {
diff --git a/filesystem/filesystem.go b/filesystem/filesystem.go
index 1365d4a..d01608f 100644
--- a/filesystem/filesystem.go
+++ b/filesystem/filesystem.go
@@ -72,6 +72,9 @@
// Hash and signing algorithm for avbtool. Default is SHA256_RSA4096.
Avb_algorithm *string
+ // Hash and signing algorithm for avbtool. Default is SHA256_RSA4096.
+ Avb_hash_algorithm *string
+
// Name of the partition stored in vbmeta desc. Defaults to the name of this module.
Partition_name *string
@@ -261,6 +264,14 @@
Input(rootZip).
Input(rebasedDepsZip)
+ // run host_init_verifier
+ // Ideally we should have a concept of pluggable linters that verify the generated image.
+ // While such concept is not implement this will do.
+ // TODO(b/263574231): substitute with pluggable linter.
+ builder.Command().
+ BuiltTool("host_init_verifier").
+ FlagWithArg("--out_system=", rootDir.String()+"/system")
+
propFile, toolDeps := f.buildPropFile(ctx)
output := android.PathForModuleOut(ctx, f.installFileName()).OutputPath
builder.Command().BuiltTool("build_image").
@@ -333,7 +344,11 @@
addStr("avb_algorithm", algorithm)
key := android.PathForModuleSrc(ctx, proptools.String(f.properties.Avb_private_key))
addPath("avb_key_path", key)
- addStr("avb_add_hashtree_footer_args", "--do_not_generate_fec")
+ avb_add_hashtree_footer_args := "--do_not_generate_fec"
+ if hashAlgorithm := proptools.String(f.properties.Avb_hash_algorithm); hashAlgorithm != "" {
+ avb_add_hashtree_footer_args += " --hash_algorithm " + hashAlgorithm
+ }
+ addStr("avb_add_hashtree_footer_args", avb_add_hashtree_footer_args)
partitionName := proptools.StringDefault(f.properties.Partition_name, f.Name())
addStr("partition_name", partitionName)
addStr("avb_salt", f.salt())
diff --git a/java/aar.go b/java/aar.go
index 8a83792..ccd68cd 100644
--- a/java/aar.go
+++ b/java/aar.go
@@ -525,7 +525,7 @@
if sdkDep.hasFrameworkLibs() {
a.aapt.deps(ctx, sdkDep)
}
- a.usesLibrary.deps(ctx, sdkDep.hasFrameworkLibs())
+ a.usesLibrary.deps(ctx, false)
}
func (a *AndroidLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
diff --git a/java/app.go b/java/app.go
index eb1b474..df6698d 100755
--- a/java/app.go
+++ b/java/app.go
@@ -1295,14 +1295,14 @@
}
}
-func (u *usesLibrary) deps(ctx android.BottomUpMutatorContext, hasFrameworkLibs bool) {
+func (u *usesLibrary) deps(ctx android.BottomUpMutatorContext, addCompatDeps bool) {
if !ctx.Config().UnbundledBuild() || ctx.Config().UnbundledBuildImage() {
ctx.AddVariationDependencies(nil, usesLibReqTag, u.usesLibraryProperties.Uses_libs...)
ctx.AddVariationDependencies(nil, usesLibOptTag, u.presentOptionalUsesLibs(ctx)...)
- // Only add these extra dependencies if the module depends on framework libs. This avoids
- // creating a cyclic dependency:
+ // Only add these extra dependencies if the module is an app that depends on framework
+ // libs. This avoids creating a cyclic dependency:
// e.g. framework-res -> org.apache.http.legacy -> ... -> framework-res.
- if hasFrameworkLibs {
+ if addCompatDeps {
// Dexpreopt needs paths to the dex jars of these libraries in order to construct
// class loader context for dex2oat. Add them as a dependency with a special tag.
ctx.AddVariationDependencies(nil, usesLibCompat29ReqTag, dexpreopt.CompatUsesLibs29...)
diff --git a/java/droiddoc.go b/java/droiddoc.go
index 8a291ad..aa55f37 100644
--- a/java/droiddoc.go
+++ b/java/droiddoc.go
@@ -598,7 +598,7 @@
// Droiddoc always gets "-source 1.8" because it doesn't support 1.9 sources. For modules with 1.9
// sources, droiddoc will get sources produced by metalava which will have already stripped out the
// 1.9 language features.
- cmd.FlagWithArg("-source ", "1.8").
+ cmd.FlagWithArg("-source ", getStubsJavaVersion().String()).
Flag("-J-Xmx1600m").
Flag("-J-XX:-OmitStackTraceInFastThrow").
Flag("-XDignore.symbol.file").
diff --git a/java/droidstubs.go b/java/droidstubs.go
index 5777b18..2ad2969 100644
--- a/java/droidstubs.go
+++ b/java/droidstubs.go
@@ -18,11 +18,13 @@
"fmt"
"path/filepath"
"regexp"
+ "sort"
"strings"
"github.com/google/blueprint/proptools"
"android/soong/android"
+ "android/soong/bazel"
"android/soong/java/config"
"android/soong/remoteexec"
)
@@ -834,6 +836,74 @@
}
}
+var _ android.ApiProvider = (*Droidstubs)(nil)
+
+type bazelJavaApiContributionAttributes struct {
+ Api bazel.LabelAttribute
+ Api_surface *string
+}
+
+func (d *Droidstubs) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) {
+ props := bazel.BazelTargetModuleProperties{
+ Rule_class: "java_api_contribution",
+ Bzl_load_location: "//build/bazel/rules/apis:java_api_contribution.bzl",
+ }
+ apiFile := d.properties.Check_api.Current.Api_file
+ // Do not generate a target if check_api is not set
+ if apiFile == nil {
+ return
+ }
+ attrs := &bazelJavaApiContributionAttributes{
+ Api: *bazel.MakeLabelAttribute(
+ android.BazelLabelForModuleSrcSingle(ctx, proptools.String(apiFile)).Label,
+ ),
+ Api_surface: proptools.StringPtr(bazelApiSurfaceName(d.Name())),
+ }
+ ctx.CreateBazelTargetModule(props, android.CommonAttributes{
+ Name: android.ApiContributionTargetName(ctx.ModuleName()),
+ }, attrs)
+}
+
+// TODO (b/262014796): Export the API contributions of CorePlatformApi
+// A map to populate the api surface of a droidstub from a substring appearing in its name
+// This map assumes that droidstubs (either checked-in or created by java_sdk_library)
+// use a strict naming convention
+var (
+ droidstubsModuleNamingToSdkKind = map[string]android.SdkKind{
+ //public is commented out since the core libraries use public in their java_sdk_library names
+ "intracore": android.SdkIntraCore,
+ "intra.core": android.SdkIntraCore,
+ "system_server": android.SdkSystemServer,
+ "system-server": android.SdkSystemServer,
+ "system": android.SdkSystem,
+ "module_lib": android.SdkModule,
+ "module-lib": android.SdkModule,
+ "test": android.SdkTest,
+ }
+)
+
+// A helper function that returns the api surface of the corresponding java_api_contribution Bazel target
+// The api_surface is populated using the naming convention of the droidstubs module.
+func bazelApiSurfaceName(name string) string {
+ // Sort the keys so that longer strings appear first
+ // Otherwise substrings like system will match both system and system_server
+ sortedKeys := make([]string, 0)
+ for key := range droidstubsModuleNamingToSdkKind {
+ sortedKeys = append(sortedKeys, key)
+ }
+ sort.Slice(sortedKeys, func(i, j int) bool {
+ return len(sortedKeys[i]) > len(sortedKeys[j])
+ })
+ for _, sortedKey := range sortedKeys {
+ if strings.Contains(name, sortedKey) {
+ sdkKind := droidstubsModuleNamingToSdkKind[sortedKey]
+ return sdkKind.String() + "api"
+ }
+ }
+ // Default is publicapi
+ return android.SdkPublic.String() + "api"
+}
+
func StubsDefaultsFactory() android.Module {
module := &DocDefaults{}
diff --git a/java/droidstubs_test.go b/java/droidstubs_test.go
index 25f8c86..ef2e6dc 100644
--- a/java/droidstubs_test.go
+++ b/java/droidstubs_test.go
@@ -304,3 +304,45 @@
android.AssertStringDoesContain(t, "sdk-extensions-root present", cmdline, "--sdk-extensions-root sdk/extensions")
android.AssertStringDoesContain(t, "sdk-extensions-info present", cmdline, "--sdk-extensions-info sdk/extensions/info.txt")
}
+
+func TestApiSurfaceFromDroidStubsName(t *testing.T) {
+ testCases := []struct {
+ desc string
+ name string
+ expectedApiSurface string
+ }{
+ {
+ desc: "Default is publicapi",
+ name: "mydroidstubs",
+ expectedApiSurface: "publicapi",
+ },
+ {
+ desc: "name contains system substring",
+ name: "mydroidstubs.system.suffix",
+ expectedApiSurface: "systemapi",
+ },
+ {
+ desc: "name contains system_server substring",
+ name: "mydroidstubs.system_server.suffix",
+ expectedApiSurface: "system-serverapi",
+ },
+ {
+ desc: "name contains module_lib substring",
+ name: "mydroidstubs.module_lib.suffix",
+ expectedApiSurface: "module-libapi",
+ },
+ {
+ desc: "name contains test substring",
+ name: "mydroidstubs.test.suffix",
+ expectedApiSurface: "testapi",
+ },
+ {
+ desc: "name contains intra.core substring",
+ name: "mydroidstubs.intra.core.suffix",
+ expectedApiSurface: "intracoreapi",
+ },
+ }
+ for _, tc := range testCases {
+ android.AssertStringEquals(t, tc.desc, tc.expectedApiSurface, bazelApiSurfaceName(tc.name))
+ }
+}
diff --git a/java/java.go b/java/java.go
index b3abc91..275abbe 100644
--- a/java/java.go
+++ b/java/java.go
@@ -521,6 +521,11 @@
}
}
+// Java version for stubs generation
+func getStubsJavaVersion() javaVersion {
+ return JAVA_VERSION_8
+}
+
type javaVersion int
const (
@@ -1718,6 +1723,7 @@
al.stubsJar = android.PathForModuleOut(ctx, ctx.ModuleName(), "android.jar")
var flags javaBuilderFlags
+ flags.javaVersion = getStubsJavaVersion()
flags.javacFlags = strings.Join(al.properties.Javacflags, " ")
TransformJavaToClasses(ctx, al.stubsJar, 0, android.Paths{},