Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 1 | // 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 | |
| 15 | package cc |
| 16 | |
| 17 | import ( |
| 18 | "fmt" |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 19 | "path/filepath" |
Dan Albert | ad66593 | 2021-06-07 13:19:49 -0700 | [diff] [blame] | 20 | "runtime" |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 21 | "strings" |
Colin Cross | e8a67a7 | 2016-08-07 21:17:54 -0700 | [diff] [blame] | 22 | "sync" |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 23 | |
| 24 | "github.com/google/blueprint" |
Jiyong Park | ee9b117 | 2021-04-06 17:40:32 +0900 | [diff] [blame] | 25 | "github.com/google/blueprint/proptools" |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 26 | |
| 27 | "android/soong/android" |
Spandan Das | 1278c2c | 2022-08-19 18:17:28 +0000 | [diff] [blame] | 28 | "android/soong/bazel" |
Jingwen Chen | 341f735 | 2022-01-11 05:42:49 +0000 | [diff] [blame] | 29 | "android/soong/cc/config" |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 30 | ) |
| 31 | |
sophiez | 58cabb7 | 2020-05-29 13:37:12 -0700 | [diff] [blame] | 32 | func init() { |
Dan Albert | 06f58af | 2020-06-22 15:10:31 -0700 | [diff] [blame] | 33 | pctx.HostBinToolVariable("ndkStubGenerator", "ndkstubgen") |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 34 | pctx.HostBinToolVariable("abidw", "abidw") |
Matthias Maennich | ca8ae65 | 2023-06-30 21:52:17 +0100 | [diff] [blame] | 35 | pctx.HostBinToolVariable("stg", "stg") |
Matthias Maennich | 658bb4d | 2023-06-30 23:28:15 +0100 | [diff] [blame] | 36 | pctx.HostBinToolVariable("stgdiff", "stgdiff") |
sophiez | 58cabb7 | 2020-05-29 13:37:12 -0700 | [diff] [blame] | 37 | } |
| 38 | |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 39 | var ( |
Colin Cross | 9d45bb7 | 2016-08-29 16:14:13 -0700 | [diff] [blame] | 40 | genStubSrc = pctx.AndroidStaticRule("genStubSrc", |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 41 | blueprint.RuleParams{ |
Dan Albert | 06f58af | 2020-06-22 15:10:31 -0700 | [diff] [blame] | 42 | Command: "$ndkStubGenerator --arch $arch --api $apiLevel " + |
| 43 | "--api-map $apiMap $flags $in $out", |
| 44 | CommandDeps: []string{"$ndkStubGenerator"}, |
Jiyong Park | 3fd0baf | 2018-12-07 16:25:39 +0900 | [diff] [blame] | 45 | }, "arch", "apiLevel", "apiMap", "flags") |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 46 | |
Matthias Maennich | 55486f8 | 2023-07-03 12:25:27 +0100 | [diff] [blame^] | 47 | // TODO(b/156513478): remove once migration to STG is complete |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 48 | abidw = pctx.AndroidStaticRule("abidw", |
| 49 | blueprint.RuleParams{ |
| 50 | Command: "$abidw --type-id-style hash --no-corpus-path " + |
Matthias Maennich | c2346f1 | 2021-09-02 20:45:33 +0100 | [diff] [blame] | 51 | "--no-show-locs --no-comp-dir-path -w $symbolList " + |
| 52 | "$in --out-file $out", |
| 53 | CommandDeps: []string{"$abidw"}, |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 54 | }, "symbolList") |
| 55 | |
Matthias Maennich | 55486f8 | 2023-07-03 12:25:27 +0100 | [diff] [blame^] | 56 | stg = pctx.AndroidStaticRule("stg", |
| 57 | blueprint.RuleParams{ |
| 58 | Command: "$stg -S :$symbolList --elf $in -o $out", |
| 59 | CommandDeps: []string{"$stg"}, |
| 60 | }, "symbolList") |
| 61 | |
| 62 | // TODO(b/156513478): remove once migration to STG is complete |
Matthias Maennich | ca8ae65 | 2023-06-30 21:52:17 +0100 | [diff] [blame] | 63 | xml2stg = pctx.AndroidStaticRule("xml2stg", |
Matthias Maennich | c2346f1 | 2021-09-02 20:45:33 +0100 | [diff] [blame] | 64 | blueprint.RuleParams{ |
Matthias Maennich | ca8ae65 | 2023-06-30 21:52:17 +0100 | [diff] [blame] | 65 | Command: "$stg --abi -i $in -o $out", |
| 66 | CommandDeps: []string{"$stg"}, |
| 67 | }) |
Matthias Maennich | c2346f1 | 2021-09-02 20:45:33 +0100 | [diff] [blame] | 68 | |
Matthias Maennich | 658bb4d | 2023-06-30 23:28:15 +0100 | [diff] [blame] | 69 | stgdiff = pctx.AndroidStaticRule("stgdiff", |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 70 | blueprint.RuleParams{ |
| 71 | // Need to create *some* output for ninja. We don't want to use tee |
| 72 | // because we don't want to spam the build output with "nothing |
| 73 | // changed" messages, so redirect output message to $out, and if |
| 74 | // changes were detected print the output and fail. |
Matthias Maennich | 658bb4d | 2023-06-30 23:28:15 +0100 | [diff] [blame] | 75 | Command: "$stgdiff $args --stg $in -o $out || (cat $out && false)", |
| 76 | CommandDeps: []string{"$stgdiff"}, |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 77 | }, "args") |
| 78 | |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 79 | ndkLibrarySuffix = ".ndk" |
Colin Cross | 4d9c2d1 | 2016-07-29 12:48:20 -0700 | [diff] [blame] | 80 | |
Colin Cross | 95f1ca0 | 2020-10-29 20:47:22 -0700 | [diff] [blame] | 81 | ndkKnownLibsKey = android.NewOnceKey("ndkKnownLibsKey") |
Dan Albert | de5aade | 2020-06-30 12:32:51 -0700 | [diff] [blame] | 82 | // protects ndkKnownLibs writes during parallel BeginMutator. |
| 83 | ndkKnownLibsLock sync.Mutex |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 84 | |
| 85 | stubImplementation = dependencyTag{name: "stubImplementation"} |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 86 | ) |
| 87 | |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 88 | // The First_version and Unversioned_until properties of this struct should not |
| 89 | // be used directly, but rather through the ApiLevel returning methods |
| 90 | // firstVersion() and unversionedUntil(). |
| 91 | |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 92 | // Creates a stub shared library based on the provided version file. |
| 93 | // |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 94 | // Example: |
| 95 | // |
Spandan Das | 73bcafc | 2022-08-18 23:26:00 +0000 | [diff] [blame] | 96 | // ndk_library { |
| 97 | // |
| 98 | // name: "libfoo", |
| 99 | // symbol_file: "libfoo.map.txt", |
| 100 | // first_version: "9", |
| 101 | // |
| 102 | // } |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 103 | type libraryProperties struct { |
| 104 | // Relative path to the symbol map. |
| 105 | // An example file can be seen here: TODO(danalbert): Make an example. |
Inseob Kim | 5eb7ee9 | 2022-04-27 10:30:34 +0900 | [diff] [blame] | 106 | Symbol_file *string `android:"path"` |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 107 | |
| 108 | // The first API level a library was available. A library will be generated |
| 109 | // for every API level beginning with this one. |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 110 | First_version *string |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 111 | |
Dan Albert | 98dbb3b | 2017-01-03 15:16:29 -0800 | [diff] [blame] | 112 | // The first API level that library should have the version script applied. |
| 113 | // This defaults to the value of first_version, and should almost never be |
| 114 | // used. This is only needed to work around platform bugs like |
| 115 | // https://github.com/android-ndk/ndk/issues/265. |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 116 | Unversioned_until *string |
Dan Albert | 604086f | 2021-06-15 13:23:44 -0700 | [diff] [blame] | 117 | |
Spandan Das | 73bcafc | 2022-08-18 23:26:00 +0000 | [diff] [blame] | 118 | // Headers presented by this library to the Public API Surface |
| 119 | Export_header_libs []string |
Matthias Maennich | 55486f8 | 2023-07-03 12:25:27 +0100 | [diff] [blame^] | 120 | |
| 121 | // TODO(b/156513478): remove once migration to STG is complete |
| 122 | // Fall back to the legacy abidw ABI extraction pipeline |
| 123 | Legacy_use_abidw *bool |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 124 | } |
| 125 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 126 | type stubDecorator struct { |
| 127 | *libraryDecorator |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 128 | |
| 129 | properties libraryProperties |
Dan Albert | 2bc91ba | 2016-07-28 17:40:28 -0700 | [diff] [blame] | 130 | |
sophiez | 58cabb7 | 2020-05-29 13:37:12 -0700 | [diff] [blame] | 131 | versionScriptPath android.ModuleGenPath |
| 132 | parsedCoverageXmlPath android.ModuleOutPath |
| 133 | installPath android.Path |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 134 | abiDumpPath android.OutputPath |
| 135 | abiDiffPaths android.Paths |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 136 | |
| 137 | apiLevel android.ApiLevel |
| 138 | firstVersion android.ApiLevel |
| 139 | unversionedUntil android.ApiLevel |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 140 | } |
| 141 | |
Colin Cross | 0477b42 | 2020-10-13 18:43:54 -0700 | [diff] [blame] | 142 | var _ versionedInterface = (*stubDecorator)(nil) |
| 143 | |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 144 | func shouldUseVersionScript(ctx BaseModuleContext, stub *stubDecorator) bool { |
| 145 | return stub.apiLevel.GreaterThanOrEqualTo(stub.unversionedUntil) |
Dan Albert | 98dbb3b | 2017-01-03 15:16:29 -0800 | [diff] [blame] | 146 | } |
| 147 | |
Colin Cross | 0477b42 | 2020-10-13 18:43:54 -0700 | [diff] [blame] | 148 | func (stub *stubDecorator) implementationModuleName(name string) string { |
| 149 | return strings.TrimSuffix(name, ndkLibrarySuffix) |
| 150 | } |
| 151 | |
Colin Cross | 3572cf7 | 2020-10-01 15:58:11 -0700 | [diff] [blame] | 152 | func ndkLibraryVersions(ctx android.BaseMutatorContext, from android.ApiLevel) []string { |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 153 | var versions []android.ApiLevel |
| 154 | versionStrs := []string{} |
| 155 | for _, version := range ctx.Config().AllSupportedApiLevels() { |
| 156 | if version.GreaterThanOrEqualTo(from) { |
| 157 | versions = append(versions, version) |
| 158 | versionStrs = append(versionStrs, version.String()) |
| 159 | } |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 160 | } |
Dan Albert | 0b176c8 | 2020-07-23 16:43:25 -0700 | [diff] [blame] | 161 | versionStrs = append(versionStrs, android.FutureApiLevel.String()) |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 162 | |
Colin Cross | 5ec407b | 2020-09-30 11:41:33 -0700 | [diff] [blame] | 163 | return versionStrs |
| 164 | } |
| 165 | |
Colin Cross | 3572cf7 | 2020-10-01 15:58:11 -0700 | [diff] [blame] | 166 | func (this *stubDecorator) stubsVersions(ctx android.BaseMutatorContext) []string { |
| 167 | if !ctx.Module().Enabled() { |
| 168 | return nil |
| 169 | } |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 170 | if ctx.Target().NativeBridge == android.NativeBridgeEnabled { |
| 171 | ctx.Module().Disable() |
| 172 | return nil |
| 173 | } |
Colin Cross | 3572cf7 | 2020-10-01 15:58:11 -0700 | [diff] [blame] | 174 | firstVersion, err := nativeApiLevelFromUser(ctx, |
| 175 | String(this.properties.First_version)) |
| 176 | if err != nil { |
| 177 | ctx.PropertyErrorf("first_version", err.Error()) |
| 178 | return nil |
| 179 | } |
| 180 | return ndkLibraryVersions(ctx, firstVersion) |
| 181 | } |
| 182 | |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 183 | func (this *stubDecorator) initializeProperties(ctx BaseModuleContext) bool { |
Colin Cross | 5ec407b | 2020-09-30 11:41:33 -0700 | [diff] [blame] | 184 | this.apiLevel = nativeApiLevelOrPanic(ctx, this.stubsVersion()) |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 185 | |
| 186 | var err error |
| 187 | this.firstVersion, err = nativeApiLevelFromUser(ctx, |
| 188 | String(this.properties.First_version)) |
| 189 | if err != nil { |
| 190 | ctx.PropertyErrorf("first_version", err.Error()) |
| 191 | return false |
| 192 | } |
| 193 | |
Jiyong Park | ee9b117 | 2021-04-06 17:40:32 +0900 | [diff] [blame] | 194 | str := proptools.StringDefault(this.properties.Unversioned_until, "minimum") |
| 195 | this.unversionedUntil, err = nativeApiLevelFromUser(ctx, str) |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 196 | if err != nil { |
| 197 | ctx.PropertyErrorf("unversioned_until", err.Error()) |
| 198 | return false |
| 199 | } |
| 200 | |
| 201 | return true |
| 202 | } |
| 203 | |
Colin Cross | 95f1ca0 | 2020-10-29 20:47:22 -0700 | [diff] [blame] | 204 | func getNDKKnownLibs(config android.Config) *[]string { |
| 205 | return config.Once(ndkKnownLibsKey, func() interface{} { |
| 206 | return &[]string{} |
| 207 | }).(*[]string) |
| 208 | } |
| 209 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 210 | func (c *stubDecorator) compilerInit(ctx BaseModuleContext) { |
Dan Albert | 7e9d295 | 2016-08-04 13:02:36 -0700 | [diff] [blame] | 211 | c.baseCompiler.compilerInit(ctx) |
| 212 | |
Dan Willemsen | 01a9059 | 2017-04-07 15:21:13 -0700 | [diff] [blame] | 213 | name := ctx.baseModuleName() |
| 214 | if strings.HasSuffix(name, ndkLibrarySuffix) { |
| 215 | ctx.PropertyErrorf("name", "Do not append %q manually, just use the base name", ndkLibrarySuffix) |
| 216 | } |
| 217 | |
Dan Albert | de5aade | 2020-06-30 12:32:51 -0700 | [diff] [blame] | 218 | ndkKnownLibsLock.Lock() |
| 219 | defer ndkKnownLibsLock.Unlock() |
Colin Cross | 95f1ca0 | 2020-10-29 20:47:22 -0700 | [diff] [blame] | 220 | ndkKnownLibs := getNDKKnownLibs(ctx.Config()) |
| 221 | for _, lib := range *ndkKnownLibs { |
Dan Albert | 7e9d295 | 2016-08-04 13:02:36 -0700 | [diff] [blame] | 222 | if lib == name { |
| 223 | return |
| 224 | } |
| 225 | } |
Colin Cross | 95f1ca0 | 2020-10-29 20:47:22 -0700 | [diff] [blame] | 226 | *ndkKnownLibs = append(*ndkKnownLibs, name) |
Dan Albert | 7e9d295 | 2016-08-04 13:02:36 -0700 | [diff] [blame] | 227 | } |
| 228 | |
Jingwen Chen | 341f735 | 2022-01-11 05:42:49 +0000 | [diff] [blame] | 229 | var stubLibraryCompilerFlags = []string{ |
| 230 | // We're knowingly doing some otherwise unsightly things with builtin |
| 231 | // functions here. We're just generating stub libraries, so ignore it. |
| 232 | "-Wno-incompatible-library-redeclaration", |
| 233 | "-Wno-incomplete-setjmp-declaration", |
| 234 | "-Wno-builtin-requires-header", |
| 235 | "-Wno-invalid-noreturn", |
| 236 | "-Wall", |
| 237 | "-Werror", |
| 238 | // These libraries aren't actually used. Don't worry about unwinding |
| 239 | // (avoids the need to link an unwinder into a fake library). |
| 240 | "-fno-unwind-tables", |
| 241 | } |
| 242 | |
| 243 | func init() { |
| 244 | config.ExportStringList("StubLibraryCompilerFlags", stubLibraryCompilerFlags) |
| 245 | } |
| 246 | |
George Burgess IV | f5310e3 | 2017-07-19 11:39:53 -0700 | [diff] [blame] | 247 | func addStubLibraryCompilerFlags(flags Flags) Flags { |
Jingwen Chen | 341f735 | 2022-01-11 05:42:49 +0000 | [diff] [blame] | 248 | flags.Global.CFlags = append(flags.Global.CFlags, stubLibraryCompilerFlags...) |
Jiyong Park | 48d75ef | 2019-11-21 15:11:49 +0900 | [diff] [blame] | 249 | // All symbols in the stubs library should be visible. |
| 250 | if inList("-fvisibility=hidden", flags.Local.CFlags) { |
| 251 | flags.Local.CFlags = append(flags.Local.CFlags, "-fvisibility=default") |
| 252 | } |
George Burgess IV | f5310e3 | 2017-07-19 11:39:53 -0700 | [diff] [blame] | 253 | return flags |
| 254 | } |
| 255 | |
Colin Cross | f18e110 | 2017-11-16 14:33:08 -0800 | [diff] [blame] | 256 | func (stub *stubDecorator) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags { |
| 257 | flags = stub.baseCompiler.compilerFlags(ctx, flags, deps) |
George Burgess IV | f5310e3 | 2017-07-19 11:39:53 -0700 | [diff] [blame] | 258 | return addStubLibraryCompilerFlags(flags) |
| 259 | } |
| 260 | |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 261 | type ndkApiOutputs struct { |
| 262 | stubSrc android.ModuleGenPath |
| 263 | versionScript android.ModuleGenPath |
| 264 | symbolList android.ModuleGenPath |
| 265 | } |
| 266 | |
| 267 | func parseNativeAbiDefinition(ctx ModuleContext, symbolFile string, |
| 268 | apiLevel android.ApiLevel, genstubFlags string) ndkApiOutputs { |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 269 | |
Dan Willemsen | b916b80 | 2017-03-19 13:44:32 -0700 | [diff] [blame] | 270 | stubSrcPath := android.PathForModuleGen(ctx, "stub.c") |
| 271 | versionScriptPath := android.PathForModuleGen(ctx, "stub.map") |
| 272 | symbolFilePath := android.PathForModuleSrc(ctx, symbolFile) |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 273 | symbolListPath := android.PathForModuleGen(ctx, "abi_symbol_list.txt") |
Dan Albert | 49927d2 | 2017-03-28 15:00:46 -0700 | [diff] [blame] | 274 | apiLevelsJson := android.GetApiLevelsJson(ctx) |
Colin Cross | ae88703 | 2017-10-23 17:16:14 -0700 | [diff] [blame] | 275 | ctx.Build(pctx, android.BuildParams{ |
Colin Cross | 67a5c13 | 2017-05-09 13:45:28 -0700 | [diff] [blame] | 276 | Rule: genStubSrc, |
| 277 | Description: "generate stubs " + symbolFilePath.Rel(), |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 278 | Outputs: []android.WritablePath{stubSrcPath, versionScriptPath, |
| 279 | symbolListPath}, |
| 280 | Input: symbolFilePath, |
| 281 | Implicits: []android.Path{apiLevelsJson}, |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 282 | Args: map[string]string{ |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 283 | "arch": ctx.Arch().ArchType.String(), |
| 284 | "apiLevel": apiLevel.String(), |
Dan Albert | 49927d2 | 2017-03-28 15:00:46 -0700 | [diff] [blame] | 285 | "apiMap": apiLevelsJson.String(), |
Jiyong Park | 3fd0baf | 2018-12-07 16:25:39 +0900 | [diff] [blame] | 286 | "flags": genstubFlags, |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 287 | }, |
| 288 | }) |
| 289 | |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 290 | return ndkApiOutputs{ |
| 291 | stubSrc: stubSrcPath, |
| 292 | versionScript: versionScriptPath, |
| 293 | symbolList: symbolListPath, |
| 294 | } |
| 295 | } |
| 296 | |
| 297 | func compileStubLibrary(ctx ModuleContext, flags Flags, src android.Path) Objects { |
Mitch Phillips | 4e5f9a1 | 2022-04-29 13:12:28 -0700 | [diff] [blame] | 298 | // libc/libm stubs libraries end up mismatching with clang's internal definition of these |
| 299 | // functions (which have noreturn attributes and other things). Because we just want to create a |
| 300 | // stub with symbol definitions, and types aren't important in C, ignore the mismatch. |
| 301 | flags.Local.ConlyFlags = append(flags.Local.ConlyFlags, "-fno-builtin") |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 302 | return compileObjs(ctx, flagsToBuilderFlags(flags), "", |
Chih-Hung Hsieh | 9db8a0c | 2022-02-17 12:54:45 -0800 | [diff] [blame] | 303 | android.Paths{src}, nil, nil, nil, nil) |
Dan Willemsen | b916b80 | 2017-03-19 13:44:32 -0700 | [diff] [blame] | 304 | } |
| 305 | |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 306 | func (this *stubDecorator) findImplementationLibrary(ctx ModuleContext) android.Path { |
| 307 | dep := ctx.GetDirectDepWithTag(strings.TrimSuffix(ctx.ModuleName(), ndkLibrarySuffix), |
| 308 | stubImplementation) |
| 309 | if dep == nil { |
| 310 | ctx.ModuleErrorf("Could not find implementation for stub") |
| 311 | return nil |
| 312 | } |
| 313 | impl, ok := dep.(*Module) |
| 314 | if !ok { |
| 315 | ctx.ModuleErrorf("Implementation for stub is not correct module type") |
Alan Stokes | 73d3245 | 2022-11-01 14:05:08 +0000 | [diff] [blame] | 316 | return nil |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 317 | } |
| 318 | output := impl.UnstrippedOutputFile() |
| 319 | if output == nil { |
| 320 | ctx.ModuleErrorf("implementation module (%s) has no output", impl) |
| 321 | return nil |
| 322 | } |
| 323 | |
| 324 | return output |
| 325 | } |
| 326 | |
| 327 | func (this *stubDecorator) libraryName(ctx ModuleContext) string { |
| 328 | return strings.TrimSuffix(ctx.ModuleName(), ndkLibrarySuffix) |
| 329 | } |
| 330 | |
| 331 | func (this *stubDecorator) findPrebuiltAbiDump(ctx ModuleContext, |
| 332 | apiLevel android.ApiLevel) android.OptionalPath { |
| 333 | |
| 334 | subpath := filepath.Join("prebuilts/abi-dumps/ndk", apiLevel.String(), |
Matthias Maennich | ca8ae65 | 2023-06-30 21:52:17 +0100 | [diff] [blame] | 335 | ctx.Arch().ArchType.String(), this.libraryName(ctx), "abi.stg") |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 336 | return android.ExistentPathForSource(ctx, subpath) |
| 337 | } |
| 338 | |
| 339 | // Feature flag. |
Dan Albert | f71006a | 2022-04-14 23:08:51 +0000 | [diff] [blame] | 340 | func canDumpAbi(config android.Config) bool { |
| 341 | if runtime.GOOS == "darwin" { |
| 342 | return false |
| 343 | } |
| 344 | // abidw doesn't currently handle top-byte-ignore correctly. Disable ABI |
| 345 | // dumping for those configs while we wait for a fix. We'll still have ABI |
| 346 | // checking coverage from non-hwasan builds. |
| 347 | // http://b/190554910 |
| 348 | if android.InList("hwaddress", config.SanitizeDevice()) { |
| 349 | return false |
| 350 | } |
Dan Albert | 326ab24 | 2023-04-20 17:38:29 +0000 | [diff] [blame] | 351 | // http://b/156513478 |
| 352 | // http://b/277624006 |
| 353 | // This step is expensive. We're not able to do anything with the outputs of |
| 354 | // this step yet (canDiffAbi is flagged off because libabigail isn't able to |
| 355 | // handle all our libraries), disable it. There's no sense in protecting |
| 356 | // against checking in code that breaks abidw since by the time any of this |
| 357 | // can be turned on we'll need to migrate to STG anyway. |
| 358 | return false |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 359 | } |
| 360 | |
| 361 | // Feature flag to disable diffing against prebuilts. |
Dan Albert | ad66593 | 2021-06-07 13:19:49 -0700 | [diff] [blame] | 362 | func canDiffAbi() bool { |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 363 | return false |
| 364 | } |
| 365 | |
Matthias Maennich | 55486f8 | 2023-07-03 12:25:27 +0100 | [diff] [blame^] | 366 | // TODO(b/156513478): remove once migration to STG is complete |
| 367 | func (this *stubDecorator) dumpAbiLegacy(ctx ModuleContext, symbolList android.Path) { |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 368 | implementationLibrary := this.findImplementationLibrary(ctx) |
Matthias Maennich | c2346f1 | 2021-09-02 20:45:33 +0100 | [diff] [blame] | 369 | abiRawPath := getNdkAbiDumpInstallBase(ctx).Join(ctx, |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 370 | this.apiLevel.String(), ctx.Arch().ArchType.String(), |
Matthias Maennich | c2346f1 | 2021-09-02 20:45:33 +0100 | [diff] [blame] | 371 | this.libraryName(ctx), "abi.raw.xml") |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 372 | ctx.Build(pctx, android.BuildParams{ |
| 373 | Rule: abidw, |
| 374 | Description: fmt.Sprintf("abidw %s", implementationLibrary), |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 375 | Input: implementationLibrary, |
Matthias Maennich | c2346f1 | 2021-09-02 20:45:33 +0100 | [diff] [blame] | 376 | Output: abiRawPath, |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 377 | Implicit: symbolList, |
| 378 | Args: map[string]string{ |
| 379 | "symbolList": symbolList.String(), |
| 380 | }, |
| 381 | }) |
Dan Albert | 604086f | 2021-06-15 13:23:44 -0700 | [diff] [blame] | 382 | |
Matthias Maennich | c2346f1 | 2021-09-02 20:45:33 +0100 | [diff] [blame] | 383 | this.abiDumpPath = getNdkAbiDumpInstallBase(ctx).Join(ctx, |
| 384 | this.apiLevel.String(), ctx.Arch().ArchType.String(), |
Matthias Maennich | ca8ae65 | 2023-06-30 21:52:17 +0100 | [diff] [blame] | 385 | this.libraryName(ctx), "abi.stg") |
Matthias Maennich | c2346f1 | 2021-09-02 20:45:33 +0100 | [diff] [blame] | 386 | ctx.Build(pctx, android.BuildParams{ |
Matthias Maennich | ca8ae65 | 2023-06-30 21:52:17 +0100 | [diff] [blame] | 387 | Rule: xml2stg, |
| 388 | Description: fmt.Sprintf("xml2stg %s", implementationLibrary), |
Matthias Maennich | c2346f1 | 2021-09-02 20:45:33 +0100 | [diff] [blame] | 389 | Input: abiRawPath, |
| 390 | Output: this.abiDumpPath, |
| 391 | }) |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 392 | } |
| 393 | |
Matthias Maennich | 55486f8 | 2023-07-03 12:25:27 +0100 | [diff] [blame^] | 394 | func (this *stubDecorator) dumpAbi(ctx ModuleContext, symbolList android.Path) { |
| 395 | implementationLibrary := this.findImplementationLibrary(ctx) |
| 396 | this.abiDumpPath = getNdkAbiDumpInstallBase(ctx).Join(ctx, |
| 397 | this.apiLevel.String(), ctx.Arch().ArchType.String(), |
| 398 | this.libraryName(ctx), "abi.stg") |
| 399 | ctx.Build(pctx, android.BuildParams{ |
| 400 | Rule: stg, |
| 401 | Description: fmt.Sprintf("stg %s", implementationLibrary), |
| 402 | Input: implementationLibrary, |
| 403 | Implicit: symbolList, |
| 404 | Output: this.abiDumpPath, |
| 405 | Args: map[string]string{ |
| 406 | "symbolList": symbolList.String(), |
| 407 | }, |
| 408 | }) |
| 409 | } |
| 410 | |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 411 | func findNextApiLevel(ctx ModuleContext, apiLevel android.ApiLevel) *android.ApiLevel { |
| 412 | apiLevels := append(ctx.Config().AllSupportedApiLevels(), |
| 413 | android.FutureApiLevel) |
| 414 | for _, api := range apiLevels { |
| 415 | if api.GreaterThan(apiLevel) { |
| 416 | return &api |
| 417 | } |
| 418 | } |
| 419 | return nil |
| 420 | } |
| 421 | |
| 422 | func (this *stubDecorator) diffAbi(ctx ModuleContext) { |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 423 | // Catch any ABI changes compared to the checked-in definition of this API |
| 424 | // level. |
Matthias Maennich | 658bb4d | 2023-06-30 23:28:15 +0100 | [diff] [blame] | 425 | abiDiffPath := android.PathForModuleOut(ctx, "stgdiff.timestamp") |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 426 | prebuiltAbiDump := this.findPrebuiltAbiDump(ctx, this.apiLevel) |
Dan Albert | f7cb563 | 2022-11-29 17:20:16 +0000 | [diff] [blame] | 427 | missingPrebuiltError := fmt.Sprintf( |
| 428 | "Did not find prebuilt ABI dump for %q (%q). Generate with "+ |
| 429 | "//development/tools/ndk/update_ndk_abi.sh.", this.libraryName(ctx), |
| 430 | prebuiltAbiDump.InvalidReason()) |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 431 | if !prebuiltAbiDump.Valid() { |
| 432 | ctx.Build(pctx, android.BuildParams{ |
| 433 | Rule: android.ErrorRule, |
| 434 | Output: abiDiffPath, |
| 435 | Args: map[string]string{ |
| 436 | "error": missingPrebuiltError, |
| 437 | }, |
| 438 | }) |
| 439 | } else { |
| 440 | ctx.Build(pctx, android.BuildParams{ |
Matthias Maennich | 658bb4d | 2023-06-30 23:28:15 +0100 | [diff] [blame] | 441 | Rule: stgdiff, |
| 442 | Description: fmt.Sprintf("Comparing ABI %s %s", prebuiltAbiDump, |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 443 | this.abiDumpPath), |
| 444 | Output: abiDiffPath, |
| 445 | Inputs: android.Paths{prebuiltAbiDump.Path(), this.abiDumpPath}, |
Matthias Maennich | 658bb4d | 2023-06-30 23:28:15 +0100 | [diff] [blame] | 446 | Args: map[string]string{ |
| 447 | "args": "--format=small", |
| 448 | }, |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 449 | }) |
| 450 | } |
| 451 | this.abiDiffPaths = append(this.abiDiffPaths, abiDiffPath) |
| 452 | |
| 453 | // Also ensure that the ABI of the next API level (if there is one) matches |
| 454 | // this API level. *New* ABI is allowed, but any changes to APIs that exist |
| 455 | // in this API level are disallowed. |
| 456 | if !this.apiLevel.IsCurrent() { |
| 457 | nextApiLevel := findNextApiLevel(ctx, this.apiLevel) |
| 458 | if nextApiLevel == nil { |
| 459 | panic(fmt.Errorf("could not determine which API level follows "+ |
| 460 | "non-current API level %s", this.apiLevel)) |
| 461 | } |
| 462 | nextAbiDiffPath := android.PathForModuleOut(ctx, |
| 463 | "abidiff_next.timestamp") |
| 464 | nextAbiDump := this.findPrebuiltAbiDump(ctx, *nextApiLevel) |
| 465 | if !nextAbiDump.Valid() { |
| 466 | ctx.Build(pctx, android.BuildParams{ |
| 467 | Rule: android.ErrorRule, |
| 468 | Output: nextAbiDiffPath, |
| 469 | Args: map[string]string{ |
| 470 | "error": missingPrebuiltError, |
| 471 | }, |
| 472 | }) |
| 473 | } else { |
| 474 | ctx.Build(pctx, android.BuildParams{ |
Matthias Maennich | 658bb4d | 2023-06-30 23:28:15 +0100 | [diff] [blame] | 475 | Rule: stgdiff, |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 476 | Description: fmt.Sprintf("abidiff %s %s", this.abiDumpPath, |
| 477 | nextAbiDump), |
| 478 | Output: nextAbiDiffPath, |
| 479 | Inputs: android.Paths{this.abiDumpPath, nextAbiDump.Path()}, |
| 480 | Args: map[string]string{ |
Matthias Maennich | 658bb4d | 2023-06-30 23:28:15 +0100 | [diff] [blame] | 481 | "args": "--format=small --ignore=interface_addition", |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 482 | }, |
| 483 | }) |
| 484 | } |
| 485 | this.abiDiffPaths = append(this.abiDiffPaths, nextAbiDiffPath) |
| 486 | } |
| 487 | } |
| 488 | |
Dan Willemsen | b916b80 | 2017-03-19 13:44:32 -0700 | [diff] [blame] | 489 | func (c *stubDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects { |
Nan Zhang | 0007d81 | 2017-11-07 10:57:05 -0800 | [diff] [blame] | 490 | if !strings.HasSuffix(String(c.properties.Symbol_file), ".map.txt") { |
Dan Albert | 15be0c6 | 2017-06-13 15:14:56 -0700 | [diff] [blame] | 491 | ctx.PropertyErrorf("symbol_file", "must end with .map.txt") |
| 492 | } |
| 493 | |
Colin Cross | 5ec407b | 2020-09-30 11:41:33 -0700 | [diff] [blame] | 494 | if !c.buildStubs() { |
| 495 | // NDK libraries have no implementation variant, nothing to do |
| 496 | return Objects{} |
| 497 | } |
| 498 | |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 499 | if !c.initializeProperties(ctx) { |
| 500 | // Emits its own errors, so we don't need to. |
| 501 | return Objects{} |
| 502 | } |
| 503 | |
sophiez | 58cabb7 | 2020-05-29 13:37:12 -0700 | [diff] [blame] | 504 | symbolFile := String(c.properties.Symbol_file) |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 505 | nativeAbiResult := parseNativeAbiDefinition(ctx, symbolFile, c.apiLevel, "") |
| 506 | objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc) |
| 507 | c.versionScriptPath = nativeAbiResult.versionScript |
Dan Albert | f71006a | 2022-04-14 23:08:51 +0000 | [diff] [blame] | 508 | if canDumpAbi(ctx.Config()) { |
Matthias Maennich | 55486f8 | 2023-07-03 12:25:27 +0100 | [diff] [blame^] | 509 | if proptools.BoolDefault(c.properties.Legacy_use_abidw, false) { |
| 510 | c.dumpAbiLegacy(ctx, nativeAbiResult.symbolList) |
| 511 | } else { |
| 512 | c.dumpAbi(ctx, nativeAbiResult.symbolList) |
| 513 | } |
Dan Albert | ad66593 | 2021-06-07 13:19:49 -0700 | [diff] [blame] | 514 | if canDiffAbi() { |
Dan Albert | f1d14c7 | 2020-07-30 14:32:55 -0700 | [diff] [blame] | 515 | c.diffAbi(ctx) |
| 516 | } |
| 517 | } |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 518 | if c.apiLevel.IsCurrent() && ctx.PrimaryArch() { |
sophiez | 4c4f803 | 2021-08-16 22:54:00 -0700 | [diff] [blame] | 519 | c.parsedCoverageXmlPath = parseSymbolFileForAPICoverage(ctx, symbolFile) |
sophiez | 58cabb7 | 2020-05-29 13:37:12 -0700 | [diff] [blame] | 520 | } |
Dan Willemsen | b916b80 | 2017-03-19 13:44:32 -0700 | [diff] [blame] | 521 | return objs |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 522 | } |
| 523 | |
Spandan Das | 73bcafc | 2022-08-18 23:26:00 +0000 | [diff] [blame] | 524 | // Add a dependency on the header modules of this ndk_library |
Colin Cross | 37047f1 | 2016-12-13 17:06:13 -0800 | [diff] [blame] | 525 | func (linker *stubDecorator) linkerDeps(ctx DepsContext, deps Deps) Deps { |
Spandan Das | 73bcafc | 2022-08-18 23:26:00 +0000 | [diff] [blame] | 526 | return Deps{ |
| 527 | HeaderLibs: linker.properties.Export_header_libs, |
| 528 | } |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 529 | } |
| 530 | |
Dan Willemsen | 01a9059 | 2017-04-07 15:21:13 -0700 | [diff] [blame] | 531 | func (linker *stubDecorator) Name(name string) string { |
| 532 | return name + ndkLibrarySuffix |
| 533 | } |
| 534 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 535 | func (stub *stubDecorator) linkerFlags(ctx ModuleContext, flags Flags) Flags { |
Dan Willemsen | 01a9059 | 2017-04-07 15:21:13 -0700 | [diff] [blame] | 536 | stub.libraryDecorator.libName = ctx.baseModuleName() |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 537 | return stub.libraryDecorator.linkerFlags(ctx, flags) |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 538 | } |
| 539 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 540 | func (stub *stubDecorator) link(ctx ModuleContext, flags Flags, deps PathDeps, |
Dan Willemsen | 5cb580f | 2016-09-26 17:33:01 -0700 | [diff] [blame] | 541 | objs Objects) android.Path { |
Dan Albert | 2bc91ba | 2016-07-28 17:40:28 -0700 | [diff] [blame] | 542 | |
Colin Cross | 5ec407b | 2020-09-30 11:41:33 -0700 | [diff] [blame] | 543 | if !stub.buildStubs() { |
| 544 | // NDK libraries have no implementation variant, nothing to do |
| 545 | return nil |
| 546 | } |
| 547 | |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 548 | if shouldUseVersionScript(ctx, stub) { |
Dan Albert | 98dbb3b | 2017-01-03 15:16:29 -0800 | [diff] [blame] | 549 | linkerScriptFlag := "-Wl,--version-script," + stub.versionScriptPath.String() |
Colin Cross | 4af21ed | 2019-11-04 09:37:55 -0800 | [diff] [blame] | 550 | flags.Local.LdFlags = append(flags.Local.LdFlags, linkerScriptFlag) |
Dan Willemsen | 939408a | 2019-06-10 18:02:25 -0700 | [diff] [blame] | 551 | flags.LdFlagsDeps = append(flags.LdFlagsDeps, stub.versionScriptPath) |
Dan Albert | 98dbb3b | 2017-01-03 15:16:29 -0800 | [diff] [blame] | 552 | } |
| 553 | |
Colin Cross | 5ec407b | 2020-09-30 11:41:33 -0700 | [diff] [blame] | 554 | stub.libraryDecorator.skipAPIDefine = true |
Dan Willemsen | 5cb580f | 2016-09-26 17:33:01 -0700 | [diff] [blame] | 555 | return stub.libraryDecorator.link(ctx, flags, deps, objs) |
Dan Albert | 2bc91ba | 2016-07-28 17:40:28 -0700 | [diff] [blame] | 556 | } |
| 557 | |
Pirama Arumuga Nainar | 65c95ff | 2019-03-25 10:21:31 -0700 | [diff] [blame] | 558 | func (stub *stubDecorator) nativeCoverage() bool { |
| 559 | return false |
| 560 | } |
| 561 | |
Dan Albert | 4048bb0 | 2023-04-03 20:19:07 +0000 | [diff] [blame] | 562 | // Returns the install path for unversioned NDK libraries (currently only static |
| 563 | // libraries). |
| 564 | func getUnversionedLibraryInstallPath(ctx ModuleContext) android.InstallPath { |
| 565 | return getNdkSysrootBase(ctx).Join(ctx, "usr/lib", config.NDKTriple(ctx.toolchain())) |
| 566 | } |
Rebecca Chyung | 961cf1c | 2023-04-03 05:17:17 +0000 | [diff] [blame] | 567 | |
Dan Albert | 4048bb0 | 2023-04-03 20:19:07 +0000 | [diff] [blame] | 568 | // Returns the install path for versioned NDK libraries. These are most often |
| 569 | // stubs, but the same paths are used for CRT objects. |
| 570 | func getVersionedLibraryInstallPath(ctx ModuleContext, apiLevel android.ApiLevel) android.InstallPath { |
| 571 | return getUnversionedLibraryInstallPath(ctx).Join(ctx, apiLevel.String()) |
| 572 | } |
| 573 | |
| 574 | func (stub *stubDecorator) install(ctx ModuleContext, path android.Path) { |
| 575 | installDir := getVersionedLibraryInstallPath(ctx, stub.apiLevel) |
Colin Cross | 0875c52 | 2017-11-28 17:34:01 -0800 | [diff] [blame] | 576 | stub.installPath = ctx.InstallFile(installDir, path.Base(), path) |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 577 | } |
| 578 | |
Colin Cross | 3624285 | 2017-06-23 15:06:31 -0700 | [diff] [blame] | 579 | func newStubLibrary() *Module { |
Colin Cross | ab3b732 | 2016-12-09 14:46:15 -0800 | [diff] [blame] | 580 | module, library := NewLibrary(android.DeviceSupported) |
| 581 | library.BuildOnlyShared() |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 582 | module.stl = nil |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 583 | module.sanitize = nil |
ThiƩbaud Weksteen | d458745 | 2020-08-19 14:53:01 +0200 | [diff] [blame] | 584 | library.disableStripping() |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 585 | |
Colin Cross | b916a38 | 2016-07-29 17:28:03 -0700 | [diff] [blame] | 586 | stub := &stubDecorator{ |
| 587 | libraryDecorator: library, |
| 588 | } |
| 589 | module.compiler = stub |
| 590 | module.linker = stub |
| 591 | module.installer = stub |
Colin Cross | 31076b3 | 2020-10-23 17:22:06 -0700 | [diff] [blame] | 592 | module.library = stub |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 593 | |
Colin Cross | c511bc5 | 2020-04-07 16:50:32 +0000 | [diff] [blame] | 594 | module.Properties.AlwaysSdk = true |
| 595 | module.Properties.Sdk_version = StringPtr("current") |
| 596 | |
Colin Cross | 3624285 | 2017-06-23 15:06:31 -0700 | [diff] [blame] | 597 | module.AddProperties(&stub.properties, &library.MutatedProperties) |
| 598 | |
| 599 | return module |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 600 | } |
| 601 | |
Dan Albert | f740ed0 | 2020-07-24 14:19:06 -0700 | [diff] [blame] | 602 | // ndk_library creates a library that exposes a stub implementation of functions |
| 603 | // and variables for use at build time only. |
Jooyung Han | b90e491 | 2019-12-09 18:21:48 +0900 | [diff] [blame] | 604 | func NdkLibraryFactory() android.Module { |
Colin Cross | 3624285 | 2017-06-23 15:06:31 -0700 | [diff] [blame] | 605 | module := newStubLibrary() |
| 606 | android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibBoth) |
Spandan Das | 1278c2c | 2022-08-19 18:17:28 +0000 | [diff] [blame] | 607 | android.InitBazelModule(module) |
Colin Cross | 3624285 | 2017-06-23 15:06:31 -0700 | [diff] [blame] | 608 | return module |
Dan Albert | 914449f | 2016-06-17 16:45:24 -0700 | [diff] [blame] | 609 | } |
Spandan Das | 1278c2c | 2022-08-19 18:17:28 +0000 | [diff] [blame] | 610 | |
| 611 | type bazelCcApiContributionAttributes struct { |
| 612 | Api bazel.LabelAttribute |
| 613 | Api_surfaces bazel.StringListAttribute |
| 614 | Hdrs bazel.LabelListAttribute |
| 615 | Library_name string |
| 616 | } |
| 617 | |
| 618 | // Names of the cc_api_header targets in the bp2build workspace |
Spandan Das | 4238c65 | 2022-09-09 01:38:47 +0000 | [diff] [blame] | 619 | func apiHeaderLabels(ctx android.TopDownMutatorContext, hdrLibs []string) bazel.LabelList { |
Spandan Das | 1278c2c | 2022-08-19 18:17:28 +0000 | [diff] [blame] | 620 | addSuffix := func(ctx android.BazelConversionPathContext, module blueprint.Module) string { |
| 621 | label := android.BazelModuleLabel(ctx, module) |
| 622 | return android.ApiContributionTargetName(label) |
| 623 | } |
Spandan Das | 4238c65 | 2022-09-09 01:38:47 +0000 | [diff] [blame] | 624 | return android.BazelLabelForModuleDepsWithFn(ctx, hdrLibs, addSuffix) |
Spandan Das | 1278c2c | 2022-08-19 18:17:28 +0000 | [diff] [blame] | 625 | } |