blob: 349d03d2c076740d4e5ec49b247145c4b2feefd9 [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
Zach Johnson3df4e632020-11-06 11:56:27 -0800582func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
583 ccLibDepTag, ok := depTag.(libraryDependencyTag)
584 return ok && ccLibDepTag.header()
585}
586
Roland Levillainf89cd092019-07-29 16:22:59 +0100587func IsRuntimeDepTag(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 == runtimeDepTag
590}
591
592func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700593 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100594 return ok && ccDepTag == testPerSrcDepTag
595}
596
Colin Crossca860ac2016-01-04 14:34:37 -0800597// Module contains the properties and members used by all C/C++ module types, and implements
598// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
599// to construct the output file. Behavior can be customized with a Customizer interface
600type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700601 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700602 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900603 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900604 android.SdkBase
Colin Crossc472d572015-03-17 15:06:21 -0700605
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700606 Properties BaseProperties
607 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700608
Colin Crossca860ac2016-01-04 14:34:37 -0800609 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700610 hod android.HostOrDeviceSupported
611 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700612
Paul Duffina0843f62019-12-13 19:50:38 +0000613 // Allowable SdkMemberTypes of this module type.
614 sdkMemberTypes []android.SdkMemberType
615
Colin Crossca860ac2016-01-04 14:34:37 -0800616 // delegates, initialize before calling Init
Colin Crossb4ce0ec2016-09-13 13:41:39 -0700617 features []feature
618 compiler compiler
619 linker linker
620 installer installer
621 stl *stl
622 sanitize *sanitize
Dan Willemsen581341d2017-02-09 16:16:31 -0800623 coverage *coverage
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800624 sabi *sabi
Justin Yun8effde42017-06-23 19:24:43 +0900625 vndkdep *vndkdep
Stephen Craneba090d12017-05-09 15:44:35 -0700626 lto *lto
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700627 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800628
Colin Cross31076b32020-10-23 17:22:06 -0700629 library libraryInterface
630
Colin Cross635c3b02016-05-18 15:37:25 -0700631 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800632
Colin Crossb98c8b02016-07-29 13:44:28 -0700633 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700634
635 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800636
637 // Flags used to compile this module
638 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700639
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800640 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700641 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900642
643 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800644 // Kythe (source file indexer) paths for this compilation module
645 kytheFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900646
647 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700648 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700649
650 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700651}
652
Ivan Lozano52767be2019-10-18 14:49:46 -0700653func (c *Module) Toc() android.OptionalPath {
654 if c.linker != nil {
655 if library, ok := c.linker.(libraryInterface); ok {
656 return library.toc()
657 }
658 }
659 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
660}
661
662func (c *Module) ApiLevel() string {
663 if c.linker != nil {
664 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700665 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700666 }
667 }
668 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
669}
670
671func (c *Module) Static() bool {
672 if c.linker != nil {
673 if library, ok := c.linker.(libraryInterface); ok {
674 return library.static()
675 }
676 }
677 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
678}
679
680func (c *Module) Shared() bool {
681 if c.linker != nil {
682 if library, ok := c.linker.(libraryInterface); ok {
683 return library.shared()
684 }
685 }
686 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
687}
688
689func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000690 if c.stl != nil {
691 return c.stl.Properties.SelectedStl
692 }
693 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700694}
695
696func (c *Module) ToolchainLibrary() bool {
697 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
698 return true
699 }
700 return false
701}
702
703func (c *Module) NdkPrebuiltStl() bool {
704 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
705 return true
706 }
707 return false
708}
709
710func (c *Module) StubDecorator() bool {
711 if _, ok := c.linker.(*stubDecorator); ok {
712 return true
713 }
714 return false
715}
716
717func (c *Module) SdkVersion() string {
718 return String(c.Properties.Sdk_version)
719}
720
Artur Satayev480e25b2020-04-27 18:53:18 +0100721func (c *Module) MinSdkVersion() string {
722 return String(c.Properties.Min_sdk_version)
723}
724
Dan Albert92fe7402020-07-15 13:33:30 -0700725func (c *Module) SplitPerApiLevel() bool {
Colin Cross1348ce32020-10-01 13:37:16 -0700726 if !c.canUseSdk() {
727 return false
728 }
Dan Albert92fe7402020-07-15 13:33:30 -0700729 if linker, ok := c.linker.(*objectLinker); ok {
730 return linker.isCrt()
731 }
732 return false
733}
734
Colin Crossc511bc52020-04-07 16:50:32 +0000735func (c *Module) AlwaysSdk() bool {
736 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
737}
738
Ivan Lozano183a3212019-10-18 14:18:45 -0700739func (c *Module) CcLibrary() bool {
740 if c.linker != nil {
741 if _, ok := c.linker.(*libraryDecorator); ok {
742 return true
743 }
Colin Crossd48fe732020-09-23 20:37:24 -0700744 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
745 return true
746 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700747 }
748 return false
749}
750
751func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -0700752 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700753 return true
754 }
755 return false
756}
757
Ivan Lozano2b262972019-11-21 12:30:50 -0800758func (c *Module) NonCcVariants() bool {
759 return false
760}
761
Ivan Lozano183a3212019-10-18 14:18:45 -0700762func (c *Module) SetStatic() {
763 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700764 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700765 library.setStatic()
766 return
767 }
768 }
769 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
770}
771
772func (c *Module) SetShared() {
773 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700774 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700775 library.setShared()
776 return
777 }
778 }
779 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
780}
781
782func (c *Module) BuildStaticVariant() bool {
783 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700784 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700785 return library.buildStatic()
786 }
787 }
788 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
789}
790
791func (c *Module) BuildSharedVariant() bool {
792 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700793 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700794 return library.buildShared()
795 }
796 }
797 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
798}
799
800func (c *Module) Module() android.Module {
801 return c
802}
803
Jiyong Parkc20eee32018-09-05 22:36:17 +0900804func (c *Module) OutputFile() android.OptionalPath {
805 return c.outputFile
806}
807
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400808func (c *Module) CoverageFiles() android.Paths {
809 if c.linker != nil {
810 if library, ok := c.linker.(libraryInterface); ok {
811 return library.objs().coverageFiles
812 }
813 }
814 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
815}
816
Ivan Lozano183a3212019-10-18 14:18:45 -0700817var _ LinkableInterface = (*Module)(nil)
818
Jiyong Park719b4462019-01-13 00:39:51 +0900819func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900820 if c.linker != nil {
821 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +0900822 }
823 return nil
824}
825
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900826func (c *Module) CoverageOutputFile() android.OptionalPath {
827 if c.linker != nil {
828 return c.linker.coverageOutputFilePath()
829 }
830 return android.OptionalPath{}
831}
832
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900833func (c *Module) RelativeInstallPath() string {
834 if c.installer != nil {
835 return c.installer.relativeInstallPath()
836 }
837 return ""
838}
839
Jooyung Han344d5432019-08-23 11:17:39 +0900840func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +0900841 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +0900842}
843
Colin Cross36242852017-06-23 15:06:31 -0700844func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -0700845 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -0800846 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -0700847 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800848 }
849 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -0700850 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800851 }
852 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -0700853 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800854 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700855 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -0700856 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -0700857 }
Colin Cross16b23492016-01-06 14:41:07 -0800858 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -0700859 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -0800860 }
Dan Willemsen581341d2017-02-09 16:16:31 -0800861 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -0700862 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -0800863 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800864 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -0700865 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800866 }
Justin Yun8effde42017-06-23 19:24:43 +0900867 if c.vndkdep != nil {
868 c.AddProperties(c.vndkdep.props()...)
869 }
Stephen Craneba090d12017-05-09 15:44:35 -0700870 if c.lto != nil {
871 c.AddProperties(c.lto.props()...)
872 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700873 if c.pgo != nil {
874 c.AddProperties(c.pgo.props()...)
875 }
Colin Crossca860ac2016-01-04 14:34:37 -0800876 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -0700877 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800878 }
Colin Crossc472d572015-03-17 15:06:21 -0700879
Jiyong Park1613e552020-09-14 19:43:17 +0900880 c.Prefer32(func(ctx android.BaseModuleContext, base *android.ModuleBase, os android.OsType) bool {
Elliott Hughes79ae3412020-04-17 15:49:49 -0700881 // Windows builds always prefer 32-bit
Jiyong Park1613e552020-09-14 19:43:17 +0900882 return os == android.Windows
Colin Crossa9d8bee2018-10-02 13:59:46 -0700883 })
Colin Cross36242852017-06-23 15:06:31 -0700884 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +0900885 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +0900886 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +0900887 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +0900888
Colin Cross36242852017-06-23 15:06:31 -0700889 return c
Colin Crossc472d572015-03-17 15:06:21 -0700890}
891
Colin Crossb916a382016-07-29 17:28:03 -0700892// Returns true for dependency roots (binaries)
893// TODO(ccross): also handle dlopenable libraries
894func (c *Module) isDependencyRoot() bool {
895 if root, ok := c.linker.(interface {
896 isDependencyRoot() bool
897 }); ok {
898 return root.isDependencyRoot()
899 }
900 return false
901}
902
Justin Yun5f7f7e82019-11-18 19:52:14 +0900903// Returns true if the module is using VNDK libraries instead of the libraries in /system/lib or /system/lib64.
904// "product" and "vendor" variant modules return true for this function.
905// When BOARD_VNDK_VERSION is set, vendor variants of "vendor_available: true", "vendor: true",
906// "soc_specific: true" and more vendor installed modules are included here.
907// When PRODUCT_PRODUCT_VNDK_VERSION is set, product variants of "vendor_available: true" or
908// "product_specific: true" modules are included here.
Ivan Lozano52767be2019-10-18 14:49:46 -0700909func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +0900910 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700911}
912
Colin Crossc511bc52020-04-07 16:50:32 +0000913func (c *Module) canUseSdk() bool {
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700914 return c.Os() == android.Android && !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +0000915}
916
917func (c *Module) UseSdk() bool {
918 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -0700919 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +0000920 }
921 return false
922}
923
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800924func (c *Module) isCoverageVariant() bool {
925 return c.coverage.Properties.IsCoverageVariant
926}
927
Peter Collingbournead84f972019-12-17 16:46:18 -0800928func (c *Module) IsNdk() bool {
Colin Crossf0913fb2020-07-29 12:59:39 -0700929 return inList(c.BaseModuleName(), ndkKnownLibs)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800930}
931
Inseob Kim9516ee92019-05-09 10:56:13 +0900932func (c *Module) isLlndk(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800933 // Returns true for both LLNDK (public) and LLNDK-private libs.
Jooyung Han0302a842019-10-30 18:43:49 +0900934 return isLlndkLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800935}
936
Inseob Kim9516ee92019-05-09 10:56:13 +0900937func (c *Module) isLlndkPublic(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800938 // Returns true only for LLNDK (public) libs.
Jooyung Han0302a842019-10-30 18:43:49 +0900939 name := c.BaseModuleName()
940 return isLlndkLibrary(name, config) && !isVndkPrivateLibrary(name, config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800941}
942
Inseob Kim9516ee92019-05-09 10:56:13 +0900943func (c *Module) isVndkPrivate(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800944 // Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Jooyung Han0302a842019-10-30 18:43:49 +0900945 return isVndkPrivateLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800946}
947
Ivan Lozano52767be2019-10-18 14:49:46 -0700948func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +0800949 if vndkdep := c.vndkdep; vndkdep != nil {
950 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +0900951 }
952 return false
953}
954
Yi Kong7e53c572018-02-14 18:16:12 +0800955func (c *Module) isPgoCompile() bool {
956 if pgo := c.pgo; pgo != nil {
957 return pgo.Properties.PgoCompile
958 }
959 return false
960}
961
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800962func (c *Module) isNDKStubLibrary() bool {
963 if _, ok := c.compiler.(*stubDecorator); ok {
964 return true
965 }
966 return false
967}
968
Logan Chienf3511742017-10-31 18:04:35 +0800969func (c *Module) isVndkSp() bool {
970 if vndkdep := c.vndkdep; vndkdep != nil {
971 return vndkdep.isVndkSp()
972 }
973 return false
974}
975
976func (c *Module) isVndkExt() bool {
977 if vndkdep := c.vndkdep; vndkdep != nil {
978 return vndkdep.isVndkExt()
979 }
980 return false
981}
982
Ivan Lozano52767be2019-10-18 14:49:46 -0700983func (c *Module) MustUseVendorVariant() bool {
Jooyung Han097087b2019-10-22 19:32:18 +0900984 return c.isVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -0800985}
986
Logan Chienf3511742017-10-31 18:04:35 +0800987func (c *Module) getVndkExtendsModuleName() string {
988 if vndkdep := c.vndkdep; vndkdep != nil {
989 return vndkdep.getVndkExtendsModuleName()
990 }
991 return ""
992}
993
Jiyong Park25fc6a92018-11-18 18:02:45 +0900994func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -0700995 if lib := c.library; lib != nil {
996 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +0900997 }
998 return false
999}
1000
1001func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001002 if lib := c.library; lib != nil {
1003 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001004 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001005 return false
1006}
1007
Colin Cross0477b422020-10-13 18:43:54 -07001008// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1009// the implementation. If it is an implementation library it returns its own name.
1010func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1011 name := ctx.OtherModuleName(c)
1012 if versioned, ok := c.linker.(versionedInterface); ok {
1013 name = versioned.implementationModuleName(name)
1014 }
1015 return name
1016}
1017
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001018func (c *Module) bootstrap() bool {
1019 return Bool(c.Properties.Bootstrap)
1020}
1021
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001022func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001023 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1024 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1025 return false
1026 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001027 return c.linker != nil && c.linker.nativeCoverage()
1028}
1029
Inseob Kim8471cda2019-11-15 09:59:12 +09001030func (c *Module) isSnapshotPrebuilt() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09001031 if p, ok := c.linker.(interface{ isSnapshotPrebuilt() bool }); ok {
1032 return p.isSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001033 }
1034 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001035}
1036
Bill Peckham945441c2020-08-31 16:07:58 -07001037func (c *Module) ExcludeFromVendorSnapshot() bool {
1038 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1039}
1040
Jiyong Parkf1194352019-02-25 11:05:47 +09001041func isBionic(name string) bool {
1042 switch name {
Martin Stjernholm203489b2019-11-11 15:33:27 +00001043 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001044 return true
1045 }
1046 return false
1047}
1048
Martin Stjernholm279de572019-09-10 23:18:20 +01001049func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001050 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001051 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001052 }
1053 return isBionic(name)
1054}
1055
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001056func (c *Module) XrefCcFiles() android.Paths {
1057 return c.kytheFiles
1058}
1059
Colin Crossca860ac2016-01-04 14:34:37 -08001060type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001061 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001062 moduleContextImpl
1063}
1064
Colin Cross37047f12016-12-13 17:06:13 -08001065type depsContext struct {
1066 android.BottomUpMutatorContext
1067 moduleContextImpl
1068}
1069
Colin Crossca860ac2016-01-04 14:34:37 -08001070type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001071 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001072 moduleContextImpl
1073}
1074
1075type moduleContextImpl struct {
1076 mod *Module
1077 ctx BaseModuleContext
1078}
1079
Colin Crossb98c8b02016-07-29 13:44:28 -07001080func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001081 return ctx.mod.toolchain(ctx.ctx)
1082}
1083
1084func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001085 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001086}
1087
1088func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001089 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001090}
1091
Jiyong Park1d1119f2019-07-29 21:27:18 +09001092func (ctx *moduleContextImpl) header() bool {
1093 return ctx.mod.header()
1094}
1095
Inseob Kim7f283f42020-06-01 21:53:49 +09001096func (ctx *moduleContextImpl) binary() bool {
1097 return ctx.mod.binary()
1098}
1099
Inseob Kim1042d292020-06-01 23:23:05 +09001100func (ctx *moduleContextImpl) object() bool {
1101 return ctx.mod.object()
1102}
1103
Jooyung Hanccce2f22020-03-07 03:45:53 +09001104func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001105 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001106}
1107
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001108func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001109 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001110}
1111
1112func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001113 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001114 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001115 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001116 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001117 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001118 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001119 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001120 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001121 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001122 }
1123 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001124}
1125
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001126func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001127 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001128}
Justin Yun8effde42017-06-23 19:24:43 +09001129
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001130func (ctx *moduleContextImpl) isNdk() bool {
Peter Collingbournead84f972019-12-17 16:46:18 -08001131 return ctx.mod.IsNdk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001132}
1133
Inseob Kim9516ee92019-05-09 10:56:13 +09001134func (ctx *moduleContextImpl) isLlndk(config android.Config) bool {
1135 return ctx.mod.isLlndk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001136}
1137
Inseob Kim9516ee92019-05-09 10:56:13 +09001138func (ctx *moduleContextImpl) isLlndkPublic(config android.Config) bool {
1139 return ctx.mod.isLlndkPublic(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001140}
1141
Inseob Kim9516ee92019-05-09 10:56:13 +09001142func (ctx *moduleContextImpl) isVndkPrivate(config android.Config) bool {
1143 return ctx.mod.isVndkPrivate(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001144}
1145
Logan Chienf3511742017-10-31 18:04:35 +08001146func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001147 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001148}
1149
Yi Kong7e53c572018-02-14 18:16:12 +08001150func (ctx *moduleContextImpl) isPgoCompile() bool {
1151 return ctx.mod.isPgoCompile()
1152}
1153
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001154func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1155 return ctx.mod.isNDKStubLibrary()
1156}
1157
Justin Yun8effde42017-06-23 19:24:43 +09001158func (ctx *moduleContextImpl) isVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001159 return ctx.mod.isVndkSp()
1160}
1161
1162func (ctx *moduleContextImpl) isVndkExt() bool {
1163 return ctx.mod.isVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001164}
1165
Vic Yangefd249e2018-11-12 20:19:56 -08001166func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001167 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001168}
1169
Logan Chien2f2b8902018-07-10 15:01:19 +08001170// Check whether ABI dumps should be created for this module.
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001171func (ctx *moduleContextImpl) shouldCreateSourceAbiDump() bool {
Logan Chien2f2b8902018-07-10 15:01:19 +08001172 if ctx.ctx.Config().IsEnvTrue("SKIP_ABI_CHECKS") {
1173 return false
Jayant Chowdharyea0a2e12018-03-01 19:12:16 -08001174 }
Doug Hornc32c6b02019-01-17 14:44:05 -08001175
Hsin-Yi Chenf81bb652020-04-07 21:42:19 +08001176 // Coverage builds have extra symbols.
1177 if ctx.mod.isCoverageVariant() {
1178 return false
1179 }
1180
Doug Hornc32c6b02019-01-17 14:44:05 -08001181 if ctx.ctx.Fuchsia() {
1182 return false
1183 }
1184
Logan Chien2f2b8902018-07-10 15:01:19 +08001185 if sanitize := ctx.mod.sanitize; sanitize != nil {
1186 if !sanitize.isVariantOnProductionDevice() {
1187 return false
1188 }
1189 }
1190 if !ctx.ctx.Device() {
1191 // Host modules do not need ABI dumps.
1192 return false
1193 }
Colin Cross31076b32020-10-23 17:22:06 -07001194 if ctx.isNDKStubLibrary() {
Hsin-Yi Chenf6a95462019-06-25 14:46:52 +08001195 // Stubs do not need ABI dumps.
1196 return false
1197 }
Colin Cross31076b32020-10-23 17:22:06 -07001198 if lib := ctx.mod.library; lib != nil && lib.buildStubs() {
1199 // Stubs do not need ABI dumps.
1200 return false
1201 }
1202
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001203 return true
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001204}
1205
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001206func (ctx *moduleContextImpl) selectedStl() string {
1207 if stl := ctx.mod.stl; stl != nil {
1208 return stl.Properties.SelectedStl
1209 }
1210 return ""
1211}
1212
Ivan Lozanobd721262018-11-27 14:33:03 -08001213func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1214 return ctx.mod.linker.useClangLld(actx)
1215}
1216
Colin Crossce75d2c2016-10-06 16:12:58 -07001217func (ctx *moduleContextImpl) baseModuleName() string {
1218 return ctx.mod.ModuleBase.BaseModuleName()
1219}
1220
Logan Chienf3511742017-10-31 18:04:35 +08001221func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1222 return ctx.mod.getVndkExtendsModuleName()
1223}
1224
Logan Chiene274fc92019-12-03 11:18:32 -08001225func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001226 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001227}
1228
Colin Crosse07f2312020-08-13 11:24:56 -07001229func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001230 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001231}
1232
Dan Albertc8060532020-07-22 22:32:17 -07001233func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001234 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001235}
1236
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001237func (ctx *moduleContextImpl) bootstrap() bool {
1238 return ctx.mod.bootstrap()
1239}
1240
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001241func (ctx *moduleContextImpl) nativeCoverage() bool {
1242 return ctx.mod.nativeCoverage()
1243}
1244
Colin Cross56a83212020-09-15 18:30:11 -07001245func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1246 return ctx.mod.DirectlyInAnyApex()
1247}
1248
Colin Cross635c3b02016-05-18 15:37:25 -07001249func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001250 return &Module{
1251 hod: hod,
1252 multilib: multilib,
1253 }
1254}
1255
Colin Cross635c3b02016-05-18 15:37:25 -07001256func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001257 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001258 module.features = []feature{
1259 &tidyFeature{},
1260 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001261 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001262 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001263 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001264 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001265 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001266 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001267 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001268 return module
1269}
1270
Colin Crossce75d2c2016-10-06 16:12:58 -07001271func (c *Module) Prebuilt() *android.Prebuilt {
1272 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1273 return p.prebuilt()
1274 }
1275 return nil
1276}
1277
1278func (c *Module) Name() string {
1279 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001280 if p, ok := c.linker.(interface {
1281 Name(string) string
1282 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001283 name = p.Name(name)
1284 }
1285 return name
1286}
1287
Alex Light3d673592019-01-18 14:37:31 -08001288func (c *Module) Symlinks() []string {
1289 if p, ok := c.installer.(interface {
1290 symlinkList() []string
1291 }); ok {
1292 return p.symlinkList()
1293 }
1294 return nil
1295}
1296
Roland Levillainf89cd092019-07-29 16:22:59 +01001297func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1298 test, ok := c.linker.(testPerSrc)
1299 return ok && test.isAllTestsVariation()
1300}
1301
Chris Parsons216e10a2020-07-09 17:12:52 -04001302func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001303 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001304 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001305 }); ok {
1306 return p.dataPaths()
1307 }
1308 return nil
1309}
1310
Justin Yun5f7f7e82019-11-18 19:52:14 +09001311func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1312 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1313 // "current", it will append the VNDK version to the name suffix.
1314 var vndkVersion string
1315 var nameSuffix string
1316 if c.inProduct() {
1317 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
1318 nameSuffix = productSuffix
1319 } else {
1320 vndkVersion = ctx.DeviceConfig().VndkVersion()
1321 nameSuffix = vendorSuffix
1322 }
1323 if vndkVersion == "current" {
1324 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1325 }
1326 if c.Properties.VndkVersion != vndkVersion {
1327 // add version suffix only if the module is using different vndk version than the
1328 // version in product or vendor partition.
1329 nameSuffix += "." + c.Properties.VndkVersion
1330 }
1331 return nameSuffix
1332}
1333
Colin Cross635c3b02016-05-18 15:37:25 -07001334func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Roland Levillainf2fad972019-06-28 15:41:19 +01001335 // Handle the case of a test module split by `test_per_src` mutator.
Roland Levillainf89cd092019-07-29 16:22:59 +01001336 //
1337 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1338 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1339 // module and return early, as this module does not produce an output file per se.
1340 if c.IsTestPerSrcAllTestsVariation() {
1341 c.outputFile = android.OptionalPath{}
1342 return
Roland Levillainf2fad972019-06-28 15:41:19 +01001343 }
1344
Colin Cross56a83212020-09-15 18:30:11 -07001345 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1346 if !apexInfo.IsForPlatform() {
1347 c.hideApexVariantFromMake = true
1348 }
1349
Jooyung Han38002912019-05-16 04:01:54 +09001350 c.makeLinkType = c.getMakeLinkType(actx)
Inseob Kim9516ee92019-05-09 10:56:13 +09001351
Inseob Kim64c43952019-08-26 16:52:35 +09001352 c.Properties.SubName = ""
1353
1354 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1355 c.Properties.SubName += nativeBridgeSuffix
1356 }
1357
Justin Yun5f7f7e82019-11-18 19:52:14 +09001358 _, llndk := c.linker.(*llndkStubDecorator)
1359 _, llndkHeader := c.linker.(*llndkHeadersDecorator)
1360 if llndk || llndkHeader || (c.UseVndk() && c.HasVendorVariant()) {
1361 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1362 // added for product variant only when we have vendor and product variants with core
1363 // variant. The suffix is not added for vendor-only or product-only module.
1364 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
1365 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001366 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1367 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
1368 c.Properties.SubName += vendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001369 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
1370 c.Properties.SubName += ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001371 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
1372 c.Properties.SubName += vendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001373 } else if c.InRecovery() && !c.OnlyInRecovery() {
Inseob Kim64c43952019-08-26 16:52:35 +09001374 c.Properties.SubName += recoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001375 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001376 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001377 if c.SplitPerApiLevel() {
1378 c.Properties.SubName += "." + c.SdkVersion()
1379 }
Inseob Kim64c43952019-08-26 16:52:35 +09001380 }
1381
Colin Crossca860ac2016-01-04 14:34:37 -08001382 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001383 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001384 moduleContextImpl: moduleContextImpl{
1385 mod: c,
1386 },
1387 }
1388 ctx.ctx = ctx
1389
Colin Crossf18e1102017-11-16 14:33:08 -08001390 deps := c.depsToPaths(ctx)
1391 if ctx.Failed() {
1392 return
1393 }
1394
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001395 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1396 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1397 }
1398
Colin Crossca860ac2016-01-04 14:34:37 -08001399 flags := Flags{
1400 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001401 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001402 }
Colin Crossca860ac2016-01-04 14:34:37 -08001403 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001404 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001405 }
1406 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001407 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001408 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001409 if c.stl != nil {
1410 flags = c.stl.flags(ctx, flags)
1411 }
Colin Cross16b23492016-01-06 14:41:07 -08001412 if c.sanitize != nil {
1413 flags = c.sanitize.flags(ctx, flags)
1414 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001415 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001416 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001417 }
Stephen Craneba090d12017-05-09 15:44:35 -07001418 if c.lto != nil {
1419 flags = c.lto.flags(ctx, flags)
1420 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001421 if c.pgo != nil {
1422 flags = c.pgo.flags(ctx, flags)
1423 }
Colin Crossca860ac2016-01-04 14:34:37 -08001424 for _, feature := range c.features {
1425 flags = feature.flags(ctx, flags)
1426 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001427 if ctx.Failed() {
1428 return
1429 }
1430
Colin Cross4af21ed2019-11-04 09:37:55 -08001431 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1432 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1433 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001434
Colin Cross4af21ed2019-11-04 09:37:55 -08001435 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001436
1437 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001438 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001439 }
1440 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001441 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001442 }
1443
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001444 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001445 // We need access to all the flags seen by a source file.
1446 if c.sabi != nil {
1447 flags = c.sabi.flags(ctx, flags)
1448 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001449
Colin Cross4af21ed2019-11-04 09:37:55 -08001450 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001451
Colin Crossca860ac2016-01-04 14:34:37 -08001452 // Optimization to reduce size of build.ninja
1453 // Replace the long list of flags for each file with a module-local variable
Colin Cross4af21ed2019-11-04 09:37:55 -08001454 ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))
1455 ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))
1456 ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))
1457 flags.Local.CFlags = []string{"$cflags"}
1458 flags.Local.CppFlags = []string{"$cppflags"}
1459 flags.Local.AsFlags = []string{"$asflags"}
Colin Crossca860ac2016-01-04 14:34:37 -08001460
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001461 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001462 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001463 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001464 if ctx.Failed() {
1465 return
1466 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001467 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001468 }
1469
Colin Crossca860ac2016-01-04 14:34:37 -08001470 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001471 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001472 if ctx.Failed() {
1473 return
1474 }
Colin Cross635c3b02016-05-18 15:37:25 -07001475 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001476
1477 // If a lib is directly included in any of the APEXes, unhide the stubs
1478 // variant having the latest version gets visible to make. In addition,
1479 // the non-stubs variant is renamed to <libname>.bootstrap. This is to
1480 // force anything in the make world to link against the stubs library.
1481 // (unless it is explicitly referenced via .bootstrap suffix or the
1482 // module is marked with 'bootstrap: true').
Colin Cross56a83212020-09-15 18:30:11 -07001483 if c.HasStubsVariants() && c.AnyVariantDirectlyInAnyApex() && !c.InRamdisk() &&
Ivan Lozano52767be2019-10-18 14:49:46 -07001484 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001485 c.IsStubs() && !c.InVendorRamdisk() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001486 c.Properties.HideFromMake = false // unhide
1487 // Note: this is still non-installable
1488 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001489
1490 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current.
1491 if i, ok := c.linker.(snapshotLibraryInterface); ok && ctx.DeviceConfig().VndkVersion() == "current" {
Colin Cross56a83212020-09-15 18:30:11 -07001492 if isSnapshotAware(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001493 i.collectHeadersForSnapshot(ctx)
1494 }
1495 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001496 }
Colin Cross5049f022015-03-18 13:28:46 -07001497
Colin Cross56a83212020-09-15 18:30:11 -07001498 if c.installable(apexInfo) {
Colin Crossce75d2c2016-10-06 16:12:58 -07001499 c.installer.install(ctx, c.outputFile.Path())
1500 if ctx.Failed() {
1501 return
Colin Crossca860ac2016-01-04 14:34:37 -08001502 }
Paul Duffin0cb37b92020-03-04 14:52:46 +00001503 } else if !proptools.BoolDefault(c.Properties.Installable, true) {
1504 // If the module has been specifically configure to not be installed then
1505 // skip the installation as otherwise it will break when running inside make
1506 // as the output path to install will not be specified. Not all uninstallable
1507 // modules can skip installation as some are needed for resolving make side
1508 // dependencies.
1509 c.SkipInstall()
Dan Albertc403f7c2015-03-18 14:01:18 -07001510 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001511}
1512
Colin Cross0ea8ba82019-06-06 14:33:29 -07001513func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001514 if c.cachedToolchain == nil {
Colin Crossb98c8b02016-07-29 13:44:28 -07001515 c.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
Colin Cross3f40fa42015-01-30 17:27:36 -08001516 }
Colin Crossca860ac2016-01-04 14:34:37 -08001517 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001518}
1519
Colin Crossca860ac2016-01-04 14:34:37 -08001520func (c *Module) begin(ctx BaseModuleContext) {
1521 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001522 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001523 }
Colin Crossca860ac2016-01-04 14:34:37 -08001524 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001525 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001526 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001527 if c.stl != nil {
1528 c.stl.begin(ctx)
1529 }
Colin Cross16b23492016-01-06 14:41:07 -08001530 if c.sanitize != nil {
1531 c.sanitize.begin(ctx)
1532 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001533 if c.coverage != nil {
1534 c.coverage.begin(ctx)
1535 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001536 if c.sabi != nil {
1537 c.sabi.begin(ctx)
1538 }
Justin Yun8effde42017-06-23 19:24:43 +09001539 if c.vndkdep != nil {
1540 c.vndkdep.begin(ctx)
1541 }
Stephen Craneba090d12017-05-09 15:44:35 -07001542 if c.lto != nil {
1543 c.lto.begin(ctx)
1544 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001545 if c.pgo != nil {
1546 c.pgo.begin(ctx)
1547 }
Colin Crossca860ac2016-01-04 14:34:37 -08001548 for _, feature := range c.features {
1549 feature.begin(ctx)
1550 }
Dan Albert92fe7402020-07-15 13:33:30 -07001551 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001552 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001553 if err != nil {
1554 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001555 c.Properties.Sdk_version = nil
1556 } else {
1557 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001558 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001559 }
Colin Crossca860ac2016-01-04 14:34:37 -08001560}
1561
Colin Cross37047f12016-12-13 17:06:13 -08001562func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001563 deps := Deps{}
1564
1565 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001566 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001567 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001568 // Add the PGO dependency (the clang_rt.profile runtime library), which
1569 // sometimes depends on symbols from libgcc, before libgcc gets added
1570 // in linkerDeps().
Pirama Arumuga Nainar49b53d52017-10-04 16:47:29 -07001571 if c.pgo != nil {
1572 deps = c.pgo.deps(ctx, deps)
1573 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001574 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001575 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001576 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001577 if c.stl != nil {
1578 deps = c.stl.deps(ctx, deps)
1579 }
Colin Cross16b23492016-01-06 14:41:07 -08001580 if c.sanitize != nil {
1581 deps = c.sanitize.deps(ctx, deps)
1582 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001583 if c.coverage != nil {
1584 deps = c.coverage.deps(ctx, deps)
1585 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001586 if c.sabi != nil {
1587 deps = c.sabi.deps(ctx, deps)
1588 }
Justin Yun8effde42017-06-23 19:24:43 +09001589 if c.vndkdep != nil {
1590 deps = c.vndkdep.deps(ctx, deps)
1591 }
Stephen Craneba090d12017-05-09 15:44:35 -07001592 if c.lto != nil {
1593 deps = c.lto.deps(ctx, deps)
1594 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001595 for _, feature := range c.features {
1596 deps = feature.deps(ctx, deps)
1597 }
1598
Colin Crossb6715442017-10-24 11:13:31 -07001599 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1600 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1601 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1602 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1603 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1604 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001605 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001606
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001607 for _, lib := range deps.ReexportSharedLibHeaders {
1608 if !inList(lib, deps.SharedLibs) {
1609 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1610 }
1611 }
1612
1613 for _, lib := range deps.ReexportStaticLibHeaders {
1614 if !inList(lib, deps.StaticLibs) {
1615 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs: '%s'", lib)
1616 }
1617 }
1618
Colin Cross5950f382016-12-13 12:50:57 -08001619 for _, lib := range deps.ReexportHeaderLibHeaders {
1620 if !inList(lib, deps.HeaderLibs) {
1621 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1622 }
1623 }
1624
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001625 for _, gen := range deps.ReexportGeneratedHeaders {
1626 if !inList(gen, deps.GeneratedHeaders) {
1627 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1628 }
1629 }
1630
Colin Crossc99deeb2016-04-11 15:06:20 -07001631 return deps
1632}
1633
Dan Albert7e9d2952016-08-04 13:02:36 -07001634func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001635 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001636 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001637 moduleContextImpl: moduleContextImpl{
1638 mod: c,
1639 },
1640 }
1641 ctx.ctx = ctx
1642
Colin Crossca860ac2016-01-04 14:34:37 -08001643 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001644}
1645
Jiyong Park7ed9de32018-10-15 22:25:07 +09001646// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09001647func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001648 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1649 version := name[sharp+1:]
1650 libname := name[:sharp]
1651 return libname, version
1652 }
1653 return name, ""
1654}
1655
Dan Albert92fe7402020-07-15 13:33:30 -07001656func GetCrtVariations(ctx android.BottomUpMutatorContext,
1657 m LinkableInterface) []blueprint.Variation {
1658 if ctx.Os() != android.Android {
1659 return nil
1660 }
1661 if m.UseSdk() {
1662 return []blueprint.Variation{
1663 {Mutator: "sdk", Variation: "sdk"},
Colin Crossbbc941b2020-09-30 12:27:01 -07001664 {Mutator: "version", Variation: m.SdkVersion()},
Dan Albert92fe7402020-07-15 13:33:30 -07001665 }
1666 }
1667 return []blueprint.Variation{
1668 {Mutator: "sdk", Variation: ""},
1669 }
1670}
1671
Colin Crosse7257d22020-09-24 09:56:18 -07001672func (c *Module) addSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext,
1673 variations []blueprint.Variation, depTag libraryDependencyTag, name, version string, far bool) {
1674
1675 variations = append([]blueprint.Variation(nil), variations...)
1676
Colin Cross3146c5c2020-09-30 15:34:40 -07001677 if version != "" && CanBeOrLinkAgainstVersionVariants(c) {
Colin Crosse7257d22020-09-24 09:56:18 -07001678 // Version is explicitly specified. i.e. libFoo#30
1679 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
1680 depTag.explicitlyVersioned = true
1681 }
Colin Crosse7257d22020-09-24 09:56:18 -07001682
Colin Cross0de8a1e2020-09-18 14:15:30 -07001683 if far {
1684 ctx.AddFarVariationDependencies(variations, depTag, name)
1685 } else {
1686 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07001687 }
1688}
1689
Colin Cross1e676be2016-10-12 14:38:15 -07001690func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09001691 if !c.Enabled() {
1692 return
1693 }
1694
Colin Cross37047f12016-12-13 17:06:13 -08001695 ctx := &depsContext{
1696 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07001697 moduleContextImpl: moduleContextImpl{
1698 mod: c,
1699 },
1700 }
1701 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08001702
Colin Crossc99deeb2016-04-11 15:06:20 -07001703 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001704
Yo Chiang219968c2020-09-22 18:45:04 +08001705 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
1706
Dan Albert914449f2016-06-17 16:45:24 -07001707 variantNdkLibs := []string{}
1708 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07001709 if ctx.Os() == android.Android {
Inseob Kimeec88e12020-01-22 11:11:29 +09001710 // rewriteLibs takes a list of names of shared libraries and scans it for three types
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001711 // of names:
Dan Albert914449f2016-06-17 16:45:24 -07001712 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001713 // 1. Name of an NDK library that refers to a prebuilt module.
1714 // For each of these, it adds the name of the prebuilt module (which will be in
1715 // prebuilts/ndk) to the list of nonvariant libs.
1716 // 2. Name of an NDK library that refers to an ndk_library module.
1717 // For each of these, it adds the name of the ndk_library module to the list of
1718 // variant libs.
1719 // 3. Anything else (so anything that isn't an NDK library).
1720 // It adds these to the nonvariantLibs list.
Dan Albert914449f2016-06-17 16:45:24 -07001721 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001722 // The caller can then know to add the variantLibs dependencies differently from the
1723 // nonvariantLibs
Inseob Kim9516ee92019-05-09 10:56:13 +09001724
Inseob Kim9516ee92019-05-09 10:56:13 +09001725 vendorPublicLibraries := vendorPublicLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001726 vendorSnapshotSharedLibs := vendorSnapshotSharedLibs(actx.Config())
1727
1728 rewriteVendorLibs := func(lib string) string {
1729 if isLlndkLibrary(lib, ctx.Config()) {
1730 return lib + llndkLibrarySuffix
1731 }
1732
1733 // only modules with BOARD_VNDK_VERSION uses snapshot.
1734 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1735 return lib
1736 }
1737
1738 if snapshot, ok := vendorSnapshotSharedLibs.get(lib, actx.Arch().ArchType); ok {
1739 return snapshot
1740 }
1741
1742 return lib
1743 }
1744
1745 rewriteLibs := func(list []string) (nonvariantLibs []string, variantLibs []string) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001746 variantLibs = []string{}
1747 nonvariantLibs = []string{}
Dan Albert914449f2016-06-17 16:45:24 -07001748 for _, entry := range list {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001749 // strip #version suffix out
Jiyong Park73c54ee2019-10-22 20:31:18 +09001750 name, _ := StubsLibNameAndVersion(entry)
Dan Albertde5aade2020-06-30 12:32:51 -07001751 if ctx.useSdk() && inList(name, ndkKnownLibs) {
1752 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Inseob Kimeec88e12020-01-22 11:11:29 +09001753 } else if ctx.useVndk() {
1754 nonvariantLibs = append(nonvariantLibs, rewriteVendorLibs(entry))
Inseob Kim9516ee92019-05-09 10:56:13 +09001755 } else if (ctx.Platform() || ctx.ProductSpecific()) && inList(name, *vendorPublicLibraries) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001756 vendorPublicLib := name + vendorPublicLibrarySuffix
Jiyong Park374510b2018-03-19 18:23:01 +09001757 if actx.OtherModuleExists(vendorPublicLib) {
1758 nonvariantLibs = append(nonvariantLibs, vendorPublicLib)
1759 } else {
1760 // This can happen if vendor_public_library module is defined in a
1761 // namespace that isn't visible to the current module. In that case,
1762 // link to the original library.
Jiyong Park7ed9de32018-10-15 22:25:07 +09001763 nonvariantLibs = append(nonvariantLibs, name)
Jiyong Park374510b2018-03-19 18:23:01 +09001764 }
Dan Albert914449f2016-06-17 16:45:24 -07001765 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001766 // put name#version back
Dan Willemsen7cbf5f82017-03-28 00:08:30 -07001767 nonvariantLibs = append(nonvariantLibs, entry)
Dan Willemsen72d39932016-07-08 23:23:48 -07001768 }
1769 }
Dan Albert914449f2016-06-17 16:45:24 -07001770 return nonvariantLibs, variantLibs
Dan Willemsen72d39932016-07-08 23:23:48 -07001771 }
1772
Inseob Kimeec88e12020-01-22 11:11:29 +09001773 deps.SharedLibs, variantNdkLibs = rewriteLibs(deps.SharedLibs)
1774 deps.LateSharedLibs, variantLateNdkLibs = rewriteLibs(deps.LateSharedLibs)
1775 deps.ReexportSharedLibHeaders, _ = rewriteLibs(deps.ReexportSharedLibHeaders)
1776 if ctx.useVndk() {
1777 for idx, lib := range deps.RuntimeLibs {
1778 deps.RuntimeLibs[idx] = rewriteVendorLibs(lib)
1779 }
1780 }
Dan Willemsen72d39932016-07-08 23:23:48 -07001781 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001782
Jiyong Park7e636d02019-01-28 16:16:54 +09001783 buildStubs := false
Colin Crossc88c2722020-09-28 17:32:47 -07001784 if versioned, ok := c.linker.(versionedInterface); ok {
1785 if versioned.buildStubs() {
1786 buildStubs = true
Colin Crossd48fe732020-09-23 20:37:24 -07001787 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001788 }
1789
Inseob Kimeec88e12020-01-22 11:11:29 +09001790 rewriteSnapshotLibs := func(lib string, snapshotMap *snapshotMap) string {
1791 // only modules with BOARD_VNDK_VERSION uses snapshot.
1792 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1793 return lib
1794 }
1795
1796 if snapshot, ok := snapshotMap.get(lib, actx.Arch().ArchType); ok {
1797 return snapshot
1798 }
1799
1800 return lib
1801 }
1802
1803 vendorSnapshotHeaderLibs := vendorSnapshotHeaderLibs(actx.Config())
Colin Cross32ec36c2016-12-15 07:39:51 -08001804 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001805 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08001806 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001807 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08001808 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001809
1810 lib = rewriteSnapshotLibs(lib, vendorSnapshotHeaderLibs)
1811
Jiyong Park7e636d02019-01-28 16:16:54 +09001812 if buildStubs {
Colin Cross7228ecd2019-11-18 16:00:16 -08001813 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001814 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09001815 } else {
1816 actx.AddVariationDependencies(nil, depTag, lib)
1817 }
1818 }
1819
1820 if buildStubs {
1821 // Stubs lib does not have dependency to other static/shared libraries.
1822 // Don't proceed.
1823 return
Colin Cross32ec36c2016-12-15 07:39:51 -08001824 }
Colin Cross5950f382016-12-13 12:50:57 -08001825
Inseob Kimc0907f12019-02-08 21:00:45 +09001826 syspropImplLibraries := syspropImplLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001827 vendorSnapshotStaticLibs := vendorSnapshotStaticLibs(actx.Config())
Inseob Kimc0907f12019-02-08 21:00:45 +09001828
Jiyong Park5d1598f2019-02-25 22:14:17 +09001829 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001830 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09001831 if impl, ok := syspropImplLibraries[lib]; ok {
1832 lib = impl
1833 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001834
1835 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1836
Jiyong Park5d1598f2019-02-25 22:14:17 +09001837 actx.AddVariationDependencies([]blueprint.Variation{
1838 {Mutator: "link", Variation: "static"},
1839 }, depTag, lib)
1840 }
1841
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001842 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001843 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001844 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001845 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001846 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001847
1848 if impl, ok := syspropImplLibraries[lib]; ok {
1849 lib = impl
1850 }
1851
Inseob Kimeec88e12020-01-22 11:11:29 +09001852 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1853
Dan Willemsen59339a22018-07-22 21:18:45 -07001854 actx.AddVariationDependencies([]blueprint.Variation{
1855 {Mutator: "link", Variation: "static"},
1856 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001857 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001858
Jooyung Han75568392020-03-20 04:29:24 +09001859 // staticUnwinderDep is treated as staticDep for Q apexes
1860 // so that native libraries/binaries are linked with static unwinder
1861 // because Q libc doesn't have unwinder APIs
1862 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07001863 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08001864 actx.AddVariationDependencies([]blueprint.Variation{
1865 {Mutator: "link", Variation: "static"},
Colin Cross6e511a92020-07-27 21:26:48 -07001866 }, depTag, rewriteSnapshotLibs(staticUnwinder(actx), vendorSnapshotStaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08001867 }
1868
Inseob Kimeec88e12020-01-22 11:11:29 +09001869 for _, lib := range deps.LateStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001870 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
Inseob Kimeec88e12020-01-22 11:11:29 +09001871 actx.AddVariationDependencies([]blueprint.Variation{
1872 {Mutator: "link", Variation: "static"},
Colin Cross6e511a92020-07-27 21:26:48 -07001873 }, depTag, rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs))
Inseob Kimeec88e12020-01-22 11:11:29 +09001874 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001875
Jiyong Park7ed9de32018-10-15 22:25:07 +09001876 // shared lib names without the #version suffix
1877 var sharedLibNames []string
1878
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001879 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001880 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001881 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001882 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001883 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001884
1885 if impl, ok := syspropImplLibraries[lib]; ok {
1886 lib = impl
1887 }
1888
Jiyong Park73c54ee2019-10-22 20:31:18 +09001889 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09001890 sharedLibNames = append(sharedLibNames, name)
1891
Colin Crosse7257d22020-09-24 09:56:18 -07001892 variations := []blueprint.Variation{
1893 {Mutator: "link", Variation: "shared"},
1894 }
1895 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001896 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001897
Jiyong Park7ed9de32018-10-15 22:25:07 +09001898 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001899 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001900 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
1901 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
1902 // linking against both the stubs lib and the non-stubs lib at the same time.
1903 continue
1904 }
Colin Cross6e511a92020-07-27 21:26:48 -07001905 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07001906 variations := []blueprint.Variation{
1907 {Mutator: "link", Variation: "shared"},
1908 }
1909 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09001910 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001911
Dan Willemsen59339a22018-07-22 21:18:45 -07001912 actx.AddVariationDependencies([]blueprint.Variation{
1913 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04001914 }, dataLibDepTag, deps.DataLibs...)
1915
1916 actx.AddVariationDependencies([]blueprint.Variation{
1917 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07001918 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08001919
Colin Cross68861832016-07-08 10:41:41 -07001920 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001921
1922 for _, gen := range deps.GeneratedHeaders {
1923 depTag := genHeaderDepTag
1924 if inList(gen, deps.ReexportGeneratedHeaders) {
1925 depTag = genHeaderExportDepTag
1926 }
1927 actx.AddDependency(c, depTag, gen)
1928 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07001929
Inseob Kim1042d292020-06-01 23:23:05 +09001930 vendorSnapshotObjects := vendorSnapshotObjects(actx.Config())
1931
Dan Albert92fe7402020-07-15 13:33:30 -07001932 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07001933 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07001934 if deps.CrtBegin != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001935 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
1936 rewriteSnapshotLibs(deps.CrtBegin, vendorSnapshotObjects))
Colin Crossca860ac2016-01-04 14:34:37 -08001937 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001938 if deps.CrtEnd != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07001939 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
1940 rewriteSnapshotLibs(deps.CrtEnd, vendorSnapshotObjects))
Colin Cross21b9a242015-03-24 14:15:58 -07001941 }
Dan Willemsena0790e32018-10-12 00:24:23 -07001942 if deps.LinkerFlagsFile != "" {
1943 actx.AddDependency(c, linkerFlagsDepTag, deps.LinkerFlagsFile)
1944 }
1945 if deps.DynamicLinker != "" {
1946 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07001947 }
Dan Albert914449f2016-06-17 16:45:24 -07001948
1949 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07001950
1951 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07001952 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07001953 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07001954 {Mutator: "link", Variation: "shared"},
1955 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07001956
1957 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07001958 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07001959 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07001960 {Mutator: "link", Variation: "shared"},
1961 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08001962
1963 if vndkdep := c.vndkdep; vndkdep != nil {
1964 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08001965 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08001966 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07001967 {Mutator: "link", Variation: "shared"},
1968 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08001969 }
1970 }
Colin Cross6362e272015-10-29 15:25:03 -07001971}
Colin Cross21b9a242015-03-24 14:15:58 -07001972
Colin Crosse40b4ea2018-10-02 22:25:58 -07001973func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07001974 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
1975 c.beginMutator(ctx)
1976 }
1977}
1978
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001979// Whether a module can link to another module, taking into
1980// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09001981func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07001982 tag blueprint.DependencyTag) {
1983
1984 switch t := tag.(type) {
1985 case dependencyTag:
1986 if t != vndkExtDepTag {
1987 return
1988 }
1989 case libraryDependencyTag:
1990 default:
1991 return
1992 }
1993
Ivan Lozano52767be2019-10-18 14:49:46 -07001994 if from.Module().Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001995 // Host code is not restricted
1996 return
1997 }
Ivan Lozano52767be2019-10-18 14:49:46 -07001998
1999 // VNDK is cc.Module supported only for now.
2000 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002001 // Though vendor code is limited by the vendor mutator,
2002 // each vendor-available module needs to check
2003 // link-type for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002004 if ccTo, ok := to.(*Module); ok {
2005 if ccFrom.vndkdep != nil {
2006 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2007 }
2008 } else {
2009 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002010 }
2011 return
2012 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002013 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002014 // Platform code can link to anything
2015 return
2016 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002017 if from.InRamdisk() {
2018 // Ramdisk code is not NDK
2019 return
2020 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002021 if from.InVendorRamdisk() {
2022 // Vendor ramdisk code is not NDK
2023 return
2024 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002025 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002026 // Recovery code is not NDK
2027 return
2028 }
Colin Cross31076b32020-10-23 17:22:06 -07002029 if c, ok := to.(*Module); ok {
2030 if c.ToolchainLibrary() {
2031 // These are always allowed
2032 return
2033 }
2034 if c.NdkPrebuiltStl() {
2035 // These are allowed, but they don't set sdk_version
2036 return
2037 }
2038 if c.StubDecorator() {
2039 // These aren't real libraries, but are the stub shared libraries that are included in
2040 // the NDK.
2041 return
2042 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002043 }
Logan Chien834b9a62019-01-14 15:39:03 +08002044
Ivan Lozano52767be2019-10-18 14:49:46 -07002045 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002046 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2047 // to link to libc++ (non-NDK and without sdk_version).
2048 return
2049 }
2050
Ivan Lozano52767be2019-10-18 14:49:46 -07002051 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002052 // NDK code linking to platform code is never okay.
2053 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002054 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002055 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002056 }
2057
2058 // At this point we know we have two NDK libraries, but we need to
2059 // check that we're not linking against anything built against a higher
2060 // API level, as it is only valid to link against older or equivalent
2061 // APIs.
2062
Inseob Kim01a28722018-04-11 09:48:45 +09002063 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002064 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002065 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002066 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002067 // Current can't be linked against by anything else.
2068 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002069 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002070 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002071 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002072 if err != nil {
2073 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002074 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002075 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002076 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002077 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002078 if err != nil {
2079 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002080 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002081 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002082 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002083
Inseob Kim01a28722018-04-11 09:48:45 +09002084 if toApi > fromApi {
2085 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002086 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002087 }
2088 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002089 }
Dan Albert202fe492017-12-15 13:56:59 -08002090
2091 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002092 fromStl := from.SelectedStl()
2093 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002094 if fromStl == "" || toStl == "" {
2095 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002096 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002097 // We can be permissive with the system "STL" since it is only the C++
2098 // ABI layer, but in the future we should make sure that everyone is
2099 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002100 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002101 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002102 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2103 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002104 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002105}
2106
Jooyung Han479ca172020-10-19 18:51:07 +09002107func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2108 if c, ok := ctx.Module().(*Module); ok {
2109 ctx.VisitDirectDeps(func(dep android.Module) {
2110 depTag := ctx.OtherModuleDependencyTag(dep)
2111 ccDep, ok := dep.(LinkableInterface)
2112 if ok {
2113 checkLinkType(ctx, c, ccDep, depTag)
2114 }
2115 })
2116 }
2117}
2118
Jiyong Park5fb8c102018-04-09 12:03:06 +09002119// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002120// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2121// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002122// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002123func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2124 check := func(child, parent android.Module) bool {
2125 to, ok := child.(*Module)
2126 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002127 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002128 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002129
Jooyung Hana70f0672019-01-18 15:20:43 +09002130 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2131 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002132 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002133
Jooyung Han479ca172020-10-19 18:51:07 +09002134 // Even if target lib has no vendor variant, keep checking dependency graph
2135 // in case it depends on vendor_available but not double_loadable transtively.
Ivan Lozano52767be2019-10-18 14:49:46 -07002136 if !to.HasVendorVariant() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002137 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002138 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002139
Jooyung Han0302a842019-10-30 18:43:49 +09002140 if to.isVndkSp() || to.isLlndk(ctx.Config()) || Bool(to.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002141 return false
2142 }
2143
2144 var stringPath []string
2145 for _, m := range ctx.GetWalkPath() {
2146 stringPath = append(stringPath, m.Name())
2147 }
2148 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2149 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
2150 "(dependency: %s)", ctx.OtherModuleName(to), strings.Join(stringPath, " -> "))
2151 return false
2152 }
2153 if module, ok := ctx.Module().(*Module); ok {
2154 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jooyung Han0302a842019-10-30 18:43:49 +09002155 if module.isLlndk(ctx.Config()) || Bool(module.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002156 ctx.WalkDeps(check)
2157 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002158 }
2159 }
2160}
2161
Colin Cross0de8a1e2020-09-18 14:15:30 -07002162// Returns the highest version which is <= maxSdkVersion.
2163// For example, with maxSdkVersion is 10 and versionList is [9,11]
2164// it returns 9 as string. The list of stubs must be in order from
2165// oldest to newest.
2166func (c *Module) chooseSdkVersion(ctx android.PathContext, stubsInfo []SharedLibraryStubsInfo,
2167 maxSdkVersion android.ApiLevel) (SharedLibraryStubsInfo, error) {
2168
2169 for i := range stubsInfo {
2170 stubInfo := stubsInfo[len(stubsInfo)-i-1]
2171 var ver android.ApiLevel
2172 if stubInfo.Version == "" {
2173 ver = android.FutureApiLevel
2174 } else {
2175 var err error
2176 ver, err = android.ApiLevelFromUser(ctx, stubInfo.Version)
2177 if err != nil {
2178 return SharedLibraryStubsInfo{}, err
2179 }
2180 }
2181 if ver.LessThanOrEqualTo(maxSdkVersion) {
2182 return stubInfo, nil
2183 }
2184 }
2185 var versionList []string
2186 for _, stubInfo := range stubsInfo {
2187 versionList = append(versionList, stubInfo.Version)
2188 }
2189 return SharedLibraryStubsInfo{}, fmt.Errorf("not found a version(<=%s) in versionList: %v", maxSdkVersion.String(), versionList)
2190}
2191
Colin Crossc99deeb2016-04-11 15:06:20 -07002192// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002193func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002194 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002195
Colin Cross0de8a1e2020-09-18 14:15:30 -07002196 var directStaticDeps []StaticLibraryInfo
2197 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002198
Colin Cross0de8a1e2020-09-18 14:15:30 -07002199 reexportExporter := func(exporter FlagExporterInfo) {
2200 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2201 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2202 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2203 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2204 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002205 }
2206
Jooyung Hande34d232020-07-23 13:04:15 +09002207 // For the dependency from platform to apex, use the latest stubs
2208 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002209 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2210 if !apexInfo.IsForPlatform() {
2211 c.apexSdkVersion = apexInfo.MinSdkVersion(ctx)
Jooyung Hande34d232020-07-23 13:04:15 +09002212 }
2213
2214 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2215 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2216 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2217 // (b/144430859)
2218 c.apexSdkVersion = android.FutureApiLevel
2219 }
2220
Colin Crossd11fcda2017-10-23 17:59:01 -07002221 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002222 depName := ctx.OtherModuleName(dep)
2223 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002224
Ivan Lozano52767be2019-10-18 14:49:46 -07002225 ccDep, ok := dep.(LinkableInterface)
2226 if !ok {
2227
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002228 // handling for a few module types that aren't cc Module but that are also supported
2229 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002230 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002231 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002232 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2233 genRule.GeneratedSourceFiles()...)
2234 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002235 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002236 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002237 // Support exported headers from a generated_sources dependency
2238 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002239 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002240 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002241 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002242 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002243 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002244 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002245 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002246 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002247 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2248 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002249 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002250 // 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 +09002251 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002252
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002253 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002254 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002255 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002256 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002257 case linkerFlagsDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002258 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002259 files := genRule.GeneratedSourceFiles()
2260 if len(files) == 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002261 depPaths.LinkerFlagsFile = android.OptionalPathForPath(files[0])
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002262 } else if len(files) > 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002263 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 -07002264 }
2265 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002266 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002267 }
Colin Crossca860ac2016-01-04 14:34:37 -08002268 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002269 return
2270 }
2271
Colin Crossfe17f6f2019-03-28 19:30:56 -07002272 if depTag == android.ProtoPluginDepTag {
2273 return
2274 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002275 if depTag == llndkImplDep {
2276 return
2277 }
Colin Crossfe17f6f2019-03-28 19:30:56 -07002278
Colin Crossd11fcda2017-10-23 17:59:01 -07002279 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002280 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2281 return
2282 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002283 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002284 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2285 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002286 return
2287 }
2288
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002289 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002290 // Skip reused objects for stub libraries, they use their own stub object file instead.
2291 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2292 // version mutator, so the stubs variant is created from the shared variant that
2293 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002294 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002295 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2296 objs := staticAnalogue.ReuseObjects
2297 depPaths.Objs = depPaths.Objs.Append(objs)
2298 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2299 reexportExporter(depExporterInfo)
2300 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002301 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002302 }
2303
Colin Cross6e511a92020-07-27 21:26:48 -07002304 linkFile := ccDep.OutputFile()
2305
2306 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2307 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002308 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002309 return
2310 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002311
Colin Cross0de8a1e2020-09-18 14:15:30 -07002312 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002313
Colin Cross6e511a92020-07-27 21:26:48 -07002314 var ptr *android.Paths
2315 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002316
Colin Cross6e511a92020-07-27 21:26:48 -07002317 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002318
Colin Cross6e511a92020-07-27 21:26:48 -07002319 switch {
2320 case libDepTag.header():
2321 // nothing
2322 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002323 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2324 if !ctx.Config().AllowMissingDependencies() {
2325 ctx.ModuleErrorf("module %q is not a shared library", depName)
2326 } else {
2327 ctx.AddMissingDependencies([]string{depName})
2328 }
2329 return
2330 }
2331 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
2332 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryImplementationStubsInfoProvider).(SharedLibraryImplementationStubsInfo)
2333
2334 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedLibraryStubsInfos) > 0 {
2335 useStubs := false
Colin Cross31076b32020-10-23 17:22:06 -07002336
2337 if lib := moduleLibraryInterface(dep); lib.buildStubs() && c.UseVndk() { // LLNDK
Colin Cross0de8a1e2020-09-18 14:15:30 -07002338 if !apexInfo.IsForPlatform() {
2339 // For platform libraries, use current version of LLNDK
2340 // If this is for use_vendor apex we will apply the same rules
2341 // of apex sdk enforcement below to choose right version.
2342 useStubs = true
2343 }
2344 } else if apexInfo.IsForPlatform() {
2345 // If not building for APEX, use stubs only when it is from
2346 // an APEX (and not from platform)
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002347 // However, for host, ramdisk, vendor_ramdisk, recovery or bootstrap modules,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002348 // always link to non-stub variant
2349 useStubs = dep.(android.ApexModule).AnyVariantDirectlyInAnyApex() && !c.bootstrap()
2350 // Another exception: if this module is bundled with an APEX, then
2351 // it is linked with the non-stub variant of a module in the APEX
2352 // as if this is part of the APEX.
2353 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2354 for _, apexContents := range testFor.ApexContents {
2355 if apexContents.DirectlyInApex(depName) {
2356 useStubs = false
2357 break
2358 }
2359 }
2360 } else {
2361 // If building for APEX, use stubs when the parent is in any APEX that
2362 // the child is not in.
2363 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
2364 }
2365
2366 // when to use (unspecified) stubs, check min_sdk_version and choose the right one
2367 if useStubs {
2368 sharedLibraryStubsInfo, err :=
2369 c.chooseSdkVersion(ctx, sharedLibraryStubsInfo.SharedLibraryStubsInfos, c.apexSdkVersion)
2370 if err != nil {
2371 ctx.OtherModuleErrorf(dep, err.Error())
2372 return
2373 }
2374 sharedLibraryInfo = sharedLibraryStubsInfo.SharedLibraryInfo
2375 depExporterInfo = sharedLibraryStubsInfo.FlagExporterInfo
2376 }
2377 }
2378
2379 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2380 depFile = sharedLibraryInfo.TableOfContents
2381
Colin Cross6e511a92020-07-27 21:26:48 -07002382 ptr = &depPaths.SharedLibs
2383 switch libDepTag.Order {
2384 case earlyLibraryDependency:
2385 ptr = &depPaths.EarlySharedLibs
2386 depPtr = &depPaths.EarlySharedLibsDeps
2387 case normalLibraryDependency:
2388 ptr = &depPaths.SharedLibs
2389 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002390 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002391 case lateLibraryDependency:
2392 ptr = &depPaths.LateSharedLibs
2393 depPtr = &depPaths.LateSharedLibsDeps
2394 default:
2395 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002396 }
Colin Cross6e511a92020-07-27 21:26:48 -07002397 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002398 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2399 if !ctx.Config().AllowMissingDependencies() {
2400 ctx.ModuleErrorf("module %q is not a static library", depName)
2401 } else {
2402 ctx.AddMissingDependencies([]string{depName})
2403 }
2404 return
2405 }
2406 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2407 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002408 if libDepTag.wholeStatic {
2409 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002410 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2411 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002412 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002413 // This case normally catches prebuilt static
2414 // libraries, but it can also occur when
2415 // AllowMissingDependencies is on and the
2416 // dependencies has no sources of its own
2417 // but has a whole_static_libs dependency
2418 // on a missing library. We want to depend
2419 // on the .a file so that there is something
2420 // in the dependency tree that contains the
2421 // error rule for the missing transitive
2422 // dependency.
2423 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002424 }
Colin Cross6e511a92020-07-27 21:26:48 -07002425 } else {
2426 switch libDepTag.Order {
2427 case earlyLibraryDependency:
2428 panic(fmt.Errorf("early static libs not suppported"))
2429 case normalLibraryDependency:
2430 // static dependencies will be handled separately so they can be ordered
2431 // using transitive dependencies.
2432 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002433 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002434 case lateLibraryDependency:
2435 ptr = &depPaths.LateStaticLibs
2436 default:
2437 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002438 }
2439 }
2440 }
2441
Colin Cross6e511a92020-07-27 21:26:48 -07002442 if libDepTag.static() && !libDepTag.wholeStatic {
2443 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2444 ctx.ModuleErrorf("module %q not a static library", depName)
2445 return
2446 }
Logan Chien43d34c32017-12-20 01:17:32 +08002447
Colin Cross6e511a92020-07-27 21:26:48 -07002448 // When combining coverage files for shared libraries and executables, coverage files
2449 // in static libraries act as if they were whole static libraries. The same goes for
2450 // source based Abi dump files.
2451 if c, ok := ccDep.(*Module); ok {
2452 staticLib := c.linker.(libraryInterface)
2453 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2454 staticLib.objs().coverageFiles...)
2455 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2456 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002457 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002458 // Handle non-CC modules here
2459 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002460 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002461 }
2462 }
2463
Colin Cross6e511a92020-07-27 21:26:48 -07002464 if ptr != nil {
2465 if !linkFile.Valid() {
2466 if !ctx.Config().AllowMissingDependencies() {
2467 ctx.ModuleErrorf("module %q missing output file", depName)
2468 } else {
2469 ctx.AddMissingDependencies([]string{depName})
2470 }
2471 return
2472 }
2473 *ptr = append(*ptr, linkFile.Path())
2474 }
2475
2476 if depPtr != nil {
2477 dep := depFile
2478 if !dep.Valid() {
2479 dep = linkFile
2480 }
2481 *depPtr = append(*depPtr, dep.Path())
2482 }
2483
Colin Cross0de8a1e2020-09-18 14:15:30 -07002484 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2485 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2486 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2487 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2488
2489 if libDepTag.reexportFlags {
2490 reexportExporter(depExporterInfo)
2491 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2492 // Re-exported shared library headers must be included as well since they can help us with type information
2493 // about template instantiations (instantiated from their headers).
2494 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2495 // scripts.
2496 c.sabi.Properties.ReexportedIncludes = append(
2497 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2498 }
2499
Colin Cross6e511a92020-07-27 21:26:48 -07002500 makeLibName := c.makeLibName(ctx, ccDep, depName) + libDepTag.makeSuffix
2501 switch {
2502 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002503 c.Properties.AndroidMkHeaderLibs = append(
2504 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002505 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002506 if lib := moduleLibraryInterface(dep); lib != nil {
2507 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002508 // Add the dependency to the APEX(es) providing the library so that
2509 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002510 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
2511 for _, an := range depApexInfo.InApexes {
Colin Cross6e511a92020-07-27 21:26:48 -07002512 c.Properties.ApexesProvidingSharedLibs = append(
2513 c.Properties.ApexesProvidingSharedLibs, an)
2514 }
2515 }
2516 }
2517
2518 // Note: the order of libs in this list is not important because
2519 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002520 c.Properties.AndroidMkSharedLibs = append(
2521 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002522 // Record baseLibName for snapshots.
2523 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, baseLibName(depName))
2524 case libDepTag.static():
2525 if libDepTag.wholeStatic {
2526 c.Properties.AndroidMkWholeStaticLibs = append(
2527 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2528 } else {
2529 c.Properties.AndroidMkStaticLibs = append(
2530 c.Properties.AndroidMkStaticLibs, makeLibName)
2531 }
2532 }
2533 } else {
2534 switch depTag {
2535 case runtimeDepTag:
2536 c.Properties.AndroidMkRuntimeLibs = append(
2537 c.Properties.AndroidMkRuntimeLibs, c.makeLibName(ctx, ccDep, depName)+libDepTag.makeSuffix)
2538 // Record baseLibName for snapshots.
2539 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, baseLibName(depName))
2540 case objDepTag:
2541 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2542 case CrtBeginDepTag:
2543 depPaths.CrtBegin = linkFile
2544 case CrtEndDepTag:
2545 depPaths.CrtEnd = linkFile
2546 case dynamicLinkerDepTag:
2547 depPaths.DynamicLinker = linkFile
2548 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002549 }
Colin Crossca860ac2016-01-04 14:34:37 -08002550 })
2551
Jeff Gaston294356f2017-09-27 17:05:30 -07002552 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002553 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2554 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2555 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002556
Colin Crossdd84e052017-05-17 13:44:16 -07002557 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002558 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002559 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2560 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002561 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002562 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2563 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002564 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002565 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002566 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002567
2568 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002569 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002570 }
Colin Crossdd84e052017-05-17 13:44:16 -07002571
Colin Crossca860ac2016-01-04 14:34:37 -08002572 return depPaths
2573}
2574
Colin Cross0de8a1e2020-09-18 14:15:30 -07002575// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
2576// to match the topological order of the dependency tree, including any static analogues of
2577// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
2578// of the transitive dependencies.
2579func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
2580 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
2581 var staticPaths android.Paths
2582 for _, staticDep := range staticDeps {
2583 staticPaths = append(staticPaths, staticDep.StaticLibrary)
2584 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
2585 }
2586 for _, sharedDep := range sharedDeps {
2587 if sharedDep.StaticAnalogue != nil {
2588 transitiveStaticLibsBuilder.Transitive(sharedDep.StaticAnalogue.TransitiveStaticLibrariesForOrdering)
2589 }
2590 }
2591 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
2592
2593 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
2594
2595 // reorder the dependencies based on transitive dependencies
2596 staticPaths = android.FirstUniquePaths(staticPaths)
2597 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
2598
2599 if len(orderedStaticPaths) != len(staticPaths) {
2600 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
2601 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
2602 }
2603
2604 return orderedStaticPaths, transitiveStaticLibs
2605}
2606
Colin Cross6e511a92020-07-27 21:26:48 -07002607// baseLibName trims known prefixes and suffixes
2608func baseLibName(depName string) string {
2609 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
2610 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
2611 libName = strings.TrimPrefix(libName, "prebuilt_")
2612 return libName
2613}
2614
2615func (c *Module) makeLibName(ctx android.ModuleContext, ccDep LinkableInterface, depName string) string {
2616 vendorSuffixModules := vendorSuffixModules(ctx.Config())
2617 vendorPublicLibraries := vendorPublicLibraries(ctx.Config())
2618
2619 libName := baseLibName(depName)
2620 isLLndk := isLlndkLibrary(libName, ctx.Config())
2621 isVendorPublicLib := inList(libName, *vendorPublicLibraries)
2622 bothVendorAndCoreVariantsExist := ccDep.HasVendorVariant() || isLLndk
2623
2624 if c, ok := ccDep.(*Module); ok {
2625 // Use base module name for snapshots when exporting to Makefile.
2626 if c.isSnapshotPrebuilt() {
2627 baseName := c.BaseModuleName()
2628
2629 if c.IsVndk() {
2630 return baseName + ".vendor"
2631 }
2632
2633 if vendorSuffixModules[baseName] {
2634 return baseName + ".vendor"
2635 } else {
2636 return baseName
2637 }
2638 }
2639 }
2640
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002641 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
2642 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07002643 // The vendor module is a no-vendor-variant VNDK library. Depend on the
2644 // core module instead.
2645 return libName
2646 } else if c.UseVndk() && bothVendorAndCoreVariantsExist {
2647 // The vendor module in Make will have been renamed to not conflict with the core
2648 // module, so update the dependency name here accordingly.
2649 return libName + c.getNameSuffixWithVndkVersion(ctx)
2650 } else if (ctx.Platform() || ctx.ProductSpecific()) && isVendorPublicLib {
2651 return libName + vendorPublicLibrarySuffix
2652 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
2653 return libName + ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002654 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
2655 return libName + vendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002656 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
2657 return libName + recoverySuffix
2658 } else if ccDep.Module().Target().NativeBridge == android.NativeBridgeEnabled {
2659 return libName + nativeBridgeSuffix
2660 } else {
2661 return libName
2662 }
2663}
2664
Colin Crossca860ac2016-01-04 14:34:37 -08002665func (c *Module) InstallInData() bool {
2666 if c.installer == nil {
2667 return false
2668 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002669 return c.installer.inData()
2670}
2671
2672func (c *Module) InstallInSanitizerDir() bool {
2673 if c.installer == nil {
2674 return false
2675 }
2676 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07002677 return true
2678 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002679 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08002680}
2681
Yifan Hong1b3348d2020-01-21 15:53:22 -08002682func (c *Module) InstallInRamdisk() bool {
2683 return c.InRamdisk()
2684}
2685
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002686func (c *Module) InstallInVendorRamdisk() bool {
2687 return c.InVendorRamdisk()
2688}
2689
Jiyong Parkf9332f12018-02-01 00:54:12 +09002690func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07002691 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09002692}
2693
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002694func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002695 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002696 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002697 return
2698 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002699 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002700}
2701
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07002702func (c *Module) HostToolPath() android.OptionalPath {
2703 if c.installer == nil {
2704 return android.OptionalPath{}
2705 }
2706 return c.installer.hostToolPath()
2707}
2708
Nan Zhangd4e641b2017-07-12 12:55:28 -07002709func (c *Module) IntermPathForModuleOut() android.OptionalPath {
2710 return c.outputFile
2711}
2712
Colin Cross41955e82019-05-29 14:40:35 -07002713func (c *Module) OutputFiles(tag string) (android.Paths, error) {
2714 switch tag {
2715 case "":
2716 if c.outputFile.Valid() {
2717 return android.Paths{c.outputFile.Path()}, nil
2718 }
2719 return android.Paths{}, nil
2720 default:
2721 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002722 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002723}
2724
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00002725func (c *Module) static() bool {
2726 if static, ok := c.linker.(interface {
2727 static() bool
2728 }); ok {
2729 return static.static()
2730 }
2731 return false
2732}
2733
Jiyong Park379de2f2018-12-19 02:47:14 +09002734func (c *Module) staticBinary() bool {
2735 if static, ok := c.linker.(interface {
2736 staticBinary() bool
2737 }); ok {
2738 return static.staticBinary()
2739 }
2740 return false
2741}
2742
Jiyong Park1d1119f2019-07-29 21:27:18 +09002743func (c *Module) header() bool {
2744 if h, ok := c.linker.(interface {
2745 header() bool
2746 }); ok {
2747 return h.header()
2748 }
2749 return false
2750}
2751
Inseob Kim7f283f42020-06-01 21:53:49 +09002752func (c *Module) binary() bool {
2753 if b, ok := c.linker.(interface {
2754 binary() bool
2755 }); ok {
2756 return b.binary()
2757 }
2758 return false
2759}
2760
Inseob Kim1042d292020-06-01 23:23:05 +09002761func (c *Module) object() bool {
2762 if o, ok := c.linker.(interface {
2763 object() bool
2764 }); ok {
2765 return o.object()
2766 }
2767 return false
2768}
2769
Jooyung Han38002912019-05-16 04:01:54 +09002770func (c *Module) getMakeLinkType(actx android.ModuleContext) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07002771 if c.UseVndk() {
Jooyung Han38002912019-05-16 04:01:54 +09002772 if lib, ok := c.linker.(*llndkStubDecorator); ok {
2773 if Bool(lib.Properties.Vendor_available) {
Colin Crossb60190a2018-09-04 16:28:17 -07002774 return "native:vndk"
2775 }
Jooyung Han38002912019-05-16 04:01:54 +09002776 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07002777 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002778 if c.IsVndk() && !c.isVndkExt() {
Jooyung Han38002912019-05-16 04:01:54 +09002779 if Bool(c.VendorProperties.Vendor_available) {
2780 return "native:vndk"
2781 }
2782 return "native:vndk_private"
2783 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09002784 if c.inProduct() {
2785 return "native:product"
2786 }
Jooyung Han38002912019-05-16 04:01:54 +09002787 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08002788 } else if c.InRamdisk() {
2789 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002790 } else if c.InVendorRamdisk() {
2791 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07002792 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07002793 return "native:recovery"
2794 } else if c.Target().Os == android.Android && String(c.Properties.Sdk_version) != "" {
2795 return "native:ndk:none:none"
2796 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
2797 //family, link := getNdkStlFamilyAndLinkType(c)
2798 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07002799 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08002800 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07002801 } else {
2802 return "native:platform"
2803 }
2804}
2805
Jiyong Park9d452992018-10-03 00:38:19 +09002806// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01002807// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09002808func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07002809 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09002810 // Stub libs and prebuilt libs in a versioned SDK are not
2811 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07002812 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01002813 } else if _, ok := c.linker.(testPerSrc); ok {
2814 return true
Jiyong Park9d452992018-10-03 00:38:19 +09002815 }
2816 return false
2817}
2818
Jiyong Parka90ca002019-10-07 15:47:24 +09002819func (c *Module) AvailableFor(what string) bool {
2820 if linker, ok := c.linker.(interface {
2821 availableFor(string) bool
2822 }); ok {
2823 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
2824 } else {
2825 return c.ApexModuleBase.AvailableFor(what)
2826 }
2827}
2828
Jiyong Park62304bb2020-04-13 16:19:48 +09002829func (c *Module) TestFor() []string {
2830 if test, ok := c.linker.(interface {
2831 testFor() []string
2832 }); ok {
2833 return test.testFor()
2834 } else {
2835 return c.ApexModuleBase.TestFor()
2836 }
2837}
2838
Colin Crossaede88c2020-08-11 12:17:01 -07002839func (c *Module) UniqueApexVariations() bool {
2840 if u, ok := c.compiler.(interface {
2841 uniqueApexVariations() bool
2842 }); ok {
2843 return u.uniqueApexVariations()
2844 } else {
2845 return false
2846 }
2847}
2848
Paul Duffin0cb37b92020-03-04 14:52:46 +00002849// Return true if the module is ever installable.
2850func (c *Module) EverInstallable() bool {
2851 return c.installer != nil &&
2852 // Check to see whether the module is actually ever installable.
2853 c.installer.everInstallable()
2854}
2855
Colin Cross56a83212020-09-15 18:30:11 -07002856func (c *Module) installable(apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00002857 ret := c.EverInstallable() &&
2858 // Check to see whether the module has been configured to not be installed.
2859 proptools.BoolDefault(c.Properties.Installable, true) &&
2860 !c.Properties.PreventInstall && c.outputFile.Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09002861
2862 // The platform variant doesn't need further condition. Apex variants however might not
2863 // be installable because it will likely to be included in the APEX and won't appear
2864 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07002865 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09002866 return ret
2867 }
2868
2869 // Special case for modules that are configured to be installed to /data, which includes
2870 // test modules. For these modules, both APEX and non-APEX variants are considered as
2871 // installable. This is because even the APEX variants won't be included in the APEX, but
2872 // will anyway be installed to /data/*.
2873 // See b/146995717
2874 if c.InstallInData() {
2875 return ret
2876 }
2877
2878 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09002879}
2880
Logan Chien41eabe62019-04-10 13:33:58 +08002881func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
2882 if c.linker != nil {
2883 if library, ok := c.linker.(*libraryDecorator); ok {
2884 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
2885 }
2886 }
2887}
2888
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002889func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07002890 depTag := ctx.OtherModuleDependencyTag(dep)
2891 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
2892
2893 if cc, ok := dep.(*Module); ok {
2894 if cc.HasStubsVariants() {
2895 if isLibDepTag && libDepTag.shared() {
2896 // dynamic dep to a stubs lib crosses APEX boundary
2897 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002898 }
Colin Cross6e511a92020-07-27 21:26:48 -07002899 if IsRuntimeDepTag(depTag) {
2900 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002901 return false
2902 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002903 }
Colin Crossaac32222020-07-29 12:51:56 -07002904 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07002905 // shared_lib dependency from a static lib is considered as crossing
2906 // the APEX boundary because the dependency doesn't actually is
2907 // linked; the dependency is used only during the compilation phase.
2908 return false
2909 }
2910 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002911 if depTag == stubImplDepTag || depTag == llndkImplDep {
2912 // We don't track beyond LLNDK or from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09002913 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002914 }
2915 return true
2916}
2917
Dan Albertc8060532020-07-22 22:32:17 -07002918func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
2919 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09002920 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
2921 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
2922 return nil
2923 }
2924 // b/154569636: set min_sdk_version correctly for toolchain_libraries
2925 if c.ToolchainLibrary() {
2926 return nil
2927 }
2928 // We don't check for prebuilt modules
2929 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
2930 return nil
2931 }
2932 minSdkVersion := c.MinSdkVersion()
2933 if minSdkVersion == "apex_inherit" {
2934 return nil
2935 }
2936 if minSdkVersion == "" {
2937 // JNI libs within APK-in-APEX fall into here
2938 // Those are okay to set sdk_version instead
2939 // We don't have to check if this is a SDK variant because
2940 // non-SDK variant resets sdk_version, which works too.
2941 minSdkVersion = c.SdkVersion()
2942 }
Dan Albertc8060532020-07-22 22:32:17 -07002943 if minSdkVersion == "" {
2944 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
2945 }
2946 // Not using nativeApiLevelFromUser because the context here is not
2947 // necessarily a native context.
2948 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09002949 if err != nil {
2950 return err
2951 }
Dan Albertc8060532020-07-22 22:32:17 -07002952
2953 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09002954 return fmt.Errorf("newer SDK(%v)", ver)
2955 }
2956 return nil
2957}
2958
Colin Cross2ba19d92015-05-07 15:44:20 -07002959//
Colin Crosscfad1192015-11-02 16:43:11 -08002960// Defaults
2961//
Colin Crossca860ac2016-01-04 14:34:37 -08002962type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07002963 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07002964 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09002965 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08002966}
2967
Patrice Arrudac249c712019-03-19 17:00:29 -07002968// cc_defaults provides a set of properties that can be inherited by other cc
2969// modules. A module can use the properties from a cc_defaults using
2970// `defaults: ["<:default_module_name>"]`. Properties of both modules are
2971// merged (when possible) by prepending the default module's values to the
2972// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07002973func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07002974 return DefaultsFactory()
2975}
2976
Colin Cross36242852017-06-23 15:06:31 -07002977func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08002978 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08002979
Colin Cross36242852017-06-23 15:06:31 -07002980 module.AddProperties(props...)
2981 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08002982 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002983 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002984 &BaseCompilerProperties{},
2985 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01002986 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07002987 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07002988 &StaticProperties{},
2989 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07002990 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002991 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07002992 &TestProperties{},
2993 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07002994 &BenchmarkProperties{},
Mitch Phillips4e4ab8a2019-09-13 17:32:50 -07002995 &FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002996 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08002997 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07002998 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07002999 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003000 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003001 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003002 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003003 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003004 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003005 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003006 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003007 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3008 &RustBindgenClangProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003009 )
Colin Crosscfad1192015-11-02 16:43:11 -08003010
Jooyung Hancc372c52019-09-25 15:18:44 +09003011 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003012
3013 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003014}
3015
Jiyong Park6a43f042017-10-12 23:05:00 +09003016func squashVendorSrcs(m *Module) {
3017 if lib, ok := m.compiler.(*libraryDecorator); ok {
3018 lib.baseCompiler.Properties.Srcs = append(lib.baseCompiler.Properties.Srcs,
3019 lib.baseCompiler.Properties.Target.Vendor.Srcs...)
3020
3021 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs,
3022 lib.baseCompiler.Properties.Target.Vendor.Exclude_srcs...)
Jooyung Hanac07f882020-07-05 03:54:35 +09003023
3024 lib.baseCompiler.Properties.Exclude_generated_sources = append(lib.baseCompiler.Properties.Exclude_generated_sources,
3025 lib.baseCompiler.Properties.Target.Vendor.Exclude_generated_sources...)
Jiyong Park6a43f042017-10-12 23:05:00 +09003026 }
3027}
3028
Jiyong Parkf9332f12018-02-01 00:54:12 +09003029func squashRecoverySrcs(m *Module) {
3030 if lib, ok := m.compiler.(*libraryDecorator); ok {
3031 lib.baseCompiler.Properties.Srcs = append(lib.baseCompiler.Properties.Srcs,
3032 lib.baseCompiler.Properties.Target.Recovery.Srcs...)
3033
3034 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs,
3035 lib.baseCompiler.Properties.Target.Recovery.Exclude_srcs...)
Jooyung Hanac07f882020-07-05 03:54:35 +09003036
3037 lib.baseCompiler.Properties.Exclude_generated_sources = append(lib.baseCompiler.Properties.Exclude_generated_sources,
3038 lib.baseCompiler.Properties.Target.Recovery.Exclude_generated_sources...)
Jiyong Parkf9332f12018-02-01 00:54:12 +09003039 }
3040}
3041
Yifan Hong6da33c22020-10-27 15:01:21 -07003042func squashVendorRamdiskSrcs(m *Module) {
3043 if lib, ok := m.compiler.(*libraryDecorator); ok {
3044 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs, lib.baseCompiler.Properties.Target.Vendor_ramdisk.Exclude_srcs...)
3045 }
3046}
3047
Jiyong Park2286afd2020-06-16 21:58:53 +09003048func (c *Module) IsSdkVariant() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07003049 return c.Properties.IsSdkVariant || c.AlwaysSdk()
Jiyong Park2286afd2020-06-16 21:58:53 +09003050}
3051
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003052func kytheExtractAllFactory() android.Singleton {
3053 return &kytheExtractAllSingleton{}
3054}
3055
3056type kytheExtractAllSingleton struct {
3057}
3058
3059func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3060 var xrefTargets android.Paths
3061 ctx.VisitAllModules(func(module android.Module) {
3062 if ccModule, ok := module.(xref); ok {
3063 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3064 }
3065 })
3066 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3067 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003068 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003069 }
3070}
3071
Colin Cross06a931b2015-10-28 17:23:31 -07003072var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003073var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003074var BoolPtr = proptools.BoolPtr
3075var String = proptools.String
3076var StringPtr = proptools.StringPtr