blob: a32ef1fc050bda6af95e7d6e27668aa10ac221d5 [file] [log] [blame]
Dan Albert914449f2016-06-17 16:45:24 -07001// Copyright 2016 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17import (
18 "fmt"
Dan Albert914449f2016-06-17 16:45:24 -070019 "strings"
Colin Crosse8a67a72016-08-07 21:17:54 -070020 "sync"
Dan Albert914449f2016-06-17 16:45:24 -070021
22 "github.com/google/blueprint"
Jiyong Parkee9b1172021-04-06 17:40:32 +090023 "github.com/google/blueprint/proptools"
Dan Albert914449f2016-06-17 16:45:24 -070024
25 "android/soong/android"
26)
27
sophiez58cabb72020-05-29 13:37:12 -070028func init() {
Dan Albert06f58af2020-06-22 15:10:31 -070029 pctx.HostBinToolVariable("ndkStubGenerator", "ndkstubgen")
sophiez58cabb72020-05-29 13:37:12 -070030 pctx.HostBinToolVariable("ndk_api_coverage_parser", "ndk_api_coverage_parser")
31}
32
Dan Albert914449f2016-06-17 16:45:24 -070033var (
Colin Cross9d45bb72016-08-29 16:14:13 -070034 genStubSrc = pctx.AndroidStaticRule("genStubSrc",
Dan Albert914449f2016-06-17 16:45:24 -070035 blueprint.RuleParams{
Dan Albert06f58af2020-06-22 15:10:31 -070036 Command: "$ndkStubGenerator --arch $arch --api $apiLevel " +
37 "--api-map $apiMap $flags $in $out",
38 CommandDeps: []string{"$ndkStubGenerator"},
Jiyong Park3fd0baf2018-12-07 16:25:39 +090039 }, "arch", "apiLevel", "apiMap", "flags")
Dan Albert914449f2016-06-17 16:45:24 -070040
sophiez58cabb72020-05-29 13:37:12 -070041 parseNdkApiRule = pctx.AndroidStaticRule("parseNdkApiRule",
42 blueprint.RuleParams{
43 Command: "$ndk_api_coverage_parser $in $out --api-map $apiMap",
44 CommandDeps: []string{"$ndk_api_coverage_parser"},
45 }, "apiMap")
46
Dan Albert914449f2016-06-17 16:45:24 -070047 ndkLibrarySuffix = ".ndk"
Colin Cross4d9c2d12016-07-29 12:48:20 -070048
Colin Cross95f1ca02020-10-29 20:47:22 -070049 ndkKnownLibsKey = android.NewOnceKey("ndkKnownLibsKey")
Dan Albertde5aade2020-06-30 12:32:51 -070050 // protects ndkKnownLibs writes during parallel BeginMutator.
51 ndkKnownLibsLock sync.Mutex
Dan Albert914449f2016-06-17 16:45:24 -070052)
53
Dan Albert1a246272020-07-06 14:49:35 -070054// The First_version and Unversioned_until properties of this struct should not
55// be used directly, but rather through the ApiLevel returning methods
56// firstVersion() and unversionedUntil().
57
Dan Albert914449f2016-06-17 16:45:24 -070058// Creates a stub shared library based on the provided version file.
59//
Dan Albert914449f2016-06-17 16:45:24 -070060// Example:
61//
62// ndk_library {
Dan Willemsen01a90592017-04-07 15:21:13 -070063// name: "libfoo",
Dan Albert914449f2016-06-17 16:45:24 -070064// symbol_file: "libfoo.map.txt",
65// first_version: "9",
66// }
67//
68type libraryProperties struct {
69 // Relative path to the symbol map.
70 // An example file can be seen here: TODO(danalbert): Make an example.
Nan Zhang0007d812017-11-07 10:57:05 -080071 Symbol_file *string
Dan Albert914449f2016-06-17 16:45:24 -070072
73 // The first API level a library was available. A library will be generated
74 // for every API level beginning with this one.
Nan Zhang0007d812017-11-07 10:57:05 -080075 First_version *string
Dan Albert914449f2016-06-17 16:45:24 -070076
Dan Albert98dbb3b2017-01-03 15:16:29 -080077 // The first API level that library should have the version script applied.
78 // This defaults to the value of first_version, and should almost never be
79 // used. This is only needed to work around platform bugs like
80 // https://github.com/android-ndk/ndk/issues/265.
Nan Zhang0007d812017-11-07 10:57:05 -080081 Unversioned_until *string
Dan Albert98dbb3b2017-01-03 15:16:29 -080082
Dan Albert23d37e02018-11-28 08:30:10 -080083 // True if this API is not yet ready to be shipped in the NDK. It will be
84 // available in the platform for testing, but will be excluded from the
85 // sysroot provided to the NDK proper.
86 Draft bool
Dan Albert914449f2016-06-17 16:45:24 -070087}
88
Colin Crossb916a382016-07-29 17:28:03 -070089type stubDecorator struct {
90 *libraryDecorator
Dan Albert914449f2016-06-17 16:45:24 -070091
92 properties libraryProperties
Dan Albert2bc91ba2016-07-28 17:40:28 -070093
sophiez58cabb72020-05-29 13:37:12 -070094 versionScriptPath android.ModuleGenPath
95 parsedCoverageXmlPath android.ModuleOutPath
96 installPath android.Path
Dan Albert1a246272020-07-06 14:49:35 -070097
98 apiLevel android.ApiLevel
99 firstVersion android.ApiLevel
100 unversionedUntil android.ApiLevel
Dan Albert914449f2016-06-17 16:45:24 -0700101}
102
Colin Cross0477b422020-10-13 18:43:54 -0700103var _ versionedInterface = (*stubDecorator)(nil)
104
Dan Albert1a246272020-07-06 14:49:35 -0700105func shouldUseVersionScript(ctx BaseModuleContext, stub *stubDecorator) bool {
106 return stub.apiLevel.GreaterThanOrEqualTo(stub.unversionedUntil)
Dan Albert98dbb3b2017-01-03 15:16:29 -0800107}
108
Colin Cross0477b422020-10-13 18:43:54 -0700109func (stub *stubDecorator) implementationModuleName(name string) string {
110 return strings.TrimSuffix(name, ndkLibrarySuffix)
111}
112
Colin Cross3572cf72020-10-01 15:58:11 -0700113func ndkLibraryVersions(ctx android.BaseMutatorContext, from android.ApiLevel) []string {
Dan Albert1a246272020-07-06 14:49:35 -0700114 var versions []android.ApiLevel
115 versionStrs := []string{}
116 for _, version := range ctx.Config().AllSupportedApiLevels() {
117 if version.GreaterThanOrEqualTo(from) {
118 versions = append(versions, version)
119 versionStrs = append(versionStrs, version.String())
120 }
Dan Albert914449f2016-06-17 16:45:24 -0700121 }
Dan Albert0b176c82020-07-23 16:43:25 -0700122 versionStrs = append(versionStrs, android.FutureApiLevel.String())
Dan Albert914449f2016-06-17 16:45:24 -0700123
Colin Cross5ec407b2020-09-30 11:41:33 -0700124 return versionStrs
125}
126
Colin Cross3572cf72020-10-01 15:58:11 -0700127func (this *stubDecorator) stubsVersions(ctx android.BaseMutatorContext) []string {
128 if !ctx.Module().Enabled() {
129 return nil
130 }
131 firstVersion, err := nativeApiLevelFromUser(ctx,
132 String(this.properties.First_version))
133 if err != nil {
134 ctx.PropertyErrorf("first_version", err.Error())
135 return nil
136 }
137 return ndkLibraryVersions(ctx, firstVersion)
138}
139
Dan Albert1a246272020-07-06 14:49:35 -0700140func (this *stubDecorator) initializeProperties(ctx BaseModuleContext) bool {
Colin Cross5ec407b2020-09-30 11:41:33 -0700141 this.apiLevel = nativeApiLevelOrPanic(ctx, this.stubsVersion())
Dan Albert1a246272020-07-06 14:49:35 -0700142
143 var err error
144 this.firstVersion, err = nativeApiLevelFromUser(ctx,
145 String(this.properties.First_version))
146 if err != nil {
147 ctx.PropertyErrorf("first_version", err.Error())
148 return false
149 }
150
Jiyong Parkee9b1172021-04-06 17:40:32 +0900151 str := proptools.StringDefault(this.properties.Unversioned_until, "minimum")
152 this.unversionedUntil, err = nativeApiLevelFromUser(ctx, str)
Dan Albert1a246272020-07-06 14:49:35 -0700153 if err != nil {
154 ctx.PropertyErrorf("unversioned_until", err.Error())
155 return false
156 }
157
158 return true
159}
160
Colin Cross95f1ca02020-10-29 20:47:22 -0700161func getNDKKnownLibs(config android.Config) *[]string {
162 return config.Once(ndkKnownLibsKey, func() interface{} {
163 return &[]string{}
164 }).(*[]string)
165}
166
Colin Crossb916a382016-07-29 17:28:03 -0700167func (c *stubDecorator) compilerInit(ctx BaseModuleContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -0700168 c.baseCompiler.compilerInit(ctx)
169
Dan Willemsen01a90592017-04-07 15:21:13 -0700170 name := ctx.baseModuleName()
171 if strings.HasSuffix(name, ndkLibrarySuffix) {
172 ctx.PropertyErrorf("name", "Do not append %q manually, just use the base name", ndkLibrarySuffix)
173 }
174
Dan Albertde5aade2020-06-30 12:32:51 -0700175 ndkKnownLibsLock.Lock()
176 defer ndkKnownLibsLock.Unlock()
Colin Cross95f1ca02020-10-29 20:47:22 -0700177 ndkKnownLibs := getNDKKnownLibs(ctx.Config())
178 for _, lib := range *ndkKnownLibs {
Dan Albert7e9d2952016-08-04 13:02:36 -0700179 if lib == name {
180 return
181 }
182 }
Colin Cross95f1ca02020-10-29 20:47:22 -0700183 *ndkKnownLibs = append(*ndkKnownLibs, name)
Dan Albert7e9d2952016-08-04 13:02:36 -0700184}
185
George Burgess IVf5310e32017-07-19 11:39:53 -0700186func addStubLibraryCompilerFlags(flags Flags) Flags {
Colin Cross4af21ed2019-11-04 09:37:55 -0800187 flags.Global.CFlags = append(flags.Global.CFlags,
George Burgess IVf5310e32017-07-19 11:39:53 -0700188 // We're knowingly doing some otherwise unsightly things with builtin
189 // functions here. We're just generating stub libraries, so ignore it.
190 "-Wno-incompatible-library-redeclaration",
Nick Desaulnierseb207442019-12-12 10:15:42 -0800191 "-Wno-incomplete-setjmp-declaration",
George Burgess IVf5310e32017-07-19 11:39:53 -0700192 "-Wno-builtin-requires-header",
193 "-Wno-invalid-noreturn",
Chih-Hung Hsieh64a38dc2017-11-14 14:09:14 -0800194 "-Wall",
195 "-Werror",
George Burgess IVf5310e32017-07-19 11:39:53 -0700196 // These libraries aren't actually used. Don't worry about unwinding
197 // (avoids the need to link an unwinder into a fake library).
198 "-fno-unwind-tables",
199 )
Jiyong Park48d75ef2019-11-21 15:11:49 +0900200 // All symbols in the stubs library should be visible.
201 if inList("-fvisibility=hidden", flags.Local.CFlags) {
202 flags.Local.CFlags = append(flags.Local.CFlags, "-fvisibility=default")
203 }
George Burgess IVf5310e32017-07-19 11:39:53 -0700204 return flags
205}
206
Colin Crossf18e1102017-11-16 14:33:08 -0800207func (stub *stubDecorator) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
208 flags = stub.baseCompiler.compilerFlags(ctx, flags, deps)
George Burgess IVf5310e32017-07-19 11:39:53 -0700209 return addStubLibraryCompilerFlags(flags)
210}
211
Jiyong Park3fd0baf2018-12-07 16:25:39 +0900212func compileStubLibrary(ctx ModuleContext, flags Flags, symbolFile, apiLevel, genstubFlags string) (Objects, android.ModuleGenPath) {
Dan Albert914449f2016-06-17 16:45:24 -0700213 arch := ctx.Arch().ArchType.String()
214
Dan Willemsenb916b802017-03-19 13:44:32 -0700215 stubSrcPath := android.PathForModuleGen(ctx, "stub.c")
216 versionScriptPath := android.PathForModuleGen(ctx, "stub.map")
217 symbolFilePath := android.PathForModuleSrc(ctx, symbolFile)
Dan Albert49927d22017-03-28 15:00:46 -0700218 apiLevelsJson := android.GetApiLevelsJson(ctx)
Colin Crossae887032017-10-23 17:16:14 -0700219 ctx.Build(pctx, android.BuildParams{
Colin Cross67a5c132017-05-09 13:45:28 -0700220 Rule: genStubSrc,
221 Description: "generate stubs " + symbolFilePath.Rel(),
222 Outputs: []android.WritablePath{stubSrcPath, versionScriptPath},
223 Input: symbolFilePath,
224 Implicits: []android.Path{apiLevelsJson},
Dan Albert914449f2016-06-17 16:45:24 -0700225 Args: map[string]string{
226 "arch": arch,
Dan Willemsenb916b802017-03-19 13:44:32 -0700227 "apiLevel": apiLevel,
Dan Albert49927d22017-03-28 15:00:46 -0700228 "apiMap": apiLevelsJson.String(),
Jiyong Park3fd0baf2018-12-07 16:25:39 +0900229 "flags": genstubFlags,
Dan Albert914449f2016-06-17 16:45:24 -0700230 },
231 })
232
Dan Albert914449f2016-06-17 16:45:24 -0700233 subdir := ""
Colin Cross2f336352016-10-26 10:03:47 -0700234 srcs := []android.Path{stubSrcPath}
Pirama Arumuga Nainar70ba5a32017-12-19 15:11:01 -0800235 return compileObjs(ctx, flagsToBuilderFlags(flags), subdir, srcs, nil, nil), versionScriptPath
Dan Willemsenb916b802017-03-19 13:44:32 -0700236}
237
sophiez58cabb72020-05-29 13:37:12 -0700238func parseSymbolFileForCoverage(ctx ModuleContext, symbolFile string) android.ModuleOutPath {
239 apiLevelsJson := android.GetApiLevelsJson(ctx)
240 symbolFilePath := android.PathForModuleSrc(ctx, symbolFile)
241 outputFileName := strings.Split(symbolFilePath.Base(), ".")[0]
242 parsedApiCoveragePath := android.PathForModuleOut(ctx, outputFileName+".xml")
243 ctx.Build(pctx, android.BuildParams{
244 Rule: parseNdkApiRule,
245 Description: "parse ndk api symbol file for api coverage: " + symbolFilePath.Rel(),
246 Outputs: []android.WritablePath{parsedApiCoveragePath},
247 Input: symbolFilePath,
sophiez148b3172020-06-11 17:27:56 -0700248 Implicits: []android.Path{apiLevelsJson},
sophiez58cabb72020-05-29 13:37:12 -0700249 Args: map[string]string{
250 "apiMap": apiLevelsJson.String(),
251 },
252 })
253 return parsedApiCoveragePath
254}
255
Dan Willemsenb916b802017-03-19 13:44:32 -0700256func (c *stubDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
Nan Zhang0007d812017-11-07 10:57:05 -0800257 if !strings.HasSuffix(String(c.properties.Symbol_file), ".map.txt") {
Dan Albert15be0c62017-06-13 15:14:56 -0700258 ctx.PropertyErrorf("symbol_file", "must end with .map.txt")
259 }
260
Colin Cross5ec407b2020-09-30 11:41:33 -0700261 if !c.buildStubs() {
262 // NDK libraries have no implementation variant, nothing to do
263 return Objects{}
264 }
265
Dan Albert1a246272020-07-06 14:49:35 -0700266 if !c.initializeProperties(ctx) {
267 // Emits its own errors, so we don't need to.
268 return Objects{}
269 }
270
sophiez58cabb72020-05-29 13:37:12 -0700271 symbolFile := String(c.properties.Symbol_file)
272 objs, versionScript := compileStubLibrary(ctx, flags, symbolFile,
Dan Albert1a246272020-07-06 14:49:35 -0700273 c.apiLevel.String(), "")
Dan Willemsenb916b802017-03-19 13:44:32 -0700274 c.versionScriptPath = versionScript
Dan Albert1a246272020-07-06 14:49:35 -0700275 if c.apiLevel.IsCurrent() && ctx.PrimaryArch() {
sophiez58cabb72020-05-29 13:37:12 -0700276 c.parsedCoverageXmlPath = parseSymbolFileForCoverage(ctx, symbolFile)
277 }
Dan Willemsenb916b802017-03-19 13:44:32 -0700278 return objs
Dan Albert914449f2016-06-17 16:45:24 -0700279}
280
Colin Cross37047f12016-12-13 17:06:13 -0800281func (linker *stubDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps {
Dan Albert914449f2016-06-17 16:45:24 -0700282 return Deps{}
283}
284
Dan Willemsen01a90592017-04-07 15:21:13 -0700285func (linker *stubDecorator) Name(name string) string {
286 return name + ndkLibrarySuffix
287}
288
Colin Crossb916a382016-07-29 17:28:03 -0700289func (stub *stubDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags {
Dan Willemsen01a90592017-04-07 15:21:13 -0700290 stub.libraryDecorator.libName = ctx.baseModuleName()
Colin Crossb916a382016-07-29 17:28:03 -0700291 return stub.libraryDecorator.linkerFlags(ctx, flags)
Dan Albert914449f2016-06-17 16:45:24 -0700292}
293
Colin Crossb916a382016-07-29 17:28:03 -0700294func (stub *stubDecorator) link(ctx ModuleContext, flags Flags, deps PathDeps,
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700295 objs Objects) android.Path {
Dan Albert2bc91ba2016-07-28 17:40:28 -0700296
Colin Cross5ec407b2020-09-30 11:41:33 -0700297 if !stub.buildStubs() {
298 // NDK libraries have no implementation variant, nothing to do
299 return nil
300 }
301
Dan Albert1a246272020-07-06 14:49:35 -0700302 if shouldUseVersionScript(ctx, stub) {
Dan Albert98dbb3b2017-01-03 15:16:29 -0800303 linkerScriptFlag := "-Wl,--version-script," + stub.versionScriptPath.String()
Colin Cross4af21ed2019-11-04 09:37:55 -0800304 flags.Local.LdFlags = append(flags.Local.LdFlags, linkerScriptFlag)
Dan Willemsen939408a2019-06-10 18:02:25 -0700305 flags.LdFlagsDeps = append(flags.LdFlagsDeps, stub.versionScriptPath)
Dan Albert98dbb3b2017-01-03 15:16:29 -0800306 }
307
Colin Cross5ec407b2020-09-30 11:41:33 -0700308 stub.libraryDecorator.skipAPIDefine = true
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700309 return stub.libraryDecorator.link(ctx, flags, deps, objs)
Dan Albert2bc91ba2016-07-28 17:40:28 -0700310}
311
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700312func (stub *stubDecorator) nativeCoverage() bool {
313 return false
314}
315
Colin Crossb916a382016-07-29 17:28:03 -0700316func (stub *stubDecorator) install(ctx ModuleContext, path android.Path) {
Dan Albert914449f2016-06-17 16:45:24 -0700317 arch := ctx.Target().Arch.ArchType.Name
Dan Albert914449f2016-06-17 16:45:24 -0700318 // arm64 isn't actually a multilib toolchain, so unlike the other LP64
319 // architectures it's just installed to lib.
320 libDir := "lib"
321 if ctx.toolchain().Is64Bit() && arch != "arm64" {
322 libDir = "lib64"
323 }
324
325 installDir := getNdkInstallBase(ctx).Join(ctx, fmt.Sprintf(
Dan Albert1a246272020-07-06 14:49:35 -0700326 "platforms/android-%s/arch-%s/usr/%s", stub.apiLevel, arch, libDir))
Colin Cross0875c522017-11-28 17:34:01 -0800327 stub.installPath = ctx.InstallFile(installDir, path.Base(), path)
Dan Albert914449f2016-06-17 16:45:24 -0700328}
329
Colin Cross36242852017-06-23 15:06:31 -0700330func newStubLibrary() *Module {
Colin Crossab3b7322016-12-09 14:46:15 -0800331 module, library := NewLibrary(android.DeviceSupported)
332 library.BuildOnlyShared()
Dan Albert914449f2016-06-17 16:45:24 -0700333 module.stl = nil
Colin Crossb916a382016-07-29 17:28:03 -0700334 module.sanitize = nil
ThiƩbaud Weksteend4587452020-08-19 14:53:01 +0200335 library.disableStripping()
Dan Albert914449f2016-06-17 16:45:24 -0700336
Colin Crossb916a382016-07-29 17:28:03 -0700337 stub := &stubDecorator{
338 libraryDecorator: library,
339 }
340 module.compiler = stub
341 module.linker = stub
342 module.installer = stub
Colin Cross31076b32020-10-23 17:22:06 -0700343 module.library = stub
Dan Albert914449f2016-06-17 16:45:24 -0700344
Colin Crossc511bc52020-04-07 16:50:32 +0000345 module.Properties.AlwaysSdk = true
346 module.Properties.Sdk_version = StringPtr("current")
347
Colin Cross36242852017-06-23 15:06:31 -0700348 module.AddProperties(&stub.properties, &library.MutatedProperties)
349
350 return module
Dan Albert914449f2016-06-17 16:45:24 -0700351}
352
Dan Albertf740ed02020-07-24 14:19:06 -0700353// ndk_library creates a library that exposes a stub implementation of functions
354// and variables for use at build time only.
Jooyung Hanb90e4912019-12-09 18:21:48 +0900355func NdkLibraryFactory() android.Module {
Colin Cross36242852017-06-23 15:06:31 -0700356 module := newStubLibrary()
357 android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibBoth)
358 return module
Dan Albert914449f2016-06-17 16:45:24 -0700359}