From 38917496e5e87fd638dc2a5a8dff937bb436480c Mon Sep 17 00:00:00 2001 From: Hamzeh Zawawy Date: Wed, 5 Apr 2023 22:08:46 +0000 Subject: [PATCH] Support removing suffix for device specific prebuilt during build Some device specific prebuilts have a suffix that varies depending on the lunch target. The resulting install dependency binary has the suffix. The fuzzer build expects the presubmit binary without the suffix. This change is to drop the suffix. Test: make haiku Change-Id: I8eadd84bf5797659b17bc428dca47b7c3f382aff --- cc/cc.go | 2 +- cc/fuzz.go | 49 +++++++++++++++++++++++++++++++++---------------- cc/linkable.go | 2 +- rust/fuzz.go | 10 ++++++---- rust/rust.go | 2 +- 5 files changed, 42 insertions(+), 23 deletions(-) diff --git a/cc/cc.go b/cc/cc.go index 3fbefcd51..7237686e4 100644 --- a/cc/cc.go +++ b/cc/cc.go @@ -1086,7 +1086,7 @@ func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule { panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName())) } -func (c *Module) FuzzSharedLibraries() android.Paths { +func (c *Module) FuzzSharedLibraries() android.RuleBuilderInstalls { if fuzzer, ok := c.compiler.(*fuzzBinary); ok { return fuzzer.sharedLibraries } diff --git a/cc/fuzz.go b/cc/fuzz.go index 7aa8b91c7..38792e6d5 100644 --- a/cc/fuzz.go +++ b/cc/fuzz.go @@ -103,7 +103,7 @@ type fuzzBinary struct { *baseCompiler fuzzPackagedModule fuzz.FuzzPackagedModule installedSharedDeps []string - sharedLibraries android.Paths + sharedLibraries android.RuleBuilderInstalls } func (fuzz *fuzzBinary) fuzzBinary() bool { @@ -213,19 +213,19 @@ func IsValidSharedDependency(dependency android.Module) bool { } func SharedLibraryInstallLocation( - libraryPath android.Path, isHost bool, fuzzDir string, archString string) string { + libraryBase string, isHost bool, fuzzDir string, archString string) string { installLocation := "$(PRODUCT_OUT)/data" if isHost { installLocation = "$(HOST_OUT)" } installLocation = filepath.Join( - installLocation, fuzzDir, archString, "lib", libraryPath.Base()) + installLocation, fuzzDir, archString, "lib", libraryBase) return installLocation } // Get the device-only shared library symbols install directory. -func SharedLibrarySymbolsInstallLocation(libraryPath android.Path, fuzzDir string, archString string) string { - return filepath.Join("$(PRODUCT_OUT)/symbols/data/", fuzzDir, archString, "/lib/", libraryPath.Base()) +func SharedLibrarySymbolsInstallLocation(libraryBase string, fuzzDir string, archString string) string { + return filepath.Join("$(PRODUCT_OUT)/symbols/data/", fuzzDir, archString, "/lib/", libraryBase) } func (fuzzBin *fuzzBinary) install(ctx ModuleContext, file android.Path) { @@ -242,15 +242,16 @@ func (fuzzBin *fuzzBinary) install(ctx ModuleContext, file android.Path) { // Grab the list of required shared libraries. fuzzBin.sharedLibraries, _ = CollectAllSharedDependencies(ctx) - for _, lib := range fuzzBin.sharedLibraries { + for _, ruleBuilderInstall := range fuzzBin.sharedLibraries { + install := ruleBuilderInstall.To fuzzBin.installedSharedDeps = append(fuzzBin.installedSharedDeps, SharedLibraryInstallLocation( - lib, ctx.Host(), installBase, ctx.Arch().ArchType.String())) + install, ctx.Host(), installBase, ctx.Arch().ArchType.String())) // Also add the dependency on the shared library symbols dir. if !ctx.Host() { fuzzBin.installedSharedDeps = append(fuzzBin.installedSharedDeps, - SharedLibrarySymbolsInstallLocation(lib, installBase, ctx.Arch().ArchType.String())) + SharedLibrarySymbolsInstallLocation(install, installBase, ctx.Arch().ArchType.String())) } } } @@ -453,19 +454,21 @@ func (s *ccRustFuzzPackager) MakeVars(ctx android.MakeVarsContext) { // GetSharedLibsToZip finds and marks all the transiently-dependent shared libraries for // packaging. -func GetSharedLibsToZip(sharedLibraries android.Paths, module LinkableInterface, s *fuzz.FuzzPackager, archString string, destinationPathPrefix string, sharedLibraryInstalled *map[string]bool) []fuzz.FileToZip { +func GetSharedLibsToZip(sharedLibraries android.RuleBuilderInstalls, module LinkableInterface, s *fuzz.FuzzPackager, archString string, destinationPathPrefix string, sharedLibraryInstalled *map[string]bool) []fuzz.FileToZip { var files []fuzz.FileToZip fuzzDir := "fuzz" - for _, library := range sharedLibraries { + for _, ruleBuilderInstall := range sharedLibraries { + library := ruleBuilderInstall.From + install := ruleBuilderInstall.To files = append(files, fuzz.FileToZip{library, destinationPathPrefix}) // For each architecture-specific shared library dependency, we need to // install it to the output directory. Setup the install destination here, // which will be used by $(copy-many-files) in the Make backend. installDestination := SharedLibraryInstallLocation( - library, module.Host(), fuzzDir, archString) + install, module.Host(), fuzzDir, archString) if (*sharedLibraryInstalled)[installDestination] { continue } @@ -483,7 +486,7 @@ func GetSharedLibsToZip(sharedLibraries android.Paths, module LinkableInterface, // we want symbolization tools (like `stack`) to be able to find the symbols // in $ANDROID_PRODUCT_OUT/symbols automagically. if !module.Host() { - symbolsInstallDestination := SharedLibrarySymbolsInstallLocation(library, fuzzDir, archString) + symbolsInstallDestination := SharedLibrarySymbolsInstallLocation(install, fuzzDir, archString) symbolsInstallDestination = strings.ReplaceAll(symbolsInstallDestination, "$", "$$") s.SharedLibInstallStrings = append(s.SharedLibInstallStrings, library.String()+":"+symbolsInstallDestination) @@ -497,12 +500,12 @@ func GetSharedLibsToZip(sharedLibraries android.Paths, module LinkableInterface, // VisitDirectDeps is used first to avoid incorrectly using the core libraries (sanitizer // runtimes, libc, libdl, etc.) from a dependency. This may cause issues when dependencies // have explicit sanitizer tags, as we may get a dependency on an unsanitized libc, etc. -func CollectAllSharedDependencies(ctx android.ModuleContext) (android.Paths, []android.Module) { +func CollectAllSharedDependencies(ctx android.ModuleContext) (android.RuleBuilderInstalls, []android.Module) { seen := make(map[string]bool) recursed := make(map[string]bool) deps := []android.Module{} - var sharedLibraries android.Paths + var sharedLibraries android.RuleBuilderInstalls // Enumerate the first level of dependencies, as we discard all non-library // modules in the BFS loop below. @@ -510,22 +513,36 @@ func CollectAllSharedDependencies(ctx android.ModuleContext) (android.Paths, []a if !IsValidSharedDependency(dep) { return } + if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) { + return + } if seen[ctx.OtherModuleName(dep)] { return } seen[ctx.OtherModuleName(dep)] = true deps = append(deps, dep) - sharedLibraries = append(sharedLibraries, android.OutputFileForModule(ctx, dep, "unstripped")) + + sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo) + installDestination := sharedLibraryInfo.SharedLibrary.Base() + ruleBuilderInstall := android.RuleBuilderInstall{android.OutputFileForModule(ctx, dep, "unstripped"), installDestination} + sharedLibraries = append(sharedLibraries, ruleBuilderInstall) }) ctx.WalkDeps(func(child, parent android.Module) bool { if !IsValidSharedDependency(child) { return false } + if !ctx.OtherModuleHasProvider(child, SharedLibraryInfoProvider) { + return false + } if !seen[ctx.OtherModuleName(child)] { seen[ctx.OtherModuleName(child)] = true deps = append(deps, child) - sharedLibraries = append(sharedLibraries, android.OutputFileForModule(ctx, child, "unstripped")) + + sharedLibraryInfo := ctx.OtherModuleProvider(child, SharedLibraryInfoProvider).(SharedLibraryInfo) + installDestination := sharedLibraryInfo.SharedLibrary.Base() + ruleBuilderInstall := android.RuleBuilderInstall{android.OutputFileForModule(ctx, child, "unstripped"), installDestination} + sharedLibraries = append(sharedLibraries, ruleBuilderInstall) } if recursed[ctx.OtherModuleName(child)] { diff --git a/cc/linkable.go b/cc/linkable.go index 9578807f8..557f5d2b3 100644 --- a/cc/linkable.go +++ b/cc/linkable.go @@ -130,7 +130,7 @@ type LinkableInterface interface { // FuzzSharedLibraries returns the shared library dependencies for this module. // Expects that IsFuzzModule returns true. - FuzzSharedLibraries() android.Paths + FuzzSharedLibraries() android.RuleBuilderInstalls Device() bool Host() bool diff --git a/rust/fuzz.go b/rust/fuzz.go index d7e7ddfff..c2b940525 100644 --- a/rust/fuzz.go +++ b/rust/fuzz.go @@ -31,7 +31,7 @@ type fuzzDecorator struct { *binaryDecorator fuzzPackagedModule fuzz.FuzzPackagedModule - sharedLibraries android.Paths + sharedLibraries android.RuleBuilderInstalls installedSharedDeps []string } @@ -119,15 +119,17 @@ func (fuzz *fuzzDecorator) install(ctx ModuleContext) { // Grab the list of required shared libraries. fuzz.sharedLibraries, _ = cc.CollectAllSharedDependencies(ctx) - for _, lib := range fuzz.sharedLibraries { + for _, ruleBuilderInstall := range fuzz.sharedLibraries { + install := ruleBuilderInstall.To + fuzz.installedSharedDeps = append(fuzz.installedSharedDeps, cc.SharedLibraryInstallLocation( - lib, ctx.Host(), installBase, ctx.Arch().ArchType.String())) + install, ctx.Host(), installBase, ctx.Arch().ArchType.String())) // Also add the dependency on the shared library symbols dir. if !ctx.Host() { fuzz.installedSharedDeps = append(fuzz.installedSharedDeps, - cc.SharedLibrarySymbolsInstallLocation(lib, installBase, ctx.Arch().ArchType.String())) + cc.SharedLibrarySymbolsInstallLocation(install, installBase, ctx.Arch().ArchType.String())) } } } diff --git a/rust/rust.go b/rust/rust.go index 7b520cdb0..dc53cc028 100644 --- a/rust/rust.go +++ b/rust/rust.go @@ -649,7 +649,7 @@ func (mod *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule { panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", mod.BaseModuleName())) } -func (mod *Module) FuzzSharedLibraries() android.Paths { +func (mod *Module) FuzzSharedLibraries() android.RuleBuilderInstalls { if fuzzer, ok := mod.compiler.(*fuzzDecorator); ok { return fuzzer.sharedLibraries }