blob: 3297e41565e6a957431cb7f07fcf337bce260a01 [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 Yun5f7f7e82019-11-18 19:52:14 +0900317 // In addition, this module should be allowed to be directly depended by
318 // product modules with `product_specific: true`.
319 // If set to true, three variants will be built separately, one like
320 // normal, another limited to the set of libraries and headers
321 // that are exposed to /vendor modules, and the other to /product modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700322 //
Justin Yun5f7f7e82019-11-18 19:52:14 +0900323 // The vendor and product variants may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700324 // so it shouldn't have any unversioned runtime dependencies, or
325 // make assumptions about the system that may not be true in the
326 // future.
327 //
Justin Yun5f7f7e82019-11-18 19:52:14 +0900328 // If set to false, this module becomes inaccessible from /vendor or /product
329 // modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900330 //
331 // Default value is true when vndk: {enabled: true} or vendor: true.
332 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700333 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
Justin Yun5f7f7e82019-11-18 19:52:14 +0900334 // If PRODUCT_PRODUCT_VNDK_VERSION isn't set, product variant will not be used.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700335 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900336
337 // whether this module is capable of being loaded with other instance
338 // (possibly an older version) of the same module in the same process.
339 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
340 // can be double loaded in a vendor process if the library is also a
341 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
342 // explicitly marked as `double_loadable: true` by the owner, or the dependency
343 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
344 Double_loadable *bool
Colin Crossca860ac2016-01-04 14:34:37 -0800345}
346
Colin Crossca860ac2016-01-04 14:34:37 -0800347type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800348 static() bool
349 staticBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900350 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900351 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900352 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700353 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900354 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700355 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800356 sdkVersion() string
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700357 useVndk() bool
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800358 isNdk() bool
Inseob Kim9516ee92019-05-09 10:56:13 +0900359 isLlndk(config android.Config) bool
360 isLlndkPublic(config android.Config) bool
361 isVndkPrivate(config android.Config) bool
Justin Yun8effde42017-06-23 19:24:43 +0900362 isVndk() bool
363 isVndkSp() bool
Logan Chienf3511742017-10-31 18:04:35 +0800364 isVndkExt() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900365 inProduct() bool
366 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800367 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700368 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900369 inRecovery() bool
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800370 shouldCreateSourceAbiDump() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700371 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700372 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800373 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800374 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800375 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800376 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800377 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700378 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700379 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900380 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800381 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700382 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700383 directlyInAnyApex() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800384}
385
386type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700387 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800388 ModuleContextIntf
389}
390
391type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700392 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800393 ModuleContextIntf
394}
395
Colin Cross37047f12016-12-13 17:06:13 -0800396type DepsContext interface {
397 android.BottomUpMutatorContext
398 ModuleContextIntf
399}
400
Colin Crossca860ac2016-01-04 14:34:37 -0800401type feature interface {
402 begin(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800403 deps(ctx DepsContext, deps Deps) Deps
Colin Crossca860ac2016-01-04 14:34:37 -0800404 flags(ctx ModuleContext, flags Flags) Flags
405 props() []interface{}
406}
407
408type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700409 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800410 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800411 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700412 compilerProps() []interface{}
413
Colin Cross76fada02016-07-27 10:31:13 -0700414 appendCflags([]string)
415 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700416 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800417}
418
419type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700420 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800421 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700422 linkerFlags(ctx ModuleContext, flags Flags) Flags
423 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800424 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700425
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700426 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700427 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900428 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700429
430 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900431 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000432
433 // Get the deps that have been explicitly specified in the properties.
434 // Only updates the
435 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
436}
437
438type specifiedDeps struct {
439 sharedLibs []string
Martin Stjernholm10566a02020-03-24 01:19:52 +0000440 systemSharedLibs []string // Note nil and [] are semantically distinct.
Colin Crossca860ac2016-01-04 14:34:37 -0800441}
442
443type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700444 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700445 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000446 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800447 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700448 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700449 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900450 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100451 makeUninstallable(mod *Module)
Colin Crossca860ac2016-01-04 14:34:37 -0800452}
453
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800454type xref interface {
455 XrefCcFiles() android.Paths
456}
457
Colin Cross6e511a92020-07-27 21:26:48 -0700458type libraryDependencyKind int
459
460const (
461 headerLibraryDependency = iota
462 sharedLibraryDependency
463 staticLibraryDependency
464)
465
466func (k libraryDependencyKind) String() string {
467 switch k {
468 case headerLibraryDependency:
469 return "headerLibraryDependency"
470 case sharedLibraryDependency:
471 return "sharedLibraryDependency"
472 case staticLibraryDependency:
473 return "staticLibraryDependency"
474 default:
475 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
476 }
477}
478
479type libraryDependencyOrder int
480
481const (
482 earlyLibraryDependency = -1
483 normalLibraryDependency = 0
484 lateLibraryDependency = 1
485)
486
487func (o libraryDependencyOrder) String() string {
488 switch o {
489 case earlyLibraryDependency:
490 return "earlyLibraryDependency"
491 case normalLibraryDependency:
492 return "normalLibraryDependency"
493 case lateLibraryDependency:
494 return "lateLibraryDependency"
495 default:
496 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
497 }
498}
499
500// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
501// tags that have a set of predefined tag objects that are reused for each dependency, a
502// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
503// That means that comparing a libraryDependencyTag for equality will only be equal if all
504// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
505// then check individual metadata fields instead.
506type libraryDependencyTag struct {
507 blueprint.BaseDependencyTag
508
509 // These are exported so that fmt.Printf("%#v") can call their String methods.
510 Kind libraryDependencyKind
511 Order libraryDependencyOrder
512
513 wholeStatic bool
514
515 reexportFlags bool
516 explicitlyVersioned bool
517 dataLib bool
518 ndk bool
519
520 staticUnwinder bool
521
522 makeSuffix string
523}
524
525// header returns true if the libraryDependencyTag is tagging a header lib dependency.
526func (d libraryDependencyTag) header() bool {
527 return d.Kind == headerLibraryDependency
528}
529
530// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
531func (d libraryDependencyTag) shared() bool {
532 return d.Kind == sharedLibraryDependency
533}
534
535// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
536func (d libraryDependencyTag) static() bool {
537 return d.Kind == staticLibraryDependency
538}
539
540// dependencyTag is used for tagging miscellanous dependency types that don't fit into
541// libraryDependencyTag. Each tag object is created globally and reused for multiple
542// dependencies (although since the object contains no references, assigning a tag to a
543// variable and modifying it will not modify the original). Users can compare the tag
544// returned by ctx.OtherModuleDependencyTag against the global original
545type dependencyTag struct {
546 blueprint.BaseDependencyTag
547 name string
548}
549
Colin Crossc99deeb2016-04-11 15:06:20 -0700550var (
Colin Cross6e511a92020-07-27 21:26:48 -0700551 genSourceDepTag = dependencyTag{name: "gen source"}
552 genHeaderDepTag = dependencyTag{name: "gen header"}
553 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
554 objDepTag = dependencyTag{name: "obj"}
555 linkerFlagsDepTag = dependencyTag{name: "linker flags file"}
556 dynamicLinkerDepTag = dependencyTag{name: "dynamic linker"}
557 reuseObjTag = dependencyTag{name: "reuse objects"}
558 staticVariantTag = dependencyTag{name: "static variant"}
559 vndkExtDepTag = dependencyTag{name: "vndk extends"}
560 dataLibDepTag = dependencyTag{name: "data lib"}
561 runtimeDepTag = dependencyTag{name: "runtime lib"}
562 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700563 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700564)
565
Colin Cross56a83212020-09-15 18:30:11 -0700566type copyDirectlyInAnyApexDependencyTag dependencyTag
567
568func (copyDirectlyInAnyApexDependencyTag) CopyDirectlyInAnyApex() {}
569
570var _ android.CopyDirectlyInAnyApexTag = copyDirectlyInAnyApexDependencyTag{}
571
Roland Levillainf89cd092019-07-29 16:22:59 +0100572func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700573 ccLibDepTag, ok := depTag.(libraryDependencyTag)
574 return ok && ccLibDepTag.shared()
575}
576
577func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
578 ccLibDepTag, ok := depTag.(libraryDependencyTag)
579 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100580}
581
582func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700583 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100584 return ok && ccDepTag == runtimeDepTag
585}
586
587func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700588 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100589 return ok && ccDepTag == testPerSrcDepTag
590}
591
Colin Crossca860ac2016-01-04 14:34:37 -0800592// Module contains the properties and members used by all C/C++ module types, and implements
593// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
594// to construct the output file. Behavior can be customized with a Customizer interface
595type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700596 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700597 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900598 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900599 android.SdkBase
Colin Crossc472d572015-03-17 15:06:21 -0700600
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700601 Properties BaseProperties
602 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700603
Colin Crossca860ac2016-01-04 14:34:37 -0800604 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700605 hod android.HostOrDeviceSupported
606 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700607
Paul Duffina0843f62019-12-13 19:50:38 +0000608 // Allowable SdkMemberTypes of this module type.
609 sdkMemberTypes []android.SdkMemberType
610
Colin Crossca860ac2016-01-04 14:34:37 -0800611 // delegates, initialize before calling Init
Colin Crossb4ce0ec2016-09-13 13:41:39 -0700612 features []feature
613 compiler compiler
614 linker linker
615 installer installer
616 stl *stl
617 sanitize *sanitize
Dan Willemsen581341d2017-02-09 16:16:31 -0800618 coverage *coverage
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800619 sabi *sabi
Justin Yun8effde42017-06-23 19:24:43 +0900620 vndkdep *vndkdep
Stephen Craneba090d12017-05-09 15:44:35 -0700621 lto *lto
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700622 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800623
Colin Cross31076b32020-10-23 17:22:06 -0700624 library libraryInterface
625
Colin Cross635c3b02016-05-18 15:37:25 -0700626 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800627
Colin Crossb98c8b02016-07-29 13:44:28 -0700628 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700629
630 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800631
632 // Flags used to compile this module
633 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700634
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800635 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700636 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900637
638 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800639 // Kythe (source file indexer) paths for this compilation module
640 kytheFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900641
642 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700643 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700644
645 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700646}
647
Ivan Lozano52767be2019-10-18 14:49:46 -0700648func (c *Module) Toc() android.OptionalPath {
649 if c.linker != nil {
650 if library, ok := c.linker.(libraryInterface); ok {
651 return library.toc()
652 }
653 }
654 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
655}
656
657func (c *Module) ApiLevel() string {
658 if c.linker != nil {
659 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700660 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700661 }
662 }
663 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
664}
665
666func (c *Module) Static() bool {
667 if c.linker != nil {
668 if library, ok := c.linker.(libraryInterface); ok {
669 return library.static()
670 }
671 }
672 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
673}
674
675func (c *Module) Shared() bool {
676 if c.linker != nil {
677 if library, ok := c.linker.(libraryInterface); ok {
678 return library.shared()
679 }
680 }
681 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
682}
683
684func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000685 if c.stl != nil {
686 return c.stl.Properties.SelectedStl
687 }
688 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700689}
690
691func (c *Module) ToolchainLibrary() bool {
692 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
693 return true
694 }
695 return false
696}
697
698func (c *Module) NdkPrebuiltStl() bool {
699 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
700 return true
701 }
702 return false
703}
704
705func (c *Module) StubDecorator() bool {
706 if _, ok := c.linker.(*stubDecorator); ok {
707 return true
708 }
709 return false
710}
711
712func (c *Module) SdkVersion() string {
713 return String(c.Properties.Sdk_version)
714}
715
Artur Satayev480e25b2020-04-27 18:53:18 +0100716func (c *Module) MinSdkVersion() string {
717 return String(c.Properties.Min_sdk_version)
718}
719
Dan Albert92fe7402020-07-15 13:33:30 -0700720func (c *Module) SplitPerApiLevel() bool {
Colin Cross1348ce32020-10-01 13:37:16 -0700721 if !c.canUseSdk() {
722 return false
723 }
Dan Albert92fe7402020-07-15 13:33:30 -0700724 if linker, ok := c.linker.(*objectLinker); ok {
725 return linker.isCrt()
726 }
727 return false
728}
729
Colin Crossc511bc52020-04-07 16:50:32 +0000730func (c *Module) AlwaysSdk() bool {
731 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
732}
733
Ivan Lozano183a3212019-10-18 14:18:45 -0700734func (c *Module) CcLibrary() bool {
735 if c.linker != nil {
736 if _, ok := c.linker.(*libraryDecorator); ok {
737 return true
738 }
Colin Crossd48fe732020-09-23 20:37:24 -0700739 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
740 return true
741 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700742 }
743 return false
744}
745
746func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -0700747 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700748 return true
749 }
750 return false
751}
752
Ivan Lozano2b262972019-11-21 12:30:50 -0800753func (c *Module) NonCcVariants() bool {
754 return false
755}
756
Ivan Lozano183a3212019-10-18 14:18:45 -0700757func (c *Module) SetStatic() {
758 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700759 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700760 library.setStatic()
761 return
762 }
763 }
764 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
765}
766
767func (c *Module) SetShared() {
768 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700769 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700770 library.setShared()
771 return
772 }
773 }
774 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
775}
776
777func (c *Module) BuildStaticVariant() bool {
778 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700779 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700780 return library.buildStatic()
781 }
782 }
783 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
784}
785
786func (c *Module) BuildSharedVariant() bool {
787 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700788 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700789 return library.buildShared()
790 }
791 }
792 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
793}
794
795func (c *Module) Module() android.Module {
796 return c
797}
798
Jiyong Parkc20eee32018-09-05 22:36:17 +0900799func (c *Module) OutputFile() android.OptionalPath {
800 return c.outputFile
801}
802
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400803func (c *Module) CoverageFiles() android.Paths {
804 if c.linker != nil {
805 if library, ok := c.linker.(libraryInterface); ok {
806 return library.objs().coverageFiles
807 }
808 }
809 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
810}
811
Ivan Lozano183a3212019-10-18 14:18:45 -0700812var _ LinkableInterface = (*Module)(nil)
813
Jiyong Park719b4462019-01-13 00:39:51 +0900814func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900815 if c.linker != nil {
816 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +0900817 }
818 return nil
819}
820
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900821func (c *Module) CoverageOutputFile() android.OptionalPath {
822 if c.linker != nil {
823 return c.linker.coverageOutputFilePath()
824 }
825 return android.OptionalPath{}
826}
827
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900828func (c *Module) RelativeInstallPath() string {
829 if c.installer != nil {
830 return c.installer.relativeInstallPath()
831 }
832 return ""
833}
834
Jooyung Han344d5432019-08-23 11:17:39 +0900835func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +0900836 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +0900837}
838
Colin Cross36242852017-06-23 15:06:31 -0700839func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -0700840 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -0800841 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -0700842 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800843 }
844 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -0700845 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800846 }
847 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -0700848 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800849 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700850 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -0700851 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -0700852 }
Colin Cross16b23492016-01-06 14:41:07 -0800853 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -0700854 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -0800855 }
Dan Willemsen581341d2017-02-09 16:16:31 -0800856 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -0700857 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -0800858 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800859 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -0700860 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800861 }
Justin Yun8effde42017-06-23 19:24:43 +0900862 if c.vndkdep != nil {
863 c.AddProperties(c.vndkdep.props()...)
864 }
Stephen Craneba090d12017-05-09 15:44:35 -0700865 if c.lto != nil {
866 c.AddProperties(c.lto.props()...)
867 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700868 if c.pgo != nil {
869 c.AddProperties(c.pgo.props()...)
870 }
Colin Crossca860ac2016-01-04 14:34:37 -0800871 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -0700872 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800873 }
Colin Crossc472d572015-03-17 15:06:21 -0700874
Jiyong Park1613e552020-09-14 19:43:17 +0900875 c.Prefer32(func(ctx android.BaseModuleContext, base *android.ModuleBase, os android.OsType) bool {
Elliott Hughes79ae3412020-04-17 15:49:49 -0700876 // Windows builds always prefer 32-bit
Jiyong Park1613e552020-09-14 19:43:17 +0900877 return os == android.Windows
Colin Crossa9d8bee2018-10-02 13:59:46 -0700878 })
Colin Cross36242852017-06-23 15:06:31 -0700879 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +0900880 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +0900881 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +0900882 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +0900883
Colin Cross36242852017-06-23 15:06:31 -0700884 return c
Colin Crossc472d572015-03-17 15:06:21 -0700885}
886
Colin Crossb916a382016-07-29 17:28:03 -0700887// Returns true for dependency roots (binaries)
888// TODO(ccross): also handle dlopenable libraries
889func (c *Module) isDependencyRoot() bool {
890 if root, ok := c.linker.(interface {
891 isDependencyRoot() bool
892 }); ok {
893 return root.isDependencyRoot()
894 }
895 return false
896}
897
Justin Yun5f7f7e82019-11-18 19:52:14 +0900898// Returns true if the module is using VNDK libraries instead of the libraries in /system/lib or /system/lib64.
899// "product" and "vendor" variant modules return true for this function.
900// When BOARD_VNDK_VERSION is set, vendor variants of "vendor_available: true", "vendor: true",
901// "soc_specific: true" and more vendor installed modules are included here.
902// When PRODUCT_PRODUCT_VNDK_VERSION is set, product variants of "vendor_available: true" or
903// "product_specific: true" modules are included here.
Ivan Lozano52767be2019-10-18 14:49:46 -0700904func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +0900905 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700906}
907
Colin Crossc511bc52020-04-07 16:50:32 +0000908func (c *Module) canUseSdk() bool {
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700909 return c.Os() == android.Android && !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +0000910}
911
912func (c *Module) UseSdk() bool {
913 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -0700914 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +0000915 }
916 return false
917}
918
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800919func (c *Module) isCoverageVariant() bool {
920 return c.coverage.Properties.IsCoverageVariant
921}
922
Peter Collingbournead84f972019-12-17 16:46:18 -0800923func (c *Module) IsNdk() bool {
Colin Crossf0913fb2020-07-29 12:59:39 -0700924 return inList(c.BaseModuleName(), ndkKnownLibs)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800925}
926
Inseob Kim9516ee92019-05-09 10:56:13 +0900927func (c *Module) isLlndk(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800928 // Returns true for both LLNDK (public) and LLNDK-private libs.
Jooyung Han0302a842019-10-30 18:43:49 +0900929 return isLlndkLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800930}
931
Inseob Kim9516ee92019-05-09 10:56:13 +0900932func (c *Module) isLlndkPublic(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800933 // Returns true only for LLNDK (public) libs.
Jooyung Han0302a842019-10-30 18:43:49 +0900934 name := c.BaseModuleName()
935 return isLlndkLibrary(name, config) && !isVndkPrivateLibrary(name, config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800936}
937
Inseob Kim9516ee92019-05-09 10:56:13 +0900938func (c *Module) isVndkPrivate(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800939 // Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Jooyung Han0302a842019-10-30 18:43:49 +0900940 return isVndkPrivateLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800941}
942
Ivan Lozano52767be2019-10-18 14:49:46 -0700943func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +0800944 if vndkdep := c.vndkdep; vndkdep != nil {
945 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +0900946 }
947 return false
948}
949
Yi Kong7e53c572018-02-14 18:16:12 +0800950func (c *Module) isPgoCompile() bool {
951 if pgo := c.pgo; pgo != nil {
952 return pgo.Properties.PgoCompile
953 }
954 return false
955}
956
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800957func (c *Module) isNDKStubLibrary() bool {
958 if _, ok := c.compiler.(*stubDecorator); ok {
959 return true
960 }
961 return false
962}
963
Logan Chienf3511742017-10-31 18:04:35 +0800964func (c *Module) isVndkSp() bool {
965 if vndkdep := c.vndkdep; vndkdep != nil {
966 return vndkdep.isVndkSp()
967 }
968 return false
969}
970
971func (c *Module) isVndkExt() bool {
972 if vndkdep := c.vndkdep; vndkdep != nil {
973 return vndkdep.isVndkExt()
974 }
975 return false
976}
977
Ivan Lozano52767be2019-10-18 14:49:46 -0700978func (c *Module) MustUseVendorVariant() bool {
Jooyung Han097087b2019-10-22 19:32:18 +0900979 return c.isVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -0800980}
981
Logan Chienf3511742017-10-31 18:04:35 +0800982func (c *Module) getVndkExtendsModuleName() string {
983 if vndkdep := c.vndkdep; vndkdep != nil {
984 return vndkdep.getVndkExtendsModuleName()
985 }
986 return ""
987}
988
Jiyong Park25fc6a92018-11-18 18:02:45 +0900989func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -0700990 if lib := c.library; lib != nil {
991 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +0900992 }
993 return false
994}
995
996func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -0700997 if lib := c.library; lib != nil {
998 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -0700999 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001000 return false
1001}
1002
Colin Cross0477b422020-10-13 18:43:54 -07001003// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1004// the implementation. If it is an implementation library it returns its own name.
1005func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1006 name := ctx.OtherModuleName(c)
1007 if versioned, ok := c.linker.(versionedInterface); ok {
1008 name = versioned.implementationModuleName(name)
1009 }
1010 return name
1011}
1012
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001013func (c *Module) bootstrap() bool {
1014 return Bool(c.Properties.Bootstrap)
1015}
1016
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001017func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001018 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1019 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1020 return false
1021 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001022 return c.linker != nil && c.linker.nativeCoverage()
1023}
1024
Inseob Kim8471cda2019-11-15 09:59:12 +09001025func (c *Module) isSnapshotPrebuilt() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09001026 if p, ok := c.linker.(interface{ isSnapshotPrebuilt() bool }); ok {
1027 return p.isSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001028 }
1029 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001030}
1031
Bill Peckham945441c2020-08-31 16:07:58 -07001032func (c *Module) ExcludeFromVendorSnapshot() bool {
1033 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1034}
1035
Jiyong Parkf1194352019-02-25 11:05:47 +09001036func isBionic(name string) bool {
1037 switch name {
Martin Stjernholm203489b2019-11-11 15:33:27 +00001038 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001039 return true
1040 }
1041 return false
1042}
1043
Martin Stjernholm279de572019-09-10 23:18:20 +01001044func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001045 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001046 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001047 }
1048 return isBionic(name)
1049}
1050
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001051func (c *Module) XrefCcFiles() android.Paths {
1052 return c.kytheFiles
1053}
1054
Colin Crossca860ac2016-01-04 14:34:37 -08001055type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001056 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001057 moduleContextImpl
1058}
1059
Colin Cross37047f12016-12-13 17:06:13 -08001060type depsContext struct {
1061 android.BottomUpMutatorContext
1062 moduleContextImpl
1063}
1064
Colin Crossca860ac2016-01-04 14:34:37 -08001065type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001066 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001067 moduleContextImpl
1068}
1069
1070type moduleContextImpl struct {
1071 mod *Module
1072 ctx BaseModuleContext
1073}
1074
Colin Crossb98c8b02016-07-29 13:44:28 -07001075func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001076 return ctx.mod.toolchain(ctx.ctx)
1077}
1078
1079func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001080 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001081}
1082
1083func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001084 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001085}
1086
Jiyong Park1d1119f2019-07-29 21:27:18 +09001087func (ctx *moduleContextImpl) header() bool {
1088 return ctx.mod.header()
1089}
1090
Inseob Kim7f283f42020-06-01 21:53:49 +09001091func (ctx *moduleContextImpl) binary() bool {
1092 return ctx.mod.binary()
1093}
1094
Inseob Kim1042d292020-06-01 23:23:05 +09001095func (ctx *moduleContextImpl) object() bool {
1096 return ctx.mod.object()
1097}
1098
Jooyung Hanccce2f22020-03-07 03:45:53 +09001099func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001100 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001101}
1102
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001103func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001104 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001105}
1106
1107func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001108 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001109 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001110 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001111 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001112 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001113 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001114 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001115 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001116 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001117 }
1118 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001119}
1120
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001121func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001122 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001123}
Justin Yun8effde42017-06-23 19:24:43 +09001124
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001125func (ctx *moduleContextImpl) isNdk() bool {
Peter Collingbournead84f972019-12-17 16:46:18 -08001126 return ctx.mod.IsNdk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001127}
1128
Inseob Kim9516ee92019-05-09 10:56:13 +09001129func (ctx *moduleContextImpl) isLlndk(config android.Config) bool {
1130 return ctx.mod.isLlndk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001131}
1132
Inseob Kim9516ee92019-05-09 10:56:13 +09001133func (ctx *moduleContextImpl) isLlndkPublic(config android.Config) bool {
1134 return ctx.mod.isLlndkPublic(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001135}
1136
Inseob Kim9516ee92019-05-09 10:56:13 +09001137func (ctx *moduleContextImpl) isVndkPrivate(config android.Config) bool {
1138 return ctx.mod.isVndkPrivate(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001139}
1140
Logan Chienf3511742017-10-31 18:04:35 +08001141func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001142 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001143}
1144
Yi Kong7e53c572018-02-14 18:16:12 +08001145func (ctx *moduleContextImpl) isPgoCompile() bool {
1146 return ctx.mod.isPgoCompile()
1147}
1148
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001149func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1150 return ctx.mod.isNDKStubLibrary()
1151}
1152
Justin Yun8effde42017-06-23 19:24:43 +09001153func (ctx *moduleContextImpl) isVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001154 return ctx.mod.isVndkSp()
1155}
1156
1157func (ctx *moduleContextImpl) isVndkExt() bool {
1158 return ctx.mod.isVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001159}
1160
Vic Yangefd249e2018-11-12 20:19:56 -08001161func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001162 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001163}
1164
Logan Chien2f2b8902018-07-10 15:01:19 +08001165// Check whether ABI dumps should be created for this module.
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001166func (ctx *moduleContextImpl) shouldCreateSourceAbiDump() bool {
Logan Chien2f2b8902018-07-10 15:01:19 +08001167 if ctx.ctx.Config().IsEnvTrue("SKIP_ABI_CHECKS") {
1168 return false
Jayant Chowdharyea0a2e12018-03-01 19:12:16 -08001169 }
Doug Hornc32c6b02019-01-17 14:44:05 -08001170
Hsin-Yi Chenf81bb652020-04-07 21:42:19 +08001171 // Coverage builds have extra symbols.
1172 if ctx.mod.isCoverageVariant() {
1173 return false
1174 }
1175
Doug Hornc32c6b02019-01-17 14:44:05 -08001176 if ctx.ctx.Fuchsia() {
1177 return false
1178 }
1179
Logan Chien2f2b8902018-07-10 15:01:19 +08001180 if sanitize := ctx.mod.sanitize; sanitize != nil {
1181 if !sanitize.isVariantOnProductionDevice() {
1182 return false
1183 }
1184 }
1185 if !ctx.ctx.Device() {
1186 // Host modules do not need ABI dumps.
1187 return false
1188 }
Colin Cross31076b32020-10-23 17:22:06 -07001189 if ctx.isNDKStubLibrary() {
Hsin-Yi Chenf6a95462019-06-25 14:46:52 +08001190 // Stubs do not need ABI dumps.
1191 return false
1192 }
Colin Cross31076b32020-10-23 17:22:06 -07001193 if lib := ctx.mod.library; lib != nil && lib.buildStubs() {
1194 // Stubs do not need ABI dumps.
1195 return false
1196 }
1197
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001198 return true
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001199}
1200
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001201func (ctx *moduleContextImpl) selectedStl() string {
1202 if stl := ctx.mod.stl; stl != nil {
1203 return stl.Properties.SelectedStl
1204 }
1205 return ""
1206}
1207
Ivan Lozanobd721262018-11-27 14:33:03 -08001208func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1209 return ctx.mod.linker.useClangLld(actx)
1210}
1211
Colin Crossce75d2c2016-10-06 16:12:58 -07001212func (ctx *moduleContextImpl) baseModuleName() string {
1213 return ctx.mod.ModuleBase.BaseModuleName()
1214}
1215
Logan Chienf3511742017-10-31 18:04:35 +08001216func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1217 return ctx.mod.getVndkExtendsModuleName()
1218}
1219
Logan Chiene274fc92019-12-03 11:18:32 -08001220func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001221 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001222}
1223
Colin Crosse07f2312020-08-13 11:24:56 -07001224func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001225 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001226}
1227
Dan Albertc8060532020-07-22 22:32:17 -07001228func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001229 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001230}
1231
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001232func (ctx *moduleContextImpl) bootstrap() bool {
1233 return ctx.mod.bootstrap()
1234}
1235
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001236func (ctx *moduleContextImpl) nativeCoverage() bool {
1237 return ctx.mod.nativeCoverage()
1238}
1239
Colin Cross56a83212020-09-15 18:30:11 -07001240func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1241 return ctx.mod.DirectlyInAnyApex()
1242}
1243
Colin Cross635c3b02016-05-18 15:37:25 -07001244func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001245 return &Module{
1246 hod: hod,
1247 multilib: multilib,
1248 }
1249}
1250
Colin Cross635c3b02016-05-18 15:37:25 -07001251func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001252 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001253 module.features = []feature{
1254 &tidyFeature{},
1255 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001256 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001257 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001258 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001259 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001260 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001261 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001262 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001263 return module
1264}
1265
Colin Crossce75d2c2016-10-06 16:12:58 -07001266func (c *Module) Prebuilt() *android.Prebuilt {
1267 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1268 return p.prebuilt()
1269 }
1270 return nil
1271}
1272
1273func (c *Module) Name() string {
1274 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001275 if p, ok := c.linker.(interface {
1276 Name(string) string
1277 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001278 name = p.Name(name)
1279 }
1280 return name
1281}
1282
Alex Light3d673592019-01-18 14:37:31 -08001283func (c *Module) Symlinks() []string {
1284 if p, ok := c.installer.(interface {
1285 symlinkList() []string
1286 }); ok {
1287 return p.symlinkList()
1288 }
1289 return nil
1290}
1291
Roland Levillainf89cd092019-07-29 16:22:59 +01001292func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1293 test, ok := c.linker.(testPerSrc)
1294 return ok && test.isAllTestsVariation()
1295}
1296
Chris Parsons216e10a2020-07-09 17:12:52 -04001297func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001298 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001299 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001300 }); ok {
1301 return p.dataPaths()
1302 }
1303 return nil
1304}
1305
Justin Yun5f7f7e82019-11-18 19:52:14 +09001306func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1307 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1308 // "current", it will append the VNDK version to the name suffix.
1309 var vndkVersion string
1310 var nameSuffix string
1311 if c.inProduct() {
1312 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
1313 nameSuffix = productSuffix
1314 } else {
1315 vndkVersion = ctx.DeviceConfig().VndkVersion()
1316 nameSuffix = vendorSuffix
1317 }
1318 if vndkVersion == "current" {
1319 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1320 }
1321 if c.Properties.VndkVersion != vndkVersion {
1322 // add version suffix only if the module is using different vndk version than the
1323 // version in product or vendor partition.
1324 nameSuffix += "." + c.Properties.VndkVersion
1325 }
1326 return nameSuffix
1327}
1328
Colin Cross635c3b02016-05-18 15:37:25 -07001329func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Roland Levillainf2fad972019-06-28 15:41:19 +01001330 // Handle the case of a test module split by `test_per_src` mutator.
Roland Levillainf89cd092019-07-29 16:22:59 +01001331 //
1332 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1333 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1334 // module and return early, as this module does not produce an output file per se.
1335 if c.IsTestPerSrcAllTestsVariation() {
1336 c.outputFile = android.OptionalPath{}
1337 return
Roland Levillainf2fad972019-06-28 15:41:19 +01001338 }
1339
Colin Cross56a83212020-09-15 18:30:11 -07001340 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1341 if !apexInfo.IsForPlatform() {
1342 c.hideApexVariantFromMake = true
1343 }
1344
Jooyung Han38002912019-05-16 04:01:54 +09001345 c.makeLinkType = c.getMakeLinkType(actx)
Inseob Kim9516ee92019-05-09 10:56:13 +09001346
Inseob Kim64c43952019-08-26 16:52:35 +09001347 c.Properties.SubName = ""
1348
1349 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1350 c.Properties.SubName += nativeBridgeSuffix
1351 }
1352
Justin Yun5f7f7e82019-11-18 19:52:14 +09001353 _, llndk := c.linker.(*llndkStubDecorator)
1354 _, llndkHeader := c.linker.(*llndkHeadersDecorator)
1355 if llndk || llndkHeader || (c.UseVndk() && c.HasVendorVariant()) {
1356 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1357 // added for product variant only when we have vendor and product variants with core
1358 // variant. The suffix is not added for vendor-only or product-only module.
1359 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
1360 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001361 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1362 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
1363 c.Properties.SubName += vendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001364 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
1365 c.Properties.SubName += ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001366 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
1367 c.Properties.SubName += vendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001368 } else if c.InRecovery() && !c.OnlyInRecovery() {
Inseob Kim64c43952019-08-26 16:52:35 +09001369 c.Properties.SubName += recoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001370 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001371 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001372 if c.SplitPerApiLevel() {
1373 c.Properties.SubName += "." + c.SdkVersion()
1374 }
Inseob Kim64c43952019-08-26 16:52:35 +09001375 }
1376
Colin Crossca860ac2016-01-04 14:34:37 -08001377 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001378 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001379 moduleContextImpl: moduleContextImpl{
1380 mod: c,
1381 },
1382 }
1383 ctx.ctx = ctx
1384
Colin Crossf18e1102017-11-16 14:33:08 -08001385 deps := c.depsToPaths(ctx)
1386 if ctx.Failed() {
1387 return
1388 }
1389
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001390 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1391 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1392 }
1393
Colin Crossca860ac2016-01-04 14:34:37 -08001394 flags := Flags{
1395 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001396 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001397 }
Colin Crossca860ac2016-01-04 14:34:37 -08001398 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001399 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001400 }
1401 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001402 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001403 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001404 if c.stl != nil {
1405 flags = c.stl.flags(ctx, flags)
1406 }
Colin Cross16b23492016-01-06 14:41:07 -08001407 if c.sanitize != nil {
1408 flags = c.sanitize.flags(ctx, flags)
1409 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001410 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001411 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001412 }
Stephen Craneba090d12017-05-09 15:44:35 -07001413 if c.lto != nil {
1414 flags = c.lto.flags(ctx, flags)
1415 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001416 if c.pgo != nil {
1417 flags = c.pgo.flags(ctx, flags)
1418 }
Colin Crossca860ac2016-01-04 14:34:37 -08001419 for _, feature := range c.features {
1420 flags = feature.flags(ctx, flags)
1421 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001422 if ctx.Failed() {
1423 return
1424 }
1425
Colin Cross4af21ed2019-11-04 09:37:55 -08001426 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1427 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1428 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001429
Colin Cross4af21ed2019-11-04 09:37:55 -08001430 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001431
1432 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001433 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001434 }
1435 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001436 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001437 }
1438
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001439 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001440 // We need access to all the flags seen by a source file.
1441 if c.sabi != nil {
1442 flags = c.sabi.flags(ctx, flags)
1443 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001444
Colin Cross4af21ed2019-11-04 09:37:55 -08001445 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001446
Colin Crossca860ac2016-01-04 14:34:37 -08001447 // Optimization to reduce size of build.ninja
1448 // Replace the long list of flags for each file with a module-local variable
Colin Cross4af21ed2019-11-04 09:37:55 -08001449 ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))
1450 ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))
1451 ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))
1452 flags.Local.CFlags = []string{"$cflags"}
1453 flags.Local.CppFlags = []string{"$cppflags"}
1454 flags.Local.AsFlags = []string{"$asflags"}
Colin Crossca860ac2016-01-04 14:34:37 -08001455
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001456 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001457 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001458 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001459 if ctx.Failed() {
1460 return
1461 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001462 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001463 }
1464
Colin Crossca860ac2016-01-04 14:34:37 -08001465 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001466 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001467 if ctx.Failed() {
1468 return
1469 }
Colin Cross635c3b02016-05-18 15:37:25 -07001470 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001471
1472 // If a lib is directly included in any of the APEXes, unhide the stubs
1473 // variant having the latest version gets visible to make. In addition,
1474 // the non-stubs variant is renamed to <libname>.bootstrap. This is to
1475 // force anything in the make world to link against the stubs library.
1476 // (unless it is explicitly referenced via .bootstrap suffix or the
1477 // module is marked with 'bootstrap: true').
Colin Cross56a83212020-09-15 18:30:11 -07001478 if c.HasStubsVariants() && c.AnyVariantDirectlyInAnyApex() && !c.InRamdisk() &&
Ivan Lozano52767be2019-10-18 14:49:46 -07001479 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001480 c.IsStubs() && !c.InVendorRamdisk() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001481 c.Properties.HideFromMake = false // unhide
1482 // Note: this is still non-installable
1483 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001484
1485 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current.
1486 if i, ok := c.linker.(snapshotLibraryInterface); ok && ctx.DeviceConfig().VndkVersion() == "current" {
Colin Cross56a83212020-09-15 18:30:11 -07001487 if isSnapshotAware(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001488 i.collectHeadersForSnapshot(ctx)
1489 }
1490 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001491 }
Colin Cross5049f022015-03-18 13:28:46 -07001492
Colin Cross56a83212020-09-15 18:30:11 -07001493 if c.installable(apexInfo) {
Colin Crossce75d2c2016-10-06 16:12:58 -07001494 c.installer.install(ctx, c.outputFile.Path())
1495 if ctx.Failed() {
1496 return
Colin Crossca860ac2016-01-04 14:34:37 -08001497 }
Paul Duffin0cb37b92020-03-04 14:52:46 +00001498 } else if !proptools.BoolDefault(c.Properties.Installable, true) {
1499 // If the module has been specifically configure to not be installed then
1500 // skip the installation as otherwise it will break when running inside make
1501 // as the output path to install will not be specified. Not all uninstallable
1502 // modules can skip installation as some are needed for resolving make side
1503 // dependencies.
1504 c.SkipInstall()
Dan Albertc403f7c2015-03-18 14:01:18 -07001505 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001506}
1507
Colin Cross0ea8ba82019-06-06 14:33:29 -07001508func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001509 if c.cachedToolchain == nil {
Colin Crossb98c8b02016-07-29 13:44:28 -07001510 c.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
Colin Cross3f40fa42015-01-30 17:27:36 -08001511 }
Colin Crossca860ac2016-01-04 14:34:37 -08001512 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001513}
1514
Colin Crossca860ac2016-01-04 14:34:37 -08001515func (c *Module) begin(ctx BaseModuleContext) {
1516 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001517 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001518 }
Colin Crossca860ac2016-01-04 14:34:37 -08001519 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001520 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001521 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001522 if c.stl != nil {
1523 c.stl.begin(ctx)
1524 }
Colin Cross16b23492016-01-06 14:41:07 -08001525 if c.sanitize != nil {
1526 c.sanitize.begin(ctx)
1527 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001528 if c.coverage != nil {
1529 c.coverage.begin(ctx)
1530 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001531 if c.sabi != nil {
1532 c.sabi.begin(ctx)
1533 }
Justin Yun8effde42017-06-23 19:24:43 +09001534 if c.vndkdep != nil {
1535 c.vndkdep.begin(ctx)
1536 }
Stephen Craneba090d12017-05-09 15:44:35 -07001537 if c.lto != nil {
1538 c.lto.begin(ctx)
1539 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001540 if c.pgo != nil {
1541 c.pgo.begin(ctx)
1542 }
Colin Crossca860ac2016-01-04 14:34:37 -08001543 for _, feature := range c.features {
1544 feature.begin(ctx)
1545 }
Dan Albert92fe7402020-07-15 13:33:30 -07001546 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001547 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001548 if err != nil {
1549 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001550 c.Properties.Sdk_version = nil
1551 } else {
1552 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001553 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001554 }
Colin Crossca860ac2016-01-04 14:34:37 -08001555}
1556
Colin Cross37047f12016-12-13 17:06:13 -08001557func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001558 deps := Deps{}
1559
1560 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001561 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001562 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001563 // Add the PGO dependency (the clang_rt.profile runtime library), which
1564 // sometimes depends on symbols from libgcc, before libgcc gets added
1565 // in linkerDeps().
Pirama Arumuga Nainar49b53d52017-10-04 16:47:29 -07001566 if c.pgo != nil {
1567 deps = c.pgo.deps(ctx, deps)
1568 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001569 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001570 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001571 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001572 if c.stl != nil {
1573 deps = c.stl.deps(ctx, deps)
1574 }
Colin Cross16b23492016-01-06 14:41:07 -08001575 if c.sanitize != nil {
1576 deps = c.sanitize.deps(ctx, deps)
1577 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001578 if c.coverage != nil {
1579 deps = c.coverage.deps(ctx, deps)
1580 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001581 if c.sabi != nil {
1582 deps = c.sabi.deps(ctx, deps)
1583 }
Justin Yun8effde42017-06-23 19:24:43 +09001584 if c.vndkdep != nil {
1585 deps = c.vndkdep.deps(ctx, deps)
1586 }
Stephen Craneba090d12017-05-09 15:44:35 -07001587 if c.lto != nil {
1588 deps = c.lto.deps(ctx, deps)
1589 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001590 for _, feature := range c.features {
1591 deps = feature.deps(ctx, deps)
1592 }
1593
Colin Crossb6715442017-10-24 11:13:31 -07001594 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1595 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1596 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1597 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1598 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1599 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001600 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001601
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001602 for _, lib := range deps.ReexportSharedLibHeaders {
1603 if !inList(lib, deps.SharedLibs) {
1604 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1605 }
1606 }
1607
1608 for _, lib := range deps.ReexportStaticLibHeaders {
1609 if !inList(lib, deps.StaticLibs) {
1610 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs: '%s'", lib)
1611 }
1612 }
1613
Colin Cross5950f382016-12-13 12:50:57 -08001614 for _, lib := range deps.ReexportHeaderLibHeaders {
1615 if !inList(lib, deps.HeaderLibs) {
1616 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1617 }
1618 }
1619
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001620 for _, gen := range deps.ReexportGeneratedHeaders {
1621 if !inList(gen, deps.GeneratedHeaders) {
1622 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1623 }
1624 }
1625
Colin Crossc99deeb2016-04-11 15:06:20 -07001626 return deps
1627}
1628
Dan Albert7e9d2952016-08-04 13:02:36 -07001629func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001630 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001631 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001632 moduleContextImpl: moduleContextImpl{
1633 mod: c,
1634 },
1635 }
1636 ctx.ctx = ctx
1637
Colin Crossca860ac2016-01-04 14:34:37 -08001638 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001639}
1640
Jiyong Park7ed9de32018-10-15 22:25:07 +09001641// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09001642func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001643 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1644 version := name[sharp+1:]
1645 libname := name[:sharp]
1646 return libname, version
1647 }
1648 return name, ""
1649}
1650
Dan Albert92fe7402020-07-15 13:33:30 -07001651func GetCrtVariations(ctx android.BottomUpMutatorContext,
1652 m LinkableInterface) []blueprint.Variation {
1653 if ctx.Os() != android.Android {
1654 return nil
1655 }
1656 if m.UseSdk() {
1657 return []blueprint.Variation{
1658 {Mutator: "sdk", Variation: "sdk"},
Colin Crossbbc941b2020-09-30 12:27:01 -07001659 {Mutator: "version", Variation: m.SdkVersion()},
Dan Albert92fe7402020-07-15 13:33:30 -07001660 }
1661 }
1662 return []blueprint.Variation{
1663 {Mutator: "sdk", Variation: ""},
1664 }
1665}
1666
Colin Crosse7257d22020-09-24 09:56:18 -07001667func (c *Module) addSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext,
1668 variations []blueprint.Variation, depTag libraryDependencyTag, name, version string, far bool) {
1669
1670 variations = append([]blueprint.Variation(nil), variations...)
1671
Colin Cross3146c5c2020-09-30 15:34:40 -07001672 if version != "" && CanBeOrLinkAgainstVersionVariants(c) {
Colin Crosse7257d22020-09-24 09:56:18 -07001673 // Version is explicitly specified. i.e. libFoo#30
1674 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
1675 depTag.explicitlyVersioned = true
1676 }
Colin Crosse7257d22020-09-24 09:56:18 -07001677
Colin Cross0de8a1e2020-09-18 14:15:30 -07001678 if far {
1679 ctx.AddFarVariationDependencies(variations, depTag, name)
1680 } else {
1681 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07001682 }
1683}
1684
Colin Cross1e676be2016-10-12 14:38:15 -07001685func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09001686 if !c.Enabled() {
1687 return
1688 }
1689
Colin Cross37047f12016-12-13 17:06:13 -08001690 ctx := &depsContext{
1691 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07001692 moduleContextImpl: moduleContextImpl{
1693 mod: c,
1694 },
1695 }
1696 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08001697
Colin Crossc99deeb2016-04-11 15:06:20 -07001698 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001699
Yo Chiang219968c2020-09-22 18:45:04 +08001700 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
1701
Dan Albert914449f2016-06-17 16:45:24 -07001702 variantNdkLibs := []string{}
1703 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07001704 if ctx.Os() == android.Android {
Inseob Kimeec88e12020-01-22 11:11:29 +09001705 // rewriteLibs takes a list of names of shared libraries and scans it for three types
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001706 // of names:
Dan Albert914449f2016-06-17 16:45:24 -07001707 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001708 // 1. Name of an NDK library that refers to a prebuilt module.
1709 // For each of these, it adds the name of the prebuilt module (which will be in
1710 // prebuilts/ndk) to the list of nonvariant libs.
1711 // 2. Name of an NDK library that refers to an ndk_library module.
1712 // For each of these, it adds the name of the ndk_library module to the list of
1713 // variant libs.
1714 // 3. Anything else (so anything that isn't an NDK library).
1715 // It adds these to the nonvariantLibs list.
Dan Albert914449f2016-06-17 16:45:24 -07001716 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001717 // The caller can then know to add the variantLibs dependencies differently from the
1718 // nonvariantLibs
Inseob Kim9516ee92019-05-09 10:56:13 +09001719
Inseob Kim9516ee92019-05-09 10:56:13 +09001720 vendorPublicLibraries := vendorPublicLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001721 vendorSnapshotSharedLibs := vendorSnapshotSharedLibs(actx.Config())
1722
1723 rewriteVendorLibs := func(lib string) string {
1724 if isLlndkLibrary(lib, ctx.Config()) {
1725 return lib + llndkLibrarySuffix
1726 }
1727
1728 // only modules with BOARD_VNDK_VERSION uses snapshot.
1729 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1730 return lib
1731 }
1732
1733 if snapshot, ok := vendorSnapshotSharedLibs.get(lib, actx.Arch().ArchType); ok {
1734 return snapshot
1735 }
1736
1737 return lib
1738 }
1739
1740 rewriteLibs := func(list []string) (nonvariantLibs []string, variantLibs []string) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001741 variantLibs = []string{}
1742 nonvariantLibs = []string{}
Dan Albert914449f2016-06-17 16:45:24 -07001743 for _, entry := range list {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001744 // strip #version suffix out
Jiyong Park73c54ee2019-10-22 20:31:18 +09001745 name, _ := StubsLibNameAndVersion(entry)
Dan Albertde5aade2020-06-30 12:32:51 -07001746 if ctx.useSdk() && inList(name, ndkKnownLibs) {
1747 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Inseob Kimeec88e12020-01-22 11:11:29 +09001748 } else if ctx.useVndk() {
1749 nonvariantLibs = append(nonvariantLibs, rewriteVendorLibs(entry))
Inseob Kim9516ee92019-05-09 10:56:13 +09001750 } else if (ctx.Platform() || ctx.ProductSpecific()) && inList(name, *vendorPublicLibraries) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001751 vendorPublicLib := name + vendorPublicLibrarySuffix
Jiyong Park374510b2018-03-19 18:23:01 +09001752 if actx.OtherModuleExists(vendorPublicLib) {
1753 nonvariantLibs = append(nonvariantLibs, vendorPublicLib)
1754 } else {
1755 // This can happen if vendor_public_library module is defined in a
1756 // namespace that isn't visible to the current module. In that case,
1757 // link to the original library.
Jiyong Park7ed9de32018-10-15 22:25:07 +09001758 nonvariantLibs = append(nonvariantLibs, name)
Jiyong Park374510b2018-03-19 18:23:01 +09001759 }
Dan Albert914449f2016-06-17 16:45:24 -07001760 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001761 // put name#version back
Dan Willemsen7cbf5f82017-03-28 00:08:30 -07001762 nonvariantLibs = append(nonvariantLibs, entry)
Dan Willemsen72d39932016-07-08 23:23:48 -07001763 }
1764 }
Dan Albert914449f2016-06-17 16:45:24 -07001765 return nonvariantLibs, variantLibs
Dan Willemsen72d39932016-07-08 23:23:48 -07001766 }
1767
Inseob Kimeec88e12020-01-22 11:11:29 +09001768 deps.SharedLibs, variantNdkLibs = rewriteLibs(deps.SharedLibs)
1769 deps.LateSharedLibs, variantLateNdkLibs = rewriteLibs(deps.LateSharedLibs)
1770 deps.ReexportSharedLibHeaders, _ = rewriteLibs(deps.ReexportSharedLibHeaders)
1771 if ctx.useVndk() {
1772 for idx, lib := range deps.RuntimeLibs {
1773 deps.RuntimeLibs[idx] = rewriteVendorLibs(lib)
1774 }
1775 }
Dan Willemsen72d39932016-07-08 23:23:48 -07001776 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001777
Jiyong Park7e636d02019-01-28 16:16:54 +09001778 buildStubs := false
Colin Crossc88c2722020-09-28 17:32:47 -07001779 if versioned, ok := c.linker.(versionedInterface); ok {
1780 if versioned.buildStubs() {
1781 buildStubs = true
Colin Crossd48fe732020-09-23 20:37:24 -07001782 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001783 }
1784
Inseob Kimeec88e12020-01-22 11:11:29 +09001785 rewriteSnapshotLibs := func(lib string, snapshotMap *snapshotMap) string {
1786 // only modules with BOARD_VNDK_VERSION uses snapshot.
1787 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1788 return lib
1789 }
1790
1791 if snapshot, ok := snapshotMap.get(lib, actx.Arch().ArchType); ok {
1792 return snapshot
1793 }
1794
1795 return lib
1796 }
1797
1798 vendorSnapshotHeaderLibs := vendorSnapshotHeaderLibs(actx.Config())
Colin Cross32ec36c2016-12-15 07:39:51 -08001799 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001800 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08001801 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001802 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08001803 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001804
1805 lib = rewriteSnapshotLibs(lib, vendorSnapshotHeaderLibs)
1806
Jiyong Park7e636d02019-01-28 16:16:54 +09001807 if buildStubs {
Colin Cross7228ecd2019-11-18 16:00:16 -08001808 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001809 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09001810 } else {
1811 actx.AddVariationDependencies(nil, depTag, lib)
1812 }
1813 }
1814
1815 if buildStubs {
1816 // Stubs lib does not have dependency to other static/shared libraries.
1817 // Don't proceed.
1818 return
Colin Cross32ec36c2016-12-15 07:39:51 -08001819 }
Colin Cross5950f382016-12-13 12:50:57 -08001820
Inseob Kimc0907f12019-02-08 21:00:45 +09001821 syspropImplLibraries := syspropImplLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001822 vendorSnapshotStaticLibs := vendorSnapshotStaticLibs(actx.Config())
Inseob Kimc0907f12019-02-08 21:00:45 +09001823
Jiyong Park5d1598f2019-02-25 22:14:17 +09001824 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001825 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09001826 if impl, ok := syspropImplLibraries[lib]; ok {
1827 lib = impl
1828 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001829
1830 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1831
Jiyong Park5d1598f2019-02-25 22:14:17 +09001832 actx.AddVariationDependencies([]blueprint.Variation{
1833 {Mutator: "link", Variation: "static"},
1834 }, depTag, lib)
1835 }
1836
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001837 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001838 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001839 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001840 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001841 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001842
1843 if impl, ok := syspropImplLibraries[lib]; ok {
1844 lib = impl
1845 }
1846
Inseob Kimeec88e12020-01-22 11:11:29 +09001847 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1848
Dan Willemsen59339a22018-07-22 21:18:45 -07001849 actx.AddVariationDependencies([]blueprint.Variation{
1850 {Mutator: "link", Variation: "static"},
1851 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001852 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001853
Jooyung Han75568392020-03-20 04:29:24 +09001854 // staticUnwinderDep is treated as staticDep for Q apexes
1855 // so that native libraries/binaries are linked with static unwinder
1856 // because Q libc doesn't have unwinder APIs
1857 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07001858 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08001859 actx.AddVariationDependencies([]blueprint.Variation{
1860 {Mutator: "link", Variation: "static"},
Colin Cross6e511a92020-07-27 21:26:48 -07001861 }, depTag, rewriteSnapshotLibs(staticUnwinder(actx), vendorSnapshotStaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08001862 }
1863
Inseob Kimeec88e12020-01-22 11:11:29 +09001864 for _, lib := range deps.LateStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001865 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
Inseob Kimeec88e12020-01-22 11:11:29 +09001866 actx.AddVariationDependencies([]blueprint.Variation{
1867 {Mutator: "link", Variation: "static"},
Colin Cross6e511a92020-07-27 21:26:48 -07001868 }, depTag, rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs))
Inseob Kimeec88e12020-01-22 11:11:29 +09001869 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001870
Jiyong Park7ed9de32018-10-15 22:25:07 +09001871 // shared lib names without the #version suffix
1872 var sharedLibNames []string
1873
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001874 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001875 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001876 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001877 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001878 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001879
1880 if impl, ok := syspropImplLibraries[lib]; ok {
1881 lib = impl
1882 }
1883
Jiyong Park73c54ee2019-10-22 20:31:18 +09001884 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09001885 sharedLibNames = append(sharedLibNames, name)
1886
Colin Crosse7257d22020-09-24 09:56:18 -07001887 variations := []blueprint.Variation{
1888 {Mutator: "link", Variation: "shared"},
1889 }
1890 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001891 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001892
Jiyong Park7ed9de32018-10-15 22:25:07 +09001893 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001894 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001895 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
1896 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
1897 // linking against both the stubs lib and the non-stubs lib at the same time.
1898 continue
1899 }
Colin Cross6e511a92020-07-27 21:26:48 -07001900 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07001901 variations := []blueprint.Variation{
1902 {Mutator: "link", Variation: "shared"},
1903 }
1904 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09001905 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001906
Dan Willemsen59339a22018-07-22 21:18:45 -07001907 actx.AddVariationDependencies([]blueprint.Variation{
1908 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04001909 }, dataLibDepTag, deps.DataLibs...)
1910
1911 actx.AddVariationDependencies([]blueprint.Variation{
1912 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07001913 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08001914
Colin Cross68861832016-07-08 10:41:41 -07001915 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001916
1917 for _, gen := range deps.GeneratedHeaders {
1918 depTag := genHeaderDepTag
1919 if inList(gen, deps.ReexportGeneratedHeaders) {
1920 depTag = genHeaderExportDepTag
1921 }
1922 actx.AddDependency(c, depTag, gen)
1923 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07001924
Inseob Kim1042d292020-06-01 23:23:05 +09001925 vendorSnapshotObjects := vendorSnapshotObjects(actx.Config())
1926
Dan Albert92fe7402020-07-15 13:33:30 -07001927 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07001928 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07001929 if deps.CrtBegin != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001930 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
1931 rewriteSnapshotLibs(deps.CrtBegin, vendorSnapshotObjects))
Colin Crossca860ac2016-01-04 14:34:37 -08001932 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001933 if deps.CrtEnd != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001934 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
1935 rewriteSnapshotLibs(deps.CrtEnd, vendorSnapshotObjects))
Colin Cross21b9a242015-03-24 14:15:58 -07001936 }
Dan Willemsena0790e32018-10-12 00:24:23 -07001937 if deps.LinkerFlagsFile != "" {
1938 actx.AddDependency(c, linkerFlagsDepTag, deps.LinkerFlagsFile)
1939 }
1940 if deps.DynamicLinker != "" {
1941 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07001942 }
Dan Albert914449f2016-06-17 16:45:24 -07001943
1944 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07001945
1946 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07001947 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07001948 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07001949 {Mutator: "link", Variation: "shared"},
1950 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07001951
1952 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07001953 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07001954 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07001955 {Mutator: "link", Variation: "shared"},
1956 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08001957
1958 if vndkdep := c.vndkdep; vndkdep != nil {
1959 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08001960 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08001961 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07001962 {Mutator: "link", Variation: "shared"},
1963 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08001964 }
1965 }
Colin Cross6362e272015-10-29 15:25:03 -07001966}
Colin Cross21b9a242015-03-24 14:15:58 -07001967
Colin Crosse40b4ea2018-10-02 22:25:58 -07001968func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07001969 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
1970 c.beginMutator(ctx)
1971 }
1972}
1973
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001974// Whether a module can link to another module, taking into
1975// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09001976func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07001977 tag blueprint.DependencyTag) {
1978
1979 switch t := tag.(type) {
1980 case dependencyTag:
1981 if t != vndkExtDepTag {
1982 return
1983 }
1984 case libraryDependencyTag:
1985 default:
1986 return
1987 }
1988
Ivan Lozano52767be2019-10-18 14:49:46 -07001989 if from.Module().Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001990 // Host code is not restricted
1991 return
1992 }
Ivan Lozano52767be2019-10-18 14:49:46 -07001993
1994 // VNDK is cc.Module supported only for now.
1995 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001996 // Though vendor code is limited by the vendor mutator,
1997 // each vendor-available module needs to check
1998 // link-type for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07001999 if ccTo, ok := to.(*Module); ok {
2000 if ccFrom.vndkdep != nil {
2001 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2002 }
2003 } else {
2004 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002005 }
2006 return
2007 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002008 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002009 // Platform code can link to anything
2010 return
2011 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002012 if from.InRamdisk() {
2013 // Ramdisk code is not NDK
2014 return
2015 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002016 if from.InVendorRamdisk() {
2017 // Vendor ramdisk code is not NDK
2018 return
2019 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002020 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002021 // Recovery code is not NDK
2022 return
2023 }
Colin Cross31076b32020-10-23 17:22:06 -07002024 if c, ok := to.(*Module); ok {
2025 if c.ToolchainLibrary() {
2026 // These are always allowed
2027 return
2028 }
2029 if c.NdkPrebuiltStl() {
2030 // These are allowed, but they don't set sdk_version
2031 return
2032 }
2033 if c.StubDecorator() {
2034 // These aren't real libraries, but are the stub shared libraries that are included in
2035 // the NDK.
2036 return
2037 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002038 }
Logan Chien834b9a62019-01-14 15:39:03 +08002039
Ivan Lozano52767be2019-10-18 14:49:46 -07002040 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002041 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2042 // to link to libc++ (non-NDK and without sdk_version).
2043 return
2044 }
2045
Ivan Lozano52767be2019-10-18 14:49:46 -07002046 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002047 // NDK code linking to platform code is never okay.
2048 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002049 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002050 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002051 }
2052
2053 // At this point we know we have two NDK libraries, but we need to
2054 // check that we're not linking against anything built against a higher
2055 // API level, as it is only valid to link against older or equivalent
2056 // APIs.
2057
Inseob Kim01a28722018-04-11 09:48:45 +09002058 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002059 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002060 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002061 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002062 // Current can't be linked against by anything else.
2063 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002064 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002065 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002066 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002067 if err != nil {
2068 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002069 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002070 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002071 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002072 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002073 if err != nil {
2074 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002075 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002076 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002077 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002078
Inseob Kim01a28722018-04-11 09:48:45 +09002079 if toApi > fromApi {
2080 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002081 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002082 }
2083 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002084 }
Dan Albert202fe492017-12-15 13:56:59 -08002085
2086 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002087 fromStl := from.SelectedStl()
2088 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002089 if fromStl == "" || toStl == "" {
2090 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002091 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002092 // We can be permissive with the system "STL" since it is only the C++
2093 // ABI layer, but in the future we should make sure that everyone is
2094 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002095 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002096 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002097 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2098 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002099 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002100}
2101
Jooyung Han479ca172020-10-19 18:51:07 +09002102func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2103 if c, ok := ctx.Module().(*Module); ok {
2104 ctx.VisitDirectDeps(func(dep android.Module) {
2105 depTag := ctx.OtherModuleDependencyTag(dep)
2106 ccDep, ok := dep.(LinkableInterface)
2107 if ok {
2108 checkLinkType(ctx, c, ccDep, depTag)
2109 }
2110 })
2111 }
2112}
2113
Jiyong Park5fb8c102018-04-09 12:03:06 +09002114// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002115// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2116// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002117// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002118func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2119 check := func(child, parent android.Module) bool {
2120 to, ok := child.(*Module)
2121 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002122 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002123 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002124
Jooyung Hana70f0672019-01-18 15:20:43 +09002125 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2126 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002127 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002128
Jooyung Han479ca172020-10-19 18:51:07 +09002129 // Even if target lib has no vendor variant, keep checking dependency graph
2130 // in case it depends on vendor_available but not double_loadable transtively.
Ivan Lozano52767be2019-10-18 14:49:46 -07002131 if !to.HasVendorVariant() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002132 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002133 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002134
Jooyung Han0302a842019-10-30 18:43:49 +09002135 if to.isVndkSp() || to.isLlndk(ctx.Config()) || Bool(to.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002136 return false
2137 }
2138
2139 var stringPath []string
2140 for _, m := range ctx.GetWalkPath() {
2141 stringPath = append(stringPath, m.Name())
2142 }
2143 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2144 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
2145 "(dependency: %s)", ctx.OtherModuleName(to), strings.Join(stringPath, " -> "))
2146 return false
2147 }
2148 if module, ok := ctx.Module().(*Module); ok {
2149 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jooyung Han0302a842019-10-30 18:43:49 +09002150 if module.isLlndk(ctx.Config()) || Bool(module.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002151 ctx.WalkDeps(check)
2152 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002153 }
2154 }
2155}
2156
Colin Cross0de8a1e2020-09-18 14:15:30 -07002157// Returns the highest version which is <= maxSdkVersion.
2158// For example, with maxSdkVersion is 10 and versionList is [9,11]
2159// it returns 9 as string. The list of stubs must be in order from
2160// oldest to newest.
2161func (c *Module) chooseSdkVersion(ctx android.PathContext, stubsInfo []SharedLibraryStubsInfo,
2162 maxSdkVersion android.ApiLevel) (SharedLibraryStubsInfo, error) {
2163
2164 for i := range stubsInfo {
2165 stubInfo := stubsInfo[len(stubsInfo)-i-1]
2166 var ver android.ApiLevel
2167 if stubInfo.Version == "" {
2168 ver = android.FutureApiLevel
2169 } else {
2170 var err error
2171 ver, err = android.ApiLevelFromUser(ctx, stubInfo.Version)
2172 if err != nil {
2173 return SharedLibraryStubsInfo{}, err
2174 }
2175 }
2176 if ver.LessThanOrEqualTo(maxSdkVersion) {
2177 return stubInfo, nil
2178 }
2179 }
2180 var versionList []string
2181 for _, stubInfo := range stubsInfo {
2182 versionList = append(versionList, stubInfo.Version)
2183 }
2184 return SharedLibraryStubsInfo{}, fmt.Errorf("not found a version(<=%s) in versionList: %v", maxSdkVersion.String(), versionList)
2185}
2186
Colin Crossc99deeb2016-04-11 15:06:20 -07002187// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002188func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002189 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002190
Colin Cross0de8a1e2020-09-18 14:15:30 -07002191 var directStaticDeps []StaticLibraryInfo
2192 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002193
Colin Cross0de8a1e2020-09-18 14:15:30 -07002194 reexportExporter := func(exporter FlagExporterInfo) {
2195 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2196 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2197 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2198 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2199 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002200 }
2201
Jooyung Hande34d232020-07-23 13:04:15 +09002202 // For the dependency from platform to apex, use the latest stubs
2203 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002204 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2205 if !apexInfo.IsForPlatform() {
2206 c.apexSdkVersion = apexInfo.MinSdkVersion(ctx)
Jooyung Hande34d232020-07-23 13:04:15 +09002207 }
2208
2209 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2210 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2211 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2212 // (b/144430859)
2213 c.apexSdkVersion = android.FutureApiLevel
2214 }
2215
Colin Crossd11fcda2017-10-23 17:59:01 -07002216 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002217 depName := ctx.OtherModuleName(dep)
2218 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002219
Ivan Lozano52767be2019-10-18 14:49:46 -07002220 ccDep, ok := dep.(LinkableInterface)
2221 if !ok {
2222
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002223 // handling for a few module types that aren't cc Module but that are also supported
2224 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002225 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002226 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002227 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2228 genRule.GeneratedSourceFiles()...)
2229 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002230 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002231 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002232 // Support exported headers from a generated_sources dependency
2233 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002234 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002235 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002236 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002237 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002238 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002239 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002240 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002241 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002242 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2243 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002244 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002245 // 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 +09002246 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002247
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002248 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002249 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002250 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002251 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002252 case linkerFlagsDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002253 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002254 files := genRule.GeneratedSourceFiles()
2255 if len(files) == 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002256 depPaths.LinkerFlagsFile = android.OptionalPathForPath(files[0])
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002257 } else if len(files) > 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002258 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 -07002259 }
2260 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002261 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002262 }
Colin Crossca860ac2016-01-04 14:34:37 -08002263 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002264 return
2265 }
2266
Colin Crossfe17f6f2019-03-28 19:30:56 -07002267 if depTag == android.ProtoPluginDepTag {
2268 return
2269 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002270 if depTag == llndkImplDep {
2271 return
2272 }
Colin Crossfe17f6f2019-03-28 19:30:56 -07002273
Colin Crossd11fcda2017-10-23 17:59:01 -07002274 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002275 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2276 return
2277 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002278 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002279 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2280 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002281 return
2282 }
2283
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002284 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002285 // Skip reused objects for stub libraries, they use their own stub object file instead.
2286 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2287 // version mutator, so the stubs variant is created from the shared variant that
2288 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002289 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002290 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2291 objs := staticAnalogue.ReuseObjects
2292 depPaths.Objs = depPaths.Objs.Append(objs)
2293 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2294 reexportExporter(depExporterInfo)
2295 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002296 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002297 }
2298
Colin Cross6e511a92020-07-27 21:26:48 -07002299 linkFile := ccDep.OutputFile()
2300
2301 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2302 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002303 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002304 return
2305 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002306
Colin Cross0de8a1e2020-09-18 14:15:30 -07002307 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002308
Colin Cross6e511a92020-07-27 21:26:48 -07002309 var ptr *android.Paths
2310 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002311
Colin Cross6e511a92020-07-27 21:26:48 -07002312 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002313
Colin Cross6e511a92020-07-27 21:26:48 -07002314 switch {
2315 case libDepTag.header():
2316 // nothing
2317 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002318 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2319 if !ctx.Config().AllowMissingDependencies() {
2320 ctx.ModuleErrorf("module %q is not a shared library", depName)
2321 } else {
2322 ctx.AddMissingDependencies([]string{depName})
2323 }
2324 return
2325 }
2326 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
2327 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryImplementationStubsInfoProvider).(SharedLibraryImplementationStubsInfo)
2328
2329 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedLibraryStubsInfos) > 0 {
2330 useStubs := false
Colin Cross31076b32020-10-23 17:22:06 -07002331
2332 if lib := moduleLibraryInterface(dep); lib.buildStubs() && c.UseVndk() { // LLNDK
Colin Cross0de8a1e2020-09-18 14:15:30 -07002333 if !apexInfo.IsForPlatform() {
2334 // For platform libraries, use current version of LLNDK
2335 // If this is for use_vendor apex we will apply the same rules
2336 // of apex sdk enforcement below to choose right version.
2337 useStubs = true
2338 }
2339 } else if apexInfo.IsForPlatform() {
2340 // If not building for APEX, use stubs only when it is from
2341 // an APEX (and not from platform)
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002342 // However, for host, ramdisk, vendor_ramdisk, recovery or bootstrap modules,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002343 // always link to non-stub variant
2344 useStubs = dep.(android.ApexModule).AnyVariantDirectlyInAnyApex() && !c.bootstrap()
2345 // Another exception: if this module is bundled with an APEX, then
2346 // it is linked with the non-stub variant of a module in the APEX
2347 // as if this is part of the APEX.
2348 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2349 for _, apexContents := range testFor.ApexContents {
2350 if apexContents.DirectlyInApex(depName) {
2351 useStubs = false
2352 break
2353 }
2354 }
2355 } else {
2356 // If building for APEX, use stubs when the parent is in any APEX that
2357 // the child is not in.
2358 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
2359 }
2360
2361 // when to use (unspecified) stubs, check min_sdk_version and choose the right one
2362 if useStubs {
2363 sharedLibraryStubsInfo, err :=
2364 c.chooseSdkVersion(ctx, sharedLibraryStubsInfo.SharedLibraryStubsInfos, c.apexSdkVersion)
2365 if err != nil {
2366 ctx.OtherModuleErrorf(dep, err.Error())
2367 return
2368 }
2369 sharedLibraryInfo = sharedLibraryStubsInfo.SharedLibraryInfo
2370 depExporterInfo = sharedLibraryStubsInfo.FlagExporterInfo
2371 }
2372 }
2373
2374 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2375 depFile = sharedLibraryInfo.TableOfContents
2376
Colin Cross6e511a92020-07-27 21:26:48 -07002377 ptr = &depPaths.SharedLibs
2378 switch libDepTag.Order {
2379 case earlyLibraryDependency:
2380 ptr = &depPaths.EarlySharedLibs
2381 depPtr = &depPaths.EarlySharedLibsDeps
2382 case normalLibraryDependency:
2383 ptr = &depPaths.SharedLibs
2384 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002385 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002386 case lateLibraryDependency:
2387 ptr = &depPaths.LateSharedLibs
2388 depPtr = &depPaths.LateSharedLibsDeps
2389 default:
2390 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002391 }
Colin Cross6e511a92020-07-27 21:26:48 -07002392 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002393 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2394 if !ctx.Config().AllowMissingDependencies() {
2395 ctx.ModuleErrorf("module %q is not a static library", depName)
2396 } else {
2397 ctx.AddMissingDependencies([]string{depName})
2398 }
2399 return
2400 }
2401 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2402 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002403 if libDepTag.wholeStatic {
2404 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002405 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2406 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002407 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002408 // This case normally catches prebuilt static
2409 // libraries, but it can also occur when
2410 // AllowMissingDependencies is on and the
2411 // dependencies has no sources of its own
2412 // but has a whole_static_libs dependency
2413 // on a missing library. We want to depend
2414 // on the .a file so that there is something
2415 // in the dependency tree that contains the
2416 // error rule for the missing transitive
2417 // dependency.
2418 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002419 }
Colin Cross6e511a92020-07-27 21:26:48 -07002420 } else {
2421 switch libDepTag.Order {
2422 case earlyLibraryDependency:
2423 panic(fmt.Errorf("early static libs not suppported"))
2424 case normalLibraryDependency:
2425 // static dependencies will be handled separately so they can be ordered
2426 // using transitive dependencies.
2427 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002428 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002429 case lateLibraryDependency:
2430 ptr = &depPaths.LateStaticLibs
2431 default:
2432 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002433 }
2434 }
2435 }
2436
Colin Cross6e511a92020-07-27 21:26:48 -07002437 if libDepTag.static() && !libDepTag.wholeStatic {
2438 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2439 ctx.ModuleErrorf("module %q not a static library", depName)
2440 return
2441 }
Logan Chien43d34c32017-12-20 01:17:32 +08002442
Colin Cross6e511a92020-07-27 21:26:48 -07002443 // When combining coverage files for shared libraries and executables, coverage files
2444 // in static libraries act as if they were whole static libraries. The same goes for
2445 // source based Abi dump files.
2446 if c, ok := ccDep.(*Module); ok {
2447 staticLib := c.linker.(libraryInterface)
2448 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2449 staticLib.objs().coverageFiles...)
2450 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2451 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002452 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002453 // Handle non-CC modules here
2454 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002455 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002456 }
2457 }
2458
Colin Cross6e511a92020-07-27 21:26:48 -07002459 if ptr != nil {
2460 if !linkFile.Valid() {
2461 if !ctx.Config().AllowMissingDependencies() {
2462 ctx.ModuleErrorf("module %q missing output file", depName)
2463 } else {
2464 ctx.AddMissingDependencies([]string{depName})
2465 }
2466 return
2467 }
2468 *ptr = append(*ptr, linkFile.Path())
2469 }
2470
2471 if depPtr != nil {
2472 dep := depFile
2473 if !dep.Valid() {
2474 dep = linkFile
2475 }
2476 *depPtr = append(*depPtr, dep.Path())
2477 }
2478
Colin Cross0de8a1e2020-09-18 14:15:30 -07002479 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2480 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2481 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2482 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2483
2484 if libDepTag.reexportFlags {
2485 reexportExporter(depExporterInfo)
2486 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2487 // Re-exported shared library headers must be included as well since they can help us with type information
2488 // about template instantiations (instantiated from their headers).
2489 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2490 // scripts.
2491 c.sabi.Properties.ReexportedIncludes = append(
2492 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2493 }
2494
Colin Cross6e511a92020-07-27 21:26:48 -07002495 makeLibName := c.makeLibName(ctx, ccDep, depName) + libDepTag.makeSuffix
2496 switch {
2497 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002498 c.Properties.AndroidMkHeaderLibs = append(
2499 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002500 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002501 if lib := moduleLibraryInterface(dep); lib != nil {
2502 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002503 // Add the dependency to the APEX(es) providing the library so that
2504 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002505 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
2506 for _, an := range depApexInfo.InApexes {
Colin Cross6e511a92020-07-27 21:26:48 -07002507 c.Properties.ApexesProvidingSharedLibs = append(
2508 c.Properties.ApexesProvidingSharedLibs, an)
2509 }
2510 }
2511 }
2512
2513 // Note: the order of libs in this list is not important because
2514 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002515 c.Properties.AndroidMkSharedLibs = append(
2516 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002517 // Record baseLibName for snapshots.
2518 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, baseLibName(depName))
2519 case libDepTag.static():
2520 if libDepTag.wholeStatic {
2521 c.Properties.AndroidMkWholeStaticLibs = append(
2522 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2523 } else {
2524 c.Properties.AndroidMkStaticLibs = append(
2525 c.Properties.AndroidMkStaticLibs, makeLibName)
2526 }
2527 }
2528 } else {
2529 switch depTag {
2530 case runtimeDepTag:
2531 c.Properties.AndroidMkRuntimeLibs = append(
2532 c.Properties.AndroidMkRuntimeLibs, c.makeLibName(ctx, ccDep, depName)+libDepTag.makeSuffix)
2533 // Record baseLibName for snapshots.
2534 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, baseLibName(depName))
2535 case objDepTag:
2536 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2537 case CrtBeginDepTag:
2538 depPaths.CrtBegin = linkFile
2539 case CrtEndDepTag:
2540 depPaths.CrtEnd = linkFile
2541 case dynamicLinkerDepTag:
2542 depPaths.DynamicLinker = linkFile
2543 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002544 }
Colin Crossca860ac2016-01-04 14:34:37 -08002545 })
2546
Jeff Gaston294356f2017-09-27 17:05:30 -07002547 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002548 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2549 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2550 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002551
Colin Crossdd84e052017-05-17 13:44:16 -07002552 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002553 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002554 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2555 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002556 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002557 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2558 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002559 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002560 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002561 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002562
2563 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002564 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002565 }
Colin Crossdd84e052017-05-17 13:44:16 -07002566
Colin Crossca860ac2016-01-04 14:34:37 -08002567 return depPaths
2568}
2569
Colin Cross0de8a1e2020-09-18 14:15:30 -07002570// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
2571// to match the topological order of the dependency tree, including any static analogues of
2572// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
2573// of the transitive dependencies.
2574func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
2575 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
2576 var staticPaths android.Paths
2577 for _, staticDep := range staticDeps {
2578 staticPaths = append(staticPaths, staticDep.StaticLibrary)
2579 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
2580 }
2581 for _, sharedDep := range sharedDeps {
2582 if sharedDep.StaticAnalogue != nil {
2583 transitiveStaticLibsBuilder.Transitive(sharedDep.StaticAnalogue.TransitiveStaticLibrariesForOrdering)
2584 }
2585 }
2586 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
2587
2588 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
2589
2590 // reorder the dependencies based on transitive dependencies
2591 staticPaths = android.FirstUniquePaths(staticPaths)
2592 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
2593
2594 if len(orderedStaticPaths) != len(staticPaths) {
2595 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
2596 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
2597 }
2598
2599 return orderedStaticPaths, transitiveStaticLibs
2600}
2601
Colin Cross6e511a92020-07-27 21:26:48 -07002602// baseLibName trims known prefixes and suffixes
2603func baseLibName(depName string) string {
2604 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
2605 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
2606 libName = strings.TrimPrefix(libName, "prebuilt_")
2607 return libName
2608}
2609
2610func (c *Module) makeLibName(ctx android.ModuleContext, ccDep LinkableInterface, depName string) string {
2611 vendorSuffixModules := vendorSuffixModules(ctx.Config())
2612 vendorPublicLibraries := vendorPublicLibraries(ctx.Config())
2613
2614 libName := baseLibName(depName)
2615 isLLndk := isLlndkLibrary(libName, ctx.Config())
2616 isVendorPublicLib := inList(libName, *vendorPublicLibraries)
2617 bothVendorAndCoreVariantsExist := ccDep.HasVendorVariant() || isLLndk
2618
2619 if c, ok := ccDep.(*Module); ok {
2620 // Use base module name for snapshots when exporting to Makefile.
2621 if c.isSnapshotPrebuilt() {
2622 baseName := c.BaseModuleName()
2623
2624 if c.IsVndk() {
2625 return baseName + ".vendor"
2626 }
2627
2628 if vendorSuffixModules[baseName] {
2629 return baseName + ".vendor"
2630 } else {
2631 return baseName
2632 }
2633 }
2634 }
2635
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002636 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
2637 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07002638 // The vendor module is a no-vendor-variant VNDK library. Depend on the
2639 // core module instead.
2640 return libName
2641 } else if c.UseVndk() && bothVendorAndCoreVariantsExist {
2642 // The vendor module in Make will have been renamed to not conflict with the core
2643 // module, so update the dependency name here accordingly.
2644 return libName + c.getNameSuffixWithVndkVersion(ctx)
2645 } else if (ctx.Platform() || ctx.ProductSpecific()) && isVendorPublicLib {
2646 return libName + vendorPublicLibrarySuffix
2647 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
2648 return libName + ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002649 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
2650 return libName + vendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002651 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
2652 return libName + recoverySuffix
2653 } else if ccDep.Module().Target().NativeBridge == android.NativeBridgeEnabled {
2654 return libName + nativeBridgeSuffix
2655 } else {
2656 return libName
2657 }
2658}
2659
Colin Crossca860ac2016-01-04 14:34:37 -08002660func (c *Module) InstallInData() bool {
2661 if c.installer == nil {
2662 return false
2663 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002664 return c.installer.inData()
2665}
2666
2667func (c *Module) InstallInSanitizerDir() bool {
2668 if c.installer == nil {
2669 return false
2670 }
2671 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07002672 return true
2673 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002674 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08002675}
2676
Yifan Hong1b3348d2020-01-21 15:53:22 -08002677func (c *Module) InstallInRamdisk() bool {
2678 return c.InRamdisk()
2679}
2680
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002681func (c *Module) InstallInVendorRamdisk() bool {
2682 return c.InVendorRamdisk()
2683}
2684
Jiyong Parkf9332f12018-02-01 00:54:12 +09002685func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07002686 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09002687}
2688
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002689func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002690 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002691 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002692 return
2693 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002694 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002695}
2696
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07002697func (c *Module) HostToolPath() android.OptionalPath {
2698 if c.installer == nil {
2699 return android.OptionalPath{}
2700 }
2701 return c.installer.hostToolPath()
2702}
2703
Nan Zhangd4e641b2017-07-12 12:55:28 -07002704func (c *Module) IntermPathForModuleOut() android.OptionalPath {
2705 return c.outputFile
2706}
2707
Colin Cross41955e82019-05-29 14:40:35 -07002708func (c *Module) OutputFiles(tag string) (android.Paths, error) {
2709 switch tag {
2710 case "":
2711 if c.outputFile.Valid() {
2712 return android.Paths{c.outputFile.Path()}, nil
2713 }
2714 return android.Paths{}, nil
2715 default:
2716 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002717 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002718}
2719
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00002720func (c *Module) static() bool {
2721 if static, ok := c.linker.(interface {
2722 static() bool
2723 }); ok {
2724 return static.static()
2725 }
2726 return false
2727}
2728
Jiyong Park379de2f2018-12-19 02:47:14 +09002729func (c *Module) staticBinary() bool {
2730 if static, ok := c.linker.(interface {
2731 staticBinary() bool
2732 }); ok {
2733 return static.staticBinary()
2734 }
2735 return false
2736}
2737
Jiyong Park1d1119f2019-07-29 21:27:18 +09002738func (c *Module) header() bool {
2739 if h, ok := c.linker.(interface {
2740 header() bool
2741 }); ok {
2742 return h.header()
2743 }
2744 return false
2745}
2746
Inseob Kim7f283f42020-06-01 21:53:49 +09002747func (c *Module) binary() bool {
2748 if b, ok := c.linker.(interface {
2749 binary() bool
2750 }); ok {
2751 return b.binary()
2752 }
2753 return false
2754}
2755
Inseob Kim1042d292020-06-01 23:23:05 +09002756func (c *Module) object() bool {
2757 if o, ok := c.linker.(interface {
2758 object() bool
2759 }); ok {
2760 return o.object()
2761 }
2762 return false
2763}
2764
Jooyung Han38002912019-05-16 04:01:54 +09002765func (c *Module) getMakeLinkType(actx android.ModuleContext) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07002766 if c.UseVndk() {
Jooyung Han38002912019-05-16 04:01:54 +09002767 if lib, ok := c.linker.(*llndkStubDecorator); ok {
2768 if Bool(lib.Properties.Vendor_available) {
Colin Crossb60190a2018-09-04 16:28:17 -07002769 return "native:vndk"
2770 }
Jooyung Han38002912019-05-16 04:01:54 +09002771 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07002772 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002773 if c.IsVndk() && !c.isVndkExt() {
Jooyung Han38002912019-05-16 04:01:54 +09002774 if Bool(c.VendorProperties.Vendor_available) {
2775 return "native:vndk"
2776 }
2777 return "native:vndk_private"
2778 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09002779 if c.inProduct() {
2780 return "native:product"
2781 }
Jooyung Han38002912019-05-16 04:01:54 +09002782 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08002783 } else if c.InRamdisk() {
2784 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002785 } else if c.InVendorRamdisk() {
2786 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07002787 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07002788 return "native:recovery"
2789 } else if c.Target().Os == android.Android && String(c.Properties.Sdk_version) != "" {
2790 return "native:ndk:none:none"
2791 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
2792 //family, link := getNdkStlFamilyAndLinkType(c)
2793 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07002794 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08002795 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07002796 } else {
2797 return "native:platform"
2798 }
2799}
2800
Jiyong Park9d452992018-10-03 00:38:19 +09002801// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01002802// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09002803func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07002804 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09002805 // Stub libs and prebuilt libs in a versioned SDK are not
2806 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07002807 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01002808 } else if _, ok := c.linker.(testPerSrc); ok {
2809 return true
Jiyong Park9d452992018-10-03 00:38:19 +09002810 }
2811 return false
2812}
2813
Jiyong Parka90ca002019-10-07 15:47:24 +09002814func (c *Module) AvailableFor(what string) bool {
2815 if linker, ok := c.linker.(interface {
2816 availableFor(string) bool
2817 }); ok {
2818 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
2819 } else {
2820 return c.ApexModuleBase.AvailableFor(what)
2821 }
2822}
2823
Jiyong Park62304bb2020-04-13 16:19:48 +09002824func (c *Module) TestFor() []string {
2825 if test, ok := c.linker.(interface {
2826 testFor() []string
2827 }); ok {
2828 return test.testFor()
2829 } else {
2830 return c.ApexModuleBase.TestFor()
2831 }
2832}
2833
Colin Crossaede88c2020-08-11 12:17:01 -07002834func (c *Module) UniqueApexVariations() bool {
2835 if u, ok := c.compiler.(interface {
2836 uniqueApexVariations() bool
2837 }); ok {
2838 return u.uniqueApexVariations()
2839 } else {
2840 return false
2841 }
2842}
2843
Paul Duffin0cb37b92020-03-04 14:52:46 +00002844// Return true if the module is ever installable.
2845func (c *Module) EverInstallable() bool {
2846 return c.installer != nil &&
2847 // Check to see whether the module is actually ever installable.
2848 c.installer.everInstallable()
2849}
2850
Colin Cross56a83212020-09-15 18:30:11 -07002851func (c *Module) installable(apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00002852 ret := c.EverInstallable() &&
2853 // Check to see whether the module has been configured to not be installed.
2854 proptools.BoolDefault(c.Properties.Installable, true) &&
2855 !c.Properties.PreventInstall && c.outputFile.Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09002856
2857 // The platform variant doesn't need further condition. Apex variants however might not
2858 // be installable because it will likely to be included in the APEX and won't appear
2859 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07002860 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09002861 return ret
2862 }
2863
2864 // Special case for modules that are configured to be installed to /data, which includes
2865 // test modules. For these modules, both APEX and non-APEX variants are considered as
2866 // installable. This is because even the APEX variants won't be included in the APEX, but
2867 // will anyway be installed to /data/*.
2868 // See b/146995717
2869 if c.InstallInData() {
2870 return ret
2871 }
2872
2873 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09002874}
2875
Logan Chien41eabe62019-04-10 13:33:58 +08002876func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
2877 if c.linker != nil {
2878 if library, ok := c.linker.(*libraryDecorator); ok {
2879 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
2880 }
2881 }
2882}
2883
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002884func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07002885 depTag := ctx.OtherModuleDependencyTag(dep)
2886 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
2887
2888 if cc, ok := dep.(*Module); ok {
2889 if cc.HasStubsVariants() {
2890 if isLibDepTag && libDepTag.shared() {
2891 // dynamic dep to a stubs lib crosses APEX boundary
2892 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002893 }
Colin Cross6e511a92020-07-27 21:26:48 -07002894 if IsRuntimeDepTag(depTag) {
2895 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002896 return false
2897 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002898 }
Colin Crossaac32222020-07-29 12:51:56 -07002899 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07002900 // shared_lib dependency from a static lib is considered as crossing
2901 // the APEX boundary because the dependency doesn't actually is
2902 // linked; the dependency is used only during the compilation phase.
2903 return false
2904 }
2905 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002906 if depTag == stubImplDepTag || depTag == llndkImplDep {
2907 // We don't track beyond LLNDK or from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09002908 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002909 }
2910 return true
2911}
2912
Dan Albertc8060532020-07-22 22:32:17 -07002913func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
2914 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09002915 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
2916 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
2917 return nil
2918 }
2919 // b/154569636: set min_sdk_version correctly for toolchain_libraries
2920 if c.ToolchainLibrary() {
2921 return nil
2922 }
2923 // We don't check for prebuilt modules
2924 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
2925 return nil
2926 }
2927 minSdkVersion := c.MinSdkVersion()
2928 if minSdkVersion == "apex_inherit" {
2929 return nil
2930 }
2931 if minSdkVersion == "" {
2932 // JNI libs within APK-in-APEX fall into here
2933 // Those are okay to set sdk_version instead
2934 // We don't have to check if this is a SDK variant because
2935 // non-SDK variant resets sdk_version, which works too.
2936 minSdkVersion = c.SdkVersion()
2937 }
Dan Albertc8060532020-07-22 22:32:17 -07002938 if minSdkVersion == "" {
2939 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
2940 }
2941 // Not using nativeApiLevelFromUser because the context here is not
2942 // necessarily a native context.
2943 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09002944 if err != nil {
2945 return err
2946 }
Dan Albertc8060532020-07-22 22:32:17 -07002947
2948 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09002949 return fmt.Errorf("newer SDK(%v)", ver)
2950 }
2951 return nil
2952}
2953
Colin Cross2ba19d92015-05-07 15:44:20 -07002954//
Colin Crosscfad1192015-11-02 16:43:11 -08002955// Defaults
2956//
Colin Crossca860ac2016-01-04 14:34:37 -08002957type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07002958 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07002959 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09002960 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08002961}
2962
Patrice Arrudac249c712019-03-19 17:00:29 -07002963// cc_defaults provides a set of properties that can be inherited by other cc
2964// modules. A module can use the properties from a cc_defaults using
2965// `defaults: ["<:default_module_name>"]`. Properties of both modules are
2966// merged (when possible) by prepending the default module's values to the
2967// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07002968func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07002969 return DefaultsFactory()
2970}
2971
Colin Cross36242852017-06-23 15:06:31 -07002972func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08002973 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08002974
Colin Cross36242852017-06-23 15:06:31 -07002975 module.AddProperties(props...)
2976 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08002977 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002978 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002979 &BaseCompilerProperties{},
2980 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01002981 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07002982 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07002983 &StaticProperties{},
2984 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07002985 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002986 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07002987 &TestProperties{},
2988 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07002989 &BenchmarkProperties{},
Mitch Phillips4e4ab8a2019-09-13 17:32:50 -07002990 &FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002991 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08002992 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07002993 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07002994 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07002995 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08002996 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08002997 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09002998 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07002999 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003000 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003001 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003002 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3003 &RustBindgenClangProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003004 )
Colin Crosscfad1192015-11-02 16:43:11 -08003005
Jooyung Hancc372c52019-09-25 15:18:44 +09003006 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003007
3008 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003009}
3010
Jiyong Park6a43f042017-10-12 23:05:00 +09003011func squashVendorSrcs(m *Module) {
3012 if lib, ok := m.compiler.(*libraryDecorator); ok {
3013 lib.baseCompiler.Properties.Srcs = append(lib.baseCompiler.Properties.Srcs,
3014 lib.baseCompiler.Properties.Target.Vendor.Srcs...)
3015
3016 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs,
3017 lib.baseCompiler.Properties.Target.Vendor.Exclude_srcs...)
Jooyung Hanac07f882020-07-05 03:54:35 +09003018
3019 lib.baseCompiler.Properties.Exclude_generated_sources = append(lib.baseCompiler.Properties.Exclude_generated_sources,
3020 lib.baseCompiler.Properties.Target.Vendor.Exclude_generated_sources...)
Jiyong Park6a43f042017-10-12 23:05:00 +09003021 }
3022}
3023
Jiyong Parkf9332f12018-02-01 00:54:12 +09003024func squashRecoverySrcs(m *Module) {
3025 if lib, ok := m.compiler.(*libraryDecorator); ok {
3026 lib.baseCompiler.Properties.Srcs = append(lib.baseCompiler.Properties.Srcs,
3027 lib.baseCompiler.Properties.Target.Recovery.Srcs...)
3028
3029 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs,
3030 lib.baseCompiler.Properties.Target.Recovery.Exclude_srcs...)
Jooyung Hanac07f882020-07-05 03:54:35 +09003031
3032 lib.baseCompiler.Properties.Exclude_generated_sources = append(lib.baseCompiler.Properties.Exclude_generated_sources,
3033 lib.baseCompiler.Properties.Target.Recovery.Exclude_generated_sources...)
Jiyong Parkf9332f12018-02-01 00:54:12 +09003034 }
3035}
3036
Yifan Hong6da33c22020-10-27 15:01:21 -07003037func squashVendorRamdiskSrcs(m *Module) {
3038 if lib, ok := m.compiler.(*libraryDecorator); ok {
3039 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs, lib.baseCompiler.Properties.Target.Vendor_ramdisk.Exclude_srcs...)
3040 }
3041}
3042
Jiyong Park2286afd2020-06-16 21:58:53 +09003043func (c *Module) IsSdkVariant() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07003044 return c.Properties.IsSdkVariant || c.AlwaysSdk()
Jiyong Park2286afd2020-06-16 21:58:53 +09003045}
3046
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003047func kytheExtractAllFactory() android.Singleton {
3048 return &kytheExtractAllSingleton{}
3049}
3050
3051type kytheExtractAllSingleton struct {
3052}
3053
3054func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3055 var xrefTargets android.Paths
3056 ctx.VisitAllModules(func(module android.Module) {
3057 if ccModule, ok := module.(xref); ok {
3058 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3059 }
3060 })
3061 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3062 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003063 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003064 }
3065}
3066
Colin Cross06a931b2015-10-28 17:23:31 -07003067var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003068var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003069var BoolPtr = proptools.BoolPtr
3070var String = proptools.String
3071var StringPtr = proptools.StringPtr