blob: 1f318721a61a31bdd6218c9bbc198f37e9942164 [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
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
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Colin Cross97ba0732015-03-23 17:50:24 -070027 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070028 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070029
Colin Cross635c3b02016-05-18 15:37:25 -070030 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070031 "android/soong/cc/config"
Colin Cross5049f022015-03-18 13:28:46 -070032 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080033)
34
Colin Cross463a90e2015-06-17 14:20:06 -070035func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000036 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070037
Paul Duffin036e7002019-12-19 19:16:28 +000038 pctx.Import("android/soong/cc/config")
39}
40
41func RegisterCCBuildComponents(ctx android.RegistrationContext) {
42 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
43
44 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000045 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090046 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070047 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010048 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070049 ctx.BottomUp("version_selector", versionSelectorMutator).Parallel()
50 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070051 ctx.BottomUp("begin", BeginMutator).Parallel()
Inseob Kimac1e9862019-12-09 18:15:47 +090052 ctx.BottomUp("sysprop_cc", SyspropMutator).Parallel()
Inseob Kimeec88e12020-01-22 11:11:29 +090053 ctx.BottomUp("vendor_snapshot", VendorSnapshotMutator).Parallel()
54 ctx.BottomUp("vendor_snapshot_source", VendorSnapshotSourceMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070055 })
Colin Cross16b23492016-01-06 14:41:07 -080056
Paul Duffin036e7002019-12-19 19:16:28 +000057 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Cross1e676be2016-10-12 14:38:15 -070058 ctx.TopDown("asan_deps", sanitizerDepsMutator(asan))
59 ctx.BottomUp("asan", sanitizerMutator(asan)).Parallel()
Colin Cross16b23492016-01-06 14:41:07 -080060
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070061 ctx.TopDown("hwasan_deps", sanitizerDepsMutator(hwasan))
62 ctx.BottomUp("hwasan", sanitizerMutator(hwasan)).Parallel()
63
Mitch Phillipsbfeade62019-05-01 14:42:05 -070064 ctx.TopDown("fuzzer_deps", sanitizerDepsMutator(fuzzer))
65 ctx.BottomUp("fuzzer", sanitizerMutator(fuzzer)).Parallel()
66
Jiyong Park1d1119f2019-07-29 21:27:18 +090067 // cfi mutator shouldn't run before sanitizers that return true for
68 // incompatibleWithCfi()
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000069 ctx.TopDown("cfi_deps", sanitizerDepsMutator(cfi))
70 ctx.BottomUp("cfi", sanitizerMutator(cfi)).Parallel()
71
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -080072 ctx.TopDown("scs_deps", sanitizerDepsMutator(scs))
73 ctx.BottomUp("scs", sanitizerMutator(scs)).Parallel()
74
Colin Cross1e676be2016-10-12 14:38:15 -070075 ctx.TopDown("tsan_deps", sanitizerDepsMutator(tsan))
76 ctx.BottomUp("tsan", sanitizerMutator(tsan)).Parallel()
Dan Willemsen581341d2017-02-09 16:16:31 -080077
Colin Cross0b908332019-06-19 23:00:20 -070078 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090079 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080080
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080081 ctx.BottomUp("coverage", coverageMutator).Parallel()
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -080082 ctx.TopDown("vndk_deps", sabiDepsMutator)
Stephen Craneba090d12017-05-09 15:44:35 -070083
84 ctx.TopDown("lto_deps", ltoDepsMutator)
85 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090086
Jooyung Han479ca172020-10-19 18:51:07 +090087 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090088 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070089 })
Colin Crossb98c8b02016-07-29 13:44:28 -070090
Sasha Smundak2a4549e2018-11-05 16:49:08 -080091 android.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070092}
93
Colin Crossca860ac2016-01-04 14:34:37 -080094type Deps struct {
95 SharedLibs, LateSharedLibs []string
96 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080097 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +080098 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -070099
Chris Parsons79d66a52020-06-05 17:26:16 -0400100 // Used for data dependencies adjacent to tests
101 DataLibs []string
102
Yo Chiang219968c2020-09-22 18:45:04 +0800103 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
104 SystemSharedLibs []string
105
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800106 StaticUnwinderIfLegacy bool
107
Colin Cross5950f382016-12-13 12:50:57 -0800108 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700109
Colin Cross81413472016-04-11 14:37:39 -0700110 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700111
Dan Willemsenb40aab62016-04-20 14:21:14 -0700112 GeneratedSources []string
113 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900114 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700115
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700116 ReexportGeneratedHeaders []string
117
Colin Cross97ba0732015-03-23 17:50:24 -0700118 CrtBegin, CrtEnd string
Dan Willemsena0790e32018-10-12 00:24:23 -0700119
120 // Used for host bionic
121 LinkerFlagsFile string
122 DynamicLinker string
Colin Crossc472d572015-03-17 15:06:21 -0700123}
124
Colin Crossca860ac2016-01-04 14:34:37 -0800125type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700126 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900127 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700128 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900129 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700130 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700131 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700132
Colin Cross0de8a1e2020-09-18 14:15:30 -0700133 // Transitive static library dependencies of static libraries for use in ordering.
134 TranstiveStaticLibrariesForOrdering *android.DepSet
135
Colin Cross26c34ed2016-09-30 17:10:16 -0700136 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100137 Objs Objects
138 // Paths to .o files in dependencies that provide them. Note that these lists
139 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800140 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700141 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700142
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100143 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
144 // the libs from all whole_static_lib dependencies.
145 WholeStaticLibsFromPrebuilts android.Paths
146
Colin Cross26c34ed2016-09-30 17:10:16 -0700147 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700148 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900149 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700150
Inseob Kimd110f872019-12-06 13:15:38 +0900151 Flags []string
152 IncludeDirs android.Paths
153 SystemIncludeDirs android.Paths
154 ReexportedDirs android.Paths
155 ReexportedSystemDirs android.Paths
156 ReexportedFlags []string
157 ReexportedGeneratedHeaders android.Paths
158 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700159
Colin Cross26c34ed2016-09-30 17:10:16 -0700160 // Paths to crt*.o files
Colin Cross635c3b02016-05-18 15:37:25 -0700161 CrtBegin, CrtEnd android.OptionalPath
Dan Willemsena0790e32018-10-12 00:24:23 -0700162
163 // Path to the file container flags to use with the linker
164 LinkerFlagsFile android.OptionalPath
165
166 // Path to the dynamic linker binary
167 DynamicLinker android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700168}
169
Colin Cross4af21ed2019-11-04 09:37:55 -0800170// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
171// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
172// command line so they can be overridden by the local module flags).
173type LocalOrGlobalFlags struct {
174 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700175 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800176 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700177 CFlags []string // Flags that apply to C and C++ source files
178 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
179 ConlyFlags []string // Flags that apply to C source files
180 CppFlags []string // Flags that apply to C++ source files
181 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700182 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800183}
184
185type Flags struct {
186 Local LocalOrGlobalFlags
187 Global LocalOrGlobalFlags
188
189 aidlFlags []string // Flags that apply to aidl source files
190 rsFlags []string // Flags that apply to renderscript source files
191 libFlags []string // Flags to add libraries early to the link order
192 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
193 TidyFlags []string // Flags that apply to clang-tidy
194 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700195
Colin Crossc3199482017-03-30 15:03:04 -0700196 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800197 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700198 SystemIncludeFlags []string
199
Oliver Nguyen04526782020-04-21 12:40:27 -0700200 Toolchain config.Toolchain
201 Tidy bool
202 GcovCoverage bool
203 SAbiDump bool
204 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800205
206 RequiredInstructionSet string
Colin Cross16b23492016-01-06 14:41:07 -0800207 DynamicLinker string
208
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700209 CFlagsDeps android.Paths // Files depended on by compiler flags
210 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800211
Dan Willemsen98ab3112019-08-27 21:20:40 -0700212 AssemblerWithCpp bool
213 GroupStaticLibs bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800214
Colin Cross19878da2019-03-28 14:45:07 -0700215 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700216 protoC bool // Whether to use C instead of C++
217 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700218
219 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200220 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700221}
222
Colin Crossca860ac2016-01-04 14:34:37 -0800223// Properties used to compile all C or C++ modules
224type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700225 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800226 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700227
Colin Crossc511bc52020-04-07 16:50:32 +0000228 // Minimum sdk version supported when compiling against the ndk. Setting this property causes
229 // two variants to be built, one for the platform and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800230 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700231
Jooyung Han379660c2020-04-21 15:24:00 +0900232 // Minimum sdk version that the artifact should support when it runs as part of mainline modules(APEX).
233 Min_sdk_version *string
234
Colin Crossc511bc52020-04-07 16:50:32 +0000235 // If true, always create an sdk variant and don't create a platform variant.
236 Sdk_variant_only *bool
237
Jiyong Parkde866cb2018-12-07 23:08:36 +0900238 AndroidMkSharedLibs []string `blueprint:"mutated"`
239 AndroidMkStaticLibs []string `blueprint:"mutated"`
240 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
241 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700242 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900243 HideFromMake bool `blueprint:"mutated"`
244 PreventInstall bool `blueprint:"mutated"`
245 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700246
Yo Chiang219968c2020-09-22 18:45:04 +0800247 // Set by DepsMutator.
248 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
249
Justin Yun5f7f7e82019-11-18 19:52:14 +0900250 ImageVariationPrefix string `blueprint:"mutated"`
251 VndkVersion string `blueprint:"mutated"`
252 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800253
254 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
255 // file
256 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900257
Yifan Hong39143a92020-10-26 12:43:12 -0700258 // Make this module available when building for ramdisk.
259 // On device without a dedicated recovery partition, the module is only
260 // available after switching root into
261 // /first_stage_ramdisk. To expose the module before switching root, install
262 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800263 Ramdisk_available *bool
264
Yifan Hong39143a92020-10-26 12:43:12 -0700265 // Make this module available when building for vendor ramdisk.
266 // On device without a dedicated recovery partition, the module is only
267 // available after switching root into
268 // /first_stage_ramdisk. To expose the module before switching root, install
269 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700270 Vendor_ramdisk_available *bool
271
Jiyong Parkf9332f12018-02-01 00:54:12 +0900272 // Make this module available when building for recovery
273 Recovery_available *bool
274
Colin Crossae6c5202019-11-20 13:35:50 -0800275 // Set by imageMutator
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700276 CoreVariantNeeded bool `blueprint:"mutated"`
277 RamdiskVariantNeeded bool `blueprint:"mutated"`
278 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
279 RecoveryVariantNeeded bool `blueprint:"mutated"`
280 ExtraVariants []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900281
282 // Allows this module to use non-APEX version of libraries. Useful
283 // for building binaries that are started before APEXes are activated.
284 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900285
286 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
287 // see soong/cc/config/vndk.go
288 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900289
290 // Used by vendor snapshot to record dependencies from snapshot modules.
291 SnapshotSharedLibs []string `blueprint:"mutated"`
292 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000293
294 Installable *bool
Colin Crossc511bc52020-04-07 16:50:32 +0000295
296 // Set by factories of module types that can only be referenced from variants compiled against
297 // the SDK.
298 AlwaysSdk bool `blueprint:"mutated"`
299
300 // Variant is an SDK variant created by sdkMutator
301 IsSdkVariant bool `blueprint:"mutated"`
302 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
303 // variant to have a ".sdk" suffix.
304 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700305
306 // Normally Soong uses the directory structure to decide which modules
307 // should be included (framework) or excluded (non-framework) from the
308 // vendor snapshot, but this property allows a partner to exclude a
309 // module normally thought of as a framework module from the vendor
310 // snapshot.
311 Exclude_from_vendor_snapshot *bool
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700312}
313
314type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900315 // whether this module should be allowed to be directly depended by other
316 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900317 // If set to true, two variants will be built separately, one like
318 // normal, and the other limited to the set of libraries and headers
319 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700320 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900321 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700322 // so it shouldn't have any unversioned runtime dependencies, or
323 // make assumptions about the system that may not be true in the
324 // future.
325 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900326 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900327 //
328 // Default value is true when vndk: {enabled: true} or vendor: true.
329 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700330 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
331 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900332
Justin Yun63e9ec72020-10-29 16:49:43 +0900333 // whether this module should be allowed to be directly depended by other
334 // modules with `product_specific: true` or `product_available: true`.
335 // If set to true, an additional product variant will be built separately
336 // that is limited to the set of libraries and headers that are exposed to
337 // /product modules.
338 //
339 // The product variant may be used with a different (newer) /system,
340 // so it shouldn't have any unversioned runtime dependencies, or
341 // make assumptions about the system that may not be true in the
342 // future.
343 //
344 // It must be set to true by default for vndk: {enabled: true} modules.
345 //
346 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
347 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
348 Product_available *bool
349
Jiyong Park5fb8c102018-04-09 12:03:06 +0900350 // whether this module is capable of being loaded with other instance
351 // (possibly an older version) of the same module in the same process.
352 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
353 // can be double loaded in a vendor process if the library is also a
354 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
355 // explicitly marked as `double_loadable: true` by the owner, or the dependency
356 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
357 Double_loadable *bool
Colin Crossca860ac2016-01-04 14:34:37 -0800358}
359
Colin Crossca860ac2016-01-04 14:34:37 -0800360type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800361 static() bool
362 staticBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900363 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900364 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900365 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700366 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900367 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700368 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800369 sdkVersion() string
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700370 useVndk() bool
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800371 isNdk() bool
Inseob Kim9516ee92019-05-09 10:56:13 +0900372 isLlndk(config android.Config) bool
373 isLlndkPublic(config android.Config) bool
374 isVndkPrivate(config android.Config) bool
Justin Yun8effde42017-06-23 19:24:43 +0900375 isVndk() bool
376 isVndkSp() bool
Logan Chienf3511742017-10-31 18:04:35 +0800377 isVndkExt() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900378 inProduct() bool
379 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800380 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700381 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900382 inRecovery() bool
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800383 shouldCreateSourceAbiDump() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700384 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700385 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800386 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800387 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800388 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800389 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800390 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700391 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700392 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900393 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800394 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700395 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700396 directlyInAnyApex() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800397}
398
399type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700400 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800401 ModuleContextIntf
402}
403
404type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700405 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800406 ModuleContextIntf
407}
408
Colin Cross37047f12016-12-13 17:06:13 -0800409type DepsContext interface {
410 android.BottomUpMutatorContext
411 ModuleContextIntf
412}
413
Colin Crossca860ac2016-01-04 14:34:37 -0800414type feature interface {
415 begin(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800416 deps(ctx DepsContext, deps Deps) Deps
Colin Crossca860ac2016-01-04 14:34:37 -0800417 flags(ctx ModuleContext, flags Flags) Flags
418 props() []interface{}
419}
420
421type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700422 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800423 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800424 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700425 compilerProps() []interface{}
426
Colin Cross76fada02016-07-27 10:31:13 -0700427 appendCflags([]string)
428 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700429 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800430}
431
432type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700433 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800434 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700435 linkerFlags(ctx ModuleContext, flags Flags) Flags
436 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800437 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700438
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700439 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700440 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900441 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700442
443 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900444 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000445
446 // Get the deps that have been explicitly specified in the properties.
447 // Only updates the
448 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
449}
450
451type specifiedDeps struct {
452 sharedLibs []string
Martin Stjernholm10566a02020-03-24 01:19:52 +0000453 systemSharedLibs []string // Note nil and [] are semantically distinct.
Colin Crossca860ac2016-01-04 14:34:37 -0800454}
455
456type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700457 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700458 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000459 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800460 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700461 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700462 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900463 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100464 makeUninstallable(mod *Module)
Colin Crossca860ac2016-01-04 14:34:37 -0800465}
466
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800467type xref interface {
468 XrefCcFiles() android.Paths
469}
470
Colin Cross6e511a92020-07-27 21:26:48 -0700471type libraryDependencyKind int
472
473const (
474 headerLibraryDependency = iota
475 sharedLibraryDependency
476 staticLibraryDependency
477)
478
479func (k libraryDependencyKind) String() string {
480 switch k {
481 case headerLibraryDependency:
482 return "headerLibraryDependency"
483 case sharedLibraryDependency:
484 return "sharedLibraryDependency"
485 case staticLibraryDependency:
486 return "staticLibraryDependency"
487 default:
488 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
489 }
490}
491
492type libraryDependencyOrder int
493
494const (
495 earlyLibraryDependency = -1
496 normalLibraryDependency = 0
497 lateLibraryDependency = 1
498)
499
500func (o libraryDependencyOrder) String() string {
501 switch o {
502 case earlyLibraryDependency:
503 return "earlyLibraryDependency"
504 case normalLibraryDependency:
505 return "normalLibraryDependency"
506 case lateLibraryDependency:
507 return "lateLibraryDependency"
508 default:
509 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
510 }
511}
512
513// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
514// tags that have a set of predefined tag objects that are reused for each dependency, a
515// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
516// That means that comparing a libraryDependencyTag for equality will only be equal if all
517// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
518// then check individual metadata fields instead.
519type libraryDependencyTag struct {
520 blueprint.BaseDependencyTag
521
522 // These are exported so that fmt.Printf("%#v") can call their String methods.
523 Kind libraryDependencyKind
524 Order libraryDependencyOrder
525
526 wholeStatic bool
527
528 reexportFlags bool
529 explicitlyVersioned bool
530 dataLib bool
531 ndk bool
532
533 staticUnwinder bool
534
535 makeSuffix string
536}
537
538// header returns true if the libraryDependencyTag is tagging a header lib dependency.
539func (d libraryDependencyTag) header() bool {
540 return d.Kind == headerLibraryDependency
541}
542
543// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
544func (d libraryDependencyTag) shared() bool {
545 return d.Kind == sharedLibraryDependency
546}
547
548// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
549func (d libraryDependencyTag) static() bool {
550 return d.Kind == staticLibraryDependency
551}
552
553// dependencyTag is used for tagging miscellanous dependency types that don't fit into
554// libraryDependencyTag. Each tag object is created globally and reused for multiple
555// dependencies (although since the object contains no references, assigning a tag to a
556// variable and modifying it will not modify the original). Users can compare the tag
557// returned by ctx.OtherModuleDependencyTag against the global original
558type dependencyTag struct {
559 blueprint.BaseDependencyTag
560 name string
561}
562
Colin Crossc99deeb2016-04-11 15:06:20 -0700563var (
Colin Cross6e511a92020-07-27 21:26:48 -0700564 genSourceDepTag = dependencyTag{name: "gen source"}
565 genHeaderDepTag = dependencyTag{name: "gen header"}
566 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
567 objDepTag = dependencyTag{name: "obj"}
568 linkerFlagsDepTag = dependencyTag{name: "linker flags file"}
569 dynamicLinkerDepTag = dependencyTag{name: "dynamic linker"}
570 reuseObjTag = dependencyTag{name: "reuse objects"}
571 staticVariantTag = dependencyTag{name: "static variant"}
572 vndkExtDepTag = dependencyTag{name: "vndk extends"}
573 dataLibDepTag = dependencyTag{name: "data lib"}
574 runtimeDepTag = dependencyTag{name: "runtime lib"}
575 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700576 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700577)
578
Colin Cross56a83212020-09-15 18:30:11 -0700579type copyDirectlyInAnyApexDependencyTag dependencyTag
580
581func (copyDirectlyInAnyApexDependencyTag) CopyDirectlyInAnyApex() {}
582
583var _ android.CopyDirectlyInAnyApexTag = copyDirectlyInAnyApexDependencyTag{}
584
Roland Levillainf89cd092019-07-29 16:22:59 +0100585func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700586 ccLibDepTag, ok := depTag.(libraryDependencyTag)
587 return ok && ccLibDepTag.shared()
588}
589
590func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
591 ccLibDepTag, ok := depTag.(libraryDependencyTag)
592 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100593}
594
595func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700596 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100597 return ok && ccDepTag == runtimeDepTag
598}
599
600func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700601 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100602 return ok && ccDepTag == testPerSrcDepTag
603}
604
Colin Crossca860ac2016-01-04 14:34:37 -0800605// Module contains the properties and members used by all C/C++ module types, and implements
606// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
607// to construct the output file. Behavior can be customized with a Customizer interface
608type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700609 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700610 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900611 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900612 android.SdkBase
Colin Crossc472d572015-03-17 15:06:21 -0700613
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700614 Properties BaseProperties
615 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700616
Colin Crossca860ac2016-01-04 14:34:37 -0800617 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700618 hod android.HostOrDeviceSupported
619 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700620
Paul Duffina0843f62019-12-13 19:50:38 +0000621 // Allowable SdkMemberTypes of this module type.
622 sdkMemberTypes []android.SdkMemberType
623
Colin Crossca860ac2016-01-04 14:34:37 -0800624 // delegates, initialize before calling Init
Colin Crossb4ce0ec2016-09-13 13:41:39 -0700625 features []feature
626 compiler compiler
627 linker linker
628 installer installer
629 stl *stl
630 sanitize *sanitize
Dan Willemsen581341d2017-02-09 16:16:31 -0800631 coverage *coverage
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800632 sabi *sabi
Justin Yun8effde42017-06-23 19:24:43 +0900633 vndkdep *vndkdep
Stephen Craneba090d12017-05-09 15:44:35 -0700634 lto *lto
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700635 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800636
Colin Cross31076b32020-10-23 17:22:06 -0700637 library libraryInterface
638
Colin Cross635c3b02016-05-18 15:37:25 -0700639 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800640
Colin Crossb98c8b02016-07-29 13:44:28 -0700641 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700642
643 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800644
645 // Flags used to compile this module
646 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700647
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800648 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700649 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900650
651 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800652 // Kythe (source file indexer) paths for this compilation module
653 kytheFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900654
655 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700656 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700657
658 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700659}
660
Ivan Lozano52767be2019-10-18 14:49:46 -0700661func (c *Module) Toc() android.OptionalPath {
662 if c.linker != nil {
663 if library, ok := c.linker.(libraryInterface); ok {
664 return library.toc()
665 }
666 }
667 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
668}
669
670func (c *Module) ApiLevel() string {
671 if c.linker != nil {
672 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700673 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700674 }
675 }
676 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
677}
678
679func (c *Module) Static() bool {
680 if c.linker != nil {
681 if library, ok := c.linker.(libraryInterface); ok {
682 return library.static()
683 }
684 }
685 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
686}
687
688func (c *Module) Shared() bool {
689 if c.linker != nil {
690 if library, ok := c.linker.(libraryInterface); ok {
691 return library.shared()
692 }
693 }
694 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
695}
696
697func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000698 if c.stl != nil {
699 return c.stl.Properties.SelectedStl
700 }
701 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700702}
703
704func (c *Module) ToolchainLibrary() bool {
705 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
706 return true
707 }
708 return false
709}
710
711func (c *Module) NdkPrebuiltStl() bool {
712 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
713 return true
714 }
715 return false
716}
717
718func (c *Module) StubDecorator() bool {
719 if _, ok := c.linker.(*stubDecorator); ok {
720 return true
721 }
722 return false
723}
724
725func (c *Module) SdkVersion() string {
726 return String(c.Properties.Sdk_version)
727}
728
Artur Satayev480e25b2020-04-27 18:53:18 +0100729func (c *Module) MinSdkVersion() string {
730 return String(c.Properties.Min_sdk_version)
731}
732
Dan Albert92fe7402020-07-15 13:33:30 -0700733func (c *Module) SplitPerApiLevel() bool {
Colin Cross1348ce32020-10-01 13:37:16 -0700734 if !c.canUseSdk() {
735 return false
736 }
Dan Albert92fe7402020-07-15 13:33:30 -0700737 if linker, ok := c.linker.(*objectLinker); ok {
738 return linker.isCrt()
739 }
740 return false
741}
742
Colin Crossc511bc52020-04-07 16:50:32 +0000743func (c *Module) AlwaysSdk() bool {
744 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
745}
746
Ivan Lozano183a3212019-10-18 14:18:45 -0700747func (c *Module) CcLibrary() bool {
748 if c.linker != nil {
749 if _, ok := c.linker.(*libraryDecorator); ok {
750 return true
751 }
Colin Crossd48fe732020-09-23 20:37:24 -0700752 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
753 return true
754 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700755 }
756 return false
757}
758
759func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -0700760 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700761 return true
762 }
763 return false
764}
765
Ivan Lozano2b262972019-11-21 12:30:50 -0800766func (c *Module) NonCcVariants() bool {
767 return false
768}
769
Ivan Lozano183a3212019-10-18 14:18:45 -0700770func (c *Module) SetStatic() {
771 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700772 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700773 library.setStatic()
774 return
775 }
776 }
777 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
778}
779
780func (c *Module) SetShared() {
781 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700782 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700783 library.setShared()
784 return
785 }
786 }
787 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
788}
789
790func (c *Module) BuildStaticVariant() bool {
791 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700792 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700793 return library.buildStatic()
794 }
795 }
796 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
797}
798
799func (c *Module) BuildSharedVariant() bool {
800 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700801 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700802 return library.buildShared()
803 }
804 }
805 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
806}
807
808func (c *Module) Module() android.Module {
809 return c
810}
811
Jiyong Parkc20eee32018-09-05 22:36:17 +0900812func (c *Module) OutputFile() android.OptionalPath {
813 return c.outputFile
814}
815
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400816func (c *Module) CoverageFiles() android.Paths {
817 if c.linker != nil {
818 if library, ok := c.linker.(libraryInterface); ok {
819 return library.objs().coverageFiles
820 }
821 }
822 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
823}
824
Ivan Lozano183a3212019-10-18 14:18:45 -0700825var _ LinkableInterface = (*Module)(nil)
826
Jiyong Park719b4462019-01-13 00:39:51 +0900827func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900828 if c.linker != nil {
829 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +0900830 }
831 return nil
832}
833
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900834func (c *Module) CoverageOutputFile() android.OptionalPath {
835 if c.linker != nil {
836 return c.linker.coverageOutputFilePath()
837 }
838 return android.OptionalPath{}
839}
840
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900841func (c *Module) RelativeInstallPath() string {
842 if c.installer != nil {
843 return c.installer.relativeInstallPath()
844 }
845 return ""
846}
847
Jooyung Han344d5432019-08-23 11:17:39 +0900848func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +0900849 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +0900850}
851
Colin Cross36242852017-06-23 15:06:31 -0700852func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -0700853 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -0800854 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -0700855 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800856 }
857 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -0700858 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800859 }
860 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -0700861 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800862 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700863 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -0700864 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -0700865 }
Colin Cross16b23492016-01-06 14:41:07 -0800866 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -0700867 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -0800868 }
Dan Willemsen581341d2017-02-09 16:16:31 -0800869 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -0700870 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -0800871 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800872 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -0700873 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800874 }
Justin Yun8effde42017-06-23 19:24:43 +0900875 if c.vndkdep != nil {
876 c.AddProperties(c.vndkdep.props()...)
877 }
Stephen Craneba090d12017-05-09 15:44:35 -0700878 if c.lto != nil {
879 c.AddProperties(c.lto.props()...)
880 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700881 if c.pgo != nil {
882 c.AddProperties(c.pgo.props()...)
883 }
Colin Crossca860ac2016-01-04 14:34:37 -0800884 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -0700885 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800886 }
Colin Crossc472d572015-03-17 15:06:21 -0700887
Jiyong Park1613e552020-09-14 19:43:17 +0900888 c.Prefer32(func(ctx android.BaseModuleContext, base *android.ModuleBase, os android.OsType) bool {
Elliott Hughes79ae3412020-04-17 15:49:49 -0700889 // Windows builds always prefer 32-bit
Jiyong Park1613e552020-09-14 19:43:17 +0900890 return os == android.Windows
Colin Crossa9d8bee2018-10-02 13:59:46 -0700891 })
Colin Cross36242852017-06-23 15:06:31 -0700892 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +0900893 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +0900894 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +0900895 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +0900896
Colin Cross36242852017-06-23 15:06:31 -0700897 return c
Colin Crossc472d572015-03-17 15:06:21 -0700898}
899
Colin Crossb916a382016-07-29 17:28:03 -0700900// Returns true for dependency roots (binaries)
901// TODO(ccross): also handle dlopenable libraries
902func (c *Module) isDependencyRoot() bool {
903 if root, ok := c.linker.(interface {
904 isDependencyRoot() bool
905 }); ok {
906 return root.isDependencyRoot()
907 }
908 return false
909}
910
Justin Yun5f7f7e82019-11-18 19:52:14 +0900911// Returns true if the module is using VNDK libraries instead of the libraries in /system/lib or /system/lib64.
912// "product" and "vendor" variant modules return true for this function.
913// When BOARD_VNDK_VERSION is set, vendor variants of "vendor_available: true", "vendor: true",
914// "soc_specific: true" and more vendor installed modules are included here.
Justin Yun63e9ec72020-10-29 16:49:43 +0900915// When PRODUCT_PRODUCT_VNDK_VERSION is set, product variants of "product_available: true" or
Justin Yun5f7f7e82019-11-18 19:52:14 +0900916// "product_specific: true" modules are included here.
Ivan Lozano52767be2019-10-18 14:49:46 -0700917func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +0900918 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700919}
920
Colin Crossc511bc52020-04-07 16:50:32 +0000921func (c *Module) canUseSdk() bool {
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700922 return c.Os() == android.Android && !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +0000923}
924
925func (c *Module) UseSdk() bool {
926 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -0700927 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +0000928 }
929 return false
930}
931
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800932func (c *Module) isCoverageVariant() bool {
933 return c.coverage.Properties.IsCoverageVariant
934}
935
Peter Collingbournead84f972019-12-17 16:46:18 -0800936func (c *Module) IsNdk() bool {
Colin Crossf0913fb2020-07-29 12:59:39 -0700937 return inList(c.BaseModuleName(), ndkKnownLibs)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800938}
939
Inseob Kim9516ee92019-05-09 10:56:13 +0900940func (c *Module) isLlndk(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800941 // Returns true for both LLNDK (public) and LLNDK-private libs.
Jooyung Han0302a842019-10-30 18:43:49 +0900942 return isLlndkLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800943}
944
Inseob Kim9516ee92019-05-09 10:56:13 +0900945func (c *Module) isLlndkPublic(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800946 // Returns true only for LLNDK (public) libs.
Jooyung Han0302a842019-10-30 18:43:49 +0900947 name := c.BaseModuleName()
948 return isLlndkLibrary(name, config) && !isVndkPrivateLibrary(name, config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800949}
950
Inseob Kim9516ee92019-05-09 10:56:13 +0900951func (c *Module) isVndkPrivate(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800952 // Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Jooyung Han0302a842019-10-30 18:43:49 +0900953 return isVndkPrivateLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800954}
955
Ivan Lozano52767be2019-10-18 14:49:46 -0700956func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +0800957 if vndkdep := c.vndkdep; vndkdep != nil {
958 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +0900959 }
960 return false
961}
962
Yi Kong7e53c572018-02-14 18:16:12 +0800963func (c *Module) isPgoCompile() bool {
964 if pgo := c.pgo; pgo != nil {
965 return pgo.Properties.PgoCompile
966 }
967 return false
968}
969
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800970func (c *Module) isNDKStubLibrary() bool {
971 if _, ok := c.compiler.(*stubDecorator); ok {
972 return true
973 }
974 return false
975}
976
Logan Chienf3511742017-10-31 18:04:35 +0800977func (c *Module) isVndkSp() bool {
978 if vndkdep := c.vndkdep; vndkdep != nil {
979 return vndkdep.isVndkSp()
980 }
981 return false
982}
983
984func (c *Module) isVndkExt() bool {
985 if vndkdep := c.vndkdep; vndkdep != nil {
986 return vndkdep.isVndkExt()
987 }
988 return false
989}
990
Ivan Lozano52767be2019-10-18 14:49:46 -0700991func (c *Module) MustUseVendorVariant() bool {
Jooyung Han097087b2019-10-22 19:32:18 +0900992 return c.isVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -0800993}
994
Logan Chienf3511742017-10-31 18:04:35 +0800995func (c *Module) getVndkExtendsModuleName() string {
996 if vndkdep := c.vndkdep; vndkdep != nil {
997 return vndkdep.getVndkExtendsModuleName()
998 }
999 return ""
1000}
1001
Jiyong Park25fc6a92018-11-18 18:02:45 +09001002func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001003 if lib := c.library; lib != nil {
1004 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001005 }
1006 return false
1007}
1008
1009func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001010 if lib := c.library; lib != nil {
1011 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001012 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001013 return false
1014}
1015
Colin Cross0477b422020-10-13 18:43:54 -07001016// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1017// the implementation. If it is an implementation library it returns its own name.
1018func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1019 name := ctx.OtherModuleName(c)
1020 if versioned, ok := c.linker.(versionedInterface); ok {
1021 name = versioned.implementationModuleName(name)
1022 }
1023 return name
1024}
1025
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001026func (c *Module) bootstrap() bool {
1027 return Bool(c.Properties.Bootstrap)
1028}
1029
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001030func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001031 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1032 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1033 return false
1034 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001035 return c.linker != nil && c.linker.nativeCoverage()
1036}
1037
Inseob Kim8471cda2019-11-15 09:59:12 +09001038func (c *Module) isSnapshotPrebuilt() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09001039 if p, ok := c.linker.(interface{ isSnapshotPrebuilt() bool }); ok {
1040 return p.isSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001041 }
1042 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001043}
1044
Bill Peckham945441c2020-08-31 16:07:58 -07001045func (c *Module) ExcludeFromVendorSnapshot() bool {
1046 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1047}
1048
Jiyong Parkf1194352019-02-25 11:05:47 +09001049func isBionic(name string) bool {
1050 switch name {
Martin Stjernholm203489b2019-11-11 15:33:27 +00001051 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001052 return true
1053 }
1054 return false
1055}
1056
Martin Stjernholm279de572019-09-10 23:18:20 +01001057func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001058 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001059 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001060 }
1061 return isBionic(name)
1062}
1063
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001064func (c *Module) XrefCcFiles() android.Paths {
1065 return c.kytheFiles
1066}
1067
Colin Crossca860ac2016-01-04 14:34:37 -08001068type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001069 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001070 moduleContextImpl
1071}
1072
Colin Cross37047f12016-12-13 17:06:13 -08001073type depsContext struct {
1074 android.BottomUpMutatorContext
1075 moduleContextImpl
1076}
1077
Colin Crossca860ac2016-01-04 14:34:37 -08001078type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001079 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001080 moduleContextImpl
1081}
1082
1083type moduleContextImpl struct {
1084 mod *Module
1085 ctx BaseModuleContext
1086}
1087
Colin Crossb98c8b02016-07-29 13:44:28 -07001088func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001089 return ctx.mod.toolchain(ctx.ctx)
1090}
1091
1092func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001093 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001094}
1095
1096func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001097 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001098}
1099
Jiyong Park1d1119f2019-07-29 21:27:18 +09001100func (ctx *moduleContextImpl) header() bool {
1101 return ctx.mod.header()
1102}
1103
Inseob Kim7f283f42020-06-01 21:53:49 +09001104func (ctx *moduleContextImpl) binary() bool {
1105 return ctx.mod.binary()
1106}
1107
Inseob Kim1042d292020-06-01 23:23:05 +09001108func (ctx *moduleContextImpl) object() bool {
1109 return ctx.mod.object()
1110}
1111
Jooyung Hanccce2f22020-03-07 03:45:53 +09001112func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001113 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001114}
1115
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001116func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001117 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001118}
1119
1120func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001121 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001122 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001123 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001124 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001125 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001126 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001127 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001128 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001129 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001130 }
1131 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001132}
1133
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001134func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001135 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001136}
Justin Yun8effde42017-06-23 19:24:43 +09001137
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001138func (ctx *moduleContextImpl) isNdk() bool {
Peter Collingbournead84f972019-12-17 16:46:18 -08001139 return ctx.mod.IsNdk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001140}
1141
Inseob Kim9516ee92019-05-09 10:56:13 +09001142func (ctx *moduleContextImpl) isLlndk(config android.Config) bool {
1143 return ctx.mod.isLlndk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001144}
1145
Inseob Kim9516ee92019-05-09 10:56:13 +09001146func (ctx *moduleContextImpl) isLlndkPublic(config android.Config) bool {
1147 return ctx.mod.isLlndkPublic(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001148}
1149
Inseob Kim9516ee92019-05-09 10:56:13 +09001150func (ctx *moduleContextImpl) isVndkPrivate(config android.Config) bool {
1151 return ctx.mod.isVndkPrivate(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001152}
1153
Logan Chienf3511742017-10-31 18:04:35 +08001154func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001155 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001156}
1157
Yi Kong7e53c572018-02-14 18:16:12 +08001158func (ctx *moduleContextImpl) isPgoCompile() bool {
1159 return ctx.mod.isPgoCompile()
1160}
1161
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001162func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1163 return ctx.mod.isNDKStubLibrary()
1164}
1165
Justin Yun8effde42017-06-23 19:24:43 +09001166func (ctx *moduleContextImpl) isVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001167 return ctx.mod.isVndkSp()
1168}
1169
1170func (ctx *moduleContextImpl) isVndkExt() bool {
1171 return ctx.mod.isVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001172}
1173
Vic Yangefd249e2018-11-12 20:19:56 -08001174func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001175 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001176}
1177
Logan Chien2f2b8902018-07-10 15:01:19 +08001178// Check whether ABI dumps should be created for this module.
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001179func (ctx *moduleContextImpl) shouldCreateSourceAbiDump() bool {
Logan Chien2f2b8902018-07-10 15:01:19 +08001180 if ctx.ctx.Config().IsEnvTrue("SKIP_ABI_CHECKS") {
1181 return false
Jayant Chowdharyea0a2e12018-03-01 19:12:16 -08001182 }
Doug Hornc32c6b02019-01-17 14:44:05 -08001183
Hsin-Yi Chenf81bb652020-04-07 21:42:19 +08001184 // Coverage builds have extra symbols.
1185 if ctx.mod.isCoverageVariant() {
1186 return false
1187 }
1188
Doug Hornc32c6b02019-01-17 14:44:05 -08001189 if ctx.ctx.Fuchsia() {
1190 return false
1191 }
1192
Logan Chien2f2b8902018-07-10 15:01:19 +08001193 if sanitize := ctx.mod.sanitize; sanitize != nil {
1194 if !sanitize.isVariantOnProductionDevice() {
1195 return false
1196 }
1197 }
1198 if !ctx.ctx.Device() {
1199 // Host modules do not need ABI dumps.
1200 return false
1201 }
Colin Cross31076b32020-10-23 17:22:06 -07001202 if ctx.isNDKStubLibrary() {
Hsin-Yi Chenf6a95462019-06-25 14:46:52 +08001203 // Stubs do not need ABI dumps.
1204 return false
1205 }
Colin Cross31076b32020-10-23 17:22:06 -07001206 if lib := ctx.mod.library; lib != nil && lib.buildStubs() {
1207 // Stubs do not need ABI dumps.
1208 return false
1209 }
1210
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001211 return true
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001212}
1213
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001214func (ctx *moduleContextImpl) selectedStl() string {
1215 if stl := ctx.mod.stl; stl != nil {
1216 return stl.Properties.SelectedStl
1217 }
1218 return ""
1219}
1220
Ivan Lozanobd721262018-11-27 14:33:03 -08001221func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1222 return ctx.mod.linker.useClangLld(actx)
1223}
1224
Colin Crossce75d2c2016-10-06 16:12:58 -07001225func (ctx *moduleContextImpl) baseModuleName() string {
1226 return ctx.mod.ModuleBase.BaseModuleName()
1227}
1228
Logan Chienf3511742017-10-31 18:04:35 +08001229func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1230 return ctx.mod.getVndkExtendsModuleName()
1231}
1232
Logan Chiene274fc92019-12-03 11:18:32 -08001233func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001234 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001235}
1236
Colin Crosse07f2312020-08-13 11:24:56 -07001237func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001238 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001239}
1240
Dan Albertc8060532020-07-22 22:32:17 -07001241func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001242 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001243}
1244
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001245func (ctx *moduleContextImpl) bootstrap() bool {
1246 return ctx.mod.bootstrap()
1247}
1248
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001249func (ctx *moduleContextImpl) nativeCoverage() bool {
1250 return ctx.mod.nativeCoverage()
1251}
1252
Colin Cross56a83212020-09-15 18:30:11 -07001253func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1254 return ctx.mod.DirectlyInAnyApex()
1255}
1256
Colin Cross635c3b02016-05-18 15:37:25 -07001257func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001258 return &Module{
1259 hod: hod,
1260 multilib: multilib,
1261 }
1262}
1263
Colin Cross635c3b02016-05-18 15:37:25 -07001264func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001265 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001266 module.features = []feature{
1267 &tidyFeature{},
1268 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001269 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001270 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001271 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001272 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001273 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001274 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001275 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001276 return module
1277}
1278
Colin Crossce75d2c2016-10-06 16:12:58 -07001279func (c *Module) Prebuilt() *android.Prebuilt {
1280 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1281 return p.prebuilt()
1282 }
1283 return nil
1284}
1285
1286func (c *Module) Name() string {
1287 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001288 if p, ok := c.linker.(interface {
1289 Name(string) string
1290 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001291 name = p.Name(name)
1292 }
1293 return name
1294}
1295
Alex Light3d673592019-01-18 14:37:31 -08001296func (c *Module) Symlinks() []string {
1297 if p, ok := c.installer.(interface {
1298 symlinkList() []string
1299 }); ok {
1300 return p.symlinkList()
1301 }
1302 return nil
1303}
1304
Roland Levillainf89cd092019-07-29 16:22:59 +01001305func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1306 test, ok := c.linker.(testPerSrc)
1307 return ok && test.isAllTestsVariation()
1308}
1309
Chris Parsons216e10a2020-07-09 17:12:52 -04001310func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001311 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001312 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001313 }); ok {
1314 return p.dataPaths()
1315 }
1316 return nil
1317}
1318
Justin Yun5f7f7e82019-11-18 19:52:14 +09001319func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1320 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1321 // "current", it will append the VNDK version to the name suffix.
1322 var vndkVersion string
1323 var nameSuffix string
1324 if c.inProduct() {
1325 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
1326 nameSuffix = productSuffix
1327 } else {
1328 vndkVersion = ctx.DeviceConfig().VndkVersion()
1329 nameSuffix = vendorSuffix
1330 }
1331 if vndkVersion == "current" {
1332 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1333 }
1334 if c.Properties.VndkVersion != vndkVersion {
1335 // add version suffix only if the module is using different vndk version than the
1336 // version in product or vendor partition.
1337 nameSuffix += "." + c.Properties.VndkVersion
1338 }
1339 return nameSuffix
1340}
1341
Colin Cross635c3b02016-05-18 15:37:25 -07001342func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Roland Levillainf2fad972019-06-28 15:41:19 +01001343 // Handle the case of a test module split by `test_per_src` mutator.
Roland Levillainf89cd092019-07-29 16:22:59 +01001344 //
1345 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1346 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1347 // module and return early, as this module does not produce an output file per se.
1348 if c.IsTestPerSrcAllTestsVariation() {
1349 c.outputFile = android.OptionalPath{}
1350 return
Roland Levillainf2fad972019-06-28 15:41:19 +01001351 }
1352
Colin Cross56a83212020-09-15 18:30:11 -07001353 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1354 if !apexInfo.IsForPlatform() {
1355 c.hideApexVariantFromMake = true
1356 }
1357
Jooyung Han38002912019-05-16 04:01:54 +09001358 c.makeLinkType = c.getMakeLinkType(actx)
Inseob Kim9516ee92019-05-09 10:56:13 +09001359
Inseob Kim64c43952019-08-26 16:52:35 +09001360 c.Properties.SubName = ""
1361
1362 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1363 c.Properties.SubName += nativeBridgeSuffix
1364 }
1365
Justin Yun5f7f7e82019-11-18 19:52:14 +09001366 _, llndk := c.linker.(*llndkStubDecorator)
1367 _, llndkHeader := c.linker.(*llndkHeadersDecorator)
Justin Yun63e9ec72020-10-29 16:49:43 +09001368 if llndk || llndkHeader || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001369 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1370 // added for product variant only when we have vendor and product variants with core
1371 // variant. The suffix is not added for vendor-only or product-only module.
1372 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
1373 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001374 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1375 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
1376 c.Properties.SubName += vendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001377 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
1378 c.Properties.SubName += ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001379 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
1380 c.Properties.SubName += vendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001381 } else if c.InRecovery() && !c.OnlyInRecovery() {
Inseob Kim64c43952019-08-26 16:52:35 +09001382 c.Properties.SubName += recoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001383 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001384 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001385 if c.SplitPerApiLevel() {
1386 c.Properties.SubName += "." + c.SdkVersion()
1387 }
Inseob Kim64c43952019-08-26 16:52:35 +09001388 }
1389
Colin Crossca860ac2016-01-04 14:34:37 -08001390 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001391 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001392 moduleContextImpl: moduleContextImpl{
1393 mod: c,
1394 },
1395 }
1396 ctx.ctx = ctx
1397
Colin Crossf18e1102017-11-16 14:33:08 -08001398 deps := c.depsToPaths(ctx)
1399 if ctx.Failed() {
1400 return
1401 }
1402
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001403 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1404 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1405 }
1406
Colin Crossca860ac2016-01-04 14:34:37 -08001407 flags := Flags{
1408 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001409 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001410 }
Colin Crossca860ac2016-01-04 14:34:37 -08001411 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001412 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001413 }
1414 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001415 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001416 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001417 if c.stl != nil {
1418 flags = c.stl.flags(ctx, flags)
1419 }
Colin Cross16b23492016-01-06 14:41:07 -08001420 if c.sanitize != nil {
1421 flags = c.sanitize.flags(ctx, flags)
1422 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001423 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001424 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001425 }
Stephen Craneba090d12017-05-09 15:44:35 -07001426 if c.lto != nil {
1427 flags = c.lto.flags(ctx, flags)
1428 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001429 if c.pgo != nil {
1430 flags = c.pgo.flags(ctx, flags)
1431 }
Colin Crossca860ac2016-01-04 14:34:37 -08001432 for _, feature := range c.features {
1433 flags = feature.flags(ctx, flags)
1434 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001435 if ctx.Failed() {
1436 return
1437 }
1438
Colin Cross4af21ed2019-11-04 09:37:55 -08001439 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1440 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1441 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001442
Colin Cross4af21ed2019-11-04 09:37:55 -08001443 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001444
1445 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001446 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001447 }
1448 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001449 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001450 }
1451
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001452 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001453 // We need access to all the flags seen by a source file.
1454 if c.sabi != nil {
1455 flags = c.sabi.flags(ctx, flags)
1456 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001457
Colin Cross4af21ed2019-11-04 09:37:55 -08001458 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001459
Colin Crossca860ac2016-01-04 14:34:37 -08001460 // Optimization to reduce size of build.ninja
1461 // Replace the long list of flags for each file with a module-local variable
Colin Cross4af21ed2019-11-04 09:37:55 -08001462 ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))
1463 ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))
1464 ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))
1465 flags.Local.CFlags = []string{"$cflags"}
1466 flags.Local.CppFlags = []string{"$cppflags"}
1467 flags.Local.AsFlags = []string{"$asflags"}
Colin Crossca860ac2016-01-04 14:34:37 -08001468
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001469 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001470 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001471 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001472 if ctx.Failed() {
1473 return
1474 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001475 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001476 }
1477
Colin Crossca860ac2016-01-04 14:34:37 -08001478 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001479 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001480 if ctx.Failed() {
1481 return
1482 }
Colin Cross635c3b02016-05-18 15:37:25 -07001483 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001484
1485 // If a lib is directly included in any of the APEXes, unhide the stubs
1486 // variant having the latest version gets visible to make. In addition,
1487 // the non-stubs variant is renamed to <libname>.bootstrap. This is to
1488 // force anything in the make world to link against the stubs library.
1489 // (unless it is explicitly referenced via .bootstrap suffix or the
1490 // module is marked with 'bootstrap: true').
Colin Cross56a83212020-09-15 18:30:11 -07001491 if c.HasStubsVariants() && c.AnyVariantDirectlyInAnyApex() && !c.InRamdisk() &&
Ivan Lozano52767be2019-10-18 14:49:46 -07001492 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001493 c.IsStubs() && !c.InVendorRamdisk() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001494 c.Properties.HideFromMake = false // unhide
1495 // Note: this is still non-installable
1496 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001497
1498 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current.
1499 if i, ok := c.linker.(snapshotLibraryInterface); ok && ctx.DeviceConfig().VndkVersion() == "current" {
Colin Cross56a83212020-09-15 18:30:11 -07001500 if isSnapshotAware(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001501 i.collectHeadersForSnapshot(ctx)
1502 }
1503 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001504 }
Colin Cross5049f022015-03-18 13:28:46 -07001505
Colin Cross56a83212020-09-15 18:30:11 -07001506 if c.installable(apexInfo) {
Colin Crossce75d2c2016-10-06 16:12:58 -07001507 c.installer.install(ctx, c.outputFile.Path())
1508 if ctx.Failed() {
1509 return
Colin Crossca860ac2016-01-04 14:34:37 -08001510 }
Paul Duffin0cb37b92020-03-04 14:52:46 +00001511 } else if !proptools.BoolDefault(c.Properties.Installable, true) {
1512 // If the module has been specifically configure to not be installed then
1513 // skip the installation as otherwise it will break when running inside make
1514 // as the output path to install will not be specified. Not all uninstallable
1515 // modules can skip installation as some are needed for resolving make side
1516 // dependencies.
1517 c.SkipInstall()
Dan Albertc403f7c2015-03-18 14:01:18 -07001518 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001519}
1520
Colin Cross0ea8ba82019-06-06 14:33:29 -07001521func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001522 if c.cachedToolchain == nil {
Colin Crossb98c8b02016-07-29 13:44:28 -07001523 c.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
Colin Cross3f40fa42015-01-30 17:27:36 -08001524 }
Colin Crossca860ac2016-01-04 14:34:37 -08001525 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001526}
1527
Colin Crossca860ac2016-01-04 14:34:37 -08001528func (c *Module) begin(ctx BaseModuleContext) {
1529 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001530 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001531 }
Colin Crossca860ac2016-01-04 14:34:37 -08001532 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001533 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001534 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001535 if c.stl != nil {
1536 c.stl.begin(ctx)
1537 }
Colin Cross16b23492016-01-06 14:41:07 -08001538 if c.sanitize != nil {
1539 c.sanitize.begin(ctx)
1540 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001541 if c.coverage != nil {
1542 c.coverage.begin(ctx)
1543 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001544 if c.sabi != nil {
1545 c.sabi.begin(ctx)
1546 }
Justin Yun8effde42017-06-23 19:24:43 +09001547 if c.vndkdep != nil {
1548 c.vndkdep.begin(ctx)
1549 }
Stephen Craneba090d12017-05-09 15:44:35 -07001550 if c.lto != nil {
1551 c.lto.begin(ctx)
1552 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001553 if c.pgo != nil {
1554 c.pgo.begin(ctx)
1555 }
Colin Crossca860ac2016-01-04 14:34:37 -08001556 for _, feature := range c.features {
1557 feature.begin(ctx)
1558 }
Dan Albert92fe7402020-07-15 13:33:30 -07001559 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001560 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001561 if err != nil {
1562 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001563 c.Properties.Sdk_version = nil
1564 } else {
1565 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001566 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001567 }
Colin Crossca860ac2016-01-04 14:34:37 -08001568}
1569
Colin Cross37047f12016-12-13 17:06:13 -08001570func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001571 deps := Deps{}
1572
1573 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001574 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001575 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001576 // Add the PGO dependency (the clang_rt.profile runtime library), which
1577 // sometimes depends on symbols from libgcc, before libgcc gets added
1578 // in linkerDeps().
Pirama Arumuga Nainar49b53d52017-10-04 16:47:29 -07001579 if c.pgo != nil {
1580 deps = c.pgo.deps(ctx, deps)
1581 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001582 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001583 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001584 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001585 if c.stl != nil {
1586 deps = c.stl.deps(ctx, deps)
1587 }
Colin Cross16b23492016-01-06 14:41:07 -08001588 if c.sanitize != nil {
1589 deps = c.sanitize.deps(ctx, deps)
1590 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001591 if c.coverage != nil {
1592 deps = c.coverage.deps(ctx, deps)
1593 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001594 if c.sabi != nil {
1595 deps = c.sabi.deps(ctx, deps)
1596 }
Justin Yun8effde42017-06-23 19:24:43 +09001597 if c.vndkdep != nil {
1598 deps = c.vndkdep.deps(ctx, deps)
1599 }
Stephen Craneba090d12017-05-09 15:44:35 -07001600 if c.lto != nil {
1601 deps = c.lto.deps(ctx, deps)
1602 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001603 for _, feature := range c.features {
1604 deps = feature.deps(ctx, deps)
1605 }
1606
Colin Crossb6715442017-10-24 11:13:31 -07001607 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1608 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1609 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1610 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1611 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1612 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001613 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001614
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001615 for _, lib := range deps.ReexportSharedLibHeaders {
1616 if !inList(lib, deps.SharedLibs) {
1617 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1618 }
1619 }
1620
1621 for _, lib := range deps.ReexportStaticLibHeaders {
1622 if !inList(lib, deps.StaticLibs) {
1623 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs: '%s'", lib)
1624 }
1625 }
1626
Colin Cross5950f382016-12-13 12:50:57 -08001627 for _, lib := range deps.ReexportHeaderLibHeaders {
1628 if !inList(lib, deps.HeaderLibs) {
1629 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1630 }
1631 }
1632
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001633 for _, gen := range deps.ReexportGeneratedHeaders {
1634 if !inList(gen, deps.GeneratedHeaders) {
1635 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1636 }
1637 }
1638
Colin Crossc99deeb2016-04-11 15:06:20 -07001639 return deps
1640}
1641
Dan Albert7e9d2952016-08-04 13:02:36 -07001642func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001643 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001644 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001645 moduleContextImpl: moduleContextImpl{
1646 mod: c,
1647 },
1648 }
1649 ctx.ctx = ctx
1650
Colin Crossca860ac2016-01-04 14:34:37 -08001651 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001652}
1653
Jiyong Park7ed9de32018-10-15 22:25:07 +09001654// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09001655func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001656 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1657 version := name[sharp+1:]
1658 libname := name[:sharp]
1659 return libname, version
1660 }
1661 return name, ""
1662}
1663
Dan Albert92fe7402020-07-15 13:33:30 -07001664func GetCrtVariations(ctx android.BottomUpMutatorContext,
1665 m LinkableInterface) []blueprint.Variation {
1666 if ctx.Os() != android.Android {
1667 return nil
1668 }
1669 if m.UseSdk() {
1670 return []blueprint.Variation{
1671 {Mutator: "sdk", Variation: "sdk"},
Colin Crossbbc941b2020-09-30 12:27:01 -07001672 {Mutator: "version", Variation: m.SdkVersion()},
Dan Albert92fe7402020-07-15 13:33:30 -07001673 }
1674 }
1675 return []blueprint.Variation{
1676 {Mutator: "sdk", Variation: ""},
1677 }
1678}
1679
Colin Crosse7257d22020-09-24 09:56:18 -07001680func (c *Module) addSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext,
1681 variations []blueprint.Variation, depTag libraryDependencyTag, name, version string, far bool) {
1682
1683 variations = append([]blueprint.Variation(nil), variations...)
1684
Colin Cross3146c5c2020-09-30 15:34:40 -07001685 if version != "" && CanBeOrLinkAgainstVersionVariants(c) {
Colin Crosse7257d22020-09-24 09:56:18 -07001686 // Version is explicitly specified. i.e. libFoo#30
1687 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
1688 depTag.explicitlyVersioned = true
1689 }
Colin Crosse7257d22020-09-24 09:56:18 -07001690
Colin Cross0de8a1e2020-09-18 14:15:30 -07001691 if far {
1692 ctx.AddFarVariationDependencies(variations, depTag, name)
1693 } else {
1694 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07001695 }
1696}
1697
Colin Cross1e676be2016-10-12 14:38:15 -07001698func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09001699 if !c.Enabled() {
1700 return
1701 }
1702
Colin Cross37047f12016-12-13 17:06:13 -08001703 ctx := &depsContext{
1704 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07001705 moduleContextImpl: moduleContextImpl{
1706 mod: c,
1707 },
1708 }
1709 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08001710
Colin Crossc99deeb2016-04-11 15:06:20 -07001711 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001712
Yo Chiang219968c2020-09-22 18:45:04 +08001713 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
1714
Dan Albert914449f2016-06-17 16:45:24 -07001715 variantNdkLibs := []string{}
1716 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07001717 if ctx.Os() == android.Android {
Inseob Kimeec88e12020-01-22 11:11:29 +09001718 // rewriteLibs takes a list of names of shared libraries and scans it for three types
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001719 // of names:
Dan Albert914449f2016-06-17 16:45:24 -07001720 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001721 // 1. Name of an NDK library that refers to a prebuilt module.
1722 // For each of these, it adds the name of the prebuilt module (which will be in
1723 // prebuilts/ndk) to the list of nonvariant libs.
1724 // 2. Name of an NDK library that refers to an ndk_library module.
1725 // For each of these, it adds the name of the ndk_library module to the list of
1726 // variant libs.
1727 // 3. Anything else (so anything that isn't an NDK library).
1728 // It adds these to the nonvariantLibs list.
Dan Albert914449f2016-06-17 16:45:24 -07001729 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001730 // The caller can then know to add the variantLibs dependencies differently from the
1731 // nonvariantLibs
Inseob Kim9516ee92019-05-09 10:56:13 +09001732
Inseob Kim9516ee92019-05-09 10:56:13 +09001733 vendorPublicLibraries := vendorPublicLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001734 vendorSnapshotSharedLibs := vendorSnapshotSharedLibs(actx.Config())
1735
1736 rewriteVendorLibs := func(lib string) string {
1737 if isLlndkLibrary(lib, ctx.Config()) {
1738 return lib + llndkLibrarySuffix
1739 }
1740
1741 // only modules with BOARD_VNDK_VERSION uses snapshot.
1742 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1743 return lib
1744 }
1745
1746 if snapshot, ok := vendorSnapshotSharedLibs.get(lib, actx.Arch().ArchType); ok {
1747 return snapshot
1748 }
1749
1750 return lib
1751 }
1752
1753 rewriteLibs := func(list []string) (nonvariantLibs []string, variantLibs []string) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001754 variantLibs = []string{}
1755 nonvariantLibs = []string{}
Dan Albert914449f2016-06-17 16:45:24 -07001756 for _, entry := range list {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001757 // strip #version suffix out
Jiyong Park73c54ee2019-10-22 20:31:18 +09001758 name, _ := StubsLibNameAndVersion(entry)
Dan Albertde5aade2020-06-30 12:32:51 -07001759 if ctx.useSdk() && inList(name, ndkKnownLibs) {
1760 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Inseob Kimeec88e12020-01-22 11:11:29 +09001761 } else if ctx.useVndk() {
1762 nonvariantLibs = append(nonvariantLibs, rewriteVendorLibs(entry))
Inseob Kim9516ee92019-05-09 10:56:13 +09001763 } else if (ctx.Platform() || ctx.ProductSpecific()) && inList(name, *vendorPublicLibraries) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001764 vendorPublicLib := name + vendorPublicLibrarySuffix
Jiyong Park374510b2018-03-19 18:23:01 +09001765 if actx.OtherModuleExists(vendorPublicLib) {
1766 nonvariantLibs = append(nonvariantLibs, vendorPublicLib)
1767 } else {
1768 // This can happen if vendor_public_library module is defined in a
1769 // namespace that isn't visible to the current module. In that case,
1770 // link to the original library.
Jiyong Park7ed9de32018-10-15 22:25:07 +09001771 nonvariantLibs = append(nonvariantLibs, name)
Jiyong Park374510b2018-03-19 18:23:01 +09001772 }
Dan Albert914449f2016-06-17 16:45:24 -07001773 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001774 // put name#version back
Dan Willemsen7cbf5f82017-03-28 00:08:30 -07001775 nonvariantLibs = append(nonvariantLibs, entry)
Dan Willemsen72d39932016-07-08 23:23:48 -07001776 }
1777 }
Dan Albert914449f2016-06-17 16:45:24 -07001778 return nonvariantLibs, variantLibs
Dan Willemsen72d39932016-07-08 23:23:48 -07001779 }
1780
Inseob Kimeec88e12020-01-22 11:11:29 +09001781 deps.SharedLibs, variantNdkLibs = rewriteLibs(deps.SharedLibs)
1782 deps.LateSharedLibs, variantLateNdkLibs = rewriteLibs(deps.LateSharedLibs)
1783 deps.ReexportSharedLibHeaders, _ = rewriteLibs(deps.ReexportSharedLibHeaders)
1784 if ctx.useVndk() {
1785 for idx, lib := range deps.RuntimeLibs {
1786 deps.RuntimeLibs[idx] = rewriteVendorLibs(lib)
1787 }
1788 }
Dan Willemsen72d39932016-07-08 23:23:48 -07001789 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001790
Jiyong Park7e636d02019-01-28 16:16:54 +09001791 buildStubs := false
Colin Crossc88c2722020-09-28 17:32:47 -07001792 if versioned, ok := c.linker.(versionedInterface); ok {
1793 if versioned.buildStubs() {
1794 buildStubs = true
Colin Crossd48fe732020-09-23 20:37:24 -07001795 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001796 }
1797
Inseob Kimeec88e12020-01-22 11:11:29 +09001798 rewriteSnapshotLibs := func(lib string, snapshotMap *snapshotMap) string {
1799 // only modules with BOARD_VNDK_VERSION uses snapshot.
1800 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1801 return lib
1802 }
1803
1804 if snapshot, ok := snapshotMap.get(lib, actx.Arch().ArchType); ok {
1805 return snapshot
1806 }
1807
1808 return lib
1809 }
1810
1811 vendorSnapshotHeaderLibs := vendorSnapshotHeaderLibs(actx.Config())
Colin Cross32ec36c2016-12-15 07:39:51 -08001812 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001813 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08001814 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001815 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08001816 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001817
1818 lib = rewriteSnapshotLibs(lib, vendorSnapshotHeaderLibs)
1819
Jiyong Park7e636d02019-01-28 16:16:54 +09001820 if buildStubs {
Colin Cross7228ecd2019-11-18 16:00:16 -08001821 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001822 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09001823 } else {
1824 actx.AddVariationDependencies(nil, depTag, lib)
1825 }
1826 }
1827
1828 if buildStubs {
1829 // Stubs lib does not have dependency to other static/shared libraries.
1830 // Don't proceed.
1831 return
Colin Cross32ec36c2016-12-15 07:39:51 -08001832 }
Colin Cross5950f382016-12-13 12:50:57 -08001833
Inseob Kimc0907f12019-02-08 21:00:45 +09001834 syspropImplLibraries := syspropImplLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001835 vendorSnapshotStaticLibs := vendorSnapshotStaticLibs(actx.Config())
Inseob Kimc0907f12019-02-08 21:00:45 +09001836
Jiyong Park5d1598f2019-02-25 22:14:17 +09001837 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001838 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09001839 if impl, ok := syspropImplLibraries[lib]; ok {
1840 lib = impl
1841 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001842
1843 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1844
Jiyong Park5d1598f2019-02-25 22:14:17 +09001845 actx.AddVariationDependencies([]blueprint.Variation{
1846 {Mutator: "link", Variation: "static"},
1847 }, depTag, lib)
1848 }
1849
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001850 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001851 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001852 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001853 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001854 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001855
1856 if impl, ok := syspropImplLibraries[lib]; ok {
1857 lib = impl
1858 }
1859
Inseob Kimeec88e12020-01-22 11:11:29 +09001860 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1861
Dan Willemsen59339a22018-07-22 21:18:45 -07001862 actx.AddVariationDependencies([]blueprint.Variation{
1863 {Mutator: "link", Variation: "static"},
1864 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001865 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001866
Jooyung Han75568392020-03-20 04:29:24 +09001867 // staticUnwinderDep is treated as staticDep for Q apexes
1868 // so that native libraries/binaries are linked with static unwinder
1869 // because Q libc doesn't have unwinder APIs
1870 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07001871 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08001872 actx.AddVariationDependencies([]blueprint.Variation{
1873 {Mutator: "link", Variation: "static"},
Colin Cross6e511a92020-07-27 21:26:48 -07001874 }, depTag, rewriteSnapshotLibs(staticUnwinder(actx), vendorSnapshotStaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08001875 }
1876
Inseob Kimeec88e12020-01-22 11:11:29 +09001877 for _, lib := range deps.LateStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001878 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
Inseob Kimeec88e12020-01-22 11:11:29 +09001879 actx.AddVariationDependencies([]blueprint.Variation{
1880 {Mutator: "link", Variation: "static"},
Colin Cross6e511a92020-07-27 21:26:48 -07001881 }, depTag, rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs))
Inseob Kimeec88e12020-01-22 11:11:29 +09001882 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001883
Jiyong Park7ed9de32018-10-15 22:25:07 +09001884 // shared lib names without the #version suffix
1885 var sharedLibNames []string
1886
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001887 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001888 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001889 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001890 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001891 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001892
1893 if impl, ok := syspropImplLibraries[lib]; ok {
1894 lib = impl
1895 }
1896
Jiyong Park73c54ee2019-10-22 20:31:18 +09001897 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09001898 sharedLibNames = append(sharedLibNames, name)
1899
Colin Crosse7257d22020-09-24 09:56:18 -07001900 variations := []blueprint.Variation{
1901 {Mutator: "link", Variation: "shared"},
1902 }
1903 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001904 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001905
Jiyong Park7ed9de32018-10-15 22:25:07 +09001906 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001907 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001908 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
1909 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
1910 // linking against both the stubs lib and the non-stubs lib at the same time.
1911 continue
1912 }
Colin Cross6e511a92020-07-27 21:26:48 -07001913 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07001914 variations := []blueprint.Variation{
1915 {Mutator: "link", Variation: "shared"},
1916 }
1917 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09001918 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001919
Dan Willemsen59339a22018-07-22 21:18:45 -07001920 actx.AddVariationDependencies([]blueprint.Variation{
1921 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04001922 }, dataLibDepTag, deps.DataLibs...)
1923
1924 actx.AddVariationDependencies([]blueprint.Variation{
1925 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07001926 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08001927
Colin Cross68861832016-07-08 10:41:41 -07001928 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001929
1930 for _, gen := range deps.GeneratedHeaders {
1931 depTag := genHeaderDepTag
1932 if inList(gen, deps.ReexportGeneratedHeaders) {
1933 depTag = genHeaderExportDepTag
1934 }
1935 actx.AddDependency(c, depTag, gen)
1936 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07001937
Inseob Kim1042d292020-06-01 23:23:05 +09001938 vendorSnapshotObjects := vendorSnapshotObjects(actx.Config())
1939
Dan Albert92fe7402020-07-15 13:33:30 -07001940 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07001941 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07001942 if deps.CrtBegin != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001943 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
1944 rewriteSnapshotLibs(deps.CrtBegin, vendorSnapshotObjects))
Colin Crossca860ac2016-01-04 14:34:37 -08001945 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001946 if deps.CrtEnd != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001947 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
1948 rewriteSnapshotLibs(deps.CrtEnd, vendorSnapshotObjects))
Colin Cross21b9a242015-03-24 14:15:58 -07001949 }
Dan Willemsena0790e32018-10-12 00:24:23 -07001950 if deps.LinkerFlagsFile != "" {
1951 actx.AddDependency(c, linkerFlagsDepTag, deps.LinkerFlagsFile)
1952 }
1953 if deps.DynamicLinker != "" {
1954 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07001955 }
Dan Albert914449f2016-06-17 16:45:24 -07001956
1957 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07001958
1959 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07001960 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07001961 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07001962 {Mutator: "link", Variation: "shared"},
1963 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07001964
1965 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07001966 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07001967 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07001968 {Mutator: "link", Variation: "shared"},
1969 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08001970
1971 if vndkdep := c.vndkdep; vndkdep != nil {
1972 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08001973 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08001974 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07001975 {Mutator: "link", Variation: "shared"},
1976 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08001977 }
1978 }
Colin Cross6362e272015-10-29 15:25:03 -07001979}
Colin Cross21b9a242015-03-24 14:15:58 -07001980
Colin Crosse40b4ea2018-10-02 22:25:58 -07001981func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07001982 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
1983 c.beginMutator(ctx)
1984 }
1985}
1986
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001987// Whether a module can link to another module, taking into
1988// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09001989func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07001990 tag blueprint.DependencyTag) {
1991
1992 switch t := tag.(type) {
1993 case dependencyTag:
1994 if t != vndkExtDepTag {
1995 return
1996 }
1997 case libraryDependencyTag:
1998 default:
1999 return
2000 }
2001
Ivan Lozano52767be2019-10-18 14:49:46 -07002002 if from.Module().Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002003 // Host code is not restricted
2004 return
2005 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002006
2007 // VNDK is cc.Module supported only for now.
2008 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002009 // Though allowed dependency is limited by the image mutator,
2010 // each vendor and product module needs to check link-type
2011 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002012 if ccTo, ok := to.(*Module); ok {
2013 if ccFrom.vndkdep != nil {
2014 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2015 }
2016 } else {
2017 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002018 }
2019 return
2020 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002021 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002022 // Platform code can link to anything
2023 return
2024 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002025 if from.InRamdisk() {
2026 // Ramdisk code is not NDK
2027 return
2028 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002029 if from.InVendorRamdisk() {
2030 // Vendor ramdisk code is not NDK
2031 return
2032 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002033 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002034 // Recovery code is not NDK
2035 return
2036 }
Colin Cross31076b32020-10-23 17:22:06 -07002037 if c, ok := to.(*Module); ok {
2038 if c.ToolchainLibrary() {
2039 // These are always allowed
2040 return
2041 }
2042 if c.NdkPrebuiltStl() {
2043 // These are allowed, but they don't set sdk_version
2044 return
2045 }
2046 if c.StubDecorator() {
2047 // These aren't real libraries, but are the stub shared libraries that are included in
2048 // the NDK.
2049 return
2050 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002051 }
Logan Chien834b9a62019-01-14 15:39:03 +08002052
Ivan Lozano52767be2019-10-18 14:49:46 -07002053 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002054 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2055 // to link to libc++ (non-NDK and without sdk_version).
2056 return
2057 }
2058
Ivan Lozano52767be2019-10-18 14:49:46 -07002059 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002060 // NDK code linking to platform code is never okay.
2061 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002062 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002063 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002064 }
2065
2066 // At this point we know we have two NDK libraries, but we need to
2067 // check that we're not linking against anything built against a higher
2068 // API level, as it is only valid to link against older or equivalent
2069 // APIs.
2070
Inseob Kim01a28722018-04-11 09:48:45 +09002071 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002072 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002073 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002074 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002075 // Current can't be linked against by anything else.
2076 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002077 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002078 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002079 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002080 if err != nil {
2081 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002082 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002083 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002084 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002085 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002086 if err != nil {
2087 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002088 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002089 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002090 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002091
Inseob Kim01a28722018-04-11 09:48:45 +09002092 if toApi > fromApi {
2093 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002094 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002095 }
2096 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002097 }
Dan Albert202fe492017-12-15 13:56:59 -08002098
2099 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002100 fromStl := from.SelectedStl()
2101 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002102 if fromStl == "" || toStl == "" {
2103 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002104 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002105 // We can be permissive with the system "STL" since it is only the C++
2106 // ABI layer, but in the future we should make sure that everyone is
2107 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002108 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002109 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002110 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2111 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002112 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002113}
2114
Jooyung Han479ca172020-10-19 18:51:07 +09002115func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2116 if c, ok := ctx.Module().(*Module); ok {
2117 ctx.VisitDirectDeps(func(dep android.Module) {
2118 depTag := ctx.OtherModuleDependencyTag(dep)
2119 ccDep, ok := dep.(LinkableInterface)
2120 if ok {
2121 checkLinkType(ctx, c, ccDep, depTag)
2122 }
2123 })
2124 }
2125}
2126
Jiyong Park5fb8c102018-04-09 12:03:06 +09002127// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002128// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2129// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002130// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002131func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2132 check := func(child, parent android.Module) bool {
2133 to, ok := child.(*Module)
2134 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002135 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002136 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002137
Jooyung Hana70f0672019-01-18 15:20:43 +09002138 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2139 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002140 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002141
Justin Yun63e9ec72020-10-29 16:49:43 +09002142 // Even if target lib has no vendor variant, keep checking dependency
2143 // graph in case it depends on vendor_available or product_available
2144 // but not double_loadable transtively.
2145 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002146 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002147 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002148
Jooyung Han0302a842019-10-30 18:43:49 +09002149 if to.isVndkSp() || to.isLlndk(ctx.Config()) || Bool(to.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002150 return false
2151 }
2152
2153 var stringPath []string
2154 for _, m := range ctx.GetWalkPath() {
2155 stringPath = append(stringPath, m.Name())
2156 }
2157 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2158 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
2159 "(dependency: %s)", ctx.OtherModuleName(to), strings.Join(stringPath, " -> "))
2160 return false
2161 }
2162 if module, ok := ctx.Module().(*Module); ok {
2163 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jooyung Han0302a842019-10-30 18:43:49 +09002164 if module.isLlndk(ctx.Config()) || Bool(module.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002165 ctx.WalkDeps(check)
2166 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002167 }
2168 }
2169}
2170
Colin Cross0de8a1e2020-09-18 14:15:30 -07002171// Returns the highest version which is <= maxSdkVersion.
2172// For example, with maxSdkVersion is 10 and versionList is [9,11]
2173// it returns 9 as string. The list of stubs must be in order from
2174// oldest to newest.
2175func (c *Module) chooseSdkVersion(ctx android.PathContext, stubsInfo []SharedLibraryStubsInfo,
2176 maxSdkVersion android.ApiLevel) (SharedLibraryStubsInfo, error) {
2177
2178 for i := range stubsInfo {
2179 stubInfo := stubsInfo[len(stubsInfo)-i-1]
2180 var ver android.ApiLevel
2181 if stubInfo.Version == "" {
2182 ver = android.FutureApiLevel
2183 } else {
2184 var err error
2185 ver, err = android.ApiLevelFromUser(ctx, stubInfo.Version)
2186 if err != nil {
2187 return SharedLibraryStubsInfo{}, err
2188 }
2189 }
2190 if ver.LessThanOrEqualTo(maxSdkVersion) {
2191 return stubInfo, nil
2192 }
2193 }
2194 var versionList []string
2195 for _, stubInfo := range stubsInfo {
2196 versionList = append(versionList, stubInfo.Version)
2197 }
2198 return SharedLibraryStubsInfo{}, fmt.Errorf("not found a version(<=%s) in versionList: %v", maxSdkVersion.String(), versionList)
2199}
2200
Colin Crossc99deeb2016-04-11 15:06:20 -07002201// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002202func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002203 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002204
Colin Cross0de8a1e2020-09-18 14:15:30 -07002205 var directStaticDeps []StaticLibraryInfo
2206 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002207
Colin Cross0de8a1e2020-09-18 14:15:30 -07002208 reexportExporter := func(exporter FlagExporterInfo) {
2209 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2210 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2211 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2212 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2213 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002214 }
2215
Jooyung Hande34d232020-07-23 13:04:15 +09002216 // For the dependency from platform to apex, use the latest stubs
2217 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002218 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2219 if !apexInfo.IsForPlatform() {
2220 c.apexSdkVersion = apexInfo.MinSdkVersion(ctx)
Jooyung Hande34d232020-07-23 13:04:15 +09002221 }
2222
2223 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2224 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2225 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2226 // (b/144430859)
2227 c.apexSdkVersion = android.FutureApiLevel
2228 }
2229
Colin Crossd11fcda2017-10-23 17:59:01 -07002230 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002231 depName := ctx.OtherModuleName(dep)
2232 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002233
Ivan Lozano52767be2019-10-18 14:49:46 -07002234 ccDep, ok := dep.(LinkableInterface)
2235 if !ok {
2236
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002237 // handling for a few module types that aren't cc Module but that are also supported
2238 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002239 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002240 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002241 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2242 genRule.GeneratedSourceFiles()...)
2243 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002244 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002245 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002246 // Support exported headers from a generated_sources dependency
2247 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002248 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002249 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002250 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002251 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002252 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002253 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002254 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002255 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002256 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2257 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002258 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002259 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
Jiyong Park74955042019-10-22 20:19:51 +09002260 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002261
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002262 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002263 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002264 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002265 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002266 case linkerFlagsDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002267 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002268 files := genRule.GeneratedSourceFiles()
2269 if len(files) == 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002270 depPaths.LinkerFlagsFile = android.OptionalPathForPath(files[0])
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002271 } else if len(files) > 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002272 ctx.ModuleErrorf("module %q can only generate a single file if used for a linker flag file", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002273 }
2274 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002275 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002276 }
Colin Crossca860ac2016-01-04 14:34:37 -08002277 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002278 return
2279 }
2280
Colin Crossfe17f6f2019-03-28 19:30:56 -07002281 if depTag == android.ProtoPluginDepTag {
2282 return
2283 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002284 if depTag == llndkImplDep {
2285 return
2286 }
Colin Crossfe17f6f2019-03-28 19:30:56 -07002287
Colin Crossd11fcda2017-10-23 17:59:01 -07002288 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002289 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2290 return
2291 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002292 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002293 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2294 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002295 return
2296 }
2297
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002298 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002299 // Skip reused objects for stub libraries, they use their own stub object file instead.
2300 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2301 // version mutator, so the stubs variant is created from the shared variant that
2302 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002303 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002304 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2305 objs := staticAnalogue.ReuseObjects
2306 depPaths.Objs = depPaths.Objs.Append(objs)
2307 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2308 reexportExporter(depExporterInfo)
2309 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002310 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002311 }
2312
Colin Cross6e511a92020-07-27 21:26:48 -07002313 linkFile := ccDep.OutputFile()
2314
2315 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2316 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002317 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002318 return
2319 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002320
Colin Cross0de8a1e2020-09-18 14:15:30 -07002321 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002322
Colin Cross6e511a92020-07-27 21:26:48 -07002323 var ptr *android.Paths
2324 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002325
Colin Cross6e511a92020-07-27 21:26:48 -07002326 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002327
Colin Cross6e511a92020-07-27 21:26:48 -07002328 switch {
2329 case libDepTag.header():
2330 // nothing
2331 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002332 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2333 if !ctx.Config().AllowMissingDependencies() {
2334 ctx.ModuleErrorf("module %q is not a shared library", depName)
2335 } else {
2336 ctx.AddMissingDependencies([]string{depName})
2337 }
2338 return
2339 }
2340 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
2341 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryImplementationStubsInfoProvider).(SharedLibraryImplementationStubsInfo)
2342
2343 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedLibraryStubsInfos) > 0 {
2344 useStubs := false
Colin Cross31076b32020-10-23 17:22:06 -07002345
2346 if lib := moduleLibraryInterface(dep); lib.buildStubs() && c.UseVndk() { // LLNDK
Colin Cross0de8a1e2020-09-18 14:15:30 -07002347 if !apexInfo.IsForPlatform() {
2348 // For platform libraries, use current version of LLNDK
2349 // If this is for use_vendor apex we will apply the same rules
2350 // of apex sdk enforcement below to choose right version.
2351 useStubs = true
2352 }
2353 } else if apexInfo.IsForPlatform() {
2354 // If not building for APEX, use stubs only when it is from
2355 // an APEX (and not from platform)
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002356 // However, for host, ramdisk, vendor_ramdisk, recovery or bootstrap modules,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002357 // always link to non-stub variant
2358 useStubs = dep.(android.ApexModule).AnyVariantDirectlyInAnyApex() && !c.bootstrap()
2359 // Another exception: if this module is bundled with an APEX, then
2360 // it is linked with the non-stub variant of a module in the APEX
2361 // as if this is part of the APEX.
2362 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2363 for _, apexContents := range testFor.ApexContents {
2364 if apexContents.DirectlyInApex(depName) {
2365 useStubs = false
2366 break
2367 }
2368 }
2369 } else {
2370 // If building for APEX, use stubs when the parent is in any APEX that
2371 // the child is not in.
2372 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
2373 }
2374
2375 // when to use (unspecified) stubs, check min_sdk_version and choose the right one
2376 if useStubs {
2377 sharedLibraryStubsInfo, err :=
2378 c.chooseSdkVersion(ctx, sharedLibraryStubsInfo.SharedLibraryStubsInfos, c.apexSdkVersion)
2379 if err != nil {
2380 ctx.OtherModuleErrorf(dep, err.Error())
2381 return
2382 }
2383 sharedLibraryInfo = sharedLibraryStubsInfo.SharedLibraryInfo
2384 depExporterInfo = sharedLibraryStubsInfo.FlagExporterInfo
2385 }
2386 }
2387
2388 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2389 depFile = sharedLibraryInfo.TableOfContents
2390
Colin Cross6e511a92020-07-27 21:26:48 -07002391 ptr = &depPaths.SharedLibs
2392 switch libDepTag.Order {
2393 case earlyLibraryDependency:
2394 ptr = &depPaths.EarlySharedLibs
2395 depPtr = &depPaths.EarlySharedLibsDeps
2396 case normalLibraryDependency:
2397 ptr = &depPaths.SharedLibs
2398 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002399 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002400 case lateLibraryDependency:
2401 ptr = &depPaths.LateSharedLibs
2402 depPtr = &depPaths.LateSharedLibsDeps
2403 default:
2404 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002405 }
Colin Cross6e511a92020-07-27 21:26:48 -07002406 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002407 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2408 if !ctx.Config().AllowMissingDependencies() {
2409 ctx.ModuleErrorf("module %q is not a static library", depName)
2410 } else {
2411 ctx.AddMissingDependencies([]string{depName})
2412 }
2413 return
2414 }
2415 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2416 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002417 if libDepTag.wholeStatic {
2418 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002419 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2420 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002421 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002422 // This case normally catches prebuilt static
2423 // libraries, but it can also occur when
2424 // AllowMissingDependencies is on and the
2425 // dependencies has no sources of its own
2426 // but has a whole_static_libs dependency
2427 // on a missing library. We want to depend
2428 // on the .a file so that there is something
2429 // in the dependency tree that contains the
2430 // error rule for the missing transitive
2431 // dependency.
2432 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002433 }
Colin Cross6e511a92020-07-27 21:26:48 -07002434 } else {
2435 switch libDepTag.Order {
2436 case earlyLibraryDependency:
2437 panic(fmt.Errorf("early static libs not suppported"))
2438 case normalLibraryDependency:
2439 // static dependencies will be handled separately so they can be ordered
2440 // using transitive dependencies.
2441 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002442 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002443 case lateLibraryDependency:
2444 ptr = &depPaths.LateStaticLibs
2445 default:
2446 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002447 }
2448 }
2449 }
2450
Colin Cross6e511a92020-07-27 21:26:48 -07002451 if libDepTag.static() && !libDepTag.wholeStatic {
2452 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2453 ctx.ModuleErrorf("module %q not a static library", depName)
2454 return
2455 }
Logan Chien43d34c32017-12-20 01:17:32 +08002456
Colin Cross6e511a92020-07-27 21:26:48 -07002457 // When combining coverage files for shared libraries and executables, coverage files
2458 // in static libraries act as if they were whole static libraries. The same goes for
2459 // source based Abi dump files.
2460 if c, ok := ccDep.(*Module); ok {
2461 staticLib := c.linker.(libraryInterface)
2462 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2463 staticLib.objs().coverageFiles...)
2464 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2465 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002466 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002467 // Handle non-CC modules here
2468 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002469 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002470 }
2471 }
2472
Colin Cross6e511a92020-07-27 21:26:48 -07002473 if ptr != nil {
2474 if !linkFile.Valid() {
2475 if !ctx.Config().AllowMissingDependencies() {
2476 ctx.ModuleErrorf("module %q missing output file", depName)
2477 } else {
2478 ctx.AddMissingDependencies([]string{depName})
2479 }
2480 return
2481 }
2482 *ptr = append(*ptr, linkFile.Path())
2483 }
2484
2485 if depPtr != nil {
2486 dep := depFile
2487 if !dep.Valid() {
2488 dep = linkFile
2489 }
2490 *depPtr = append(*depPtr, dep.Path())
2491 }
2492
Colin Cross0de8a1e2020-09-18 14:15:30 -07002493 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2494 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2495 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2496 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2497
2498 if libDepTag.reexportFlags {
2499 reexportExporter(depExporterInfo)
2500 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2501 // Re-exported shared library headers must be included as well since they can help us with type information
2502 // about template instantiations (instantiated from their headers).
2503 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2504 // scripts.
2505 c.sabi.Properties.ReexportedIncludes = append(
2506 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2507 }
2508
Colin Cross6e511a92020-07-27 21:26:48 -07002509 makeLibName := c.makeLibName(ctx, ccDep, depName) + libDepTag.makeSuffix
2510 switch {
2511 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002512 c.Properties.AndroidMkHeaderLibs = append(
2513 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002514 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002515 if lib := moduleLibraryInterface(dep); lib != nil {
2516 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002517 // Add the dependency to the APEX(es) providing the library so that
2518 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002519 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
2520 for _, an := range depApexInfo.InApexes {
Colin Cross6e511a92020-07-27 21:26:48 -07002521 c.Properties.ApexesProvidingSharedLibs = append(
2522 c.Properties.ApexesProvidingSharedLibs, an)
2523 }
2524 }
2525 }
2526
2527 // Note: the order of libs in this list is not important because
2528 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002529 c.Properties.AndroidMkSharedLibs = append(
2530 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002531 // Record baseLibName for snapshots.
2532 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, baseLibName(depName))
2533 case libDepTag.static():
2534 if libDepTag.wholeStatic {
2535 c.Properties.AndroidMkWholeStaticLibs = append(
2536 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2537 } else {
2538 c.Properties.AndroidMkStaticLibs = append(
2539 c.Properties.AndroidMkStaticLibs, makeLibName)
2540 }
2541 }
2542 } else {
2543 switch depTag {
2544 case runtimeDepTag:
2545 c.Properties.AndroidMkRuntimeLibs = append(
2546 c.Properties.AndroidMkRuntimeLibs, c.makeLibName(ctx, ccDep, depName)+libDepTag.makeSuffix)
2547 // Record baseLibName for snapshots.
2548 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, baseLibName(depName))
2549 case objDepTag:
2550 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2551 case CrtBeginDepTag:
2552 depPaths.CrtBegin = linkFile
2553 case CrtEndDepTag:
2554 depPaths.CrtEnd = linkFile
2555 case dynamicLinkerDepTag:
2556 depPaths.DynamicLinker = linkFile
2557 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002558 }
Colin Crossca860ac2016-01-04 14:34:37 -08002559 })
2560
Jeff Gaston294356f2017-09-27 17:05:30 -07002561 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002562 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2563 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2564 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002565
Colin Crossdd84e052017-05-17 13:44:16 -07002566 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002567 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002568 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2569 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002570 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002571 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2572 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002573 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002574 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002575 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002576
2577 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002578 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002579 }
Colin Crossdd84e052017-05-17 13:44:16 -07002580
Colin Crossca860ac2016-01-04 14:34:37 -08002581 return depPaths
2582}
2583
Colin Cross0de8a1e2020-09-18 14:15:30 -07002584// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
2585// to match the topological order of the dependency tree, including any static analogues of
2586// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
2587// of the transitive dependencies.
2588func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
2589 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
2590 var staticPaths android.Paths
2591 for _, staticDep := range staticDeps {
2592 staticPaths = append(staticPaths, staticDep.StaticLibrary)
2593 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
2594 }
2595 for _, sharedDep := range sharedDeps {
2596 if sharedDep.StaticAnalogue != nil {
2597 transitiveStaticLibsBuilder.Transitive(sharedDep.StaticAnalogue.TransitiveStaticLibrariesForOrdering)
2598 }
2599 }
2600 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
2601
2602 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
2603
2604 // reorder the dependencies based on transitive dependencies
2605 staticPaths = android.FirstUniquePaths(staticPaths)
2606 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
2607
2608 if len(orderedStaticPaths) != len(staticPaths) {
2609 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
2610 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
2611 }
2612
2613 return orderedStaticPaths, transitiveStaticLibs
2614}
2615
Colin Cross6e511a92020-07-27 21:26:48 -07002616// baseLibName trims known prefixes and suffixes
2617func baseLibName(depName string) string {
2618 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
2619 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
2620 libName = strings.TrimPrefix(libName, "prebuilt_")
2621 return libName
2622}
2623
2624func (c *Module) makeLibName(ctx android.ModuleContext, ccDep LinkableInterface, depName string) string {
2625 vendorSuffixModules := vendorSuffixModules(ctx.Config())
2626 vendorPublicLibraries := vendorPublicLibraries(ctx.Config())
2627
2628 libName := baseLibName(depName)
2629 isLLndk := isLlndkLibrary(libName, ctx.Config())
2630 isVendorPublicLib := inList(libName, *vendorPublicLibraries)
2631 bothVendorAndCoreVariantsExist := ccDep.HasVendorVariant() || isLLndk
2632
2633 if c, ok := ccDep.(*Module); ok {
2634 // Use base module name for snapshots when exporting to Makefile.
2635 if c.isSnapshotPrebuilt() {
2636 baseName := c.BaseModuleName()
2637
2638 if c.IsVndk() {
2639 return baseName + ".vendor"
2640 }
2641
2642 if vendorSuffixModules[baseName] {
2643 return baseName + ".vendor"
2644 } else {
2645 return baseName
2646 }
2647 }
2648 }
2649
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002650 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
2651 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07002652 // The vendor module is a no-vendor-variant VNDK library. Depend on the
2653 // core module instead.
2654 return libName
2655 } else if c.UseVndk() && bothVendorAndCoreVariantsExist {
2656 // The vendor module in Make will have been renamed to not conflict with the core
2657 // module, so update the dependency name here accordingly.
2658 return libName + c.getNameSuffixWithVndkVersion(ctx)
2659 } else if (ctx.Platform() || ctx.ProductSpecific()) && isVendorPublicLib {
2660 return libName + vendorPublicLibrarySuffix
2661 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
2662 return libName + ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002663 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
2664 return libName + vendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002665 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
2666 return libName + recoverySuffix
2667 } else if ccDep.Module().Target().NativeBridge == android.NativeBridgeEnabled {
2668 return libName + nativeBridgeSuffix
2669 } else {
2670 return libName
2671 }
2672}
2673
Colin Crossca860ac2016-01-04 14:34:37 -08002674func (c *Module) InstallInData() bool {
2675 if c.installer == nil {
2676 return false
2677 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002678 return c.installer.inData()
2679}
2680
2681func (c *Module) InstallInSanitizerDir() bool {
2682 if c.installer == nil {
2683 return false
2684 }
2685 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07002686 return true
2687 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002688 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08002689}
2690
Yifan Hong1b3348d2020-01-21 15:53:22 -08002691func (c *Module) InstallInRamdisk() bool {
2692 return c.InRamdisk()
2693}
2694
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002695func (c *Module) InstallInVendorRamdisk() bool {
2696 return c.InVendorRamdisk()
2697}
2698
Jiyong Parkf9332f12018-02-01 00:54:12 +09002699func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07002700 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09002701}
2702
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002703func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002704 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002705 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002706 return
2707 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002708 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002709}
2710
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07002711func (c *Module) HostToolPath() android.OptionalPath {
2712 if c.installer == nil {
2713 return android.OptionalPath{}
2714 }
2715 return c.installer.hostToolPath()
2716}
2717
Nan Zhangd4e641b2017-07-12 12:55:28 -07002718func (c *Module) IntermPathForModuleOut() android.OptionalPath {
2719 return c.outputFile
2720}
2721
Colin Cross41955e82019-05-29 14:40:35 -07002722func (c *Module) OutputFiles(tag string) (android.Paths, error) {
2723 switch tag {
2724 case "":
2725 if c.outputFile.Valid() {
2726 return android.Paths{c.outputFile.Path()}, nil
2727 }
2728 return android.Paths{}, nil
2729 default:
2730 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002731 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002732}
2733
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00002734func (c *Module) static() bool {
2735 if static, ok := c.linker.(interface {
2736 static() bool
2737 }); ok {
2738 return static.static()
2739 }
2740 return false
2741}
2742
Jiyong Park379de2f2018-12-19 02:47:14 +09002743func (c *Module) staticBinary() bool {
2744 if static, ok := c.linker.(interface {
2745 staticBinary() bool
2746 }); ok {
2747 return static.staticBinary()
2748 }
2749 return false
2750}
2751
Jiyong Park1d1119f2019-07-29 21:27:18 +09002752func (c *Module) header() bool {
2753 if h, ok := c.linker.(interface {
2754 header() bool
2755 }); ok {
2756 return h.header()
2757 }
2758 return false
2759}
2760
Inseob Kim7f283f42020-06-01 21:53:49 +09002761func (c *Module) binary() bool {
2762 if b, ok := c.linker.(interface {
2763 binary() bool
2764 }); ok {
2765 return b.binary()
2766 }
2767 return false
2768}
2769
Inseob Kim1042d292020-06-01 23:23:05 +09002770func (c *Module) object() bool {
2771 if o, ok := c.linker.(interface {
2772 object() bool
2773 }); ok {
2774 return o.object()
2775 }
2776 return false
2777}
2778
Jooyung Han38002912019-05-16 04:01:54 +09002779func (c *Module) getMakeLinkType(actx android.ModuleContext) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07002780 if c.UseVndk() {
Jooyung Han38002912019-05-16 04:01:54 +09002781 if lib, ok := c.linker.(*llndkStubDecorator); ok {
2782 if Bool(lib.Properties.Vendor_available) {
Colin Crossb60190a2018-09-04 16:28:17 -07002783 return "native:vndk"
2784 }
Jooyung Han38002912019-05-16 04:01:54 +09002785 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07002786 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002787 if c.IsVndk() && !c.isVndkExt() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002788 // Product_available, if defined, must have the same value with Vendor_available.
Jooyung Han38002912019-05-16 04:01:54 +09002789 if Bool(c.VendorProperties.Vendor_available) {
2790 return "native:vndk"
2791 }
2792 return "native:vndk_private"
2793 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09002794 if c.inProduct() {
2795 return "native:product"
2796 }
Jooyung Han38002912019-05-16 04:01:54 +09002797 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08002798 } else if c.InRamdisk() {
2799 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002800 } else if c.InVendorRamdisk() {
2801 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07002802 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07002803 return "native:recovery"
2804 } else if c.Target().Os == android.Android && String(c.Properties.Sdk_version) != "" {
2805 return "native:ndk:none:none"
2806 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
2807 //family, link := getNdkStlFamilyAndLinkType(c)
2808 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07002809 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08002810 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07002811 } else {
2812 return "native:platform"
2813 }
2814}
2815
Jiyong Park9d452992018-10-03 00:38:19 +09002816// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01002817// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09002818func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07002819 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09002820 // Stub libs and prebuilt libs in a versioned SDK are not
2821 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07002822 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01002823 } else if _, ok := c.linker.(testPerSrc); ok {
2824 return true
Jiyong Park9d452992018-10-03 00:38:19 +09002825 }
2826 return false
2827}
2828
Jiyong Parka90ca002019-10-07 15:47:24 +09002829func (c *Module) AvailableFor(what string) bool {
2830 if linker, ok := c.linker.(interface {
2831 availableFor(string) bool
2832 }); ok {
2833 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
2834 } else {
2835 return c.ApexModuleBase.AvailableFor(what)
2836 }
2837}
2838
Jiyong Park62304bb2020-04-13 16:19:48 +09002839func (c *Module) TestFor() []string {
2840 if test, ok := c.linker.(interface {
2841 testFor() []string
2842 }); ok {
2843 return test.testFor()
2844 } else {
2845 return c.ApexModuleBase.TestFor()
2846 }
2847}
2848
Colin Crossaede88c2020-08-11 12:17:01 -07002849func (c *Module) UniqueApexVariations() bool {
2850 if u, ok := c.compiler.(interface {
2851 uniqueApexVariations() bool
2852 }); ok {
2853 return u.uniqueApexVariations()
2854 } else {
2855 return false
2856 }
2857}
2858
Paul Duffin0cb37b92020-03-04 14:52:46 +00002859// Return true if the module is ever installable.
2860func (c *Module) EverInstallable() bool {
2861 return c.installer != nil &&
2862 // Check to see whether the module is actually ever installable.
2863 c.installer.everInstallable()
2864}
2865
Colin Cross56a83212020-09-15 18:30:11 -07002866func (c *Module) installable(apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00002867 ret := c.EverInstallable() &&
2868 // Check to see whether the module has been configured to not be installed.
2869 proptools.BoolDefault(c.Properties.Installable, true) &&
2870 !c.Properties.PreventInstall && c.outputFile.Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09002871
2872 // The platform variant doesn't need further condition. Apex variants however might not
2873 // be installable because it will likely to be included in the APEX and won't appear
2874 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07002875 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09002876 return ret
2877 }
2878
2879 // Special case for modules that are configured to be installed to /data, which includes
2880 // test modules. For these modules, both APEX and non-APEX variants are considered as
2881 // installable. This is because even the APEX variants won't be included in the APEX, but
2882 // will anyway be installed to /data/*.
2883 // See b/146995717
2884 if c.InstallInData() {
2885 return ret
2886 }
2887
2888 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09002889}
2890
Logan Chien41eabe62019-04-10 13:33:58 +08002891func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
2892 if c.linker != nil {
2893 if library, ok := c.linker.(*libraryDecorator); ok {
2894 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
2895 }
2896 }
2897}
2898
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002899func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07002900 depTag := ctx.OtherModuleDependencyTag(dep)
2901 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
2902
2903 if cc, ok := dep.(*Module); ok {
2904 if cc.HasStubsVariants() {
2905 if isLibDepTag && libDepTag.shared() {
2906 // dynamic dep to a stubs lib crosses APEX boundary
2907 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002908 }
Colin Cross6e511a92020-07-27 21:26:48 -07002909 if IsRuntimeDepTag(depTag) {
2910 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002911 return false
2912 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002913 }
Colin Crossaac32222020-07-29 12:51:56 -07002914 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07002915 // shared_lib dependency from a static lib is considered as crossing
2916 // the APEX boundary because the dependency doesn't actually is
2917 // linked; the dependency is used only during the compilation phase.
2918 return false
2919 }
2920 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002921 if depTag == stubImplDepTag || depTag == llndkImplDep {
2922 // We don't track beyond LLNDK or from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09002923 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002924 }
2925 return true
2926}
2927
Dan Albertc8060532020-07-22 22:32:17 -07002928func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
2929 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09002930 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
2931 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
2932 return nil
2933 }
2934 // b/154569636: set min_sdk_version correctly for toolchain_libraries
2935 if c.ToolchainLibrary() {
2936 return nil
2937 }
2938 // We don't check for prebuilt modules
2939 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
2940 return nil
2941 }
2942 minSdkVersion := c.MinSdkVersion()
2943 if minSdkVersion == "apex_inherit" {
2944 return nil
2945 }
2946 if minSdkVersion == "" {
2947 // JNI libs within APK-in-APEX fall into here
2948 // Those are okay to set sdk_version instead
2949 // We don't have to check if this is a SDK variant because
2950 // non-SDK variant resets sdk_version, which works too.
2951 minSdkVersion = c.SdkVersion()
2952 }
Dan Albertc8060532020-07-22 22:32:17 -07002953 if minSdkVersion == "" {
2954 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
2955 }
2956 // Not using nativeApiLevelFromUser because the context here is not
2957 // necessarily a native context.
2958 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09002959 if err != nil {
2960 return err
2961 }
Dan Albertc8060532020-07-22 22:32:17 -07002962
2963 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09002964 return fmt.Errorf("newer SDK(%v)", ver)
2965 }
2966 return nil
2967}
2968
Colin Cross2ba19d92015-05-07 15:44:20 -07002969//
Colin Crosscfad1192015-11-02 16:43:11 -08002970// Defaults
2971//
Colin Crossca860ac2016-01-04 14:34:37 -08002972type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07002973 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07002974 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09002975 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08002976}
2977
Patrice Arrudac249c712019-03-19 17:00:29 -07002978// cc_defaults provides a set of properties that can be inherited by other cc
2979// modules. A module can use the properties from a cc_defaults using
2980// `defaults: ["<:default_module_name>"]`. Properties of both modules are
2981// merged (when possible) by prepending the default module's values to the
2982// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07002983func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07002984 return DefaultsFactory()
2985}
2986
Colin Cross36242852017-06-23 15:06:31 -07002987func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08002988 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08002989
Colin Cross36242852017-06-23 15:06:31 -07002990 module.AddProperties(props...)
2991 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08002992 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002993 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002994 &BaseCompilerProperties{},
2995 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01002996 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07002997 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07002998 &StaticProperties{},
2999 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003000 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003001 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003002 &TestProperties{},
3003 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003004 &BenchmarkProperties{},
Mitch Phillips4e4ab8a2019-09-13 17:32:50 -07003005 &FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003006 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003007 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003008 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003009 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003010 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003011 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003012 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003013 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003014 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003015 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003016 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003017 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3018 &RustBindgenClangProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003019 )
Colin Crosscfad1192015-11-02 16:43:11 -08003020
Jooyung Hancc372c52019-09-25 15:18:44 +09003021 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003022
3023 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003024}
3025
Jiyong Park2286afd2020-06-16 21:58:53 +09003026func (c *Module) IsSdkVariant() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07003027 return c.Properties.IsSdkVariant || c.AlwaysSdk()
Jiyong Park2286afd2020-06-16 21:58:53 +09003028}
3029
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003030func kytheExtractAllFactory() android.Singleton {
3031 return &kytheExtractAllSingleton{}
3032}
3033
3034type kytheExtractAllSingleton struct {
3035}
3036
3037func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3038 var xrefTargets android.Paths
3039 ctx.VisitAllModules(func(module android.Module) {
3040 if ccModule, ok := module.(xref); ok {
3041 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3042 }
3043 })
3044 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3045 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003046 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003047 }
3048}
3049
Colin Cross06a931b2015-10-28 17:23:31 -07003050var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003051var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003052var BoolPtr = proptools.BoolPtr
3053var String = proptools.String
3054var StringPtr = proptools.StringPtr