From c5dd4f7c1f3958bb68ad493088275b286a6acd6b Mon Sep 17 00:00:00 2001 From: Martin Stjernholm Date: Wed, 1 Apr 2020 20:38:01 +0100 Subject: [PATCH] Propagate stubs to the SDK for libraries that have them. Necessary to make the APEX build logic treat the libraries as API boundaries rather than dependencies to bundle. The .so files in the snapshots are the compiled stub libraries in this case. They are strictly speaking redundant since they can be generated from the .map.txt files in the snapshots, but doing that would require extending the cc_prebuilt_library(_shared) module types with a full compiler pass etc, and that would break a lot of assumptions in the cc package. Test: m nothing Test: Create an SDK snapshot with Bionic libs, drop it into a master-art tree without bionic/ in it, build ART APEXes, and check that the Soong phase completes (specifically no errors about various APEX libs requiring libc that is not available to them). Bug: 152481980 Change-Id: I31b928e6261198b6dd6f6b17196e714f07b64172 --- cc/cc.go | 7 +++++ cc/library.go | 6 +++- cc/library_sdk_member.go | 21 ++++++++++++++ sdk/cc_sdk_test.go | 63 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 96 insertions(+), 1 deletion(-) diff --git a/cc/cc.go b/cc/cc.go index de07229f9..6075ba111 100644 --- a/cc/cc.go +++ b/cc/cc.go @@ -583,6 +583,13 @@ func (c *Module) GetDepsInLinkOrder() []android.Path { return c.depsInLinkOrder } +func (c *Module) StubsSymbolFile() android.OptionalPath { + if library, ok := c.linker.(*libraryDecorator); ok { + return library.stubsSymbolFile + } + return android.OptionalPath{} +} + func (c *Module) StubsVersions() []string { if c.linker != nil { if library, ok := c.linker.(*libraryDecorator); ok { diff --git a/cc/library.go b/cc/library.go index b9f448bfa..26e86f940 100644 --- a/cc/library.go +++ b/cc/library.go @@ -367,6 +367,9 @@ type libraryDecorator struct { // Location of the file that should be copied to dist dir when requested distFile android.OptionalPath + // stubs.symbol_file + stubsSymbolFile android.OptionalPath + versionScriptPath android.ModuleGenPath post_install_cmds []string @@ -376,7 +379,7 @@ type libraryDecorator struct { useCoreVariant bool checkSameCoreVariant bool - // Decorated interafaces + // Decorated interfaces *baseCompiler *baseLinker *baseInstaller @@ -603,6 +606,7 @@ func (library *libraryDecorator) shouldCreateSourceAbiDump(ctx ModuleContext) bo func (library *libraryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects { if library.buildStubs() { + library.stubsSymbolFile = android.OptionalPathForModuleSrc(ctx, library.Properties.Stubs.Symbol_file) objs, versionScript := compileStubLibrary(ctx, flags, String(library.Properties.Stubs.Symbol_file), library.MutatedProperties.StubsVersion, "--apex") library.versionScriptPath = versionScript return objs diff --git a/cc/library_sdk_member.go b/cc/library_sdk_member.go index 0a11af126..4e4df5b0e 100644 --- a/cc/library_sdk_member.go +++ b/cc/library_sdk_member.go @@ -269,12 +269,21 @@ func addPossiblyArchSpecificProperties(sdkModuleContext android.ModuleContext, b for property, dirs := range includeDirs { outputProperties.AddProperty(property, dirs) } + + if len(libInfo.StubsVersion) > 0 { + symbolFilePath := filepath.Join(nativeEtcDir, libInfo.StubsSymbolFile.Path().Base()) + builder.CopyToSnapshot(libInfo.StubsSymbolFile.Path(), symbolFilePath) + stubsSet := outputProperties.AddPropertySet("stubs") + stubsSet.AddProperty("symbol_file", symbolFilePath) + stubsSet.AddProperty("versions", []string{libInfo.StubsVersion}) + } } const ( nativeIncludeDir = "include" nativeGeneratedIncludeDir = "include_gen" nativeStubDir = "lib" + nativeEtcDir = "etc" ) // path to the native library. Relative to / @@ -335,6 +344,13 @@ type nativeLibInfoProperties struct { // This field is exported as its contents may not be arch specific. SystemSharedLibs []string + // The specific stubs version for the lib variant, or empty string if stubs + // are not in use. + StubsVersion string + + // The stubs symbol file. + StubsSymbolFile android.OptionalPath + // outputFile is not exported as it is always arch specific. outputFile android.Path } @@ -370,6 +386,11 @@ func (p *nativeLibInfoProperties) PopulateFromVariant(ctx android.SdkMemberConte p.SystemSharedLibs = specifiedDeps.systemSharedLibs } p.exportedGeneratedHeaders = ccModule.ExportedGeneratedHeaders() + + if ccModule.HasStubsVariants() { + p.StubsVersion = ccModule.StubsVersion() + p.StubsSymbolFile = ccModule.StubsSymbolFile() + } } func (p *nativeLibInfoProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) { diff --git a/sdk/cc_sdk_test.go b/sdk/cc_sdk_test.go index eb64bcc16..9e6086f15 100644 --- a/sdk/cc_sdk_test.go +++ b/sdk/cc_sdk_test.go @@ -32,6 +32,7 @@ func testSdkWithCc(t *testing.T, bp string) *testSdkResult { "arm64/include/Arm64Test.h": nil, "libfoo.so": nil, "aidl/foo/bar/Test.aidl": nil, + "some/where/stubslib.map.txt": nil, } return testSdkWithFs(t, bp, fs) } @@ -1739,3 +1740,65 @@ sdk_snapshot { } `)) } + +func TestStubsLibrary(t *testing.T) { + result := testSdkWithCc(t, ` + sdk { + name: "mysdk", + native_shared_libs: ["stubslib"], + } + + cc_library { + name: "stubslib", + stubs: { + symbol_file: "some/where/stubslib.map.txt", + versions: ["1", "2", "3"], + }, + } + `) + + result.CheckSnapshot("mysdk", "", + checkAndroidBpContents(` +// This is auto-generated. DO NOT EDIT. + +cc_prebuilt_library_shared { + name: "mysdk_stubslib@current", + sdk_member_name: "stubslib", + installable: false, + stubs: { + symbol_file: "etc/stubslib.map.txt", + versions: ["3"], + }, + arch: { + arm64: { + srcs: ["arm64/lib/stubslib.so"], + }, + arm: { + srcs: ["arm/lib/stubslib.so"], + }, + }, +} + +cc_prebuilt_library_shared { + name: "stubslib", + prefer: false, + stubs: { + symbol_file: "etc/stubslib.map.txt", + versions: ["3"], + }, + arch: { + arm64: { + srcs: ["arm64/lib/stubslib.so"], + }, + arm: { + srcs: ["arm/lib/stubslib.so"], + }, + }, +} + +sdk_snapshot { + name: "mysdk@current", + native_shared_libs: ["mysdk_stubslib@current"], +} +`)) +}