diff options
41 files changed, 898 insertions, 103 deletions
diff --git a/aconfig/init.go b/aconfig/init.go index 3ed5faf6a..7e283ea47 100644 --- a/aconfig/init.go +++ b/aconfig/init.go @@ -44,6 +44,7 @@ var ( Command: `rm -rf ${out}.tmp` + ` && mkdir -p ${out}.tmp` + ` && ${aconfig} create-java-lib` + + ` --mode ${mode}` + ` --cache ${in}` + ` --out ${out}.tmp` + ` && $soong_zip -write_if_changed -jar -o ${out} -C ${out}.tmp -D ${out}.tmp` + @@ -53,7 +54,7 @@ var ( "$soong_zip", }, Restat: true, - }) + }, "mode") // For java_aconfig_library: Generate java file cppRule = pctx.AndroidStaticRule("cc_aconfig_library", diff --git a/aconfig/java_aconfig_library.go b/aconfig/java_aconfig_library.go index 53b2b10cf..53f8bd1ba 100644 --- a/aconfig/java_aconfig_library.go +++ b/aconfig/java_aconfig_library.go @@ -30,6 +30,9 @@ var declarationsTag = declarationsTagType{} type JavaAconfigDeclarationsLibraryProperties struct { // name of the aconfig_declarations module to generate a library for Aconfig_declarations string + + // whether to generate test mode version of the library + Test bool } type JavaAconfigDeclarationsLibraryCallbacks struct { @@ -61,11 +64,20 @@ func (callbacks *JavaAconfigDeclarationsLibraryCallbacks) GenerateSourceJarBuild // Generate the action to build the srcjar srcJarPath := android.PathForModuleGen(ctx, ctx.ModuleName()+".srcjar") + var mode string + if callbacks.properties.Test { + mode = "test" + } else { + mode = "production" + } ctx.Build(pctx, android.BuildParams{ Rule: javaRule, Input: declarations.IntermediatePath, Output: srcJarPath, Description: "aconfig.srcjar", + Args: map[string]string{ + "mode": mode, + }, }) // Tell the java module about the .aconfig files, so they can be propagated up the dependency chain. diff --git a/aconfig/java_aconfig_library_test.go b/aconfig/java_aconfig_library_test.go index 1808290ee..af50848f1 100644 --- a/aconfig/java_aconfig_library_test.go +++ b/aconfig/java_aconfig_library_test.go @@ -15,6 +15,7 @@ package aconfig import ( + "fmt" "strings" "testing" @@ -152,3 +153,39 @@ func TestAndroidMkBinaryThatLinksAgainstAar(t *testing.T) { runJavaAndroidMkTest(t, bp) } + +func testCodegenMode(t *testing.T, bpMode string, ruleMode string) { + result := android.GroupFixturePreparers( + PrepareForTestWithAconfigBuildComponents, + java.PrepareForTestWithJavaDefaultModules). + ExtendWithErrorHandler(android.FixtureExpectsNoErrors). + RunTestWithBp(t, fmt.Sprintf(` + aconfig_declarations { + name: "my_aconfig_declarations", + package: "com.example.package", + srcs: ["foo.aconfig"], + } + + java_aconfig_library { + name: "my_java_aconfig_library", + aconfig_declarations: "my_aconfig_declarations", + %s + } + `, bpMode)) + + module := result.ModuleForTests("my_java_aconfig_library", "android_common") + rule := module.Rule("java_aconfig_library") + android.AssertStringEquals(t, "rule must contain test mode", rule.Args["mode"], ruleMode) +} + +func TestDefaultProdMode(t *testing.T) { + testCodegenMode(t, "", "production") +} + +func TestProdMode(t *testing.T) { + testCodegenMode(t, "test: false,", "production") +} + +func TestTestMode(t *testing.T) { + testCodegenMode(t, "test: true,", "test") +} diff --git a/android/allowlists/allowlists.go b/android/allowlists/allowlists.go index 71f451b18..69bcd2e4b 100644 --- a/android/allowlists/allowlists.go +++ b/android/allowlists/allowlists.go @@ -917,7 +917,10 @@ var ( "libart_headers", // depends on unconverted modules: art_libartbase_headers "libartbase-art-gtest", // depends on unconverted modules: libgtest_isolated, libart, libart-compiler, libdexfile, libprofile "libartbased-art-gtest", // depends on unconverted modules: libgtest_isolated, libartd, libartd-compiler, libdexfiled, libprofiled + "libart-runtime", // depends on unconverted modules: apex-info-list-tinyxml, libtinyxml2, libnativeloader-headers, heapprofd_client_api, art_operator_srcs, libcpu_features, libodrstatslog, libelffile, art_cmdlineparser_headers, cpp-define-generator-definitions, libdexfile, libnativebridge, libnativeloader, libsigchain, libartbase, libprofile, cpp-define-generator-asm-support + "libart-runtime-for-test", // depends on unconverted modules: apex-info-list-tinyxml, libtinyxml2, libnativeloader-headers, heapprofd_client_api, art_operator_srcs, libcpu_features, libodrstatslog, libelffile, art_cmdlineparser_headers, cpp-define-generator-definitions, libdexfile, libnativebridge, libnativeloader, libsigchain, libartbase, libprofile, cpp-define-generator-asm-support "libartd", // depends on unconverted modules: art_operator_srcs, libcpu_features, libodrstatslog, libelffiled, art_cmdlineparser_headers, cpp-define-generator-definitions, libdexfiled, libnativebridge, libnativeloader, libsigchain, libartbased, libprofiled, cpp-define-generator-asm-support, apex-info-list-tinyxml, libtinyxml2, libnativeloader-headers, heapprofd_client_api + "libartd-runtime", // depends on unconverted modules: art_operator_srcs, libcpu_features, libodrstatslog, libelffiled, art_cmdlineparser_headers, cpp-define-generator-definitions, libdexfiled, libnativebridge, libnativeloader, libsigchain, libartbased, libprofiled, cpp-define-generator-asm-support, apex-info-list-tinyxml, libtinyxml2, libnativeloader-headers, heapprofd_client_api "libartd-runtime-gtest", // depends on unconverted modules: libgtest_isolated, libartd-compiler, libdexfiled, libprofiled, libartbased, libartbased-art-gtest "libdebuggerd", // depends on unconverted module: libdexfile "libdebuggerd_handler", // depends on unconverted module libdebuggerd_handler_core diff --git a/android/config.go b/android/config.go index 2a243eeb9..72ff2247a 100644 --- a/android/config.go +++ b/android/config.go @@ -170,6 +170,19 @@ func (c Config) RunningInsideUnitTest() bool { return c.config.TestProductVariables != nil } +// DisableHiddenApiChecks returns true if hiddenapi checks have been disabled. +// For 'eng' target variant hiddenapi checks are disabled by default for performance optimisation, +// but can be enabled by setting environment variable ENABLE_HIDDENAPI_FLAGS=true. +// For other target variants hiddenapi check are enabled by default but can be disabled by +// setting environment variable UNSAFE_DISABLE_HIDDENAPI_FLAGS=true. +// If both ENABLE_HIDDENAPI_FLAGS=true and UNSAFE_DISABLE_HIDDENAPI_FLAGS=true, then +// ENABLE_HIDDENAPI_FLAGS=true will be triggered and hiddenapi checks will be considered enabled. +func (c Config) DisableHiddenApiChecks() bool { + return !c.IsEnvTrue("ENABLE_HIDDENAPI_FLAGS") && + (c.IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") || + Bool(c.productVariables.Eng)) +} + // MaxPageSizeSupported returns the max page size supported by the device. This // value will define the ELF segment alignment for binaries (executables and // shared libraries). @@ -1909,6 +1922,10 @@ func (c *deviceConfig) RequiresInsecureExecmemForSwiftshader() bool { return c.config.productVariables.RequiresInsecureExecmemForSwiftshader } +func (c *deviceConfig) Release_aidl_use_unfrozen() bool { + return Bool(c.config.productVariables.Release_aidl_use_unfrozen) +} + func (c *config) SelinuxIgnoreNeverallows() bool { return c.productVariables.SelinuxIgnoreNeverallows } diff --git a/android/variable.go b/android/variable.go index f07ab56ec..7fb81b905 100644 --- a/android/variable.go +++ b/android/variable.go @@ -184,6 +184,13 @@ type variableProperties struct { Srcs []string `android:"arch_variant"` Exclude_srcs []string `android:"arch_variant"` } `android:"arch_variant"` + + // release_aidl_use_unfrozen is "true" when a device can + // use the unfrozen versions of AIDL interfaces. + Release_aidl_use_unfrozen struct { + Cflags []string + Cmd *string + } } `android:"arch_variant"` } @@ -462,6 +469,8 @@ type ProductVariables struct { SelinuxIgnoreNeverallows bool `json:",omitempty"` + Release_aidl_use_unfrozen *bool `json:",omitempty"` + SepolicyFreezeTestExtraDirs []string `json:",omitempty"` SepolicyFreezeTestExtraPrebuiltDirs []string `json:",omitempty"` @@ -734,7 +743,9 @@ func (p *ProductConfigProperties) AddEitherProperty( dst = append(dst, src...) (*p)[propertyName][key] = dst default: - panic(fmt.Errorf("TODO: handle merging value %#v", existing)) + if existing != propertyValue { + panic(fmt.Errorf("TODO: handle merging value %#v", existing)) + } } } else { (*p)[propertyName][key] = propertyValue @@ -947,7 +958,7 @@ func (productConfigProperties *ProductConfigProperties) AddSoongConfigProperties productConfigProperties.AddSoongConfigProperty(propertyName, namespace, soongConfigVariableName, soongConfigVariableValue, os.Name, property.Interface()) } } - } else { + } else if !archOrOsSpecificStruct.IsZero() { // One problem with supporting additional fields is that if multiple branches of // "target" overlap, we don't want them to be in the same select statement (aka // configuration axis). "android" and "host" are disjoint, so it's ok that we only diff --git a/apex/apex.go b/apex/apex.go index 325ca002b..b26d1d242 100644 --- a/apex/apex.go +++ b/apex/apex.go @@ -993,7 +993,7 @@ func (a *apexBundle) ApexInfoMutator(mctx android.TopDownMutatorContext) { // the non-system APEXes because the VNDK libraries won't be included (and duped) in the // APEX, but shared across APEXes via the VNDK APEX. useVndk := a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && mctx.Config().EnforceProductPartitionInterface()) - excludeVndkLibs := useVndk && proptools.Bool(a.properties.Use_vndk_as_stable) + excludeVndkLibs := useVndk && a.useVndkAsStable(mctx) if proptools.Bool(a.properties.Use_vndk_as_stable) { if !useVndk { mctx.PropertyErrorf("use_vndk_as_stable", "not supported for system/system_ext APEXes") @@ -2394,7 +2394,7 @@ func (a *apexBundle) depVisitor(vctx *visitorContext, ctx android.ModuleContext, // tags used below are private (e.g. `cc.sharedDepTag`). if cc.IsSharedDepTag(depTag) || cc.IsRuntimeDepTag(depTag) { if ch, ok := child.(*cc.Module); ok { - if ch.UseVndk() && proptools.Bool(a.properties.Use_vndk_as_stable) && ch.IsVndk() { + if ch.UseVndk() && a.useVndkAsStable(ctx) && ch.IsVndk() { vctx.requireNativeLibs = append(vctx.requireNativeLibs, ":vndk") return false } @@ -3716,3 +3716,12 @@ func invalidCompileMultilib(ctx android.TopDownMutatorContext, value string) { func (a *apexBundle) IsTestApex() bool { return a.testApex } + +func (a *apexBundle) useVndkAsStable(ctx android.BaseModuleContext) bool { + // VNDK cannot be linked if it is deprecated + if ctx.Config().IsVndkDeprecated() { + return false + } + + return proptools.Bool(a.properties.Use_vndk_as_stable) +} diff --git a/apex/apex_test.go b/apex/apex_test.go index df138e054..9dba08e46 100644 --- a/apex/apex_test.go +++ b/apex/apex_test.go @@ -3029,7 +3029,11 @@ func TestVendorApex_use_vndk_as_stable(t *testing.T) { vendor: true, shared_libs: ["libvndk", "libvendor"], } - `) + `, + android.FixtureModifyConfig(func(config android.Config) { + config.TestProductVariables.KeepVndk = proptools.BoolPtr(true) + }), + ) vendorVariant := "android_vendor.29_arm64_armv8-a" @@ -6790,6 +6794,10 @@ func TestApexAvailable_ApexAvailableNameWithVersionCode(t *testing.T) { public_key: "testkey.avbpubkey", private_key: "testkey.pem", } + override_apex { + name: "myoverrideapex", + base: "bar", + } `) fooManifestRule := result.ModuleForTests("foo", "android_common_foo_image").Rule("apexManifestRule") @@ -6806,6 +6814,12 @@ func TestApexAvailable_ApexAvailableNameWithVersionCode(t *testing.T) { if barActualDefaultVersion != barExpectedDefaultVersion { t.Errorf("expected to find defaultVersion %q; got %q", barExpectedDefaultVersion, barActualDefaultVersion) } + + overrideBarManifestRule := result.ModuleForTests("bar", "android_common_myoverrideapex_bar_image").Rule("apexManifestRule") + overrideBarActualDefaultVersion := overrideBarManifestRule.Args["default_version"] + if overrideBarActualDefaultVersion != barExpectedDefaultVersion { + t.Errorf("expected to find defaultVersion %q; got %q", barExpectedDefaultVersion, barActualDefaultVersion) + } } func TestApexAvailable_ApexAvailableName(t *testing.T) { diff --git a/bazel/aquery.go b/bazel/aquery.go index 3428328bd..2c080a11a 100644 --- a/bazel/aquery.go +++ b/bazel/aquery.go @@ -459,7 +459,7 @@ func (a *aqueryArtifactHandler) depsetContentHashes(inputDepsetIds []uint32) ([] // escapes the args received from aquery and creates a command string func commandString(actionEntry *analysis_v2_proto.Action) string { switch actionEntry.Mnemonic { - case "GoCompilePkg": + case "GoCompilePkg", "GoStdlib": argsEscaped := []string{} for _, arg := range actionEntry.Arguments { if arg == "" { diff --git a/bp2build/build_conversion.go b/bp2build/build_conversion.go index 0e6596bf7..3de5213b3 100644 --- a/bp2build/build_conversion.go +++ b/bp2build/build_conversion.go @@ -353,7 +353,104 @@ type goAttributes struct { Importpath bazel.StringAttribute Srcs bazel.LabelListAttribute Deps bazel.LabelListAttribute + Data bazel.LabelListAttribute Target_compatible_with bazel.LabelListAttribute + + // attributes for the dynamically generated go_test target + Embed bazel.LabelListAttribute +} + +type goTestProperties struct { + name string + dir string + testSrcs []string + linuxTestSrcs []string + darwinTestSrcs []string + testData []string + // Name of the target that should be compiled together with the test + embedName string +} + +// Creates a go_test target for bootstrap_go_package / blueprint_go_binary +func generateBazelTargetsGoTest(ctx *android.Context, goModulesMap nameToGoLibraryModule, gp goTestProperties) (BazelTarget, error) { + ca := android.CommonAttributes{ + Name: gp.name, + } + ga := goAttributes{ + Srcs: goSrcLabels(ctx.Config(), gp.dir, gp.testSrcs, gp.linuxTestSrcs, gp.darwinTestSrcs), + Data: goSrcLabels(ctx.Config(), gp.dir, gp.testData, []string{}, []string{}), + Embed: bazel.MakeLabelListAttribute( + bazel.MakeLabelList( + []bazel.Label{bazel.Label{Label: ":" + gp.embedName}}, + ), + ), + Target_compatible_with: targetNotCompatibleWithAndroid(), + } + + libTest := goBazelTarget{ + targetName: gp.name, + targetPackage: gp.dir, + bazelRuleClass: "go_test", + bazelRuleLoadLocation: "@io_bazel_rules_go//go:def.bzl", + bazelAttributes: []interface{}{&ca, &ga}, + } + return generateBazelTarget(ctx, libTest) +} + +// TODO - b/288491147: testSrcs of certain bootstrap_go_package/blueprint_go_binary are not hermetic and depend on +// testdata checked into the filesystem. +// Denylist the generation of go_test targets for these Soong modules. +// The go_library/go_binary will still be generated, since those are hermitic. +var ( + goTestsDenylist = []string{ + "android-archive-zip", + "bazel_notice_gen", + "blueprint-bootstrap-bpdoc", + "blueprint-microfactory", + "blueprint-pathtools", + "bssl_ar", + "compliance_checkmetadata", + "compliance_checkshare", + "compliance_dumpgraph", + "compliance_dumpresolutions", + "compliance_listshare", + "compliance-module", + "compliancenotice_bom", + "compliancenotice_shippedlibs", + "compliance_rtrace", + "compliance_sbom", + "golang-protobuf-internal-fuzz-jsonfuzz", + "golang-protobuf-internal-fuzz-textfuzz", + "golang-protobuf-internal-fuzz-wirefuzz", + "htmlnotice", + "protoc-gen-go", + "rbcrun-module", + "spdx-tools-builder", + "spdx-tools-builder2v1", + "spdx-tools-builder2v2", + "spdx-tools-builder2v3", + "spdx-tools-idsearcher", + "spdx-tools-spdx-json", + "spdx-tools-utils", + "soong-ui-build", + "textnotice", + "xmlnotice", + } +) + +func testOfGoPackageIsIncompatible(g *bootstrap.GoPackage) bool { + return android.InList(g.Name(), goTestsDenylist) || + // Denylist tests of soong_build + // Theses tests have a guard that prevent usage outside a test environment + // The guard (`ensureTestOnly`) looks for a `-test` in os.Args, which is present in soong's gotestrunner, but missing in `b test` + g.IsPluginFor("soong_build") || + // soong-android is a dep of soong_build + // This dependency is created by soong_build by listing it in its deps explicitly in Android.bp, and not via `plugin_for` in `soong-android` + g.Name() == "soong-android" +} + +func testOfGoBinaryIsIncompatible(g *bootstrap.GoBinary) bool { + return android.InList(g.Name(), goTestsDenylist) } func generateBazelTargetsGoPackage(ctx *android.Context, g *bootstrap.GoPackage, goModulesMap nameToGoLibraryModule) ([]BazelTarget, []error) { @@ -390,12 +487,33 @@ func generateBazelTargetsGoPackage(ctx *android.Context, g *bootstrap.GoPackage, bazelRuleLoadLocation: "@io_bazel_rules_go//go:def.bzl", bazelAttributes: []interface{}{&ca, &ga}, } - // TODO - b/284483729: Create go_test target from testSrcs - libTarget, err := generateBazelTarget(ctx, lib) - if err != nil { - return []BazelTarget{}, []error{err} + retTargets := []BazelTarget{} + var retErrs []error + if libTarget, err := generateBazelTarget(ctx, lib); err == nil { + retTargets = append(retTargets, libTarget) + } else { + retErrs = []error{err} } - return []BazelTarget{libTarget}, nil + + // If the library contains test srcs, create an additional go_test target + if !testOfGoPackageIsIncompatible(g) && (len(g.TestSrcs()) > 0 || len(g.LinuxTestSrcs()) > 0 || len(g.DarwinTestSrcs()) > 0) { + gp := goTestProperties{ + name: g.Name() + "-test", + dir: ctx.ModuleDir(g), + testSrcs: g.TestSrcs(), + linuxTestSrcs: g.LinuxTestSrcs(), + darwinTestSrcs: g.DarwinTestSrcs(), + testData: g.TestData(), + embedName: g.Name(), // embed the source go_library in the test so that its .go files are included in the compilation unit + } + if libTestTarget, err := generateBazelTargetsGoTest(ctx, goModulesMap, gp); err == nil { + retTargets = append(retTargets, libTestTarget) + } else { + retErrs = append(retErrs, err) + } + } + + return retTargets, retErrs } type goLibraryModule struct { @@ -440,6 +558,9 @@ func generateBazelTargetsGoBinary(ctx *android.Context, g *bootstrap.GoBinary, g Name: g.Name(), } + retTargets := []BazelTarget{} + var retErrs []error + // For this bootstrap_go_package dep chain, // A --> B --> C ( ---> depends on) // Soong provides the convenience of only listing B as deps of A even if a src file of A imports C @@ -450,12 +571,70 @@ func generateBazelTargetsGoBinary(ctx *android.Context, g *bootstrap.GoBinary, g // bp2build does not have sufficient info on whether C is a direct dep of A or not, so for now collect all transitive deps and add them to deps transitiveDeps := transitiveGoDeps(g.Deps(), goModulesMap) + goSource := "" + // If the library contains test srcs, create an additional go_test target + // The go_test target will embed a go_source containining the source .go files it tests + if !testOfGoBinaryIsIncompatible(g) && (len(g.TestSrcs()) > 0 || len(g.LinuxTestSrcs()) > 0 || len(g.DarwinTestSrcs()) > 0) { + // Create a go_source containing the source .go files of go_library + // This target will be an `embed` of the go_binary and go_test + goSource = g.Name() + "-source" + ca := android.CommonAttributes{ + Name: goSource, + } + ga := goAttributes{ + Srcs: goSrcLabels(ctx.Config(), ctx.ModuleDir(g), g.Srcs(), g.LinuxSrcs(), g.DarwinSrcs()), + Deps: goDepLabels(transitiveDeps, goModulesMap), + Target_compatible_with: targetNotCompatibleWithAndroid(), + } + libTestSource := goBazelTarget{ + targetName: goSource, + targetPackage: ctx.ModuleDir(g), + bazelRuleClass: "go_source", + bazelRuleLoadLocation: "@io_bazel_rules_go//go:def.bzl", + bazelAttributes: []interface{}{&ca, &ga}, + } + if libSourceTarget, err := generateBazelTarget(ctx, libTestSource); err == nil { + retTargets = append(retTargets, libSourceTarget) + } else { + retErrs = append(retErrs, err) + } + + // Create a go_test target + gp := goTestProperties{ + name: g.Name() + "-test", + dir: ctx.ModuleDir(g), + testSrcs: g.TestSrcs(), + linuxTestSrcs: g.LinuxTestSrcs(), + darwinTestSrcs: g.DarwinTestSrcs(), + testData: g.TestData(), + // embed the go_source in the test + embedName: g.Name() + "-source", + } + if libTestTarget, err := generateBazelTargetsGoTest(ctx, goModulesMap, gp); err == nil { + retTargets = append(retTargets, libTestTarget) + } else { + retErrs = append(retErrs, err) + } + + } + + // Create a go_binary target ga := goAttributes{ - Srcs: goSrcLabels(ctx.Config(), ctx.ModuleDir(g), g.Srcs(), g.LinuxSrcs(), g.DarwinSrcs()), Deps: goDepLabels(transitiveDeps, goModulesMap), Target_compatible_with: targetNotCompatibleWithAndroid(), } + // If the binary has testSrcs, embed the common `go_source` + if goSource != "" { + ga.Embed = bazel.MakeLabelListAttribute( + bazel.MakeLabelList( + []bazel.Label{bazel.Label{Label: ":" + goSource}}, + ), + ) + } else { + ga.Srcs = goSrcLabels(ctx.Config(), ctx.ModuleDir(g), g.Srcs(), g.LinuxSrcs(), g.DarwinSrcs()) + } + bin := goBazelTarget{ targetName: g.Name(), targetPackage: ctx.ModuleDir(g), @@ -463,12 +642,14 @@ func generateBazelTargetsGoBinary(ctx *android.Context, g *bootstrap.GoBinary, g bazelRuleLoadLocation: "@io_bazel_rules_go//go:def.bzl", bazelAttributes: []interface{}{&ca, &ga}, } - // TODO - b/284483729: Create go_test target from testSrcs - binTarget, err := generateBazelTarget(ctx, bin) - if err != nil { - return []BazelTarget{}, []error{err} + + if binTarget, err := generateBazelTarget(ctx, bin); err == nil { + retTargets = append(retTargets, binTarget) + } else { + retErrs = []error{err} } - return []BazelTarget{binTarget}, nil + + return retTargets, retErrs } func GenerateBazelTargets(ctx *CodegenContext, generateFilegroups bool) (conversionResults, []error) { diff --git a/bp2build/cc_library_static_conversion_test.go b/bp2build/cc_library_static_conversion_test.go index 8084a5d8e..03e9cd060 100644 --- a/bp2build/cc_library_static_conversion_test.go +++ b/bp2build/cc_library_static_conversion_test.go @@ -1003,6 +1003,38 @@ cc_library_static { }) } +func TestCcLibraryStaticGeneratedHeadersMultipleExports(t *testing.T) { + runCcLibraryStaticTestCase(t, Bp2buildTestCase{ + Blueprint: soongCcLibraryStaticPreamble + ` +genrule { + name: "generated_hdr", + cmd: "nothing to see here", + export_include_dirs: ["foo", "bar"], + bazel_module: { bp2build_available: false }, +} + +genrule { + name: "export_generated_hdr", + cmd: "nothing to see here", + export_include_dirs: ["a", "b"], + bazel_module: { bp2build_available: false }, +} + +cc_library_static { + name: "foo_static", + generated_headers: ["generated_hdr", "export_generated_hdr"], + export_generated_headers: ["export_generated_hdr"], + include_build_directory: false, +}`, + ExpectedBazelTargets: []string{ + MakeBazelTarget("cc_library_static", "foo_static", AttrNameToString{ + "deps": `[":export_generated_hdr__header_library"]`, + "implementation_deps": `[":generated_hdr__header_library"]`, + }), + }, + }) +} + // generated_headers has "variant_prepend" tag. In bp2build output, // variant info(select) should go before general info. func TestCcLibraryStaticArchSrcsExcludeSrcsGeneratedFiles(t *testing.T) { diff --git a/bp2build/cc_test_conversion_test.go b/bp2build/cc_test_conversion_test.go index 20eb092d1..3c037b494 100644 --- a/bp2build/cc_test_conversion_test.go +++ b/bp2build/cc_test_conversion_test.go @@ -120,7 +120,6 @@ cc_test_library { "//build/bazel/platforms/os:windows": [":hostlib"], "//conditions:default": [], })`, - "gtest": "True", "local_includes": `["."]`, "dynamic_deps": `[":cc_test_lib2"] + select({ "//build/bazel/platforms/os:android": [":foolib"], @@ -182,7 +181,6 @@ cc_test { "tags": `["no-remote"]`, "local_includes": `["."]`, "srcs": `["test.cpp"]`, - "gtest": "True", "deps": `[ ":libgtest_main", ":libgtest", @@ -209,7 +207,6 @@ cc_test { simpleModuleDoNotConvertBp2build("cc_library_static", "libgtest"), targets: []testBazelTarget{ {"cc_test", "mytest", AttrNameToString{ - "gtest": "True", "local_includes": `["."]`, "srcs": `["test.cpp"]`, "target_compatible_with": `["//build/bazel/platforms/os:android"]`, @@ -239,7 +236,6 @@ cc_test { simpleModuleDoNotConvertBp2build("cc_library_static", "libgtest"), targets: []testBazelTarget{ {"cc_test", "mytest", AttrNameToString{ - "gtest": "True", "local_includes": `["."]`, "srcs": `["test.cpp"]`, "target_compatible_with": `["//build/bazel/platforms/os:android"]`, @@ -273,7 +269,6 @@ cc_test { targets: []testBazelTarget{ {"cc_test", "mytest", AttrNameToString{ "auto_generate_test_config": "True", - "gtest": "True", "local_includes": `["."]`, "srcs": `["test.cpp"]`, "target_compatible_with": `["//build/bazel/platforms/os:android"]`, @@ -304,7 +299,6 @@ cc_test { simpleModuleDoNotConvertBp2build("cc_library_static", "libgtest"), targets: []testBazelTarget{ {"cc_test", "mytest", AttrNameToString{ - "gtest": "True", "local_includes": `["."]`, "srcs": `["test.cpp"]`, "target_compatible_with": `["//build/bazel/platforms/os:android"]`, @@ -332,7 +326,6 @@ cc_test { simpleModuleDoNotConvertBp2build("cc_library", "liblog"), targets: []testBazelTarget{ {"cc_test", "mytest", AttrNameToString{ - "gtest": "True", "local_includes": `["."]`, "srcs": `["test.cpp"]`, "target_compatible_with": `["//build/bazel/platforms/os:android"]`, @@ -344,3 +337,38 @@ cc_test { }) } + +func TestCcTest_GtestExplicitlySpecifiedInAndroidBp(t *testing.T) { + runCcTestTestCase(t, ccTestBp2buildTestCase{ + description: "If `gtest` is explicit in Android.bp, it should be explicit in BUILD files as well", + blueprint: ` +cc_test { + name: "mytest_with_gtest", + gtest: true, +} +cc_test { + name: "mytest_with_no_gtest", + gtest: false, +} +` + simpleModuleDoNotConvertBp2build("cc_library_static", "libgtest_main") + + simpleModuleDoNotConvertBp2build("cc_library_static", "libgtest"), + targets: []testBazelTarget{ + {"cc_test", "mytest_with_gtest", AttrNameToString{ + "local_includes": `["."]`, + "deps": `[ + ":libgtest_main", + ":libgtest", + ]`, + "gtest": "True", + "target_compatible_with": `["//build/bazel/platforms/os:android"]`, + }, + }, + {"cc_test", "mytest_with_no_gtest", AttrNameToString{ + "local_includes": `["."]`, + "gtest": "False", + "target_compatible_with": `["//build/bazel/platforms/os:android"]`, + }, + }, + }, + }) +} diff --git a/bp2build/genrule_conversion_test.go b/bp2build/genrule_conversion_test.go index 5cf4fb216..5a739699a 100644 --- a/bp2build/genrule_conversion_test.go +++ b/bp2build/genrule_conversion_test.go @@ -16,6 +16,7 @@ package bp2build import ( "fmt" + "path/filepath" "testing" "android/soong/android" @@ -695,3 +696,79 @@ func TestCcGenruleArchAndExcludeSrcs(t *testing.T) { }) }) } + +func TestGenruleWithExportIncludeDirs(t *testing.T) { + testCases := []struct { + moduleType string + factory android.ModuleFactory + hod android.HostOrDeviceSupported + }{ + { + moduleType: "genrule", + factory: genrule.GenRuleFactory, + }, + { + moduleType: "cc_genrule", + factory: cc.GenRuleFactory, + hod: android.DeviceSupported, + }, + { + moduleType: "java_genrule", + factory: java.GenRuleFactory, + hod: android.DeviceSupported, + }, + { + moduleType: "java_genrule_host", + factory: java.GenRuleFactoryHost, + hod: android.HostSupported, + }, + } + + dir := "baz" + + bp := `%s { + name: "foo", + out: ["foo.out.h"], + srcs: ["foo.in"], + cmd: "cp $(in) $(out)", + export_include_dirs: ["foo", "bar", "."], + bazel_module: { bp2build_available: true }, +}` + + for _, tc := range testCases { + moduleAttrs := AttrNameToString{ + "cmd": `"cp $(SRCS) $(OUTS)"`, + "outs": `["foo.out.h"]`, + "srcs": `["foo.in"]`, + } + + expectedBazelTargets := []string{ + makeBazelTargetHostOrDevice("genrule", "foo", moduleAttrs, tc.hod), + makeBazelTargetHostOrDevice("cc_library_headers", "foo__header_library", AttrNameToString{ + "hdrs": `[":foo"]`, + "export_includes": `[ + "foo", + "baz/foo", + "bar", + "baz/bar", + ".", + "baz", + ]`, + }, + tc.hod), + } + + t.Run(tc.moduleType, func(t *testing.T) { + RunBp2BuildTestCase(t, func(ctx android.RegistrationContext) {}, + Bp2buildTestCase{ + ModuleTypeUnderTest: tc.moduleType, + ModuleTypeUnderTestFactory: tc.factory, + Filesystem: map[string]string{ + filepath.Join(dir, "Android.bp"): fmt.Sprintf(bp, tc.moduleType), + }, + Dir: dir, + ExpectedBazelTargets: expectedBazelTargets, + }) + }) + } +} diff --git a/bp2build/go_conversion_test.go b/bp2build/go_conversion_test.go index 507fbf0ae..2387641f2 100644 --- a/bp2build/go_conversion_test.go +++ b/bp2build/go_conversion_test.go @@ -45,11 +45,17 @@ bootstrap_go_package { srcs: [ "foo_linux.go", ], + testSrcs: [ + "foo_linux_test.go", + ], }, darwin: { srcs: [ "foo_darwin.go", ], + testSrcs: [ + "foo_darwin_test.go", + ], }, testSrcs: [ "foo1_test.go", @@ -84,7 +90,21 @@ bootstrap_go_package { })`, }, android.HostSupported, - )}, + ), + makeBazelTargetHostOrDevice("go_test", "foo-test", + AttrNameToString{ + "embed": `[":foo"]`, + "srcs": `[ + "foo1_test.go", + "foo2_test.go", + ] + select({ + "//build/bazel/platforms/os:darwin": ["foo_darwin_test.go"], + "//build/bazel/platforms/os:linux_glibc": ["foo_linux_test.go"], + "//conditions:default": [], + })`, + }, + android.HostSupported, + )}, }) } @@ -125,6 +145,44 @@ bootstrap_go_package { }) } +func TestConvertGoBinaryWithTestSrcs(t *testing.T) { + bp := ` +blueprint_go_binary { + name: "foo", + srcs: ["main.go"], + testSrcs: ["main_test.go"], +} +` + t.Parallel() + runGoTests(t, Bp2buildTestCase{ + Description: "Convert blueprint_go_binary with testSrcs", + Blueprint: bp, + ExpectedBazelTargets: []string{ + makeBazelTargetHostOrDevice("go_binary", "foo", + AttrNameToString{ + "deps": `[]`, + "embed": `[":foo-source"]`, + }, + android.HostSupported, + ), + makeBazelTargetHostOrDevice("go_source", "foo-source", + AttrNameToString{ + "deps": `[]`, + "srcs": `["main.go"]`, + }, + android.HostSupported, + ), + makeBazelTargetHostOrDevice("go_test", "foo-test", + AttrNameToString{ + "embed": `[":foo-source"]`, + "srcs": `["main_test.go"]`, + }, + android.HostSupported, + ), + }, + }) +} + func TestConvertGoBinaryWithSrcInDifferentPackage(t *testing.T) { bp := ` blueprint_go_binary { diff --git a/bp2build/soong_config_module_type_conversion_test.go b/bp2build/soong_config_module_type_conversion_test.go index 813773d00..143597d2b 100644 --- a/bp2build/soong_config_module_type_conversion_test.go +++ b/bp2build/soong_config_module_type_conversion_test.go @@ -1406,3 +1406,111 @@ cc_binary { target_compatible_with = ["//build/bazel/platforms/os:android"], )`}}) } + +// If we have +// A. a soong_config_module_type with target.android_<arch>.* in properties +// B. a module that uses this module type but does not set target.android_<arch>.* via soong config vars +// Then we should not panic +func TestPanicsIfSoongConfigModuleTypeHasArchSpecificProperties(t *testing.T) { + commonBp := ` +soong_config_bool_variable { + name: "my_bool_variable", +} +soong_config_module_type { + name: "special_cc_defaults", + module_type: "cc_defaults", + config_namespace: "my_namespace", + bool_variables: ["my_bool_variable"], + properties: [ + "cflags", + "target.android_arm64.shared_libs", + ], +} +cc_binary { + name: "my_binary", + defaults: ["my_special_cc_defaults"], +} +` + testCases := []struct { + desc string + additionalBp string + isPanicExpected bool + }{ + { + desc: "target.android_arm64 is not set, bp2build should not panic", + additionalBp: ` +special_cc_defaults { + name: "my_special_cc_defaults", + soong_config_variables: { + my_bool_variable: { + cflags: ["-DFOO"], + conditions_default: { + cflags: ["-DBAR"], + } + } + }, +} + `, + isPanicExpected: false, + }, + { + desc: "target.android_arm64 is set using the bool soong config var, bp2build should panic", + additionalBp: ` +special_cc_defaults { + name: "my_special_cc_defaults", + soong_config_variables: { + my_bool_variable: { + cflags: ["-DFOO"], + target: { + android_arm64: { + shared_libs: ["liblog"], + }, + }, + conditions_default: { + cflags: ["-DBAR"], + } + } + }, +} + `, + isPanicExpected: true, + }, + { + desc: "target.android_arm64 is set using conditions_default for the bool soong config var, bp2build should panic", + additionalBp: ` +special_cc_defaults { + name: "my_special_cc_defaults", + soong_config_variables: { + my_bool_variable: { + cflags: ["-DFOO"], + conditions_default: { + cflags: ["-DBAR"], + target: { + android_arm64: { + shared_libs: ["liblog"], + }, + }, + } + } + }, +} + `, + isPanicExpected: true, + }, + } + for _, tc := range testCases { + bp2buildTestCase := Bp2buildTestCase{ + Description: tc.desc, + ModuleTypeUnderTest: "cc_binary", + ModuleTypeUnderTestFactory: cc.BinaryFactory, + Blueprint: commonBp + tc.additionalBp, + // Check in `foo` dir so that we can check whether it panics or not and not trip over an empty `ExpectedBazelTargets` + Dir: "foo", + ExpectedBazelTargets: []string{}, + } + if tc.isPanicExpected { + bp2buildTestCase.ExpectedErr = fmt.Errorf("TODO: support other target types in soong config variable structs: Android_arm64") + } + runSoongConfigModuleTypeTest(t, bp2buildTestCase) + } +} diff --git a/cc/afdo.go b/cc/afdo.go index bc7cd5212..23d196dba 100644 --- a/cc/afdo.go +++ b/cc/afdo.go @@ -131,6 +131,10 @@ func (c *Module) fdoProfileMutator(ctx android.BottomUpMutatorContext) { return } + if !c.afdo.afdoEnabled() { + return + } + ctx.VisitDirectDepsWithTag(FdoProfileTag, func(m android.Module) { if ctx.OtherModuleHasProvider(m, FdoProfileProvider) { info := ctx.OtherModuleProvider(m, FdoProfileProvider).(FdoProfileInfo) diff --git a/cc/api_level.go b/cc/api_level.go index a5571f31f..69a0d3ae4 100644 --- a/cc/api_level.go +++ b/cc/api_level.go @@ -31,7 +31,11 @@ func MinApiForArch(ctx android.EarlyModuleContext, case android.Arm64, android.X86_64: return android.FirstLp64Version case android.Riscv64: - return android.FutureApiLevel + apiLevel, err := android.ApiLevelFromUser(ctx, "VanillaIceCream") + if err != nil { + panic(err) + } + return apiLevel default: panic(fmt.Errorf("Unknown arch %q", arch)) } diff --git a/cc/bp2build.go b/cc/bp2build.go index 9895a2043..9e485d6d0 100644 --- a/cc/bp2build.go +++ b/cc/bp2build.go @@ -22,6 +22,7 @@ import ( "android/soong/android" "android/soong/bazel" "android/soong/cc/config" + "android/soong/genrule" "github.com/google/blueprint" @@ -45,6 +46,8 @@ const ( xsdSrcPartition = "xsd" + genrulePartition = "genrule" + hdrPartition = "hdr" stubsSuffix = "_stub_libs_current" @@ -172,8 +175,9 @@ func groupSrcsByExtension(ctx android.BazelConversionPathContext, srcs bazel.Lab func partitionHeaders(ctx android.BazelConversionPathContext, hdrs bazel.LabelListAttribute) bazel.PartitionToLabelListAttribute { labels := bazel.LabelPartitions{ - xsdSrcPartition: bazel.LabelPartition{LabelMapper: android.XsdLabelMapper(xsdConfigCppTarget)}, - hdrPartition: bazel.LabelPartition{Keep_remainder: true}, + xsdSrcPartition: bazel.LabelPartition{LabelMapper: android.XsdLabelMapper(xsdConfigCppTarget)}, + genrulePartition: bazel.LabelPartition{LabelMapper: genrule.GenruleCcHeaderLabelMapper}, + hdrPartition: bazel.LabelPartition{Keep_remainder: true}, } return bazel.PartitionLabelListAttribute(ctx, &hdrs, labels) } @@ -419,6 +423,10 @@ type compilerAttributes struct { xsdSrcs bazel.LabelListAttribute exportXsdSrcs bazel.LabelListAttribute + // genrule headers + genruleHeaders bazel.LabelListAttribute + exportGenruleHeaders bazel.LabelListAttribute + // Lex sources and options lSrcs bazel.LabelListAttribute llSrcs bazel.LabelListAttribute @@ -606,6 +614,9 @@ func (ca *compilerAttributes) finalize(ctx android.BazelConversionPathContext, i ca.exportXsdSrcs = partitionedHdrs[xsdSrcPartition] ca.xsdSrcs = bazel.FirstUniqueBazelLabelListAttribute(xsdSrcs) + ca.genruleHeaders = partitionedImplHdrs[genrulePartition] + ca.exportGenruleHeaders = partitionedHdrs[genrulePartition] + ca.srcs = partitionedSrcs[cppSrcPartition] ca.cSrcs = partitionedSrcs[cSrcPartition] ca.asSrcs = partitionedSrcs[asSrcPartition] @@ -900,6 +911,9 @@ func bp2BuildParseBaseProps(ctx android.Bp2buildMutatorContext, module *Module) (&compilerAttrs.srcs).Add(bp2BuildYasm(ctx, module, compilerAttrs)) + (&linkerAttrs).deps.Append(compilerAttrs.exportGenruleHeaders) + (&linkerAttrs).implementationDeps.Append(compilerAttrs.genruleHeaders) + (&linkerAttrs).wholeArchiveDeps.Append(compilerAttrs.exportXsdSrcs) (&linkerAttrs).implementationWholeArchiveDeps.Append(compilerAttrs.xsdSrcs) diff --git a/cc/compiler.go b/cc/compiler.go index 16f4a6ec0..5bed8a72f 100644 --- a/cc/compiler.go +++ b/cc/compiler.go @@ -189,13 +189,13 @@ type BaseCompilerProperties struct { // build the recovery variant of the C/C++ module. Exclude_generated_sources []string } - Vendor_ramdisk struct { + Ramdisk, Vendor_ramdisk struct { // list of source files that should not be used to - // build the vendor ramdisk variant of the C/C++ module. + // build the ramdisk variants of the C/C++ module. Exclude_srcs []string `android:"path"` - // List of additional cflags that should be used to build the vendor ramdisk - // variant of the C/C++ module. + // List of additional cflags that should be used to build the ramdisk + // variants of the C/C++ module. Cflags []string } Platform struct { @@ -351,6 +351,7 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps CheckBadCompilerFlags(ctx, "vendor.cflags", compiler.Properties.Target.Vendor.Cflags) CheckBadCompilerFlags(ctx, "product.cflags", compiler.Properties.Target.Product.Cflags) CheckBadCompilerFlags(ctx, "recovery.cflags", compiler.Properties.Target.Recovery.Cflags) + CheckBadCompilerFlags(ctx, "ramdisk.cflags", compiler.Properties.Target.Ramdisk.Cflags) CheckBadCompilerFlags(ctx, "vendor_ramdisk.cflags", compiler.Properties.Target.Vendor_ramdisk.Cflags) CheckBadCompilerFlags(ctx, "platform.cflags", compiler.Properties.Target.Platform.Cflags) @@ -536,6 +537,9 @@ func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps if ctx.inVendorRamdisk() { flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Vendor_ramdisk.Cflags)...) } + if ctx.inRamdisk() { + flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Ramdisk.Cflags)...) + } if !ctx.useSdk() { flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Platform.Cflags)...) } diff --git a/cc/config/global.go b/cc/config/global.go index 266d2789b..ff5ab051e 100644 --- a/cc/config/global.go +++ b/cc/config/global.go @@ -149,6 +149,7 @@ var ( commonGlobalLldflags = []string{ "-fuse-ld=lld", "-Wl,--icf=safe", + "-Wl,--no-demangle", } deviceGlobalCppflags = []string{ diff --git a/cc/coverage.go b/cc/coverage.go index c0f697398..cbd8a6f3e 100644 --- a/cc/coverage.go +++ b/cc/coverage.go @@ -48,6 +48,7 @@ func (cov *coverage) props() []interface{} { func getGcovProfileLibraryName(ctx ModuleContextIntf) string { // This function should only ever be called for a cc.Module, so the // following statement should always succeed. + // LINT.IfChange if ctx.useSdk() { return "libprofile-extras_ndk" } else { @@ -63,6 +64,7 @@ func getClangProfileLibraryName(ctx ModuleContextIntf) string { } else { return "libprofile-clang-extras" } + // LINT.ThenChange(library.go) } func (cov *coverage) deps(ctx DepsContext, deps Deps) Deps { diff --git a/cc/image.go b/cc/image.go index e65a9aadb..f91762adc 100644 --- a/cc/image.go +++ b/cc/image.go @@ -678,10 +678,17 @@ func squashVendorRamdiskSrcs(m *Module) { } } +func squashRamdiskSrcs(m *Module) { + if lib, ok := m.compiler.(*libraryDecorator); ok { + lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs, lib.baseCompiler.Properties.Target.Ramdisk.Exclude_srcs...) + } +} + func (c *Module) SetImageVariation(ctx android.BaseModuleContext, variant string, module android.Module) { m := module.(*Module) if variant == android.RamdiskVariation { m.MakeAsPlatform() + squashRamdiskSrcs(m) } else if variant == android.VendorRamdiskVariation { m.MakeAsPlatform() squashVendorRamdiskSrcs(m) diff --git a/cc/library.go b/cc/library.go index 266fa7511..df1dbc5b4 100644 --- a/cc/library.go +++ b/cc/library.go @@ -32,6 +32,20 @@ import ( "github.com/google/blueprint/proptools" ) +var ( + alwaysLinkLibraries = map[string]bool{ + // Coverage libraries are _always_ added as a whole_static_dep. By converting as these as + // alwayslink = True, we can add these as to deps (e.g. as a regular static dep) in Bazel + // without any extra complications in cc_shared_library roots to prevent linking the same + // library repeatedly. + "libprofile-extras_ndk": true, + "libprofile-extras": true, + "libprofile-clang-extras_ndk": true, + "libprofile-clang-extras_cfi_support": true, + "libprofile-clang-extras": true, + } +) + // LibraryProperties is a collection of properties shared by cc library rules/cc. type LibraryProperties struct { // local file name to pass to the linker as -unexported_symbols_list @@ -435,6 +449,10 @@ func libraryBp2Build(ctx android.TopDownMutatorContext, m *Module) { Bzl_load_location: "//build/bazel/rules/cc:cc_library_shared.bzl", } + if _, ok := alwaysLinkLibraries[m.Name()]; ok { + staticTargetAttrs.Alwayslink = proptools.BoolPtr(true) + } + var tagsForStaticVariant bazel.StringListAttribute if compilerAttrs.stubsSymbolFile == nil && len(compilerAttrs.stubsVersions.Value) == 0 { tagsForStaticVariant = android.ApexAvailableTagsWithoutTestApexes(ctx, m) @@ -2951,6 +2969,10 @@ func sharedOrStaticLibraryBp2Build(ctx android.TopDownMutatorContext, module *Mo var attrs interface{} if isStatic { commonAttrs.Deps.Add(baseAttributes.protoDependency) + var alwayslink *bool + if _, ok := alwaysLinkLibraries[module.Name()]; ok && isStatic { + alwayslink = proptools.BoolPtr(true) + } attrs = &bazelCcLibraryStaticAttributes{ staticOrSharedAttributes: commonAttrs, Rtti: compilerAttrs.rtti, @@ -2964,8 +2986,10 @@ func sharedOrStaticLibraryBp2Build(ctx android.TopDownMutatorContext, module *Mo Conlyflags: compilerAttrs.conlyFlags, Asflags: asFlags, - Features: *features, + Alwayslink: alwayslink, + Features: *features, } + } else { commonAttrs.Dynamic_deps.Add(baseAttributes.protoDependency) @@ -3047,7 +3071,8 @@ type bazelCcLibraryStaticAttributes struct { Conlyflags bazel.StringListAttribute Asflags bazel.StringListAttribute - Features bazel.StringListAttribute + Alwayslink *bool + Features bazel.StringListAttribute } // TODO(b/199902614): Can this be factored to share with the other Attributes? @@ -101,11 +101,12 @@ func rsGenerateCpp(ctx android.ModuleContext, rsFiles android.Paths, rsFlags str func rsFlags(ctx ModuleContext, flags Flags, properties *BaseCompilerProperties) Flags { targetApi := String(properties.Renderscript.Target_api) if targetApi == "" && ctx.useSdk() { - switch ctx.sdkVersion() { - case "current", "system_current", "test_current": - // Nothing - default: - targetApi = android.GetNumericSdkVersion(ctx.sdkVersion()) + targetApiLevel := android.ApiLevelOrPanic(ctx, ctx.sdkVersion()) + if targetApiLevel.IsCurrent() || targetApiLevel.IsPreview() { + // If the target level is current or preview, leave the 'target-api' unset. + // This signals to llvm-rs-cc that the development API should be used. + } else { + targetApi = targetApiLevel.String() } } diff --git a/cc/sanitize.go b/cc/sanitize.go index 626005b44..c1ef97034 100644 --- a/cc/sanitize.go +++ b/cc/sanitize.go @@ -56,10 +56,6 @@ var ( // higher number of "optimized out" stack variables. // b/112437883. "-instcombine-lower-dbg-declare=0", - // TODO(b/159343917): HWASan and GlobalISel don't play nicely, and - // GlobalISel is the default at -O0 on aarch64. - "--aarch64-enable-global-isel-at-O=-1", - "-fast-isel=false", "-hwasan-use-after-scope=1", "-dom-tree-reachability-max-bbs-to-explore=128", } @@ -80,8 +80,7 @@ func (stl *stl) begin(ctx BaseModuleContext) { return "" } s = deduplicateStlInput(s) - archHasNDKStl := ctx.Arch().ArchType != android.Riscv64 - if ctx.useSdk() && ctx.Device() && archHasNDKStl { + if ctx.useSdk() && ctx.Device() { switch s { case "", "system": return "ndk_system" diff --git a/cc/test.go b/cc/test.go index 53a097aba..0be230151 100644 --- a/cc/test.go +++ b/cc/test.go @@ -682,7 +682,7 @@ func (handler *ccTestBazelHandler) ProcessBazelQueryResponse(ctx android.ModuleC type testBinaryAttributes struct { binaryAttributes - Gtest bool + Gtest *bool tidyAttributes tradefed.TestConfigAttributes @@ -720,15 +720,15 @@ func testBinaryBp2build(ctx android.TopDownMutatorContext, m *Module) { m.convertTidyAttributes(ctx, &testBinaryAttrs.tidyAttributes) - gtestIsolated := m.linker.(*testBinary).isolated(ctx) - for _, propIntf := range m.GetProperties() { - if testLinkerProps, ok := propIntf.(*TestLinkerProperties); ok { - testBinaryAttrs.Gtest = proptools.BoolDefault(testLinkerProps.Gtest, true) - break - } - } + testBinary := m.linker.(*testBinary) + gtest := testBinary.gtest() + gtestIsolated := testBinary.isolated(ctx) + // Use the underling bool pointer for Gtest in attrs + // This ensures that if this property is not set in Android.bp file, it will not be set in BUILD file either + // cc_test macro will default gtest to True + testBinaryAttrs.Gtest = testBinary.LinkerProperties.Gtest - addImplicitGtestDeps(ctx, &testBinaryAttrs, gtestIsolated) + addImplicitGtestDeps(ctx, &testBinaryAttrs, gtest, gtestIsolated) for _, testProps := range m.GetProperties() { if p, ok := testProps.(*TestBinaryProperties); ok { @@ -764,7 +764,7 @@ func testBinaryBp2build(ctx android.TopDownMutatorContext, m *Module) { // cc_test that builds using gtest needs some additional deps // addImplicitGtestDeps makes these deps explicit in the generated BUILD files -func addImplicitGtestDeps(ctx android.BazelConversionPathContext, attrs *testBinaryAttributes, gtestIsolated bool) { +func addImplicitGtestDeps(ctx android.BazelConversionPathContext, attrs *testBinaryAttributes, gtest, gtestIsolated bool) { addDepsAndDedupe := func(lla *bazel.LabelListAttribute, modules []string) { moduleLabels := android.BazelLabelForModuleDeps(ctx, modules) lla.Value.Append(moduleLabels) @@ -773,7 +773,7 @@ func addImplicitGtestDeps(ctx android.BazelConversionPathContext, attrs *testBin } // this must be kept in sync with Soong's implementation in: // https://cs.android.com/android/_/android/platform/build/soong/+/460fb2d6d546b5ab493a7e5479998c4933a80f73:cc/test.go;l=300-313;drc=ec7314336a2b35ea30ce5438b83949c28e3ac429;bpv=1;bpt=0 - if attrs.Gtest { + if gtest { // TODO - b/244433197: Handle canUseSdk if gtestIsolated { addDepsAndDedupe(&attrs.Deps, []string{"libgtest_isolated_main"}) diff --git a/genrule/genrule.go b/genrule/genrule.go index 6306c2750..69ba1e94e 100644 --- a/genrule/genrule.go +++ b/genrule/genrule.go @@ -994,6 +994,7 @@ func (m *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) { tags := android.ApexAvailableTagsWithoutTestApexes(ctx, m) + bazelName := m.Name() if ctx.ModuleType() == "gensrcs" { props := bazel.BazelTargetModuleProperties{ Rule_class: "gensrcs", @@ -1021,7 +1022,6 @@ func (m *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) { break } } - bazelName := m.Name() for _, out := range outs { if out == bazelName { // This is a workaround to circumvent a Bazel warning where a genrule's @@ -1046,6 +1046,54 @@ func (m *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) { Tags: tags, }, attrs) } + + if m.needsCcLibraryHeadersBp2build() { + includeDirs := make([]string, len(m.properties.Export_include_dirs)*2) + for i, dir := range m.properties.Export_include_dirs { + includeDirs[i*2] = dir + includeDirs[i*2+1] = filepath.Clean(filepath.Join(ctx.ModuleDir(), dir)) + } + attrs := &ccHeaderLibraryAttrs{ + Hdrs: []string{":" + bazelName}, + Export_includes: includeDirs, + } + props := bazel.BazelTargetModuleProperties{ + Rule_class: "cc_library_headers", + Bzl_load_location: "//build/bazel/rules/cc:cc_library_headers.bzl", + } + ctx.CreateBazelTargetModule(props, android.CommonAttributes{ + Name: m.Name() + genruleHeaderLibrarySuffix, + Tags: tags, + }, attrs) + + } +} + +const genruleHeaderLibrarySuffix = "__header_library" + +func (m *Module) needsCcLibraryHeadersBp2build() bool { + return len(m.properties.Export_include_dirs) > 0 +} + +// GenruleCcHeaderMapper is a bazel.LabelMapper function to map genrules to a cc_library_headers +// target when they export multiple include directories. +func GenruleCcHeaderLabelMapper(ctx bazel.OtherModuleContext, label bazel.Label) (string, bool) { + mod, exists := ctx.ModuleFromName(label.OriginalModuleName) + if !exists { + return label.Label, false + } + if m, ok := mod.(*Module); ok { + if m.needsCcLibraryHeadersBp2build() { + return label.Label + genruleHeaderLibrarySuffix, true + } + } + return label.Label, false +} + +type ccHeaderLibraryAttrs struct { + Hdrs []string + + Export_includes []string } var Bool = proptools.Bool @@ -1099,6 +1147,7 @@ func getSandboxingAllowlistSets(ctx android.PathContext) *sandboxingAllowlistSet } }).(*sandboxingAllowlistSets) } + func getSandboxedRuleBuilder(ctx android.ModuleContext, r *android.RuleBuilder) *android.RuleBuilder { if !ctx.DeviceConfig().GenruleSandboxing() { return r.SandboxTools() diff --git a/java/app_builder.go b/java/app_builder.go index d20a6bfe4..d397ff7f5 100644 --- a/java/app_builder.go +++ b/java/app_builder.go @@ -225,8 +225,6 @@ func BuildBundleModule(ctx android.ModuleContext, outputFile android.WritablePat }) } -const jniJarOutputPathString = "jniJarOutput.zip" - func TransformJniLibsToJar( ctx android.ModuleContext, outputFile android.WritablePath, @@ -258,7 +256,10 @@ func TransformJniLibsToJar( rule = zipRE args["implicits"] = strings.Join(deps.Strings(), ",") } - jniJarPath := android.PathForModuleOut(ctx, jniJarOutputPathString) + var jniJarPath android.WritablePath = android.PathForModuleOut(ctx, "jniJarOutput.zip") + if len(prebuiltJniPackages) == 0 { + jniJarPath = outputFile + } ctx.Build(pctx, android.BuildParams{ Rule: rule, Description: "zip jni libs", @@ -266,12 +267,26 @@ func TransformJniLibsToJar( Implicits: deps, Args: args, }) - ctx.Build(pctx, android.BuildParams{ - Rule: mergeAssetsRule, - Description: "merge prebuilt JNI packages", - Inputs: append(prebuiltJniPackages, jniJarPath), - Output: outputFile, - }) + if len(prebuiltJniPackages) > 0 { + var mergeJniJarPath android.WritablePath = android.PathForModuleOut(ctx, "mergeJniJarOutput.zip") + if !uncompressJNI { + mergeJniJarPath = outputFile + } + ctx.Build(pctx, android.BuildParams{ + Rule: mergeAssetsRule, + Description: "merge prebuilt JNI packages", + Inputs: append(prebuiltJniPackages, jniJarPath), + Output: mergeJniJarPath, + }) + + if uncompressJNI { + ctx.Build(pctx, android.BuildParams{ + Rule: uncompressEmbeddedJniLibsRule, + Input: mergeJniJarPath, + Output: outputFile, + }) + } + } } func (a *AndroidApp) generateJavaUsedByApex(ctx android.ModuleContext) { diff --git a/java/app_test.go b/java/app_test.go index 4627ff6fc..8474ea7d6 100644 --- a/java/app_test.go +++ b/java/app_test.go @@ -1742,7 +1742,7 @@ func TestJNIABI(t *testing.T) { for _, test := range testCases { t.Run(test.name, func(t *testing.T) { app := ctx.ModuleForTests(test.name, "android_common") - jniLibZip := app.Output(jniJarOutputPathString) + jniLibZip := app.Output("jnilibs.zip") var abis []string args := strings.Fields(jniLibZip.Args["jarArgs"]) for i := 0; i < len(args); i++ { @@ -1875,7 +1875,7 @@ func TestJNIPackaging(t *testing.T) { for _, test := range testCases { t.Run(test.name, func(t *testing.T) { app := ctx.ModuleForTests(test.name, "android_common") - jniLibZip := app.MaybeOutput(jniJarOutputPathString) + jniLibZip := app.MaybeOutput("jnilibs.zip") if g, w := (jniLibZip.Rule != nil), test.packaged; g != w { t.Errorf("expected jni packaged %v, got %v", w, g) } @@ -1966,7 +1966,7 @@ func TestJNISDK(t *testing.T) { t.Run(test.name, func(t *testing.T) { app := ctx.ModuleForTests(test.name, "android_common") - jniLibZip := app.MaybeOutput(jniJarOutputPathString) + jniLibZip := app.MaybeOutput("jnilibs.zip") if len(jniLibZip.Implicits) != 1 { t.Fatalf("expected exactly one jni library, got %q", jniLibZip.Implicits.Strings()) } @@ -2986,7 +2986,7 @@ func TestStl(t *testing.T) { for _, test := range testCases { t.Run(test.name, func(t *testing.T) { app := ctx.ModuleForTests(test.name, "android_common") - jniLibZip := app.Output(jniJarOutputPathString) + jniLibZip := app.Output("jnilibs.zip") var jnis []string args := strings.Fields(jniLibZip.Args["jarArgs"]) for i := 0; i < len(args); i++ { diff --git a/java/builder.go b/java/builder.go index afbd69ee4..debf49a00 100644 --- a/java/builder.go +++ b/java/builder.go @@ -55,7 +55,7 @@ var ( `$zipTemplate${config.SoongZipCmd} -jar -o $out.tmp -C $outDir -D $outDir && ` + `if ! cmp -s "$out.tmp" "$out"; then mv "$out.tmp" "$out"; fi && ` + `if ! cmp -s "$annoSrcJar.tmp" "$annoSrcJar"; then mv "$annoSrcJar.tmp" "$annoSrcJar"; fi && ` + - `rm -rf "$srcJarDir"`, + `rm -rf "$srcJarDir" "$outDir"`, CommandDeps: []string{ "${config.JavacCmd}", "${config.SoongZipCmd}", diff --git a/java/core-libraries/Android.bp b/java/core-libraries/Android.bp index eadd9c697..de9a82d09 100644 --- a/java/core-libraries/Android.bp +++ b/java/core-libraries/Android.bp @@ -146,12 +146,43 @@ java_system_modules { ], } +java_defaults { + name: "core.module_lib.stubs.defaults", + visibility: ["//visibility:private"], + sdk_version: "none", + system_modules: "none", +} + + // A stubs target containing the parts of the public SDK & @SystemApi(MODULE_LIBRARIES) API // provided by the core libraries. // // Don't use this directly, use "sdk_version: module_current". java_library { name: "core.module_lib.stubs", + defaults: [ + "core.module_lib.stubs.defaults", + ], + static_libs: [ + "core.module_lib.stubs.from-source", + ], + product_variables: { + build_from_text_stub: { + static_libs: [ + "core.module_lib.stubs.from-text", + ], + exclude_static_libs: [ + "core.module_lib.stubs.from-source", + ], + }, + }, +} + +java_library { + name: "core.module_lib.stubs.from-source", + defaults: [ + "core.module_lib.stubs.defaults", + ], static_libs: [ "art.module.public.api.stubs.module_lib", @@ -161,9 +192,6 @@ java_library { "conscrypt.module.public.api.stubs", "i18n.module.public.api.stubs", ], - sdk_version: "none", - system_modules: "none", - visibility: ["//visibility:private"], } // Produces a dist file that is used by the @@ -249,10 +277,10 @@ java_library { product_variables: { build_from_text_stub: { static_libs: [ - "stable.core.platform.api.stubs.from-text", + "legacy.core.platform.api.stubs.from-text", ], exclude_static_libs: [ - "stable.core.platform.api.stubs.from-source", + "legacy.core.platform.api.stubs.from-source", ], }, }, diff --git a/java/core-libraries/TxtStubLibraries.bp b/java/core-libraries/TxtStubLibraries.bp index 0cf0f360b..c46f8b8ea 100644 --- a/java/core-libraries/TxtStubLibraries.bp +++ b/java/core-libraries/TxtStubLibraries.bp @@ -57,19 +57,23 @@ java_library { ], } -java_library { +java_api_library { name: "core.module_lib.stubs.from-text", - static_libs: [ - "art.module.public.api.stubs.module_lib.from-text", + api_surface: "module-lib", + api_contributions: [ + "art.module.public.api.stubs.source.api.contribution", + "art.module.public.api.stubs.source.system.api.contribution", + "art.module.public.api.stubs.source.module_lib.api.contribution", - // Replace the following with the module-lib correspondence when Conscrypt or i18N module + // Add the module-lib correspondence when Conscrypt or i18N module // provides @SystemApi(MODULE_LIBRARIES). Currently, assume that only ART module provides // @SystemApi(MODULE_LIBRARIES). - "conscrypt.module.public.api.stubs.from-text", - "i18n.module.public.api.stubs.from-text", + "conscrypt.module.public.api.stubs.source.api.contribution", + "i18n.module.public.api.stubs.source.api.contribution", + ], + libs: [ + "stub-annotations", ], - sdk_version: "none", - system_modules: "none", visibility: ["//visibility:private"], } diff --git a/java/hiddenapi.go b/java/hiddenapi.go index d25096b15..4d08b8307 100644 --- a/java/hiddenapi.go +++ b/java/hiddenapi.go @@ -106,7 +106,7 @@ func (h *hiddenAPI) initHiddenAPI(ctx android.ModuleContext, dexJar OptionalDexJ h.uncompressDexState = uncompressedDexState // If hiddenapi processing is disabled treat this as inactive. - if ctx.Config().IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") { + if ctx.Config().DisableHiddenApiChecks() { return } diff --git a/java/hiddenapi_singleton.go b/java/hiddenapi_singleton.go index 714634f58..8ec17971a 100644 --- a/java/hiddenapi_singleton.go +++ b/java/hiddenapi_singleton.go @@ -121,8 +121,8 @@ type hiddenAPISingleton struct { // hiddenAPI singleton rules func (h *hiddenAPISingleton) GenerateBuildActions(ctx android.SingletonContext) { - // Don't run any hiddenapi rules if UNSAFE_DISABLE_HIDDENAPI_FLAGS=true - if ctx.Config().IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") { + // Don't run any hiddenapi rules if hiddenapi checks are disabled + if ctx.Config().DisableHiddenApiChecks() { return } diff --git a/java/kotlin.go b/java/kotlin.go index f28d6c737..3637e2e71 100644 --- a/java/kotlin.go +++ b/java/kotlin.go @@ -42,7 +42,7 @@ var kotlinc = pctx.AndroidRemoteStaticRule("kotlinc", android.RemoteRuleSupports ` -P plugin:org.jetbrains.kotlin.jvm.abi:outputDir=$headerClassesDir && ` + `${config.SoongZipCmd} -jar -o $out -C $classesDir -D $classesDir -write_if_changed && ` + `${config.SoongZipCmd} -jar -o $headerJar -C $headerClassesDir -D $headerClassesDir -write_if_changed && ` + - `rm -rf "$srcJarDir"`, + `rm -rf "$srcJarDir" "$classesDir" "$headerClassesDir"`, CommandDeps: []string{ "${config.KotlincCmd}", "${config.KotlinCompilerJar}", diff --git a/java/platform_bootclasspath.go b/java/platform_bootclasspath.go index a4bba486d..ade739552 100644 --- a/java/platform_bootclasspath.go +++ b/java/platform_bootclasspath.go @@ -113,7 +113,7 @@ func (b *platformBootclasspathModule) DepsMutator(ctx android.BottomUpMutatorCon } func (b *platformBootclasspathModule) hiddenAPIDepsMutator(ctx android.BottomUpMutatorContext) { - if ctx.Config().IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") { + if ctx.Config().DisableHiddenApiChecks() { return } @@ -275,10 +275,10 @@ func (b *platformBootclasspathModule) generateHiddenAPIBuildActions(ctx android. bootDexJarByModule := extractBootDexJarsFromModules(ctx, modules) - // Don't run any hiddenapi rules if UNSAFE_DISABLE_HIDDENAPI_FLAGS=true. This is a performance + // Don't run any hiddenapi rules if hidden api checks are disabled. This is a performance // optimization that can be used to reduce the incremental build time but as its name suggests it // can be unsafe to use, e.g. when the changes affect anything that goes on the bootclasspath. - if ctx.Config().IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") { + if ctx.Config().DisableHiddenApiChecks() { paths := android.OutputPaths{b.hiddenAPIFlagsCSV, b.hiddenAPIIndexCSV, b.hiddenAPIMetadataCSV} for _, path := range paths { ctx.Build(pctx, android.BuildParams{ diff --git a/rust/bindgen.go b/rust/bindgen.go index 59585aaf8..c2bf6af4c 100644 --- a/rust/bindgen.go +++ b/rust/bindgen.go @@ -61,15 +61,18 @@ var ( "${cc_config.ClangBase}/${bindgenHostPrebuiltTag}/${bindgenClangVersion}/${bindgenClangLibdir}") //TODO(ivanlozano) Switch this to RuleBuilder + // + //TODO Pass the flag files directly to bindgen e.g. with @file when it supports that. + //See https://github.com/rust-lang/rust-bindgen/issues/2508. bindgen = pctx.AndroidStaticRule("bindgen", blueprint.RuleParams{ Command: "CLANG_PATH=$bindgenClang LIBCLANG_PATH=$bindgenLibClang RUSTFMT=${config.RustBin}/rustfmt " + - "$cmd $flags $in -o $out -- -MD -MF $out.d $cflags", + "$cmd $flags $$(cat $flagfiles) $in -o $out -- -MD -MF $out.d $cflags", CommandDeps: []string{"$cmd"}, Deps: blueprint.DepsGCC, Depfile: "$out.d", }, - "cmd", "flags", "cflags") + "cmd", "flags", "flagfiles", "cflags") ) func init() { @@ -90,6 +93,9 @@ type BindgenProperties struct { // list of bindgen-specific flags and options Bindgen_flags []string `android:"arch_variant"` + // list of files containing extra bindgen flags + Bindgen_flag_files []string `android:"arch_variant"` + // module name of a custom binary/script which should be used instead of the 'bindgen' binary. This custom // binary must expect arguments in a similar fashion to bindgen, e.g. // @@ -216,6 +222,14 @@ func (b *bindgenDecorator) GenerateSource(ctx ModuleContext, deps PathDeps) andr bindgenFlags := defaultBindgenFlags bindgenFlags = append(bindgenFlags, esc(b.Properties.Bindgen_flags)...) + // cat reads from stdin if its command line is empty, + // so we pass in /dev/null if there are no other flag files + bindgenFlagFiles := []string{"/dev/null"} + for _, flagFile := range b.Properties.Bindgen_flag_files { + bindgenFlagFiles = append(bindgenFlagFiles, android.PathForModuleSrc(ctx, flagFile).String()) + implicits = append(implicits, android.PathForModuleSrc(ctx, flagFile)) + } + wrapperFile := android.OptionalPathForModuleSrc(ctx, b.Properties.Wrapper_src) if !wrapperFile.Valid() { ctx.PropertyErrorf("wrapper_src", "invalid path to wrapper source") @@ -261,9 +275,10 @@ func (b *bindgenDecorator) GenerateSource(ctx ModuleContext, deps PathDeps) andr Input: wrapperFile.Path(), Implicits: implicits, Args: map[string]string{ - "cmd": cmd, - "flags": strings.Join(bindgenFlags, " "), - "cflags": strings.Join(cflags, " "), + "cmd": cmd, + "flags": strings.Join(bindgenFlags, " "), + "flagfiles": strings.Join(bindgenFlagFiles, " "), + "cflags": strings.Join(cflags, " "), }, }) diff --git a/rust/bindgen_test.go b/rust/bindgen_test.go index af04cfc89..12cdb3cb4 100644 --- a/rust/bindgen_test.go +++ b/rust/bindgen_test.go @@ -168,3 +168,28 @@ func TestBindgenDisallowedFlags(t *testing.T) { } `) } + +func TestBindgenFlagFile(t *testing.T) { + ctx := testRust(t, ` + rust_bindgen { + name: "libbindgen", + wrapper_src: "src/any.h", + crate_name: "bindgen", + stem: "libbindgen", + source_stem: "bindings", + bindgen_flag_files: [ + "flag_file.txt", + ], + } + `) + libbindgen := ctx.ModuleForTests("libbindgen", "android_arm64_armv8-a_source").Output("bindings.rs") + + if !strings.Contains(libbindgen.Args["flagfiles"], "/dev/null") { + t.Errorf("missing /dev/null in rust_bindgen rule: flags %#v", libbindgen.Args["flagfiles"]) + } + if !strings.Contains(libbindgen.Args["flagfiles"], "flag_file.txt") { + t.Errorf("missing bindgen flags file in rust_bindgen rule: flags %#v", libbindgen.Args["flagfiles"]) + } + // TODO: The best we can do right now is check $flagfiles. Once bindgen.go switches to RuleBuilder, + // we may be able to check libbinder.RuleParams.Command to see if it contains $(cat /dev/null flag_file.txt) +} diff --git a/rust/builder.go b/rust/builder.go index c31bc88d1..fbceecc80 100644 --- a/rust/builder.go +++ b/rust/builder.go @@ -228,6 +228,17 @@ func rustEnvVars(ctx ModuleContext, deps PathDeps) []string { pkgVersion := ctx.RustModule().compiler.CargoPkgVersion() if pkgVersion != "" { envVars = append(envVars, "CARGO_PKG_VERSION="+pkgVersion) + + // Ensure the version is in the form of "x.y.z" (approximately semver compliant). + // + // For our purposes, we don't care to enforce that these are integers since they may + // include other characters at times (e.g. sometimes the patch version is more than an integer). + if strings.Count(pkgVersion, ".") == 2 { + var semver_parts = strings.Split(pkgVersion, ".") + envVars = append(envVars, "CARGO_PKG_VERSION_MAJOR="+semver_parts[0]) + envVars = append(envVars, "CARGO_PKG_VERSION_MINOR="+semver_parts[1]) + envVars = append(envVars, "CARGO_PKG_VERSION_PATCH="+semver_parts[2]) + } } } diff --git a/rust/sanitize.go b/rust/sanitize.go index 0f7cf6e5f..862baf7cc 100644 --- a/rust/sanitize.go +++ b/rust/sanitize.go @@ -223,11 +223,16 @@ func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags, deps PathDeps) ( if !sanitize.Properties.SanitizerEnabled { return flags, deps } + if Bool(sanitize.Properties.Sanitize.Fuzzer) { flags.RustFlags = append(flags.RustFlags, fuzzerFlags...) - } else if Bool(sanitize.Properties.Sanitize.Hwaddress) { + } + + if Bool(sanitize.Properties.Sanitize.Hwaddress) { flags.RustFlags = append(flags.RustFlags, hwasanFlags...) - } else if Bool(sanitize.Properties.Sanitize.Address) { + } + + if Bool(sanitize.Properties.Sanitize.Address) { flags.RustFlags = append(flags.RustFlags, asanFlags...) } return flags, deps @@ -267,14 +272,12 @@ func rustSanitizerRuntimeMutator(mctx android.BottomUpMutatorContext) { var depTag blueprint.DependencyTag var deps []string - if mod.IsSanitizerEnabled(cc.Asan) || - (mod.IsSanitizerEnabled(cc.Fuzzer) && (mctx.Arch().ArchType != android.Arm64 || !mctx.Os().Bionic())) { + if mod.IsSanitizerEnabled(cc.Asan) { variations = append(variations, blueprint.Variation{Mutator: "link", Variation: "shared"}) depTag = cc.SharedDepTag() deps = []string{config.LibclangRuntimeLibrary(mod.toolchain(mctx), "asan")} - } else if mod.IsSanitizerEnabled(cc.Hwasan) || - (mod.IsSanitizerEnabled(cc.Fuzzer) && mctx.Arch().ArchType == android.Arm64 && mctx.Os().Bionic()) { + } else if mod.IsSanitizerEnabled(cc.Hwasan) { // TODO(b/204776996): HWASan for static Rust binaries isn't supported yet. if binary, ok := mod.compiler.(binaryInterface); ok { if binary.staticallyLinked() { |