blob: 01bf5f1ef0be3b2b444812d630313cfac18d4dd8 [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 Cross01fd7cc2020-02-19 16:54:04 -080045 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()
Jooyung Hanb90e4912019-12-09 18:21:48 +090048 ctx.BottomUp("ndk_api", NdkApiMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010049 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Jiyong Park25fc6a92018-11-18 18:02:45 +090050 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
87 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070088 })
Colin Crossb98c8b02016-07-29 13:44:28 -070089
Sasha Smundak2a4549e2018-11-05 16:49:08 -080090 android.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070091}
92
Colin Crossca860ac2016-01-04 14:34:37 -080093type Deps struct {
94 SharedLibs, LateSharedLibs []string
95 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080096 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +080097 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -070098
Peter Collingbournedc4f9862020-02-12 17:13:25 -080099 StaticUnwinderIfLegacy bool
100
Colin Cross5950f382016-12-13 12:50:57 -0800101 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700102
Colin Cross81413472016-04-11 14:37:39 -0700103 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700104
Dan Willemsenb40aab62016-04-20 14:21:14 -0700105 GeneratedSources []string
106 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900107 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700108
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700109 ReexportGeneratedHeaders []string
110
Colin Cross97ba0732015-03-23 17:50:24 -0700111 CrtBegin, CrtEnd string
Dan Willemsena0790e32018-10-12 00:24:23 -0700112
113 // Used for host bionic
114 LinkerFlagsFile string
115 DynamicLinker string
Colin Crossc472d572015-03-17 15:06:21 -0700116}
117
Colin Crossca860ac2016-01-04 14:34:37 -0800118type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700119 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900120 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700121 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900122 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700123 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700124 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700125
Colin Cross26c34ed2016-09-30 17:10:16 -0700126 // Paths to .o files
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700127 Objs Objects
Dan Willemsen581341d2017-02-09 16:16:31 -0800128 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700129 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700130
Colin Cross26c34ed2016-09-30 17:10:16 -0700131 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700132 GeneratedSources android.Paths
133 GeneratedHeaders android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900134 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700135
Inseob Kimd110f872019-12-06 13:15:38 +0900136 Flags []string
137 IncludeDirs android.Paths
138 SystemIncludeDirs android.Paths
139 ReexportedDirs android.Paths
140 ReexportedSystemDirs android.Paths
141 ReexportedFlags []string
142 ReexportedGeneratedHeaders android.Paths
143 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700144
Colin Cross26c34ed2016-09-30 17:10:16 -0700145 // Paths to crt*.o files
Colin Cross635c3b02016-05-18 15:37:25 -0700146 CrtBegin, CrtEnd android.OptionalPath
Dan Willemsena0790e32018-10-12 00:24:23 -0700147
148 // Path to the file container flags to use with the linker
149 LinkerFlagsFile android.OptionalPath
150
151 // Path to the dynamic linker binary
152 DynamicLinker android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700153}
154
Colin Cross4af21ed2019-11-04 09:37:55 -0800155// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
156// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
157// command line so they can be overridden by the local module flags).
158type LocalOrGlobalFlags struct {
159 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700160 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800161 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700162 CFlags []string // Flags that apply to C and C++ source files
163 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
164 ConlyFlags []string // Flags that apply to C source files
165 CppFlags []string // Flags that apply to C++ source files
166 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700167 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800168}
169
170type Flags struct {
171 Local LocalOrGlobalFlags
172 Global LocalOrGlobalFlags
173
174 aidlFlags []string // Flags that apply to aidl source files
175 rsFlags []string // Flags that apply to renderscript source files
176 libFlags []string // Flags to add libraries early to the link order
177 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
178 TidyFlags []string // Flags that apply to clang-tidy
179 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700180
Colin Crossc3199482017-03-30 15:03:04 -0700181 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800182 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700183 SystemIncludeFlags []string
184
Oliver Nguyen6f641c12020-04-21 12:40:27 -0700185 Toolchain config.Toolchain
186 Tidy bool
187 GcovCoverage bool
188 SAbiDump bool
189 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800190
191 RequiredInstructionSet string
Colin Cross16b23492016-01-06 14:41:07 -0800192 DynamicLinker string
193
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700194 CFlagsDeps android.Paths // Files depended on by compiler flags
195 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800196
Dan Willemsen98ab3112019-08-27 21:20:40 -0700197 AssemblerWithCpp bool
198 GroupStaticLibs bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800199
Colin Cross19878da2019-03-28 14:45:07 -0700200 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700201 protoC bool // Whether to use C instead of C++
202 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700203
204 Yacc *YaccProperties
Colin Crossc472d572015-03-17 15:06:21 -0700205}
206
Colin Crossca860ac2016-01-04 14:34:37 -0800207// Properties used to compile all C or C++ modules
208type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700209 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800210 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700211
Colin Cross01fd7cc2020-02-19 16:54:04 -0800212 // Minimum sdk version supported when compiling against the ndk. Setting this property causes
213 // two variants to be built, one for the platform and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800214 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700215
Jooyung Hanba118122020-04-21 15:24:00 +0900216 // Minimum sdk version that the artifact should support when it runs as part of mainline modules(APEX).
217 Min_sdk_version *string
218
Colin Cross01fd7cc2020-02-19 16:54:04 -0800219 // If true, always create an sdk variant and don't create a platform variant.
220 Sdk_variant_only *bool
221
Jiyong Parkde866cb2018-12-07 23:08:36 +0900222 AndroidMkSharedLibs []string `blueprint:"mutated"`
223 AndroidMkStaticLibs []string `blueprint:"mutated"`
224 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
225 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
226 HideFromMake bool `blueprint:"mutated"`
227 PreventInstall bool `blueprint:"mutated"`
228 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700229
Justin Yun5f7f7e82019-11-18 19:52:14 +0900230 ImageVariationPrefix string `blueprint:"mutated"`
231 VndkVersion string `blueprint:"mutated"`
232 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800233
234 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
235 // file
236 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900237
Yifan Hong1b3348d2020-01-21 15:53:22 -0800238 // Make this module available when building for ramdisk
239 Ramdisk_available *bool
240
Jiyong Parkf9332f12018-02-01 00:54:12 +0900241 // Make this module available when building for recovery
242 Recovery_available *bool
243
Colin Crossae6c5202019-11-20 13:35:50 -0800244 // Set by imageMutator
Colin Cross7228ecd2019-11-18 16:00:16 -0800245 CoreVariantNeeded bool `blueprint:"mutated"`
Yifan Hong1b3348d2020-01-21 15:53:22 -0800246 RamdiskVariantNeeded bool `blueprint:"mutated"`
Colin Cross7228ecd2019-11-18 16:00:16 -0800247 RecoveryVariantNeeded bool `blueprint:"mutated"`
Justin Yun5f7f7e82019-11-18 19:52:14 +0900248 ExtraVariants []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900249
250 // Allows this module to use non-APEX version of libraries. Useful
251 // for building binaries that are started before APEXes are activated.
252 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900253
254 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
255 // see soong/cc/config/vndk.go
256 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900257
258 // Used by vendor snapshot to record dependencies from snapshot modules.
259 SnapshotSharedLibs []string `blueprint:"mutated"`
260 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffinf51768a2020-03-04 14:52:46 +0000261
262 Installable *bool
Colin Cross01fd7cc2020-02-19 16:54:04 -0800263
264 // Set by factories of module types that can only be referenced from variants compiled against
265 // the SDK.
266 AlwaysSdk bool `blueprint:"mutated"`
267
268 // Variant is an SDK variant created by sdkMutator
269 IsSdkVariant bool `blueprint:"mutated"`
270 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
271 // variant to have a ".sdk" suffix.
272 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700273}
274
275type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900276 // whether this module should be allowed to be directly depended by other
277 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun5f7f7e82019-11-18 19:52:14 +0900278 // In addition, this module should be allowed to be directly depended by
279 // product modules with `product_specific: true`.
280 // If set to true, three variants will be built separately, one like
281 // normal, another limited to the set of libraries and headers
282 // that are exposed to /vendor modules, and the other to /product modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700283 //
Justin Yun5f7f7e82019-11-18 19:52:14 +0900284 // The vendor and product variants may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700285 // so it shouldn't have any unversioned runtime dependencies, or
286 // make assumptions about the system that may not be true in the
287 // future.
288 //
Justin Yun5f7f7e82019-11-18 19:52:14 +0900289 // If set to false, this module becomes inaccessible from /vendor or /product
290 // modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900291 //
292 // Default value is true when vndk: {enabled: true} or vendor: true.
293 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700294 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
Justin Yun5f7f7e82019-11-18 19:52:14 +0900295 // If PRODUCT_PRODUCT_VNDK_VERSION isn't set, product variant will not be used.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700296 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900297
298 // whether this module is capable of being loaded with other instance
299 // (possibly an older version) of the same module in the same process.
300 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
301 // can be double loaded in a vendor process if the library is also a
302 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
303 // explicitly marked as `double_loadable: true` by the owner, or the dependency
304 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
305 Double_loadable *bool
Colin Crossca860ac2016-01-04 14:34:37 -0800306}
307
Colin Crossca860ac2016-01-04 14:34:37 -0800308type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800309 static() bool
310 staticBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900311 header() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700312 toolchain() config.Toolchain
Jooyung Han61c41542020-03-07 03:45:53 +0900313 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700314 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800315 sdkVersion() string
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700316 useVndk() bool
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800317 isNdk() bool
Inseob Kim9516ee92019-05-09 10:56:13 +0900318 isLlndk(config android.Config) bool
319 isLlndkPublic(config android.Config) bool
320 isVndkPrivate(config android.Config) bool
Justin Yun8effde42017-06-23 19:24:43 +0900321 isVndk() bool
322 isVndkSp() bool
Logan Chienf3511742017-10-31 18:04:35 +0800323 isVndkExt() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900324 inProduct() bool
325 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800326 inRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900327 inRecovery() bool
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800328 shouldCreateSourceAbiDump() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700329 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700330 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800331 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800332 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800333 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800334 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800335 isForPlatform() bool
Jiyong Park58e364a2019-01-19 19:24:06 +0900336 apexName() string
Jooyung Han61c41542020-03-07 03:45:53 +0900337 apexSdkVersion() int
Jiyong Parkb0788572018-12-20 22:10:17 +0900338 hasStubsVariants() bool
339 isStubs() bool
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900340 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800341 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700342 nativeCoverage() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800343}
344
345type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700346 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800347 ModuleContextIntf
348}
349
350type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700351 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800352 ModuleContextIntf
353}
354
Colin Cross37047f12016-12-13 17:06:13 -0800355type DepsContext interface {
356 android.BottomUpMutatorContext
357 ModuleContextIntf
358}
359
Colin Crossca860ac2016-01-04 14:34:37 -0800360type feature interface {
361 begin(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800362 deps(ctx DepsContext, deps Deps) Deps
Colin Crossca860ac2016-01-04 14:34:37 -0800363 flags(ctx ModuleContext, flags Flags) Flags
364 props() []interface{}
365}
366
367type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700368 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800369 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800370 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700371 compilerProps() []interface{}
372
Colin Cross76fada02016-07-27 10:31:13 -0700373 appendCflags([]string)
374 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700375 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800376}
377
378type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700379 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800380 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700381 linkerFlags(ctx ModuleContext, flags Flags) Flags
382 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800383 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700384
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700385 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700386 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900387 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700388
389 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900390 coverageOutputFilePath() android.OptionalPath
Paul Duffin206433a2020-03-06 12:30:43 +0000391
392 // Get the deps that have been explicitly specified in the properties.
393 // Only updates the
394 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
395}
396
397type specifiedDeps struct {
398 sharedLibs []string
Martin Stjernholmbddfbc42020-03-24 01:19:52 +0000399 systemSharedLibs []string // Note nil and [] are semantically distinct.
Colin Crossca860ac2016-01-04 14:34:37 -0800400}
401
402type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700403 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700404 install(ctx ModuleContext, path android.Path)
Paul Duffinf51768a2020-03-04 14:52:46 +0000405 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800406 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700407 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700408 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900409 relativeInstallPath() string
Martin Stjernholm2a6e9d02020-03-31 16:05:34 +0100410 skipInstall(mod *Module)
Colin Crossca860ac2016-01-04 14:34:37 -0800411}
412
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800413type xref interface {
414 XrefCcFiles() android.Paths
415}
416
Colin Crossc99deeb2016-04-11 15:06:20 -0700417var (
Ivan Lozano183a3212019-10-18 14:18:45 -0700418 sharedExportDepTag = DependencyTag{Name: "shared", Library: true, Shared: true, ReexportFlags: true}
419 earlySharedDepTag = DependencyTag{Name: "early_shared", Library: true, Shared: true}
420 lateSharedDepTag = DependencyTag{Name: "late shared", Library: true, Shared: true}
421 staticExportDepTag = DependencyTag{Name: "static", Library: true, ReexportFlags: true}
422 lateStaticDepTag = DependencyTag{Name: "late static", Library: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800423 staticUnwinderDepTag = DependencyTag{Name: "static unwinder", Library: true}
Ivan Lozano183a3212019-10-18 14:18:45 -0700424 wholeStaticDepTag = DependencyTag{Name: "whole static", Library: true, ReexportFlags: true}
425 headerDepTag = DependencyTag{Name: "header", Library: true}
426 headerExportDepTag = DependencyTag{Name: "header", Library: true, ReexportFlags: true}
427 genSourceDepTag = DependencyTag{Name: "gen source"}
428 genHeaderDepTag = DependencyTag{Name: "gen header"}
429 genHeaderExportDepTag = DependencyTag{Name: "gen header", ReexportFlags: true}
430 objDepTag = DependencyTag{Name: "obj"}
431 linkerFlagsDepTag = DependencyTag{Name: "linker flags file"}
432 dynamicLinkerDepTag = DependencyTag{Name: "dynamic linker"}
433 reuseObjTag = DependencyTag{Name: "reuse objects"}
434 staticVariantTag = DependencyTag{Name: "static variant"}
435 ndkStubDepTag = DependencyTag{Name: "ndk stub", Library: true}
436 ndkLateStubDepTag = DependencyTag{Name: "ndk late stub", Library: true}
437 vndkExtDepTag = DependencyTag{Name: "vndk extends", Library: true}
438 runtimeDepTag = DependencyTag{Name: "runtime lib"}
439 coverageDepTag = DependencyTag{Name: "coverage"}
440 testPerSrcDepTag = DependencyTag{Name: "test_per_src"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700441)
442
Roland Levillainf89cd092019-07-29 16:22:59 +0100443func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Ivan Lozano183a3212019-10-18 14:18:45 -0700444 ccDepTag, ok := depTag.(DependencyTag)
445 return ok && ccDepTag.Shared
Roland Levillainf89cd092019-07-29 16:22:59 +0100446}
447
448func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Ivan Lozano183a3212019-10-18 14:18:45 -0700449 ccDepTag, ok := depTag.(DependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100450 return ok && ccDepTag == runtimeDepTag
451}
452
453func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Ivan Lozano183a3212019-10-18 14:18:45 -0700454 ccDepTag, ok := depTag.(DependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100455 return ok && ccDepTag == testPerSrcDepTag
456}
457
Colin Crossca860ac2016-01-04 14:34:37 -0800458// Module contains the properties and members used by all C/C++ module types, and implements
459// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
460// to construct the output file. Behavior can be customized with a Customizer interface
461type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700462 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700463 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900464 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900465 android.SdkBase
Colin Crossc472d572015-03-17 15:06:21 -0700466
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700467 Properties BaseProperties
468 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700469
Colin Crossca860ac2016-01-04 14:34:37 -0800470 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700471 hod android.HostOrDeviceSupported
472 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700473
Paul Duffina0843f62019-12-13 19:50:38 +0000474 // Allowable SdkMemberTypes of this module type.
475 sdkMemberTypes []android.SdkMemberType
476
Colin Crossca860ac2016-01-04 14:34:37 -0800477 // delegates, initialize before calling Init
Colin Crossb4ce0ec2016-09-13 13:41:39 -0700478 features []feature
479 compiler compiler
480 linker linker
481 installer installer
482 stl *stl
483 sanitize *sanitize
Dan Willemsen581341d2017-02-09 16:16:31 -0800484 coverage *coverage
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800485 sabi *sabi
Justin Yun8effde42017-06-23 19:24:43 +0900486 vndkdep *vndkdep
Stephen Craneba090d12017-05-09 15:44:35 -0700487 lto *lto
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700488 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800489
Colin Cross635c3b02016-05-18 15:37:25 -0700490 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800491
Colin Crossb98c8b02016-07-29 13:44:28 -0700492 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700493
494 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800495
496 // Flags used to compile this module
497 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700498
499 // When calling a linker, if module A depends on module B, then A must precede B in its command
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800500 // line invocation. depsInLinkOrder stores the proper ordering of all of the transitive
Jeff Gaston294356f2017-09-27 17:05:30 -0700501 // deps of this module
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800502 depsInLinkOrder android.Paths
503
504 // only non-nil when this is a shared library that reuses the objects of a static library
Ivan Lozano52767be2019-10-18 14:49:46 -0700505 staticVariant LinkableInterface
Inseob Kim9516ee92019-05-09 10:56:13 +0900506
507 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800508 // Kythe (source file indexer) paths for this compilation module
509 kytheFiles android.Paths
Jooyung Han74066602020-03-20 04:29:24 +0900510
511 // For apex variants, this is set as apex.min_sdk_version
512 apexSdkVersion int
Colin Crossc472d572015-03-17 15:06:21 -0700513}
514
Ivan Lozano52767be2019-10-18 14:49:46 -0700515func (c *Module) Toc() android.OptionalPath {
516 if c.linker != nil {
517 if library, ok := c.linker.(libraryInterface); ok {
518 return library.toc()
519 }
520 }
521 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
522}
523
524func (c *Module) ApiLevel() string {
525 if c.linker != nil {
526 if stub, ok := c.linker.(*stubDecorator); ok {
527 return stub.properties.ApiLevel
528 }
529 }
530 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
531}
532
533func (c *Module) Static() bool {
534 if c.linker != nil {
535 if library, ok := c.linker.(libraryInterface); ok {
536 return library.static()
537 }
538 }
539 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
540}
541
542func (c *Module) Shared() bool {
543 if c.linker != nil {
544 if library, ok := c.linker.(libraryInterface); ok {
545 return library.shared()
546 }
547 }
548 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
549}
550
551func (c *Module) SelectedStl() string {
Colin Cross01fd7cc2020-02-19 16:54:04 -0800552 if c.stl != nil {
553 return c.stl.Properties.SelectedStl
554 }
555 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700556}
557
558func (c *Module) ToolchainLibrary() bool {
559 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
560 return true
561 }
562 return false
563}
564
565func (c *Module) NdkPrebuiltStl() bool {
566 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
567 return true
568 }
569 return false
570}
571
572func (c *Module) StubDecorator() bool {
573 if _, ok := c.linker.(*stubDecorator); ok {
574 return true
575 }
576 return false
577}
578
579func (c *Module) SdkVersion() string {
580 return String(c.Properties.Sdk_version)
581}
582
Artur Satayev388d39b2020-04-27 18:53:18 +0100583func (c *Module) MinSdkVersion() string {
584 return String(c.Properties.Min_sdk_version)
585}
586
Colin Cross01fd7cc2020-02-19 16:54:04 -0800587func (c *Module) AlwaysSdk() bool {
588 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
589}
590
Ivan Lozanoe0833b12019-11-06 19:15:49 -0800591func (c *Module) IncludeDirs() android.Paths {
Ivan Lozano183a3212019-10-18 14:18:45 -0700592 if c.linker != nil {
593 if library, ok := c.linker.(exportedFlagsProducer); ok {
594 return library.exportedDirs()
595 }
596 }
597 panic(fmt.Errorf("IncludeDirs called on non-exportedFlagsProducer module: %q", c.BaseModuleName()))
598}
599
600func (c *Module) HasStaticVariant() bool {
601 if c.staticVariant != nil {
602 return true
603 }
604 return false
605}
606
607func (c *Module) GetStaticVariant() LinkableInterface {
608 return c.staticVariant
609}
610
611func (c *Module) SetDepsInLinkOrder(depsInLinkOrder []android.Path) {
612 c.depsInLinkOrder = depsInLinkOrder
613}
614
615func (c *Module) GetDepsInLinkOrder() []android.Path {
616 return c.depsInLinkOrder
617}
618
619func (c *Module) StubsVersions() []string {
620 if c.linker != nil {
621 if library, ok := c.linker.(*libraryDecorator); ok {
622 return library.Properties.Stubs.Versions
623 }
624 }
625 panic(fmt.Errorf("StubsVersions called on non-library module: %q", c.BaseModuleName()))
626}
627
628func (c *Module) CcLibrary() bool {
629 if c.linker != nil {
630 if _, ok := c.linker.(*libraryDecorator); ok {
631 return true
632 }
633 }
634 return false
635}
636
637func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -0700638 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700639 return true
640 }
641 return false
642}
643
Ivan Lozano2b262972019-11-21 12:30:50 -0800644func (c *Module) NonCcVariants() bool {
645 return false
646}
647
Ivan Lozano183a3212019-10-18 14:18:45 -0700648func (c *Module) SetBuildStubs() {
649 if c.linker != nil {
650 if library, ok := c.linker.(*libraryDecorator); ok {
651 library.MutatedProperties.BuildStubs = true
Ivan Lozano52767be2019-10-18 14:49:46 -0700652 c.Properties.HideFromMake = true
653 c.sanitize = nil
654 c.stl = nil
655 c.Properties.PreventInstall = true
Ivan Lozano183a3212019-10-18 14:18:45 -0700656 return
657 }
Jooyung Han67a96cd2020-03-13 15:23:36 +0900658 if _, ok := c.linker.(*llndkStubDecorator); ok {
659 c.Properties.HideFromMake = true
660 return
661 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700662 }
663 panic(fmt.Errorf("SetBuildStubs called on non-library module: %q", c.BaseModuleName()))
664}
665
Ivan Lozano52767be2019-10-18 14:49:46 -0700666func (c *Module) BuildStubs() bool {
667 if c.linker != nil {
668 if library, ok := c.linker.(*libraryDecorator); ok {
669 return library.buildStubs()
670 }
671 }
672 panic(fmt.Errorf("BuildStubs called on non-library module: %q", c.BaseModuleName()))
673}
674
Ivan Lozano183a3212019-10-18 14:18:45 -0700675func (c *Module) SetStubsVersions(version string) {
676 if c.linker != nil {
677 if library, ok := c.linker.(*libraryDecorator); ok {
678 library.MutatedProperties.StubsVersion = version
679 return
680 }
Jooyung Han67a96cd2020-03-13 15:23:36 +0900681 if llndk, ok := c.linker.(*llndkStubDecorator); ok {
682 llndk.libraryDecorator.MutatedProperties.StubsVersion = version
683 return
684 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700685 }
686 panic(fmt.Errorf("SetStubsVersions called on non-library module: %q", c.BaseModuleName()))
687}
688
Jooyung Han0c4e0162020-02-26 22:45:42 +0900689func (c *Module) StubsVersion() string {
690 if c.linker != nil {
691 if library, ok := c.linker.(*libraryDecorator); ok {
692 return library.MutatedProperties.StubsVersion
693 }
Jooyung Han67a96cd2020-03-13 15:23:36 +0900694 if llndk, ok := c.linker.(*llndkStubDecorator); ok {
695 return llndk.libraryDecorator.MutatedProperties.StubsVersion
696 }
Jooyung Han0c4e0162020-02-26 22:45:42 +0900697 }
698 panic(fmt.Errorf("StubsVersion called on non-library module: %q", c.BaseModuleName()))
699}
700
Ivan Lozano183a3212019-10-18 14:18:45 -0700701func (c *Module) SetStatic() {
702 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700703 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700704 library.setStatic()
705 return
706 }
707 }
708 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
709}
710
711func (c *Module) SetShared() {
712 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700713 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700714 library.setShared()
715 return
716 }
717 }
718 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
719}
720
721func (c *Module) BuildStaticVariant() bool {
722 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700723 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700724 return library.buildStatic()
725 }
726 }
727 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
728}
729
730func (c *Module) BuildSharedVariant() bool {
731 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700732 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700733 return library.buildShared()
734 }
735 }
736 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
737}
738
739func (c *Module) Module() android.Module {
740 return c
741}
742
Jiyong Parkc20eee32018-09-05 22:36:17 +0900743func (c *Module) OutputFile() android.OptionalPath {
744 return c.outputFile
745}
746
Ivan Lozano183a3212019-10-18 14:18:45 -0700747var _ LinkableInterface = (*Module)(nil)
748
Jiyong Park719b4462019-01-13 00:39:51 +0900749func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900750 if c.linker != nil {
751 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +0900752 }
753 return nil
754}
755
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900756func (c *Module) CoverageOutputFile() android.OptionalPath {
757 if c.linker != nil {
758 return c.linker.coverageOutputFilePath()
759 }
760 return android.OptionalPath{}
761}
762
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900763func (c *Module) RelativeInstallPath() string {
764 if c.installer != nil {
765 return c.installer.relativeInstallPath()
766 }
767 return ""
768}
769
Jooyung Han344d5432019-08-23 11:17:39 +0900770func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +0900771 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +0900772}
773
Colin Cross36242852017-06-23 15:06:31 -0700774func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -0700775 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -0800776 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -0700777 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800778 }
779 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -0700780 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800781 }
782 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -0700783 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800784 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700785 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -0700786 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -0700787 }
Colin Cross16b23492016-01-06 14:41:07 -0800788 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -0700789 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -0800790 }
Dan Willemsen581341d2017-02-09 16:16:31 -0800791 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -0700792 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -0800793 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800794 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -0700795 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800796 }
Justin Yun8effde42017-06-23 19:24:43 +0900797 if c.vndkdep != nil {
798 c.AddProperties(c.vndkdep.props()...)
799 }
Stephen Craneba090d12017-05-09 15:44:35 -0700800 if c.lto != nil {
801 c.AddProperties(c.lto.props()...)
802 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700803 if c.pgo != nil {
804 c.AddProperties(c.pgo.props()...)
805 }
Colin Crossca860ac2016-01-04 14:34:37 -0800806 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -0700807 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800808 }
Colin Crossc472d572015-03-17 15:06:21 -0700809
Colin Crossa9d8bee2018-10-02 13:59:46 -0700810 c.Prefer32(func(ctx android.BaseModuleContext, base *android.ModuleBase, class android.OsClass) bool {
811 switch class {
812 case android.Device:
813 return ctx.Config().DevicePrefer32BitExecutables()
814 case android.HostCross:
815 // Windows builds always prefer 32-bit
816 return true
817 default:
818 return false
819 }
820 })
Colin Cross36242852017-06-23 15:06:31 -0700821 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +0900822 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +0900823 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +0900824 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +0900825
Colin Cross36242852017-06-23 15:06:31 -0700826 return c
Colin Crossc472d572015-03-17 15:06:21 -0700827}
828
Colin Crossb916a382016-07-29 17:28:03 -0700829// Returns true for dependency roots (binaries)
830// TODO(ccross): also handle dlopenable libraries
831func (c *Module) isDependencyRoot() bool {
832 if root, ok := c.linker.(interface {
833 isDependencyRoot() bool
834 }); ok {
835 return root.isDependencyRoot()
836 }
837 return false
838}
839
Justin Yun5f7f7e82019-11-18 19:52:14 +0900840// Returns true if the module is using VNDK libraries instead of the libraries in /system/lib or /system/lib64.
841// "product" and "vendor" variant modules return true for this function.
842// When BOARD_VNDK_VERSION is set, vendor variants of "vendor_available: true", "vendor: true",
843// "soc_specific: true" and more vendor installed modules are included here.
844// When PRODUCT_PRODUCT_VNDK_VERSION is set, product variants of "vendor_available: true" or
845// "product_specific: true" modules are included here.
Ivan Lozano52767be2019-10-18 14:49:46 -0700846func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +0900847 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700848}
849
Colin Cross01fd7cc2020-02-19 16:54:04 -0800850func (c *Module) canUseSdk() bool {
851 return c.Os() == android.Android && !c.UseVndk() && !c.InRamdisk() && !c.InRecovery()
852}
853
854func (c *Module) UseSdk() bool {
855 if c.canUseSdk() {
856 return String(c.Properties.Sdk_version) != ""
857 }
858 return false
859}
860
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800861func (c *Module) isCoverageVariant() bool {
862 return c.coverage.Properties.IsCoverageVariant
863}
864
Peter Collingbournead84f972019-12-17 16:46:18 -0800865func (c *Module) IsNdk() bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800866 return inList(c.Name(), ndkMigratedLibs)
867}
868
Inseob Kim9516ee92019-05-09 10:56:13 +0900869func (c *Module) isLlndk(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800870 // Returns true for both LLNDK (public) and LLNDK-private libs.
Jooyung Han0302a842019-10-30 18:43:49 +0900871 return isLlndkLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800872}
873
Inseob Kim9516ee92019-05-09 10:56:13 +0900874func (c *Module) isLlndkPublic(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800875 // Returns true only for LLNDK (public) libs.
Jooyung Han0302a842019-10-30 18:43:49 +0900876 name := c.BaseModuleName()
877 return isLlndkLibrary(name, config) && !isVndkPrivateLibrary(name, config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800878}
879
Inseob Kim9516ee92019-05-09 10:56:13 +0900880func (c *Module) isVndkPrivate(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800881 // Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Jooyung Han0302a842019-10-30 18:43:49 +0900882 return isVndkPrivateLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +0800883}
884
Ivan Lozano52767be2019-10-18 14:49:46 -0700885func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +0800886 if vndkdep := c.vndkdep; vndkdep != nil {
887 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +0900888 }
889 return false
890}
891
Yi Kong7e53c572018-02-14 18:16:12 +0800892func (c *Module) isPgoCompile() bool {
893 if pgo := c.pgo; pgo != nil {
894 return pgo.Properties.PgoCompile
895 }
896 return false
897}
898
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800899func (c *Module) isNDKStubLibrary() bool {
900 if _, ok := c.compiler.(*stubDecorator); ok {
901 return true
902 }
903 return false
904}
905
Logan Chienf3511742017-10-31 18:04:35 +0800906func (c *Module) isVndkSp() bool {
907 if vndkdep := c.vndkdep; vndkdep != nil {
908 return vndkdep.isVndkSp()
909 }
910 return false
911}
912
913func (c *Module) isVndkExt() bool {
914 if vndkdep := c.vndkdep; vndkdep != nil {
915 return vndkdep.isVndkExt()
916 }
917 return false
918}
919
Ivan Lozano52767be2019-10-18 14:49:46 -0700920func (c *Module) MustUseVendorVariant() bool {
Jooyung Han097087b2019-10-22 19:32:18 +0900921 return c.isVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -0800922}
923
Logan Chienf3511742017-10-31 18:04:35 +0800924func (c *Module) getVndkExtendsModuleName() string {
925 if vndkdep := c.vndkdep; vndkdep != nil {
926 return vndkdep.getVndkExtendsModuleName()
927 }
928 return ""
929}
930
Justin Yun5f7f7e82019-11-18 19:52:14 +0900931// Returns true only when this module is configured to have core, product and vendor
Jiyong Park82e2bf32017-08-16 14:05:54 +0900932// variants.
Ivan Lozano52767be2019-10-18 14:49:46 -0700933func (c *Module) HasVendorVariant() bool {
934 return c.IsVndk() || Bool(c.VendorProperties.Vendor_available)
Jiyong Park82e2bf32017-08-16 14:05:54 +0900935}
936
Justin Yun5f7f7e82019-11-18 19:52:14 +0900937const (
938 // VendorVariationPrefix is the variant prefix used for /vendor code that compiles
939 // against the VNDK.
940 VendorVariationPrefix = "vendor."
941
942 // ProductVariationPrefix is the variant prefix used for /product code that compiles
943 // against the VNDK.
944 ProductVariationPrefix = "product."
945)
946
947// Returns true if the module is "product" variant. Usually these modules are installed in /product
948func (c *Module) inProduct() bool {
949 return c.Properties.ImageVariationPrefix == ProductVariationPrefix
950}
951
952// Returns true if the module is "vendor" variant. Usually these modules are installed in /vendor
953func (c *Module) inVendor() bool {
954 return c.Properties.ImageVariationPrefix == VendorVariationPrefix
955}
956
Yifan Hong1b3348d2020-01-21 15:53:22 -0800957func (c *Module) InRamdisk() bool {
958 return c.ModuleBase.InRamdisk() || c.ModuleBase.InstallInRamdisk()
959}
960
Ivan Lozano52767be2019-10-18 14:49:46 -0700961func (c *Module) InRecovery() bool {
Colin Cross7228ecd2019-11-18 16:00:16 -0800962 return c.ModuleBase.InRecovery() || c.ModuleBase.InstallInRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +0900963}
964
Yifan Hong1b3348d2020-01-21 15:53:22 -0800965func (c *Module) OnlyInRamdisk() bool {
966 return c.ModuleBase.InstallInRamdisk()
967}
968
Ivan Lozano52767be2019-10-18 14:49:46 -0700969func (c *Module) OnlyInRecovery() bool {
Jiyong Parkf9332f12018-02-01 00:54:12 +0900970 return c.ModuleBase.InstallInRecovery()
971}
972
Jiyong Park25fc6a92018-11-18 18:02:45 +0900973func (c *Module) IsStubs() bool {
974 if library, ok := c.linker.(*libraryDecorator); ok {
975 return library.buildStubs()
Jiyong Park379de2f2018-12-19 02:47:14 +0900976 } else if _, ok := c.linker.(*llndkStubDecorator); ok {
977 return true
Jiyong Park25fc6a92018-11-18 18:02:45 +0900978 }
979 return false
980}
981
982func (c *Module) HasStubsVariants() bool {
983 if library, ok := c.linker.(*libraryDecorator); ok {
984 return len(library.Properties.Stubs.Versions) > 0
985 }
Peter Collingbourne3478bb22019-04-24 14:41:12 -0700986 if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
987 return len(library.Properties.Stubs.Versions) > 0
988 }
Jiyong Park25fc6a92018-11-18 18:02:45 +0900989 return false
990}
991
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900992func (c *Module) bootstrap() bool {
993 return Bool(c.Properties.Bootstrap)
994}
995
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700996func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -0700997 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
998 if c.Target().NativeBridge == android.NativeBridgeEnabled {
999 return false
1000 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001001 return c.linker != nil && c.linker.nativeCoverage()
1002}
1003
Inseob Kim8471cda2019-11-15 09:59:12 +09001004func (c *Module) isSnapshotPrebuilt() bool {
Inseob Kimeec88e12020-01-22 11:11:29 +09001005 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1006 return true
1007 }
1008 if _, ok := c.linker.(*vendorSnapshotLibraryDecorator); ok {
1009 return true
1010 }
1011 if _, ok := c.linker.(*vendorSnapshotBinaryDecorator); ok {
1012 return true
1013 }
1014 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001015}
1016
Jiyong Park73c54ee2019-10-22 20:31:18 +09001017func (c *Module) ExportedIncludeDirs() android.Paths {
1018 if flagsProducer, ok := c.linker.(exportedFlagsProducer); ok {
1019 return flagsProducer.exportedDirs()
1020 }
Jiyong Park232e7852019-11-04 12:23:40 +09001021 return nil
Jiyong Park73c54ee2019-10-22 20:31:18 +09001022}
1023
1024func (c *Module) ExportedSystemIncludeDirs() android.Paths {
1025 if flagsProducer, ok := c.linker.(exportedFlagsProducer); ok {
1026 return flagsProducer.exportedSystemDirs()
1027 }
Jiyong Park232e7852019-11-04 12:23:40 +09001028 return nil
Jiyong Park73c54ee2019-10-22 20:31:18 +09001029}
1030
1031func (c *Module) ExportedFlags() []string {
1032 if flagsProducer, ok := c.linker.(exportedFlagsProducer); ok {
1033 return flagsProducer.exportedFlags()
1034 }
Jiyong Park232e7852019-11-04 12:23:40 +09001035 return nil
1036}
1037
1038func (c *Module) ExportedDeps() android.Paths {
1039 if flagsProducer, ok := c.linker.(exportedFlagsProducer); ok {
1040 return flagsProducer.exportedDeps()
1041 }
1042 return nil
Jiyong Park73c54ee2019-10-22 20:31:18 +09001043}
1044
Inseob Kimd110f872019-12-06 13:15:38 +09001045func (c *Module) ExportedGeneratedHeaders() android.Paths {
1046 if flagsProducer, ok := c.linker.(exportedFlagsProducer); ok {
1047 return flagsProducer.exportedGeneratedHeaders()
1048 }
1049 return nil
1050}
1051
Jiyong Parkf1194352019-02-25 11:05:47 +09001052func isBionic(name string) bool {
1053 switch name {
Martin Stjernholm203489b2019-11-11 15:33:27 +00001054 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001055 return true
1056 }
1057 return false
1058}
1059
Martin Stjernholm279de572019-09-10 23:18:20 +01001060func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001061 if name == "libclang_rt.hwasan-aarch64-android" {
1062 return inList("hwaddress", config.SanitizeDevice())
1063 }
1064 return isBionic(name)
1065}
1066
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001067func (c *Module) XrefCcFiles() android.Paths {
1068 return c.kytheFiles
1069}
1070
Colin Crossca860ac2016-01-04 14:34:37 -08001071type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001072 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001073 moduleContextImpl
1074}
1075
Colin Cross37047f12016-12-13 17:06:13 -08001076type depsContext struct {
1077 android.BottomUpMutatorContext
1078 moduleContextImpl
1079}
1080
Colin Crossca860ac2016-01-04 14:34:37 -08001081type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001082 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001083 moduleContextImpl
1084}
1085
Justin Yun5f7f7e82019-11-18 19:52:14 +09001086func (ctx *moduleContext) ProductSpecific() bool {
1087 return ctx.ModuleContext.ProductSpecific() ||
1088 (ctx.mod.HasVendorVariant() && ctx.mod.inProduct() && !ctx.mod.IsVndk())
1089}
1090
Jiyong Park2db76922017-11-08 16:03:48 +09001091func (ctx *moduleContext) SocSpecific() bool {
1092 return ctx.ModuleContext.SocSpecific() ||
Justin Yun5f7f7e82019-11-18 19:52:14 +09001093 (ctx.mod.HasVendorVariant() && ctx.mod.inVendor() && !ctx.mod.IsVndk())
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001094}
1095
Colin Crossca860ac2016-01-04 14:34:37 -08001096type moduleContextImpl struct {
1097 mod *Module
1098 ctx BaseModuleContext
1099}
1100
Colin Crossb98c8b02016-07-29 13:44:28 -07001101func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001102 return ctx.mod.toolchain(ctx.ctx)
1103}
1104
1105func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001106 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001107}
1108
1109func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001110 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001111}
1112
Jiyong Park1d1119f2019-07-29 21:27:18 +09001113func (ctx *moduleContextImpl) header() bool {
1114 return ctx.mod.header()
1115}
1116
Jooyung Han61c41542020-03-07 03:45:53 +09001117func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Cross01fd7cc2020-02-19 16:54:04 -08001118 return ctx.mod.canUseSdk()
Jooyung Han61c41542020-03-07 03:45:53 +09001119}
1120
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001121func (ctx *moduleContextImpl) useSdk() bool {
Colin Cross01fd7cc2020-02-19 16:54:04 -08001122 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001123}
1124
1125func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001126 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001127 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001128 vndkVer := ctx.mod.VndkVersion()
Jooyung Han424175d2020-04-08 09:22:26 +09001129 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001130 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001131 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001132 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001133 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001134 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001135 }
1136 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001137}
1138
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001139func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001140 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001141}
Justin Yun8effde42017-06-23 19:24:43 +09001142
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001143func (ctx *moduleContextImpl) isNdk() bool {
Peter Collingbournead84f972019-12-17 16:46:18 -08001144 return ctx.mod.IsNdk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001145}
1146
Inseob Kim9516ee92019-05-09 10:56:13 +09001147func (ctx *moduleContextImpl) isLlndk(config android.Config) bool {
1148 return ctx.mod.isLlndk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001149}
1150
Inseob Kim9516ee92019-05-09 10:56:13 +09001151func (ctx *moduleContextImpl) isLlndkPublic(config android.Config) bool {
1152 return ctx.mod.isLlndkPublic(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001153}
1154
Inseob Kim9516ee92019-05-09 10:56:13 +09001155func (ctx *moduleContextImpl) isVndkPrivate(config android.Config) bool {
1156 return ctx.mod.isVndkPrivate(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001157}
1158
Logan Chienf3511742017-10-31 18:04:35 +08001159func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001160 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001161}
1162
Yi Kong7e53c572018-02-14 18:16:12 +08001163func (ctx *moduleContextImpl) isPgoCompile() bool {
1164 return ctx.mod.isPgoCompile()
1165}
1166
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001167func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1168 return ctx.mod.isNDKStubLibrary()
1169}
1170
Justin Yun8effde42017-06-23 19:24:43 +09001171func (ctx *moduleContextImpl) isVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001172 return ctx.mod.isVndkSp()
1173}
1174
1175func (ctx *moduleContextImpl) isVndkExt() bool {
1176 return ctx.mod.isVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001177}
1178
Vic Yangefd249e2018-11-12 20:19:56 -08001179func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001180 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001181}
1182
Justin Yun5f7f7e82019-11-18 19:52:14 +09001183func (ctx *moduleContextImpl) inProduct() bool {
1184 return ctx.mod.inProduct()
1185}
1186
1187func (ctx *moduleContextImpl) inVendor() bool {
1188 return ctx.mod.inVendor()
1189}
1190
Yifan Hong1b3348d2020-01-21 15:53:22 -08001191func (ctx *moduleContextImpl) inRamdisk() bool {
1192 return ctx.mod.InRamdisk()
1193}
1194
Jiyong Parkf9332f12018-02-01 00:54:12 +09001195func (ctx *moduleContextImpl) inRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001196 return ctx.mod.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09001197}
1198
Logan Chien2f2b8902018-07-10 15:01:19 +08001199// Check whether ABI dumps should be created for this module.
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001200func (ctx *moduleContextImpl) shouldCreateSourceAbiDump() bool {
Logan Chien2f2b8902018-07-10 15:01:19 +08001201 if ctx.ctx.Config().IsEnvTrue("SKIP_ABI_CHECKS") {
1202 return false
Jayant Chowdharyea0a2e12018-03-01 19:12:16 -08001203 }
Doug Hornc32c6b02019-01-17 14:44:05 -08001204
1205 if ctx.ctx.Fuchsia() {
1206 return false
1207 }
1208
Logan Chien2f2b8902018-07-10 15:01:19 +08001209 if sanitize := ctx.mod.sanitize; sanitize != nil {
1210 if !sanitize.isVariantOnProductionDevice() {
1211 return false
1212 }
1213 }
1214 if !ctx.ctx.Device() {
1215 // Host modules do not need ABI dumps.
1216 return false
1217 }
Hsin-Yi Chend2451682020-01-10 16:47:50 +08001218 if ctx.isStubs() || ctx.isNDKStubLibrary() {
Hsin-Yi Chenf6a95462019-06-25 14:46:52 +08001219 // Stubs do not need ABI dumps.
1220 return false
1221 }
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001222 return true
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001223}
1224
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001225func (ctx *moduleContextImpl) selectedStl() string {
1226 if stl := ctx.mod.stl; stl != nil {
1227 return stl.Properties.SelectedStl
1228 }
1229 return ""
1230}
1231
Ivan Lozanobd721262018-11-27 14:33:03 -08001232func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1233 return ctx.mod.linker.useClangLld(actx)
1234}
1235
Colin Crossce75d2c2016-10-06 16:12:58 -07001236func (ctx *moduleContextImpl) baseModuleName() string {
1237 return ctx.mod.ModuleBase.BaseModuleName()
1238}
1239
Logan Chienf3511742017-10-31 18:04:35 +08001240func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1241 return ctx.mod.getVndkExtendsModuleName()
1242}
1243
Logan Chiene274fc92019-12-03 11:18:32 -08001244func (ctx *moduleContextImpl) isForPlatform() bool {
1245 return ctx.mod.IsForPlatform()
1246}
1247
Jiyong Park58e364a2019-01-19 19:24:06 +09001248func (ctx *moduleContextImpl) apexName() string {
1249 return ctx.mod.ApexName()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001250}
1251
Jooyung Han61c41542020-03-07 03:45:53 +09001252func (ctx *moduleContextImpl) apexSdkVersion() int {
Jooyung Han74066602020-03-20 04:29:24 +09001253 return ctx.mod.apexSdkVersion
Jooyung Han61c41542020-03-07 03:45:53 +09001254}
1255
Jiyong Parkb0788572018-12-20 22:10:17 +09001256func (ctx *moduleContextImpl) hasStubsVariants() bool {
1257 return ctx.mod.HasStubsVariants()
1258}
1259
1260func (ctx *moduleContextImpl) isStubs() bool {
1261 return ctx.mod.IsStubs()
1262}
1263
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001264func (ctx *moduleContextImpl) bootstrap() bool {
1265 return ctx.mod.bootstrap()
1266}
1267
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001268func (ctx *moduleContextImpl) nativeCoverage() bool {
1269 return ctx.mod.nativeCoverage()
1270}
1271
Colin Cross635c3b02016-05-18 15:37:25 -07001272func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001273 return &Module{
1274 hod: hod,
1275 multilib: multilib,
1276 }
1277}
1278
Colin Cross635c3b02016-05-18 15:37:25 -07001279func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001280 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001281 module.features = []feature{
1282 &tidyFeature{},
1283 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001284 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001285 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001286 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001287 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001288 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001289 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001290 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001291 return module
1292}
1293
Colin Crossce75d2c2016-10-06 16:12:58 -07001294func (c *Module) Prebuilt() *android.Prebuilt {
1295 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1296 return p.prebuilt()
1297 }
1298 return nil
1299}
1300
1301func (c *Module) Name() string {
1302 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001303 if p, ok := c.linker.(interface {
1304 Name(string) string
1305 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001306 name = p.Name(name)
1307 }
1308 return name
1309}
1310
Alex Light3d673592019-01-18 14:37:31 -08001311func (c *Module) Symlinks() []string {
1312 if p, ok := c.installer.(interface {
1313 symlinkList() []string
1314 }); ok {
1315 return p.symlinkList()
1316 }
1317 return nil
1318}
1319
Jeff Gaston294356f2017-09-27 17:05:30 -07001320// orderDeps reorders dependencies into a list such that if module A depends on B, then
1321// A will precede B in the resultant list.
1322// This is convenient for passing into a linker.
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001323// Note that directSharedDeps should be the analogous static library for each shared lib dep
1324func orderDeps(directStaticDeps []android.Path, directSharedDeps []android.Path, allTransitiveDeps map[android.Path][]android.Path) (orderedAllDeps []android.Path, orderedDeclaredDeps []android.Path) {
Jeff Gaston294356f2017-09-27 17:05:30 -07001325 // If A depends on B, then
1326 // Every list containing A will also contain B later in the list
1327 // So, after concatenating all lists, the final instance of B will have come from the same
1328 // original list as the final instance of A
1329 // So, the final instance of B will be later in the concatenation than the final A
1330 // So, keeping only the final instance of A and of B ensures that A is earlier in the output
1331 // list than B
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001332 for _, dep := range directStaticDeps {
Jeff Gaston294356f2017-09-27 17:05:30 -07001333 orderedAllDeps = append(orderedAllDeps, dep)
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001334 orderedAllDeps = append(orderedAllDeps, allTransitiveDeps[dep]...)
1335 }
1336 for _, dep := range directSharedDeps {
1337 orderedAllDeps = append(orderedAllDeps, dep)
1338 orderedAllDeps = append(orderedAllDeps, allTransitiveDeps[dep]...)
Jeff Gaston294356f2017-09-27 17:05:30 -07001339 }
1340
Colin Crossb6715442017-10-24 11:13:31 -07001341 orderedAllDeps = android.LastUniquePaths(orderedAllDeps)
Jeff Gaston294356f2017-09-27 17:05:30 -07001342
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001343 // We don't want to add any new dependencies into directStaticDeps (to allow the caller to
Jeff Gaston294356f2017-09-27 17:05:30 -07001344 // intentionally exclude or replace any unwanted transitive dependencies), so we limit the
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001345 // resultant list to only what the caller has chosen to include in directStaticDeps
1346 _, orderedDeclaredDeps = android.FilterPathList(orderedAllDeps, directStaticDeps)
Jeff Gaston294356f2017-09-27 17:05:30 -07001347
1348 return orderedAllDeps, orderedDeclaredDeps
1349}
1350
Ivan Lozano183a3212019-10-18 14:18:45 -07001351func orderStaticModuleDeps(module LinkableInterface, staticDeps []LinkableInterface, sharedDeps []LinkableInterface) (results []android.Path) {
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001352 // convert Module to Path
Ivan Lozano183a3212019-10-18 14:18:45 -07001353 var depsInLinkOrder []android.Path
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001354 allTransitiveDeps := make(map[android.Path][]android.Path, len(staticDeps))
1355 staticDepFiles := []android.Path{}
1356 for _, dep := range staticDeps {
Nicolas Geoffray0b787662020-02-04 18:27:55 +00001357 // The OutputFile may not be valid for a variant not present, and the AllowMissingDependencies flag is set.
1358 if dep.OutputFile().Valid() {
1359 allTransitiveDeps[dep.OutputFile().Path()] = dep.GetDepsInLinkOrder()
1360 staticDepFiles = append(staticDepFiles, dep.OutputFile().Path())
1361 }
Jeff Gaston294356f2017-09-27 17:05:30 -07001362 }
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001363 sharedDepFiles := []android.Path{}
1364 for _, sharedDep := range sharedDeps {
Ivan Lozano183a3212019-10-18 14:18:45 -07001365 if sharedDep.HasStaticVariant() {
1366 staticAnalogue := sharedDep.GetStaticVariant()
1367 allTransitiveDeps[staticAnalogue.OutputFile().Path()] = staticAnalogue.GetDepsInLinkOrder()
1368 sharedDepFiles = append(sharedDepFiles, staticAnalogue.OutputFile().Path())
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08001369 }
Jeff Gaston294356f2017-09-27 17:05:30 -07001370 }
1371
1372 // reorder the dependencies based on transitive dependencies
Ivan Lozano183a3212019-10-18 14:18:45 -07001373 depsInLinkOrder, results = orderDeps(staticDepFiles, sharedDepFiles, allTransitiveDeps)
1374 module.SetDepsInLinkOrder(depsInLinkOrder)
Jeff Gaston294356f2017-09-27 17:05:30 -07001375
1376 return results
Jeff Gaston294356f2017-09-27 17:05:30 -07001377}
1378
Roland Levillainf89cd092019-07-29 16:22:59 +01001379func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1380 test, ok := c.linker.(testPerSrc)
1381 return ok && test.isAllTestsVariation()
1382}
1383
Justin Yun5f7f7e82019-11-18 19:52:14 +09001384func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1385 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1386 // "current", it will append the VNDK version to the name suffix.
1387 var vndkVersion string
1388 var nameSuffix string
1389 if c.inProduct() {
1390 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
1391 nameSuffix = productSuffix
1392 } else {
1393 vndkVersion = ctx.DeviceConfig().VndkVersion()
1394 nameSuffix = vendorSuffix
1395 }
1396 if vndkVersion == "current" {
1397 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1398 }
1399 if c.Properties.VndkVersion != vndkVersion {
1400 // add version suffix only if the module is using different vndk version than the
1401 // version in product or vendor partition.
1402 nameSuffix += "." + c.Properties.VndkVersion
1403 }
1404 return nameSuffix
1405}
1406
Colin Cross635c3b02016-05-18 15:37:25 -07001407func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Roland Levillainf2fad972019-06-28 15:41:19 +01001408 // Handle the case of a test module split by `test_per_src` mutator.
Roland Levillainf89cd092019-07-29 16:22:59 +01001409 //
1410 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1411 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1412 // module and return early, as this module does not produce an output file per se.
1413 if c.IsTestPerSrcAllTestsVariation() {
1414 c.outputFile = android.OptionalPath{}
1415 return
Roland Levillainf2fad972019-06-28 15:41:19 +01001416 }
1417
Jooyung Han38002912019-05-16 04:01:54 +09001418 c.makeLinkType = c.getMakeLinkType(actx)
Inseob Kim9516ee92019-05-09 10:56:13 +09001419
Inseob Kim64c43952019-08-26 16:52:35 +09001420 c.Properties.SubName = ""
1421
1422 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1423 c.Properties.SubName += nativeBridgeSuffix
1424 }
1425
Justin Yun5f7f7e82019-11-18 19:52:14 +09001426 _, llndk := c.linker.(*llndkStubDecorator)
1427 _, llndkHeader := c.linker.(*llndkHeadersDecorator)
1428 if llndk || llndkHeader || (c.UseVndk() && c.HasVendorVariant()) {
1429 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1430 // added for product variant only when we have vendor and product variants with core
1431 // variant. The suffix is not added for vendor-only or product-only module.
1432 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
1433 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001434 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1435 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
1436 c.Properties.SubName += vendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001437 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
1438 c.Properties.SubName += ramdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001439 } else if c.InRecovery() && !c.OnlyInRecovery() {
Inseob Kim64c43952019-08-26 16:52:35 +09001440 c.Properties.SubName += recoverySuffix
Colin Cross01fd7cc2020-02-19 16:54:04 -08001441 } else if c.Properties.IsSdkVariant && c.Properties.SdkAndPlatformVariantVisibleToMake {
1442 c.Properties.SubName += sdkSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001443 }
1444
Colin Crossca860ac2016-01-04 14:34:37 -08001445 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001446 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001447 moduleContextImpl: moduleContextImpl{
1448 mod: c,
1449 },
1450 }
1451 ctx.ctx = ctx
1452
Colin Crossf18e1102017-11-16 14:33:08 -08001453 deps := c.depsToPaths(ctx)
1454 if ctx.Failed() {
1455 return
1456 }
1457
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001458 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1459 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1460 }
1461
Colin Crossca860ac2016-01-04 14:34:37 -08001462 flags := Flags{
1463 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001464 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001465 }
Colin Crossca860ac2016-01-04 14:34:37 -08001466 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001467 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001468 }
1469 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001470 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001471 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001472 if c.stl != nil {
1473 flags = c.stl.flags(ctx, flags)
1474 }
Colin Cross16b23492016-01-06 14:41:07 -08001475 if c.sanitize != nil {
1476 flags = c.sanitize.flags(ctx, flags)
1477 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001478 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001479 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001480 }
Stephen Craneba090d12017-05-09 15:44:35 -07001481 if c.lto != nil {
1482 flags = c.lto.flags(ctx, flags)
1483 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001484 if c.pgo != nil {
1485 flags = c.pgo.flags(ctx, flags)
1486 }
Colin Crossca860ac2016-01-04 14:34:37 -08001487 for _, feature := range c.features {
1488 flags = feature.flags(ctx, flags)
1489 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001490 if ctx.Failed() {
1491 return
1492 }
1493
Colin Cross4af21ed2019-11-04 09:37:55 -08001494 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1495 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1496 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001497
Colin Cross4af21ed2019-11-04 09:37:55 -08001498 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001499
1500 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001501 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001502 }
1503 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001504 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001505 }
1506
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001507 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001508 // We need access to all the flags seen by a source file.
1509 if c.sabi != nil {
1510 flags = c.sabi.flags(ctx, flags)
1511 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001512
Colin Cross4af21ed2019-11-04 09:37:55 -08001513 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001514
Colin Crossca860ac2016-01-04 14:34:37 -08001515 // Optimization to reduce size of build.ninja
1516 // Replace the long list of flags for each file with a module-local variable
Colin Cross4af21ed2019-11-04 09:37:55 -08001517 ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))
1518 ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))
1519 ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))
1520 flags.Local.CFlags = []string{"$cflags"}
1521 flags.Local.CppFlags = []string{"$cppflags"}
1522 flags.Local.AsFlags = []string{"$asflags"}
Colin Crossca860ac2016-01-04 14:34:37 -08001523
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001524 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001525 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001526 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001527 if ctx.Failed() {
1528 return
1529 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001530 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001531 }
1532
Colin Crossca860ac2016-01-04 14:34:37 -08001533 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001534 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001535 if ctx.Failed() {
1536 return
1537 }
Colin Cross635c3b02016-05-18 15:37:25 -07001538 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001539
1540 // If a lib is directly included in any of the APEXes, unhide the stubs
1541 // variant having the latest version gets visible to make. In addition,
1542 // the non-stubs variant is renamed to <libname>.bootstrap. This is to
1543 // force anything in the make world to link against the stubs library.
1544 // (unless it is explicitly referenced via .bootstrap suffix or the
1545 // module is marked with 'bootstrap: true').
Nicolas Geoffrayc22c1bf2019-01-15 19:53:23 +00001546 if c.HasStubsVariants() &&
Yifan Hong1b3348d2020-01-21 15:53:22 -08001547 android.DirectlyInAnyApex(ctx, ctx.baseModuleName()) && !c.InRamdisk() &&
Ivan Lozano52767be2019-10-18 14:49:46 -07001548 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001549 c.IsStubs() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001550 c.Properties.HideFromMake = false // unhide
1551 // Note: this is still non-installable
1552 }
Inseob Kimac775b22020-03-03 22:06:32 +09001553
1554 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current.
1555 if i, ok := c.linker.(snapshotLibraryInterface); ok && ctx.DeviceConfig().VndkVersion() == "current" {
1556 if isSnapshotAware(ctx, c) {
1557 i.collectHeadersForSnapshot(ctx)
1558 }
1559 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001560 }
Colin Cross5049f022015-03-18 13:28:46 -07001561
Inseob Kim1f086e22019-05-09 13:29:15 +09001562 if c.installable() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001563 c.installer.install(ctx, c.outputFile.Path())
1564 if ctx.Failed() {
1565 return
Colin Crossca860ac2016-01-04 14:34:37 -08001566 }
Paul Duffinf51768a2020-03-04 14:52:46 +00001567 } else if !proptools.BoolDefault(c.Properties.Installable, true) {
1568 // If the module has been specifically configure to not be installed then
1569 // skip the installation as otherwise it will break when running inside make
1570 // as the output path to install will not be specified. Not all uninstallable
1571 // modules can skip installation as some are needed for resolving make side
1572 // dependencies.
1573 c.SkipInstall()
Dan Albertc403f7c2015-03-18 14:01:18 -07001574 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001575}
1576
Colin Cross0ea8ba82019-06-06 14:33:29 -07001577func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001578 if c.cachedToolchain == nil {
Colin Crossb98c8b02016-07-29 13:44:28 -07001579 c.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
Colin Cross3f40fa42015-01-30 17:27:36 -08001580 }
Colin Crossca860ac2016-01-04 14:34:37 -08001581 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001582}
1583
Colin Crossca860ac2016-01-04 14:34:37 -08001584func (c *Module) begin(ctx BaseModuleContext) {
1585 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001586 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001587 }
Colin Crossca860ac2016-01-04 14:34:37 -08001588 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001589 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001590 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001591 if c.stl != nil {
1592 c.stl.begin(ctx)
1593 }
Colin Cross16b23492016-01-06 14:41:07 -08001594 if c.sanitize != nil {
1595 c.sanitize.begin(ctx)
1596 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001597 if c.coverage != nil {
1598 c.coverage.begin(ctx)
1599 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001600 if c.sabi != nil {
1601 c.sabi.begin(ctx)
1602 }
Justin Yun8effde42017-06-23 19:24:43 +09001603 if c.vndkdep != nil {
1604 c.vndkdep.begin(ctx)
1605 }
Stephen Craneba090d12017-05-09 15:44:35 -07001606 if c.lto != nil {
1607 c.lto.begin(ctx)
1608 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001609 if c.pgo != nil {
1610 c.pgo.begin(ctx)
1611 }
Colin Crossca860ac2016-01-04 14:34:37 -08001612 for _, feature := range c.features {
1613 feature.begin(ctx)
1614 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001615 if ctx.useSdk() {
Dan Albertf5415d72017-08-17 16:19:59 -07001616 version, err := normalizeNdkApiLevel(ctx, ctx.sdkVersion(), ctx.Arch())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001617 if err != nil {
1618 ctx.PropertyErrorf("sdk_version", err.Error())
1619 }
Nan Zhang0007d812017-11-07 10:57:05 -08001620 c.Properties.Sdk_version = StringPtr(version)
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001621 }
Colin Crossca860ac2016-01-04 14:34:37 -08001622}
1623
Colin Cross37047f12016-12-13 17:06:13 -08001624func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001625 deps := Deps{}
1626
1627 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001628 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001629 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001630 // Add the PGO dependency (the clang_rt.profile runtime library), which
1631 // sometimes depends on symbols from libgcc, before libgcc gets added
1632 // in linkerDeps().
Pirama Arumuga Nainar49b53d52017-10-04 16:47:29 -07001633 if c.pgo != nil {
1634 deps = c.pgo.deps(ctx, deps)
1635 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001636 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001637 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001638 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001639 if c.stl != nil {
1640 deps = c.stl.deps(ctx, deps)
1641 }
Colin Cross16b23492016-01-06 14:41:07 -08001642 if c.sanitize != nil {
1643 deps = c.sanitize.deps(ctx, deps)
1644 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001645 if c.coverage != nil {
1646 deps = c.coverage.deps(ctx, deps)
1647 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001648 if c.sabi != nil {
1649 deps = c.sabi.deps(ctx, deps)
1650 }
Justin Yun8effde42017-06-23 19:24:43 +09001651 if c.vndkdep != nil {
1652 deps = c.vndkdep.deps(ctx, deps)
1653 }
Stephen Craneba090d12017-05-09 15:44:35 -07001654 if c.lto != nil {
1655 deps = c.lto.deps(ctx, deps)
1656 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001657 for _, feature := range c.features {
1658 deps = feature.deps(ctx, deps)
1659 }
1660
Colin Crossb6715442017-10-24 11:13:31 -07001661 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1662 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1663 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1664 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1665 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1666 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001667 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001668
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001669 for _, lib := range deps.ReexportSharedLibHeaders {
1670 if !inList(lib, deps.SharedLibs) {
1671 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1672 }
1673 }
1674
1675 for _, lib := range deps.ReexportStaticLibHeaders {
1676 if !inList(lib, deps.StaticLibs) {
1677 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs: '%s'", lib)
1678 }
1679 }
1680
Colin Cross5950f382016-12-13 12:50:57 -08001681 for _, lib := range deps.ReexportHeaderLibHeaders {
1682 if !inList(lib, deps.HeaderLibs) {
1683 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1684 }
1685 }
1686
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001687 for _, gen := range deps.ReexportGeneratedHeaders {
1688 if !inList(gen, deps.GeneratedHeaders) {
1689 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1690 }
1691 }
1692
Colin Crossc99deeb2016-04-11 15:06:20 -07001693 return deps
1694}
1695
Dan Albert7e9d2952016-08-04 13:02:36 -07001696func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001697 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001698 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001699 moduleContextImpl: moduleContextImpl{
1700 mod: c,
1701 },
1702 }
1703 ctx.ctx = ctx
1704
Colin Crossca860ac2016-01-04 14:34:37 -08001705 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001706}
1707
Jiyong Park7ed9de32018-10-15 22:25:07 +09001708// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09001709func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001710 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1711 version := name[sharp+1:]
1712 libname := name[:sharp]
1713 return libname, version
1714 }
1715 return name, ""
1716}
1717
Colin Cross1e676be2016-10-12 14:38:15 -07001718func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09001719 if !c.Enabled() {
1720 return
1721 }
1722
Colin Cross37047f12016-12-13 17:06:13 -08001723 ctx := &depsContext{
1724 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07001725 moduleContextImpl: moduleContextImpl{
1726 mod: c,
1727 },
1728 }
1729 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08001730
Colin Crossc99deeb2016-04-11 15:06:20 -07001731 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001732
Dan Albert914449f2016-06-17 16:45:24 -07001733 variantNdkLibs := []string{}
1734 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07001735 if ctx.Os() == android.Android {
Dan Albert914449f2016-06-17 16:45:24 -07001736 version := ctx.sdkVersion()
Dan Willemsen72d39932016-07-08 23:23:48 -07001737
Inseob Kimeec88e12020-01-22 11:11:29 +09001738 // rewriteLibs takes a list of names of shared libraries and scans it for three types
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001739 // of names:
Dan Albert914449f2016-06-17 16:45:24 -07001740 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001741 // 1. Name of an NDK library that refers to a prebuilt module.
1742 // For each of these, it adds the name of the prebuilt module (which will be in
1743 // prebuilts/ndk) to the list of nonvariant libs.
1744 // 2. Name of an NDK library that refers to an ndk_library module.
1745 // For each of these, it adds the name of the ndk_library module to the list of
1746 // variant libs.
1747 // 3. Anything else (so anything that isn't an NDK library).
1748 // It adds these to the nonvariantLibs list.
Dan Albert914449f2016-06-17 16:45:24 -07001749 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001750 // The caller can then know to add the variantLibs dependencies differently from the
1751 // nonvariantLibs
Inseob Kim9516ee92019-05-09 10:56:13 +09001752
Inseob Kim9516ee92019-05-09 10:56:13 +09001753 vendorPublicLibraries := vendorPublicLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001754 vendorSnapshotSharedLibs := vendorSnapshotSharedLibs(actx.Config())
1755
1756 rewriteVendorLibs := func(lib string) string {
1757 if isLlndkLibrary(lib, ctx.Config()) {
1758 return lib + llndkLibrarySuffix
1759 }
1760
1761 // only modules with BOARD_VNDK_VERSION uses snapshot.
1762 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1763 return lib
1764 }
1765
1766 if snapshot, ok := vendorSnapshotSharedLibs.get(lib, actx.Arch().ArchType); ok {
1767 return snapshot
1768 }
1769
1770 return lib
1771 }
1772
1773 rewriteLibs := func(list []string) (nonvariantLibs []string, variantLibs []string) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001774 variantLibs = []string{}
1775 nonvariantLibs = []string{}
Dan Albert914449f2016-06-17 16:45:24 -07001776 for _, entry := range list {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001777 // strip #version suffix out
Jiyong Park73c54ee2019-10-22 20:31:18 +09001778 name, _ := StubsLibNameAndVersion(entry)
Jiyong Park7ed9de32018-10-15 22:25:07 +09001779 if ctx.useSdk() && inList(name, ndkPrebuiltSharedLibraries) {
1780 if !inList(name, ndkMigratedLibs) {
1781 nonvariantLibs = append(nonvariantLibs, name+".ndk."+version)
Dan Albert914449f2016-06-17 16:45:24 -07001782 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001783 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Dan Albert914449f2016-06-17 16:45:24 -07001784 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001785 } else if ctx.useVndk() {
1786 nonvariantLibs = append(nonvariantLibs, rewriteVendorLibs(entry))
Inseob Kim9516ee92019-05-09 10:56:13 +09001787 } else if (ctx.Platform() || ctx.ProductSpecific()) && inList(name, *vendorPublicLibraries) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001788 vendorPublicLib := name + vendorPublicLibrarySuffix
Jiyong Park374510b2018-03-19 18:23:01 +09001789 if actx.OtherModuleExists(vendorPublicLib) {
1790 nonvariantLibs = append(nonvariantLibs, vendorPublicLib)
1791 } else {
1792 // This can happen if vendor_public_library module is defined in a
1793 // namespace that isn't visible to the current module. In that case,
1794 // link to the original library.
Jiyong Park7ed9de32018-10-15 22:25:07 +09001795 nonvariantLibs = append(nonvariantLibs, name)
Jiyong Park374510b2018-03-19 18:23:01 +09001796 }
Dan Albert914449f2016-06-17 16:45:24 -07001797 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001798 // put name#version back
Dan Willemsen7cbf5f82017-03-28 00:08:30 -07001799 nonvariantLibs = append(nonvariantLibs, entry)
Dan Willemsen72d39932016-07-08 23:23:48 -07001800 }
1801 }
Dan Albert914449f2016-06-17 16:45:24 -07001802 return nonvariantLibs, variantLibs
Dan Willemsen72d39932016-07-08 23:23:48 -07001803 }
1804
Inseob Kimeec88e12020-01-22 11:11:29 +09001805 deps.SharedLibs, variantNdkLibs = rewriteLibs(deps.SharedLibs)
1806 deps.LateSharedLibs, variantLateNdkLibs = rewriteLibs(deps.LateSharedLibs)
1807 deps.ReexportSharedLibHeaders, _ = rewriteLibs(deps.ReexportSharedLibHeaders)
1808 if ctx.useVndk() {
1809 for idx, lib := range deps.RuntimeLibs {
1810 deps.RuntimeLibs[idx] = rewriteVendorLibs(lib)
1811 }
1812 }
Dan Willemsen72d39932016-07-08 23:23:48 -07001813 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001814
Jiyong Park7e636d02019-01-28 16:16:54 +09001815 buildStubs := false
Jiyong Park7ed9de32018-10-15 22:25:07 +09001816 if c.linker != nil {
1817 if library, ok := c.linker.(*libraryDecorator); ok {
1818 if library.buildStubs() {
Jiyong Park7e636d02019-01-28 16:16:54 +09001819 buildStubs = true
Jiyong Park7ed9de32018-10-15 22:25:07 +09001820 }
1821 }
1822 }
1823
Inseob Kimeec88e12020-01-22 11:11:29 +09001824 rewriteSnapshotLibs := func(lib string, snapshotMap *snapshotMap) string {
1825 // only modules with BOARD_VNDK_VERSION uses snapshot.
1826 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1827 return lib
1828 }
1829
1830 if snapshot, ok := snapshotMap.get(lib, actx.Arch().ArchType); ok {
1831 return snapshot
1832 }
1833
1834 return lib
1835 }
1836
1837 vendorSnapshotHeaderLibs := vendorSnapshotHeaderLibs(actx.Config())
Colin Cross32ec36c2016-12-15 07:39:51 -08001838 for _, lib := range deps.HeaderLibs {
1839 depTag := headerDepTag
1840 if inList(lib, deps.ReexportHeaderLibHeaders) {
1841 depTag = headerExportDepTag
1842 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001843
1844 lib = rewriteSnapshotLibs(lib, vendorSnapshotHeaderLibs)
1845
Jiyong Park7e636d02019-01-28 16:16:54 +09001846 if buildStubs {
Colin Cross7228ecd2019-11-18 16:00:16 -08001847 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001848 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09001849 } else {
1850 actx.AddVariationDependencies(nil, depTag, lib)
1851 }
1852 }
1853
1854 if buildStubs {
1855 // Stubs lib does not have dependency to other static/shared libraries.
1856 // Don't proceed.
1857 return
Colin Cross32ec36c2016-12-15 07:39:51 -08001858 }
Colin Cross5950f382016-12-13 12:50:57 -08001859
Inseob Kimc0907f12019-02-08 21:00:45 +09001860 syspropImplLibraries := syspropImplLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001861 vendorSnapshotStaticLibs := vendorSnapshotStaticLibs(actx.Config())
Inseob Kimc0907f12019-02-08 21:00:45 +09001862
Jiyong Park5d1598f2019-02-25 22:14:17 +09001863 for _, lib := range deps.WholeStaticLibs {
1864 depTag := wholeStaticDepTag
1865 if impl, ok := syspropImplLibraries[lib]; ok {
1866 lib = impl
1867 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001868
1869 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1870
Jiyong Park5d1598f2019-02-25 22:14:17 +09001871 actx.AddVariationDependencies([]blueprint.Variation{
1872 {Mutator: "link", Variation: "static"},
1873 }, depTag, lib)
1874 }
1875
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001876 for _, lib := range deps.StaticLibs {
Ivan Lozano183a3212019-10-18 14:18:45 -07001877 depTag := StaticDepTag
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001878 if inList(lib, deps.ReexportStaticLibHeaders) {
1879 depTag = staticExportDepTag
1880 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001881
1882 if impl, ok := syspropImplLibraries[lib]; ok {
1883 lib = impl
1884 }
1885
Inseob Kimeec88e12020-01-22 11:11:29 +09001886 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1887
Dan Willemsen59339a22018-07-22 21:18:45 -07001888 actx.AddVariationDependencies([]blueprint.Variation{
1889 {Mutator: "link", Variation: "static"},
1890 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001891 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001892
Jooyung Han74066602020-03-20 04:29:24 +09001893 // staticUnwinderDep is treated as staticDep for Q apexes
1894 // so that native libraries/binaries are linked with static unwinder
1895 // because Q libc doesn't have unwinder APIs
1896 if deps.StaticUnwinderIfLegacy {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08001897 actx.AddVariationDependencies([]blueprint.Variation{
1898 {Mutator: "link", Variation: "static"},
1899 }, staticUnwinderDepTag, staticUnwinder(actx))
1900 }
1901
Inseob Kimeec88e12020-01-22 11:11:29 +09001902 for _, lib := range deps.LateStaticLibs {
1903 actx.AddVariationDependencies([]blueprint.Variation{
1904 {Mutator: "link", Variation: "static"},
1905 }, lateStaticDepTag, rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs))
1906 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001907
Ivan Lozano183a3212019-10-18 14:18:45 -07001908 addSharedLibDependencies := func(depTag DependencyTag, name string, version string) {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001909 var variations []blueprint.Variation
1910 variations = append(variations, blueprint.Variation{Mutator: "link", Variation: "shared"})
Jooyung Hanc40b5192020-04-10 12:57:24 +09001911 if version != "" && VersionVariantAvailable(c) {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001912 // Version is explicitly specified. i.e. libFoo#30
1913 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozano183a3212019-10-18 14:18:45 -07001914 depTag.ExplicitlyVersioned = true
Jiyong Park25fc6a92018-11-18 18:02:45 +09001915 }
1916 actx.AddVariationDependencies(variations, depTag, name)
1917
Jooyung Han0c4e0162020-02-26 22:45:42 +09001918 // If the version is not specified, add dependency to all stubs libraries.
Jiyong Park25fc6a92018-11-18 18:02:45 +09001919 // The stubs library will be used when the depending module is built for APEX and
1920 // the dependent module is not in the same APEX.
Jooyung Hanc40b5192020-04-10 12:57:24 +09001921 if version == "" && VersionVariantAvailable(c) {
Jooyung Han0c4e0162020-02-26 22:45:42 +09001922 for _, ver := range stubsVersionsFor(actx.Config())[name] {
1923 // Note that depTag.ExplicitlyVersioned is false in this case.
1924 actx.AddVariationDependencies([]blueprint.Variation{
1925 {Mutator: "link", Variation: "shared"},
1926 {Mutator: "version", Variation: ver},
1927 }, depTag, name)
1928 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001929 }
1930 }
1931
Jiyong Park7ed9de32018-10-15 22:25:07 +09001932 // shared lib names without the #version suffix
1933 var sharedLibNames []string
1934
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001935 for _, lib := range deps.SharedLibs {
Ivan Lozano183a3212019-10-18 14:18:45 -07001936 depTag := SharedDepTag
Jiyong Parkd7536ba2020-01-16 17:14:23 +09001937 if c.static() {
1938 depTag = SharedFromStaticDepTag
1939 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001940 if inList(lib, deps.ReexportSharedLibHeaders) {
1941 depTag = sharedExportDepTag
1942 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001943
1944 if impl, ok := syspropImplLibraries[lib]; ok {
1945 lib = impl
1946 }
1947
Jiyong Park73c54ee2019-10-22 20:31:18 +09001948 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09001949 sharedLibNames = append(sharedLibNames, name)
1950
Jiyong Park25fc6a92018-11-18 18:02:45 +09001951 addSharedLibDependencies(depTag, name, version)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001952 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001953
Jiyong Park7ed9de32018-10-15 22:25:07 +09001954 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001955 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001956 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
1957 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
1958 // linking against both the stubs lib and the non-stubs lib at the same time.
1959 continue
1960 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001961 addSharedLibDependencies(lateSharedDepTag, lib, "")
Jiyong Park7ed9de32018-10-15 22:25:07 +09001962 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001963
Dan Willemsen59339a22018-07-22 21:18:45 -07001964 actx.AddVariationDependencies([]blueprint.Variation{
1965 {Mutator: "link", Variation: "shared"},
1966 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08001967
Colin Cross68861832016-07-08 10:41:41 -07001968 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001969
1970 for _, gen := range deps.GeneratedHeaders {
1971 depTag := genHeaderDepTag
1972 if inList(gen, deps.ReexportGeneratedHeaders) {
1973 depTag = genHeaderExportDepTag
1974 }
1975 actx.AddDependency(c, depTag, gen)
1976 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07001977
Colin Cross42d48b72018-08-29 14:10:52 -07001978 actx.AddVariationDependencies(nil, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07001979
1980 if deps.CrtBegin != "" {
Ivan Lozano183a3212019-10-18 14:18:45 -07001981 actx.AddVariationDependencies(nil, CrtBeginDepTag, deps.CrtBegin)
Colin Crossca860ac2016-01-04 14:34:37 -08001982 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001983 if deps.CrtEnd != "" {
Ivan Lozano183a3212019-10-18 14:18:45 -07001984 actx.AddVariationDependencies(nil, CrtEndDepTag, deps.CrtEnd)
Colin Cross21b9a242015-03-24 14:15:58 -07001985 }
Dan Willemsena0790e32018-10-12 00:24:23 -07001986 if deps.LinkerFlagsFile != "" {
1987 actx.AddDependency(c, linkerFlagsDepTag, deps.LinkerFlagsFile)
1988 }
1989 if deps.DynamicLinker != "" {
1990 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07001991 }
Dan Albert914449f2016-06-17 16:45:24 -07001992
1993 version := ctx.sdkVersion()
1994 actx.AddVariationDependencies([]blueprint.Variation{
Dan Willemsen59339a22018-07-22 21:18:45 -07001995 {Mutator: "ndk_api", Variation: version},
1996 {Mutator: "link", Variation: "shared"},
1997 }, ndkStubDepTag, variantNdkLibs...)
Dan Albert914449f2016-06-17 16:45:24 -07001998 actx.AddVariationDependencies([]blueprint.Variation{
Dan Willemsen59339a22018-07-22 21:18:45 -07001999 {Mutator: "ndk_api", Variation: version},
2000 {Mutator: "link", Variation: "shared"},
2001 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002002
2003 if vndkdep := c.vndkdep; vndkdep != nil {
2004 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002005 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002006 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002007 {Mutator: "link", Variation: "shared"},
2008 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08002009 }
2010 }
Colin Cross6362e272015-10-29 15:25:03 -07002011}
Colin Cross21b9a242015-03-24 14:15:58 -07002012
Colin Crosse40b4ea2018-10-02 22:25:58 -07002013func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002014 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2015 c.beginMutator(ctx)
2016 }
2017}
2018
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002019// Whether a module can link to another module, taking into
2020// account NDK linking.
Ivan Lozano52767be2019-10-18 14:49:46 -07002021func checkLinkType(ctx android.ModuleContext, from LinkableInterface, to LinkableInterface, tag DependencyTag) {
2022 if from.Module().Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002023 // Host code is not restricted
2024 return
2025 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002026
2027 // VNDK is cc.Module supported only for now.
2028 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002029 // Though vendor code is limited by the vendor mutator,
2030 // each vendor-available module needs to check
2031 // link-type for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002032 if ccTo, ok := to.(*Module); ok {
2033 if ccFrom.vndkdep != nil {
2034 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2035 }
2036 } else {
2037 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002038 }
2039 return
2040 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002041 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002042 // Platform code can link to anything
2043 return
2044 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002045 if from.InRamdisk() {
2046 // Ramdisk code is not NDK
2047 return
2048 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002049 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002050 // Recovery code is not NDK
2051 return
2052 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002053 if to.ToolchainLibrary() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002054 // These are always allowed
2055 return
2056 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002057 if to.NdkPrebuiltStl() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002058 // These are allowed, but they don't set sdk_version
2059 return
2060 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002061 if to.StubDecorator() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002062 // These aren't real libraries, but are the stub shared libraries that are included in
2063 // the NDK.
2064 return
2065 }
Logan Chien834b9a62019-01-14 15:39:03 +08002066
Ivan Lozano52767be2019-10-18 14:49:46 -07002067 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002068 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2069 // to link to libc++ (non-NDK and without sdk_version).
2070 return
2071 }
2072
Ivan Lozano52767be2019-10-18 14:49:46 -07002073 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002074 // NDK code linking to platform code is never okay.
2075 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002076 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002077 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002078 }
2079
2080 // At this point we know we have two NDK libraries, but we need to
2081 // check that we're not linking against anything built against a higher
2082 // API level, as it is only valid to link against older or equivalent
2083 // APIs.
2084
Inseob Kim01a28722018-04-11 09:48:45 +09002085 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002086 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002087 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002088 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002089 // Current can't be linked against by anything else.
2090 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002091 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002092 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002093 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002094 if err != nil {
2095 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002096 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002097 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002098 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002099 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002100 if err != nil {
2101 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002102 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002103 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002104 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002105
Inseob Kim01a28722018-04-11 09:48:45 +09002106 if toApi > fromApi {
2107 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002108 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002109 }
2110 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002111 }
Dan Albert202fe492017-12-15 13:56:59 -08002112
2113 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002114 fromStl := from.SelectedStl()
2115 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002116 if fromStl == "" || toStl == "" {
2117 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002118 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002119 // We can be permissive with the system "STL" since it is only the C++
2120 // ABI layer, but in the future we should make sure that everyone is
2121 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002122 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002123 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002124 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2125 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002126 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002127}
2128
Jiyong Park5fb8c102018-04-09 12:03:06 +09002129// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002130// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2131// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002132// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002133func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2134 check := func(child, parent android.Module) bool {
2135 to, ok := child.(*Module)
2136 if !ok {
2137 // follow thru cc.Defaults, etc.
2138 return true
2139 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002140
Jooyung Hana70f0672019-01-18 15:20:43 +09002141 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2142 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002143 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002144
2145 // if target lib has no vendor variant, keep checking dependency graph
Ivan Lozano52767be2019-10-18 14:49:46 -07002146 if !to.HasVendorVariant() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002147 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002148 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002149
Jooyung Han0302a842019-10-30 18:43:49 +09002150 if to.isVndkSp() || to.isLlndk(ctx.Config()) || Bool(to.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002151 return false
2152 }
2153
2154 var stringPath []string
2155 for _, m := range ctx.GetWalkPath() {
2156 stringPath = append(stringPath, m.Name())
2157 }
2158 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2159 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
2160 "(dependency: %s)", ctx.OtherModuleName(to), strings.Join(stringPath, " -> "))
2161 return false
2162 }
2163 if module, ok := ctx.Module().(*Module); ok {
2164 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jooyung Han0302a842019-10-30 18:43:49 +09002165 if module.isLlndk(ctx.Config()) || Bool(module.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002166 ctx.WalkDeps(check)
2167 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002168 }
2169 }
2170}
2171
Colin Crossc99deeb2016-04-11 15:06:20 -07002172// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002173func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002174 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002175
Ivan Lozano183a3212019-10-18 14:18:45 -07002176 directStaticDeps := []LinkableInterface{}
2177 directSharedDeps := []LinkableInterface{}
Jeff Gaston294356f2017-09-27 17:05:30 -07002178
Inseob Kim9516ee92019-05-09 10:56:13 +09002179 vendorPublicLibraries := vendorPublicLibraries(ctx.Config())
2180
Inseob Kim69378442019-06-03 19:10:47 +09002181 reexportExporter := func(exporter exportedFlagsProducer) {
2182 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.exportedDirs()...)
2183 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.exportedSystemDirs()...)
2184 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.exportedFlags()...)
2185 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.exportedDeps()...)
Inseob Kimd110f872019-12-06 13:15:38 +09002186 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.exportedGeneratedHeaders()...)
Inseob Kim69378442019-06-03 19:10:47 +09002187 }
2188
Colin Crossd11fcda2017-10-23 17:59:01 -07002189 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002190 depName := ctx.OtherModuleName(dep)
2191 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002192
Ivan Lozano52767be2019-10-18 14:49:46 -07002193 ccDep, ok := dep.(LinkableInterface)
2194 if !ok {
2195
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002196 // handling for a few module types that aren't cc Module but that are also supported
2197 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002198 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002199 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002200 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2201 genRule.GeneratedSourceFiles()...)
2202 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002203 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002204 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002205 // Support exported headers from a generated_sources dependency
2206 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002207 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002208 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002209 depPaths.GeneratedHeaders = append(depPaths.GeneratedHeaders,
Inseob Kimd110f872019-12-06 13:15:38 +09002210 genRule.GeneratedSourceFiles()...)
2211 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002212 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002213 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002214 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002215 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002216 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002217 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2218 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002219 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002220 // 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 +09002221 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002222
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002223 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002224 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002225 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002226 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002227 case linkerFlagsDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002228 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002229 files := genRule.GeneratedSourceFiles()
2230 if len(files) == 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002231 depPaths.LinkerFlagsFile = android.OptionalPathForPath(files[0])
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002232 } else if len(files) > 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002233 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 -07002234 }
2235 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002236 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002237 }
Colin Crossca860ac2016-01-04 14:34:37 -08002238 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002239 return
2240 }
2241
Colin Crossfe17f6f2019-03-28 19:30:56 -07002242 if depTag == android.ProtoPluginDepTag {
2243 return
2244 }
Jooyung Han67a96cd2020-03-13 15:23:36 +09002245 if depTag == llndkImplDep {
2246 return
2247 }
Colin Crossfe17f6f2019-03-28 19:30:56 -07002248
Colin Crossd11fcda2017-10-23 17:59:01 -07002249 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002250 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2251 return
2252 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002253 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han67a96cd2020-03-13 15:23:36 +09002254 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2255 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002256 return
2257 }
2258
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002259 // re-exporting flags
2260 if depTag == reuseObjTag {
Ivan Lozano52767be2019-10-18 14:49:46 -07002261 // reusing objects only make sense for cc.Modules.
2262 if ccReuseDep, ok := ccDep.(*Module); ok && ccDep.CcLibraryInterface() {
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08002263 c.staticVariant = ccDep
Ivan Lozano52767be2019-10-18 14:49:46 -07002264 objs, exporter := ccReuseDep.compiler.(libraryInterface).reuseObjs()
Colin Cross10d22312017-05-03 11:01:58 -07002265 depPaths.Objs = depPaths.Objs.Append(objs)
Inseob Kim69378442019-06-03 19:10:47 +09002266 reexportExporter(exporter)
Colin Crossbba99042016-11-23 15:45:05 -08002267 return
2268 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002269 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09002270
Jiyong Parke4bb9862019-02-01 00:31:10 +09002271 if depTag == staticVariantTag {
Ivan Lozano52767be2019-10-18 14:49:46 -07002272 // staticVariants are a cc.Module specific concept.
2273 if _, ok := ccDep.(*Module); ok && ccDep.CcLibraryInterface() {
Jiyong Parke4bb9862019-02-01 00:31:10 +09002274 c.staticVariant = ccDep
2275 return
2276 }
2277 }
2278
Jooyung Han74066602020-03-20 04:29:24 +09002279 // For the dependency from platform to apex, use the latest stubs
2280 c.apexSdkVersion = android.FutureApiLevel
2281 if !c.IsForPlatform() {
2282 c.apexSdkVersion = c.ApexProperties.Info.MinSdkVersion
2283 }
2284
2285 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2286 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2287 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2288 // (b/144430859)
2289 c.apexSdkVersion = android.FutureApiLevel
2290 }
2291
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002292 if depTag == staticUnwinderDepTag {
Jooyung Han74066602020-03-20 04:29:24 +09002293 // Use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
2294 if c.apexSdkVersion <= android.SdkVersion_Android10 {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002295 depTag = StaticDepTag
2296 } else {
2297 return
2298 }
2299 }
2300
Ivan Lozano183a3212019-10-18 14:18:45 -07002301 // Extract ExplicitlyVersioned field from the depTag and reset it inside the struct.
2302 // Otherwise, SharedDepTag and lateSharedDepTag with ExplicitlyVersioned set to true
2303 // won't be matched to SharedDepTag and lateSharedDepTag.
Jiyong Park25fc6a92018-11-18 18:02:45 +09002304 explicitlyVersioned := false
Ivan Lozano183a3212019-10-18 14:18:45 -07002305 if t, ok := depTag.(DependencyTag); ok {
2306 explicitlyVersioned = t.ExplicitlyVersioned
2307 t.ExplicitlyVersioned = false
Jiyong Park25fc6a92018-11-18 18:02:45 +09002308 depTag = t
2309 }
2310
Ivan Lozano183a3212019-10-18 14:18:45 -07002311 if t, ok := depTag.(DependencyTag); ok && t.Library {
Jiyong Park16e91a02018-12-20 18:18:08 +09002312 depIsStatic := false
2313 switch depTag {
Ivan Lozano183a3212019-10-18 14:18:45 -07002314 case StaticDepTag, staticExportDepTag, lateStaticDepTag, wholeStaticDepTag:
Jiyong Park16e91a02018-12-20 18:18:08 +09002315 depIsStatic = true
2316 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002317 if ccDep.CcLibrary() && !depIsStatic {
2318 depIsStubs := ccDep.BuildStubs()
Jooyung Hanc40b5192020-04-10 12:57:24 +09002319 depHasStubs := VersionVariantAvailable(c) && ccDep.HasStubsVariants()
Jiyong Park0ddfcd12018-12-11 01:35:25 +09002320 depInSameApex := android.DirectlyInApex(c.ApexName(), depName)
Nicolas Geoffrayc22c1bf2019-01-15 19:53:23 +00002321 depInPlatform := !android.DirectlyInAnyApex(ctx, depName)
Jiyong Park25fc6a92018-11-18 18:02:45 +09002322
2323 var useThisDep bool
2324 if depIsStubs && explicitlyVersioned {
2325 // Always respect dependency to the versioned stubs (i.e. libX#10)
2326 useThisDep = true
2327 } else if !depHasStubs {
2328 // Use non-stub variant if that is the only choice
2329 // (i.e. depending on a lib without stubs.version property)
2330 useThisDep = true
2331 } else if c.IsForPlatform() {
2332 // If not building for APEX, use stubs only when it is from
2333 // an APEX (and not from platform)
2334 useThisDep = (depInPlatform != depIsStubs)
Jooyung Hanc40b5192020-04-10 12:57:24 +09002335 if c.bootstrap() {
2336 // However, for host, ramdisk, recovery or bootstrap modules,
Jiyong Park25fc6a92018-11-18 18:02:45 +09002337 // always link to non-stub variant
2338 useThisDep = !depIsStubs
2339 }
Jiyong Parkf0d01b72020-04-13 16:19:48 +09002340 for _, testFor := range c.TestFor() {
2341 // Another exception: if this module is bundled with an APEX, then
2342 // it is linked with the non-stub variant of a module in the APEX
2343 // as if this is part of the APEX.
2344 if android.DirectlyInApex(testFor, depName) {
2345 useThisDep = !depIsStubs
2346 break
2347 }
2348 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09002349 } else {
2350 // If building for APEX, use stubs only when it is not from
2351 // the same APEX
2352 useThisDep = (depInSameApex != depIsStubs)
2353 }
2354
Jooyung Han0c4e0162020-02-26 22:45:42 +09002355 // when to use (unspecified) stubs, check min_sdk_version and choose the right one
2356 if useThisDep && depIsStubs && !explicitlyVersioned {
Jooyung Han74066602020-03-20 04:29:24 +09002357 versionToUse, err := c.ChooseSdkVersion(ccDep.StubsVersions(), c.apexSdkVersion)
Jooyung Han0c4e0162020-02-26 22:45:42 +09002358 if err != nil {
2359 ctx.OtherModuleErrorf(dep, err.Error())
2360 return
2361 }
2362 if versionToUse != ccDep.StubsVersion() {
2363 useThisDep = false
2364 }
2365 }
2366
Jiyong Park25fc6a92018-11-18 18:02:45 +09002367 if !useThisDep {
2368 return // stop processing this dep
2369 }
2370 }
Jooyung Han67a96cd2020-03-13 15:23:36 +09002371 if c.UseVndk() {
2372 if m, ok := ccDep.(*Module); ok && m.IsStubs() { // LLNDK
2373 // by default, use current version of LLNDK
2374 versionToUse := ""
2375 versions := stubsVersionsFor(ctx.Config())[depName]
2376 if c.ApexName() != "" && len(versions) > 0 {
2377 // if this is for use_vendor apex && dep has stubsVersions
2378 // apply the same rule of apex sdk enforcement to choose right version
2379 var err error
Jooyung Han74066602020-03-20 04:29:24 +09002380 versionToUse, err = c.ChooseSdkVersion(versions, c.apexSdkVersion)
Jooyung Han67a96cd2020-03-13 15:23:36 +09002381 if err != nil {
2382 ctx.OtherModuleErrorf(dep, err.Error())
2383 return
2384 }
2385 }
2386 if versionToUse != ccDep.StubsVersion() {
2387 return
2388 }
2389 }
2390 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09002391
Ivan Lozanoe0833b12019-11-06 19:15:49 -08002392 depPaths.IncludeDirs = append(depPaths.IncludeDirs, ccDep.IncludeDirs()...)
2393
Ivan Lozano52767be2019-10-18 14:49:46 -07002394 // Exporting flags only makes sense for cc.Modules
2395 if _, ok := ccDep.(*Module); ok {
2396 if i, ok := ccDep.(*Module).linker.(exportedFlagsProducer); ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002397 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, i.exportedSystemDirs()...)
Inseob Kimd110f872019-12-06 13:15:38 +09002398 depPaths.GeneratedHeaders = append(depPaths.GeneratedHeaders, i.exportedGeneratedHeaders()...)
2399 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, i.exportedDeps()...)
Ivan Lozano52767be2019-10-18 14:49:46 -07002400 depPaths.Flags = append(depPaths.Flags, i.exportedFlags()...)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002401
Ivan Lozano52767be2019-10-18 14:49:46 -07002402 if t.ReexportFlags {
2403 reexportExporter(i)
2404 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2405 // Re-exported shared library headers must be included as well since they can help us with type information
2406 // about template instantiations (instantiated from their headers).
2407 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2408 // scripts.
2409 c.sabi.Properties.ReexportedIncludes = append(
2410 c.sabi.Properties.ReexportedIncludes, i.exportedDirs().Strings()...)
2411 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002412 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002413 }
Logan Chienf3511742017-10-31 18:04:35 +08002414 checkLinkType(ctx, c, ccDep, t)
Colin Crossc99deeb2016-04-11 15:06:20 -07002415 }
2416
Colin Cross26c34ed2016-09-30 17:10:16 -07002417 var ptr *android.Paths
Colin Cross635c3b02016-05-18 15:37:25 -07002418 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002419
Ivan Lozano52767be2019-10-18 14:49:46 -07002420 linkFile := ccDep.OutputFile()
Colin Cross26c34ed2016-09-30 17:10:16 -07002421 depFile := android.OptionalPath{}
2422
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002423 switch depTag {
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002424 case ndkStubDepTag, SharedDepTag, SharedFromStaticDepTag, sharedExportDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07002425 ptr = &depPaths.SharedLibs
2426 depPtr = &depPaths.SharedLibsDeps
Ivan Lozano52767be2019-10-18 14:49:46 -07002427 depFile = ccDep.Toc()
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08002428 directSharedDeps = append(directSharedDeps, ccDep)
Ivan Lozano183a3212019-10-18 14:18:45 -07002429
Jiyong Park64a44f22019-01-18 14:37:08 +09002430 case earlySharedDepTag:
2431 ptr = &depPaths.EarlySharedLibs
2432 depPtr = &depPaths.EarlySharedLibsDeps
Ivan Lozano52767be2019-10-18 14:49:46 -07002433 depFile = ccDep.Toc()
Jiyong Park64a44f22019-01-18 14:37:08 +09002434 directSharedDeps = append(directSharedDeps, ccDep)
Dan Albert914449f2016-06-17 16:45:24 -07002435 case lateSharedDepTag, ndkLateStubDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07002436 ptr = &depPaths.LateSharedLibs
2437 depPtr = &depPaths.LateSharedLibsDeps
Ivan Lozano52767be2019-10-18 14:49:46 -07002438 depFile = ccDep.Toc()
Ivan Lozano183a3212019-10-18 14:18:45 -07002439 case StaticDepTag, staticExportDepTag:
Jeff Gaston294356f2017-09-27 17:05:30 -07002440 ptr = nil
2441 directStaticDeps = append(directStaticDeps, ccDep)
Colin Crossc99deeb2016-04-11 15:06:20 -07002442 case lateStaticDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07002443 ptr = &depPaths.LateStaticLibs
Colin Crossc99deeb2016-04-11 15:06:20 -07002444 case wholeStaticDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07002445 ptr = &depPaths.WholeStaticLibs
Ivan Lozano52767be2019-10-18 14:49:46 -07002446 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002447 ctx.ModuleErrorf("module %q not a static library", depName)
Colin Crossc99deeb2016-04-11 15:06:20 -07002448 return
2449 }
2450
Ivan Lozano52767be2019-10-18 14:49:46 -07002451 // Because the static library objects are included, this only makes sense
2452 // in the context of proper cc.Modules.
2453 if ccWholeStaticLib, ok := ccDep.(*Module); ok {
2454 staticLib := ccWholeStaticLib.linker.(libraryInterface)
2455 if missingDeps := staticLib.getWholeStaticMissingDeps(); missingDeps != nil {
2456 postfix := " (required by " + ctx.OtherModuleName(dep) + ")"
2457 for i := range missingDeps {
2458 missingDeps[i] += postfix
2459 }
2460 ctx.AddMissingDependencies(missingDeps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002461 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002462 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLib.objs())
2463 } else {
2464 ctx.ModuleErrorf(
2465 "non-cc.Modules cannot be included as whole static libraries.", depName)
2466 return
Colin Crossc99deeb2016-04-11 15:06:20 -07002467 }
Colin Cross5950f382016-12-13 12:50:57 -08002468 case headerDepTag:
2469 // Nothing
Colin Crossc99deeb2016-04-11 15:06:20 -07002470 case objDepTag:
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002471 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
Ivan Lozano183a3212019-10-18 14:18:45 -07002472 case CrtBeginDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07002473 depPaths.CrtBegin = linkFile
Ivan Lozano183a3212019-10-18 14:18:45 -07002474 case CrtEndDepTag:
Colin Cross26c34ed2016-09-30 17:10:16 -07002475 depPaths.CrtEnd = linkFile
Dan Willemsena0790e32018-10-12 00:24:23 -07002476 case dynamicLinkerDepTag:
2477 depPaths.DynamicLinker = linkFile
Colin Crossc99deeb2016-04-11 15:06:20 -07002478 }
2479
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002480 switch depTag {
Ivan Lozano183a3212019-10-18 14:18:45 -07002481 case StaticDepTag, staticExportDepTag, lateStaticDepTag:
Ivan Lozano52767be2019-10-18 14:49:46 -07002482 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002483 ctx.ModuleErrorf("module %q not a static library", depName)
Dan Willemsen581341d2017-02-09 16:16:31 -08002484 return
2485 }
2486
2487 // When combining coverage files for shared libraries and executables, coverage files
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08002488 // in static libraries act as if they were whole static libraries. The same goes for
2489 // source based Abi dump files.
Ivan Lozano52767be2019-10-18 14:49:46 -07002490 // This should only be done for cc.Modules
2491 if c, ok := ccDep.(*Module); ok {
2492 staticLib := c.linker.(libraryInterface)
2493 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2494 staticLib.objs().coverageFiles...)
2495 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2496 staticLib.objs().sAbiDumpFiles...)
2497 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002498 }
2499
Colin Cross26c34ed2016-09-30 17:10:16 -07002500 if ptr != nil {
Colin Crossce75d2c2016-10-06 16:12:58 -07002501 if !linkFile.Valid() {
Isaac Chen2c0a1802019-10-15 17:16:05 +08002502 if !ctx.Config().AllowMissingDependencies() {
2503 ctx.ModuleErrorf("module %q missing output file", depName)
2504 } else {
2505 ctx.AddMissingDependencies([]string{depName})
2506 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002507 return
2508 }
Colin Cross26c34ed2016-09-30 17:10:16 -07002509 *ptr = append(*ptr, linkFile.Path())
2510 }
2511
Colin Crossc99deeb2016-04-11 15:06:20 -07002512 if depPtr != nil {
Colin Cross26c34ed2016-09-30 17:10:16 -07002513 dep := depFile
2514 if !dep.Valid() {
2515 dep = linkFile
2516 }
2517 *depPtr = append(*depPtr, dep.Path())
Colin Crossca860ac2016-01-04 14:34:37 -08002518 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002519
Inseob Kimeec88e12020-01-22 11:11:29 +09002520 vendorSuffixModules := vendorSuffixModules(ctx.Config())
2521
2522 baseLibName := func(depName string) string {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002523 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
Jiyong Park374510b2018-03-19 18:23:01 +09002524 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Jiyong Park27b188b2017-07-18 13:23:39 +09002525 libName = strings.TrimPrefix(libName, "prebuilt_")
Inseob Kimeec88e12020-01-22 11:11:29 +09002526 return libName
2527 }
2528
2529 makeLibName := func(depName string) string {
2530 libName := baseLibName(depName)
Jooyung Han0302a842019-10-30 18:43:49 +09002531 isLLndk := isLlndkLibrary(libName, ctx.Config())
Inseob Kim9516ee92019-05-09 10:56:13 +09002532 isVendorPublicLib := inList(libName, *vendorPublicLibraries)
Ivan Lozano52767be2019-10-18 14:49:46 -07002533 bothVendorAndCoreVariantsExist := ccDep.HasVendorVariant() || isLLndk
Vic Yangefd249e2018-11-12 20:19:56 -08002534
Inseob Kimeec88e12020-01-22 11:11:29 +09002535 if c, ok := ccDep.(*Module); ok {
2536 // Use base module name for snapshots when exporting to Makefile.
Inseob Kim7ac1fa72020-03-14 01:30:34 +09002537 if c.isSnapshotPrebuilt() {
Inseob Kimeec88e12020-01-22 11:11:29 +09002538 baseName := c.BaseModuleName()
Inseob Kim7ac1fa72020-03-14 01:30:34 +09002539
2540 if c.IsVndk() {
2541 return baseName + ".vendor"
2542 }
2543
Inseob Kimeec88e12020-01-22 11:11:29 +09002544 if vendorSuffixModules[baseName] {
2545 return baseName + ".vendor"
2546 } else {
2547 return baseName
2548 }
2549 }
2550 }
2551
Yifan Hong1b3348d2020-01-21 15:53:22 -08002552 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() && !c.InRamdisk() && !c.InRecovery() {
Vic Yangefd249e2018-11-12 20:19:56 -08002553 // The vendor module is a no-vendor-variant VNDK library. Depend on the
2554 // core module instead.
2555 return libName
Ivan Lozano52767be2019-10-18 14:49:46 -07002556 } else if c.UseVndk() && bothVendorAndCoreVariantsExist {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002557 // The vendor module in Make will have been renamed to not conflict with the core
2558 // module, so update the dependency name here accordingly.
Justin Yun5f7f7e82019-11-18 19:52:14 +09002559 return libName + c.getNameSuffixWithVndkVersion(ctx)
Jiyong Park374510b2018-03-19 18:23:01 +09002560 } else if (ctx.Platform() || ctx.ProductSpecific()) && isVendorPublicLib {
Logan Chien43d34c32017-12-20 01:17:32 +08002561 return libName + vendorPublicLibrarySuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08002562 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
2563 return libName + ramdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07002564 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002565 return libName + recoverySuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07002566 } else if ccDep.Module().Target().NativeBridge == android.NativeBridgeEnabled {
dimitry43204492019-05-23 13:24:38 +02002567 return libName + nativeBridgeSuffix
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002568 } else {
Logan Chien43d34c32017-12-20 01:17:32 +08002569 return libName
Jiyong Park27b188b2017-07-18 13:23:39 +09002570 }
Logan Chien43d34c32017-12-20 01:17:32 +08002571 }
2572
2573 // Export the shared libs to Make.
2574 switch depTag {
Ivan Lozano183a3212019-10-18 14:18:45 -07002575 case SharedDepTag, sharedExportDepTag, lateSharedDepTag, earlySharedDepTag:
Ivan Lozano52767be2019-10-18 14:49:46 -07002576 if ccDep.CcLibrary() {
2577 if ccDep.BuildStubs() && android.InAnyApex(depName) {
Logan Chien09106e12019-01-18 14:57:48 +08002578 // Add the dependency to the APEX(es) providing the library so that
Jiyong Parkde866cb2018-12-07 23:08:36 +09002579 // m <module> can trigger building the APEXes as well.
Jiyong Park0ddfcd12018-12-11 01:35:25 +09002580 for _, an := range android.GetApexesForModule(depName) {
Jiyong Parkde866cb2018-12-07 23:08:36 +09002581 c.Properties.ApexesProvidingSharedLibs = append(
2582 c.Properties.ApexesProvidingSharedLibs, an)
2583 }
Jiyong Parkde866cb2018-12-07 23:08:36 +09002584 }
2585 }
2586
Jiyong Park27b188b2017-07-18 13:23:39 +09002587 // Note: the order of libs in this list is not important because
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002588 // they merely serve as Make dependencies and do not affect this lib itself.
Logan Chien43d34c32017-12-20 01:17:32 +08002589 c.Properties.AndroidMkSharedLibs = append(
2590 c.Properties.AndroidMkSharedLibs, makeLibName(depName))
Inseob Kimeec88e12020-01-22 11:11:29 +09002591 // Record baseLibName for snapshots.
2592 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, baseLibName(depName))
Logan Chienc7f797e2019-01-14 15:35:08 +08002593 case ndkStubDepTag, ndkLateStubDepTag:
Logan Chienc7f797e2019-01-14 15:35:08 +08002594 c.Properties.AndroidMkSharedLibs = append(
2595 c.Properties.AndroidMkSharedLibs,
Ivan Lozano52767be2019-10-18 14:49:46 -07002596 depName+"."+ccDep.ApiLevel())
Ivan Lozano183a3212019-10-18 14:18:45 -07002597 case StaticDepTag, staticExportDepTag, lateStaticDepTag:
Jaewoong Jung16c7d3d2018-11-16 01:19:56 +00002598 c.Properties.AndroidMkStaticLibs = append(
2599 c.Properties.AndroidMkStaticLibs, makeLibName(depName))
Logan Chien43d34c32017-12-20 01:17:32 +08002600 case runtimeDepTag:
2601 c.Properties.AndroidMkRuntimeLibs = append(
2602 c.Properties.AndroidMkRuntimeLibs, makeLibName(depName))
Inseob Kimeec88e12020-01-22 11:11:29 +09002603 // Record baseLibName for snapshots.
2604 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, baseLibName(depName))
Jaewoong Jung16c7d3d2018-11-16 01:19:56 +00002605 case wholeStaticDepTag:
2606 c.Properties.AndroidMkWholeStaticLibs = append(
2607 c.Properties.AndroidMkWholeStaticLibs, makeLibName(depName))
Jiyong Park27b188b2017-07-18 13:23:39 +09002608 }
Colin Crossca860ac2016-01-04 14:34:37 -08002609 })
2610
Jeff Gaston294356f2017-09-27 17:05:30 -07002611 // use the ordered dependencies as this module's dependencies
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -08002612 depPaths.StaticLibs = append(depPaths.StaticLibs, orderStaticModuleDeps(c, directStaticDeps, directSharedDeps)...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002613
Colin Crossdd84e052017-05-17 13:44:16 -07002614 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002615 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002616 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2617 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002618 depPaths.GeneratedHeaders = android.FirstUniquePaths(depPaths.GeneratedHeaders)
Inseob Kimd110f872019-12-06 13:15:38 +09002619 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002620 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2621 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002622 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002623 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002624 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002625
2626 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002627 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002628 }
Colin Crossdd84e052017-05-17 13:44:16 -07002629
Colin Crossca860ac2016-01-04 14:34:37 -08002630 return depPaths
2631}
2632
2633func (c *Module) InstallInData() bool {
2634 if c.installer == nil {
2635 return false
2636 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002637 return c.installer.inData()
2638}
2639
2640func (c *Module) InstallInSanitizerDir() bool {
2641 if c.installer == nil {
2642 return false
2643 }
2644 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07002645 return true
2646 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002647 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08002648}
2649
Yifan Hong1b3348d2020-01-21 15:53:22 -08002650func (c *Module) InstallInRamdisk() bool {
2651 return c.InRamdisk()
2652}
2653
Jiyong Parkf9332f12018-02-01 00:54:12 +09002654func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07002655 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09002656}
2657
Martin Stjernholm2a6e9d02020-03-31 16:05:34 +01002658func (c *Module) SkipInstall() {
2659 if c.installer == nil {
2660 c.ModuleBase.SkipInstall()
2661 return
2662 }
2663 c.installer.skipInstall(c)
2664}
2665
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07002666func (c *Module) HostToolPath() android.OptionalPath {
2667 if c.installer == nil {
2668 return android.OptionalPath{}
2669 }
2670 return c.installer.hostToolPath()
2671}
2672
Nan Zhangd4e641b2017-07-12 12:55:28 -07002673func (c *Module) IntermPathForModuleOut() android.OptionalPath {
2674 return c.outputFile
2675}
2676
Colin Cross41955e82019-05-29 14:40:35 -07002677func (c *Module) OutputFiles(tag string) (android.Paths, error) {
2678 switch tag {
2679 case "":
2680 if c.outputFile.Valid() {
2681 return android.Paths{c.outputFile.Path()}, nil
2682 }
2683 return android.Paths{}, nil
2684 default:
2685 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002686 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002687}
2688
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00002689func (c *Module) static() bool {
2690 if static, ok := c.linker.(interface {
2691 static() bool
2692 }); ok {
2693 return static.static()
2694 }
2695 return false
2696}
2697
Jiyong Park379de2f2018-12-19 02:47:14 +09002698func (c *Module) staticBinary() bool {
2699 if static, ok := c.linker.(interface {
2700 staticBinary() bool
2701 }); ok {
2702 return static.staticBinary()
2703 }
2704 return false
2705}
2706
Jiyong Park1d1119f2019-07-29 21:27:18 +09002707func (c *Module) header() bool {
2708 if h, ok := c.linker.(interface {
2709 header() bool
2710 }); ok {
2711 return h.header()
2712 }
2713 return false
2714}
2715
Jooyung Han38002912019-05-16 04:01:54 +09002716func (c *Module) getMakeLinkType(actx android.ModuleContext) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07002717 if c.UseVndk() {
Jooyung Han38002912019-05-16 04:01:54 +09002718 if lib, ok := c.linker.(*llndkStubDecorator); ok {
2719 if Bool(lib.Properties.Vendor_available) {
Colin Crossb60190a2018-09-04 16:28:17 -07002720 return "native:vndk"
2721 }
Jooyung Han38002912019-05-16 04:01:54 +09002722 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07002723 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002724 if c.IsVndk() && !c.isVndkExt() {
Jooyung Han38002912019-05-16 04:01:54 +09002725 if Bool(c.VendorProperties.Vendor_available) {
2726 return "native:vndk"
2727 }
2728 return "native:vndk_private"
2729 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09002730 if c.inProduct() {
2731 return "native:product"
2732 }
Jooyung Han38002912019-05-16 04:01:54 +09002733 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08002734 } else if c.InRamdisk() {
2735 return "native:ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07002736 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07002737 return "native:recovery"
2738 } else if c.Target().Os == android.Android && String(c.Properties.Sdk_version) != "" {
2739 return "native:ndk:none:none"
2740 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
2741 //family, link := getNdkStlFamilyAndLinkType(c)
2742 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07002743 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08002744 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07002745 } else {
2746 return "native:platform"
2747 }
2748}
2749
Jiyong Park9d452992018-10-03 00:38:19 +09002750// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01002751// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09002752func (c *Module) IsInstallableToApex() bool {
2753 if shared, ok := c.linker.(interface {
2754 shared() bool
2755 }); ok {
Jiyong Park73c54ee2019-10-22 20:31:18 +09002756 // Stub libs and prebuilt libs in a versioned SDK are not
2757 // installable to APEX even though they are shared libs.
2758 return shared.shared() && !c.IsStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01002759 } else if _, ok := c.linker.(testPerSrc); ok {
2760 return true
Jiyong Park9d452992018-10-03 00:38:19 +09002761 }
2762 return false
2763}
2764
Jiyong Parka90ca002019-10-07 15:47:24 +09002765func (c *Module) AvailableFor(what string) bool {
2766 if linker, ok := c.linker.(interface {
2767 availableFor(string) bool
2768 }); ok {
2769 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
2770 } else {
2771 return c.ApexModuleBase.AvailableFor(what)
2772 }
2773}
2774
Jiyong Parkf0d01b72020-04-13 16:19:48 +09002775func (c *Module) TestFor() []string {
2776 if test, ok := c.linker.(interface {
2777 testFor() []string
2778 }); ok {
2779 return test.testFor()
2780 } else {
2781 return c.ApexModuleBase.TestFor()
2782 }
2783}
2784
Paul Duffinf51768a2020-03-04 14:52:46 +00002785// Return true if the module is ever installable.
2786func (c *Module) EverInstallable() bool {
2787 return c.installer != nil &&
2788 // Check to see whether the module is actually ever installable.
2789 c.installer.everInstallable()
2790}
2791
Inseob Kim1f086e22019-05-09 13:29:15 +09002792func (c *Module) installable() bool {
Paul Duffinf51768a2020-03-04 14:52:46 +00002793 ret := c.EverInstallable() &&
2794 // Check to see whether the module has been configured to not be installed.
2795 proptools.BoolDefault(c.Properties.Installable, true) &&
2796 !c.Properties.PreventInstall && c.outputFile.Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09002797
2798 // The platform variant doesn't need further condition. Apex variants however might not
2799 // be installable because it will likely to be included in the APEX and won't appear
2800 // in the system partition.
2801 if c.IsForPlatform() {
2802 return ret
2803 }
2804
2805 // Special case for modules that are configured to be installed to /data, which includes
2806 // test modules. For these modules, both APEX and non-APEX variants are considered as
2807 // installable. This is because even the APEX variants won't be included in the APEX, but
2808 // will anyway be installed to /data/*.
2809 // See b/146995717
2810 if c.InstallInData() {
2811 return ret
2812 }
2813
2814 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09002815}
2816
Logan Chien41eabe62019-04-10 13:33:58 +08002817func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
2818 if c.linker != nil {
2819 if library, ok := c.linker.(*libraryDecorator); ok {
2820 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
2821 }
2822 }
2823}
2824
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002825func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Ivan Lozano183a3212019-10-18 14:18:45 -07002826 if depTag, ok := ctx.OtherModuleDependencyTag(dep).(DependencyTag); ok {
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002827 if cc, ok := dep.(*Module); ok {
Jiyong Park9f14b9b2020-03-01 17:29:06 +09002828 if cc.HasStubsVariants() {
2829 if depTag.Shared && depTag.Library {
2830 // dynamic dep to a stubs lib crosses APEX boundary
2831 return false
2832 }
2833 if IsRuntimeDepTag(depTag) {
2834 // runtime dep to a stubs lib also crosses APEX boundary
2835 return false
2836 }
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002837 }
2838 if depTag.FromStatic {
2839 // shared_lib dependency from a static lib is considered as crossing
2840 // the APEX boundary because the dependency doesn't actually is
2841 // linked; the dependency is used only during the compilation phase.
2842 return false
2843 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002844 }
2845 }
2846 return true
2847}
2848
Colin Cross2ba19d92015-05-07 15:44:20 -07002849//
Colin Crosscfad1192015-11-02 16:43:11 -08002850// Defaults
2851//
Colin Crossca860ac2016-01-04 14:34:37 -08002852type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07002853 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07002854 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09002855 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08002856}
2857
Patrice Arrudac249c712019-03-19 17:00:29 -07002858// cc_defaults provides a set of properties that can be inherited by other cc
2859// modules. A module can use the properties from a cc_defaults using
2860// `defaults: ["<:default_module_name>"]`. Properties of both modules are
2861// merged (when possible) by prepending the default module's values to the
2862// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07002863func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07002864 return DefaultsFactory()
2865}
2866
Colin Cross36242852017-06-23 15:06:31 -07002867func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08002868 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08002869
Colin Cross36242852017-06-23 15:06:31 -07002870 module.AddProperties(props...)
2871 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08002872 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002873 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002874 &BaseCompilerProperties{},
2875 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01002876 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07002877 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07002878 &StaticProperties{},
2879 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07002880 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002881 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07002882 &TestProperties{},
2883 &TestBinaryProperties{},
Mitch Phillips4e4ab8a2019-09-13 17:32:50 -07002884 &FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08002885 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08002886 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07002887 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07002888 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07002889 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08002890 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08002891 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09002892 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07002893 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002894 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08002895 &android.ProtoProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07002896 )
Colin Crosscfad1192015-11-02 16:43:11 -08002897
Jooyung Hancc372c52019-09-25 15:18:44 +09002898 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07002899
2900 return module
Colin Crosscfad1192015-11-02 16:43:11 -08002901}
2902
Jiyong Park6a43f042017-10-12 23:05:00 +09002903func squashVendorSrcs(m *Module) {
2904 if lib, ok := m.compiler.(*libraryDecorator); ok {
2905 lib.baseCompiler.Properties.Srcs = append(lib.baseCompiler.Properties.Srcs,
2906 lib.baseCompiler.Properties.Target.Vendor.Srcs...)
2907
2908 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs,
2909 lib.baseCompiler.Properties.Target.Vendor.Exclude_srcs...)
2910 }
2911}
2912
Jiyong Parkf9332f12018-02-01 00:54:12 +09002913func squashRecoverySrcs(m *Module) {
2914 if lib, ok := m.compiler.(*libraryDecorator); ok {
2915 lib.baseCompiler.Properties.Srcs = append(lib.baseCompiler.Properties.Srcs,
2916 lib.baseCompiler.Properties.Target.Recovery.Srcs...)
2917
2918 lib.baseCompiler.Properties.Exclude_srcs = append(lib.baseCompiler.Properties.Exclude_srcs,
2919 lib.baseCompiler.Properties.Target.Recovery.Exclude_srcs...)
2920 }
2921}
2922
Colin Cross7228ecd2019-11-18 16:00:16 -08002923var _ android.ImageInterface = (*Module)(nil)
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002924
Colin Cross7228ecd2019-11-18 16:00:16 -08002925func (m *Module) ImageMutatorBegin(mctx android.BaseModuleContext) {
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002926 // Sanity check
Logan Chienf3511742017-10-31 18:04:35 +08002927 vendorSpecific := mctx.SocSpecific() || mctx.DeviceSpecific()
Justin Yun9357f4a2018-11-28 15:14:47 +09002928 productSpecific := mctx.ProductSpecific()
Logan Chienf3511742017-10-31 18:04:35 +08002929
2930 if m.VendorProperties.Vendor_available != nil && vendorSpecific {
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002931 mctx.PropertyErrorf("vendor_available",
Jiyong Park2db76922017-11-08 16:03:48 +09002932 "doesn't make sense at the same time as `vendor: true`, `proprietary: true`, or `device_specific:true`")
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002933 }
Logan Chienf3511742017-10-31 18:04:35 +08002934
2935 if vndkdep := m.vndkdep; vndkdep != nil {
2936 if vndkdep.isVndk() {
Justin Yun98df0d12020-02-28 15:07:59 +09002937 if vendorSpecific || productSpecific {
Logan Chienf3511742017-10-31 18:04:35 +08002938 if !vndkdep.isVndkExt() {
2939 mctx.PropertyErrorf("vndk",
2940 "must set `extends: \"...\"` to vndk extension")
Justin Yun98df0d12020-02-28 15:07:59 +09002941 } else if m.VendorProperties.Vendor_available != nil {
2942 mctx.PropertyErrorf("vendor_available",
2943 "must not set at the same time as `vndk: {extends: \"...\"}`")
Logan Chienf3511742017-10-31 18:04:35 +08002944 }
2945 } else {
2946 if vndkdep.isVndkExt() {
2947 mctx.PropertyErrorf("vndk",
Justin Yun98df0d12020-02-28 15:07:59 +09002948 "must set `vendor: true` or `product_specific: true` to set `extends: %q`",
Logan Chienf3511742017-10-31 18:04:35 +08002949 m.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08002950 }
2951 if m.VendorProperties.Vendor_available == nil {
2952 mctx.PropertyErrorf("vndk",
2953 "vendor_available must be set to either true or false when `vndk: {enabled: true}`")
Logan Chienf3511742017-10-31 18:04:35 +08002954 }
2955 }
2956 } else {
2957 if vndkdep.isVndkSp() {
2958 mctx.PropertyErrorf("vndk",
2959 "must set `enabled: true` to set `support_system_process: true`")
Logan Chienf3511742017-10-31 18:04:35 +08002960 }
2961 if vndkdep.isVndkExt() {
2962 mctx.PropertyErrorf("vndk",
2963 "must set `enabled: true` to set `extends: %q`",
2964 m.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08002965 }
Justin Yun8effde42017-06-23 19:24:43 +09002966 }
2967 }
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002968
Jiyong Parkf9332f12018-02-01 00:54:12 +09002969 var coreVariantNeeded bool = false
Yifan Hong1b3348d2020-01-21 15:53:22 -08002970 var ramdiskVariantNeeded bool = false
Jiyong Parkf9332f12018-02-01 00:54:12 +09002971 var recoveryVariantNeeded bool = false
2972
Inseob Kim64c43952019-08-26 16:52:35 +09002973 var vendorVariants []string
Justin Yun5f7f7e82019-11-18 19:52:14 +09002974 var productVariants []string
Inseob Kim64c43952019-08-26 16:52:35 +09002975
2976 platformVndkVersion := mctx.DeviceConfig().PlatformVndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09002977 boardVndkVersion := mctx.DeviceConfig().VndkVersion()
2978 productVndkVersion := mctx.DeviceConfig().ProductVndkVersion()
2979 if boardVndkVersion == "current" {
2980 boardVndkVersion = platformVndkVersion
2981 }
2982 if productVndkVersion == "current" {
2983 productVndkVersion = platformVndkVersion
Inseob Kim64c43952019-08-26 16:52:35 +09002984 }
2985
Justin Yun5f7f7e82019-11-18 19:52:14 +09002986 if boardVndkVersion == "" {
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002987 // If the device isn't compiling against the VNDK, we always
2988 // use the core mode.
Jiyong Parkf9332f12018-02-01 00:54:12 +09002989 coreVariantNeeded = true
Dan Willemsen4416e5d2017-04-06 12:43:22 -07002990 } else if _, ok := m.linker.(*llndkStubDecorator); ok {
Justin Yun5f7f7e82019-11-18 19:52:14 +09002991 // LL-NDK stubs only exist in the vendor and product variants,
2992 // since the real libraries will be used in the core variant.
Inseob Kim64c43952019-08-26 16:52:35 +09002993 vendorVariants = append(vendorVariants,
2994 platformVndkVersion,
Justin Yun5f7f7e82019-11-18 19:52:14 +09002995 boardVndkVersion,
2996 )
2997 productVariants = append(productVariants,
2998 platformVndkVersion,
2999 productVndkVersion,
Inseob Kim64c43952019-08-26 16:52:35 +09003000 )
Jiyong Park2a454122017-10-19 15:59:33 +09003001 } else if _, ok := m.linker.(*llndkHeadersDecorator); ok {
3002 // ... and LL-NDK headers as well
Inseob Kim64c43952019-08-26 16:52:35 +09003003 vendorVariants = append(vendorVariants,
3004 platformVndkVersion,
Justin Yun5f7f7e82019-11-18 19:52:14 +09003005 boardVndkVersion,
3006 )
3007 productVariants = append(productVariants,
3008 platformVndkVersion,
3009 productVndkVersion,
Inseob Kim64c43952019-08-26 16:52:35 +09003010 )
Inseob Kimeec88e12020-01-22 11:11:29 +09003011 } else if m.isSnapshotPrebuilt() {
Justin Yun71549282017-11-17 12:10:28 +09003012 // Make vendor variants only for the versions in BOARD_VNDK_VERSION and
3013 // PRODUCT_EXTRA_VNDK_VERSIONS.
Inseob Kimeec88e12020-01-22 11:11:29 +09003014 if snapshot, ok := m.linker.(interface {
3015 version() string
3016 }); ok {
3017 vendorVariants = append(vendorVariants, snapshot.version())
3018 } else {
3019 mctx.ModuleErrorf("version is unknown for snapshot prebuilt")
3020 }
Justin Yun98df0d12020-02-28 15:07:59 +09003021 } else if m.HasVendorVariant() && !m.isVndkExt() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003022 // This will be available in /system, /vendor and /product
3023 // or a /system directory that is available to vendor and product.
Jiyong Parkf9332f12018-02-01 00:54:12 +09003024 coreVariantNeeded = true
Inseob Kim64c43952019-08-26 16:52:35 +09003025 vendorVariants = append(vendorVariants, platformVndkVersion)
Justin Yun5f7f7e82019-11-18 19:52:14 +09003026 productVariants = append(productVariants, platformVndkVersion)
Inseob Kimbc093672019-11-01 11:29:44 +09003027 // VNDK modules must not create BOARD_VNDK_VERSION variant because its
3028 // code is PLATFORM_VNDK_VERSION.
3029 // On the other hand, vendor_available modules which are not VNDK should
3030 // also build BOARD_VNDK_VERSION because it's installed in /vendor.
Justin Yun5f7f7e82019-11-18 19:52:14 +09003031 // vendor_available modules are also available to /product.
Inseob Kimbc093672019-11-01 11:29:44 +09003032 if !m.IsVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003033 vendorVariants = append(vendorVariants, boardVndkVersion)
3034 productVariants = append(productVariants, productVndkVersion)
Inseob Kim64c43952019-08-26 16:52:35 +09003035 }
Logan Chienf3511742017-10-31 18:04:35 +08003036 } else if vendorSpecific && String(m.Properties.Sdk_version) == "" {
Jiyong Park2db76922017-11-08 16:03:48 +09003037 // This will be available in /vendor (or /odm) only
Justin Yun5f7f7e82019-11-18 19:52:14 +09003038 vendorVariants = append(vendorVariants, boardVndkVersion)
Dan Willemsen4416e5d2017-04-06 12:43:22 -07003039 } else {
3040 // This is either in /system (or similar: /data), or is a
3041 // modules built with the NDK. Modules built with the NDK
3042 // will be restricted using the existing link type checks.
Jiyong Parkf9332f12018-02-01 00:54:12 +09003043 coreVariantNeeded = true
3044 }
3045
Justin Yun5f7f7e82019-11-18 19:52:14 +09003046 if boardVndkVersion != "" && productVndkVersion != "" {
3047 if coreVariantNeeded && productSpecific && String(m.Properties.Sdk_version) == "" {
3048 // The module has "product_specific: true" that does not create core variant.
3049 coreVariantNeeded = false
3050 productVariants = append(productVariants, productVndkVersion)
3051 }
3052 } else {
3053 // Unless PRODUCT_PRODUCT_VNDK_VERSION is set, product partition has no
3054 // restriction to use system libs.
3055 // No product variants defined in this case.
3056 productVariants = []string{}
3057 }
3058
Yifan Hong1b3348d2020-01-21 15:53:22 -08003059 if Bool(m.Properties.Ramdisk_available) {
3060 ramdiskVariantNeeded = true
3061 }
3062
3063 if m.ModuleBase.InstallInRamdisk() {
3064 ramdiskVariantNeeded = true
3065 coreVariantNeeded = false
3066 }
3067
Jiyong Parkf9332f12018-02-01 00:54:12 +09003068 if Bool(m.Properties.Recovery_available) {
3069 recoveryVariantNeeded = true
3070 }
3071
3072 if m.ModuleBase.InstallInRecovery() {
3073 recoveryVariantNeeded = true
3074 coreVariantNeeded = false
3075 }
3076
Inseob Kim64c43952019-08-26 16:52:35 +09003077 for _, variant := range android.FirstUniqueStrings(vendorVariants) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003078 m.Properties.ExtraVariants = append(m.Properties.ExtraVariants, VendorVariationPrefix+variant)
3079 }
3080
3081 for _, variant := range android.FirstUniqueStrings(productVariants) {
3082 m.Properties.ExtraVariants = append(m.Properties.ExtraVariants, ProductVariationPrefix+variant)
Jiyong Parkf9332f12018-02-01 00:54:12 +09003083 }
Colin Cross7228ecd2019-11-18 16:00:16 -08003084
Yifan Hong1b3348d2020-01-21 15:53:22 -08003085 m.Properties.RamdiskVariantNeeded = ramdiskVariantNeeded
Colin Cross7228ecd2019-11-18 16:00:16 -08003086 m.Properties.RecoveryVariantNeeded = recoveryVariantNeeded
3087 m.Properties.CoreVariantNeeded = coreVariantNeeded
3088}
3089
3090func (c *Module) CoreVariantNeeded(ctx android.BaseModuleContext) bool {
3091 return c.Properties.CoreVariantNeeded
3092}
3093
Yifan Hong1b3348d2020-01-21 15:53:22 -08003094func (c *Module) RamdiskVariantNeeded(ctx android.BaseModuleContext) bool {
3095 return c.Properties.RamdiskVariantNeeded
3096}
3097
Colin Cross7228ecd2019-11-18 16:00:16 -08003098func (c *Module) RecoveryVariantNeeded(ctx android.BaseModuleContext) bool {
3099 return c.Properties.RecoveryVariantNeeded
3100}
3101
3102func (c *Module) ExtraImageVariations(ctx android.BaseModuleContext) []string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003103 return c.Properties.ExtraVariants
Colin Cross7228ecd2019-11-18 16:00:16 -08003104}
3105
3106func (c *Module) SetImageVariation(ctx android.BaseModuleContext, variant string, module android.Module) {
3107 m := module.(*Module)
Yifan Hong1b3348d2020-01-21 15:53:22 -08003108 if variant == android.RamdiskVariation {
3109 m.MakeAsPlatform()
3110 } else if variant == android.RecoveryVariation {
Colin Cross7228ecd2019-11-18 16:00:16 -08003111 m.MakeAsPlatform()
3112 squashRecoverySrcs(m)
3113 } else if strings.HasPrefix(variant, VendorVariationPrefix) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003114 m.Properties.ImageVariationPrefix = VendorVariationPrefix
Colin Cross7228ecd2019-11-18 16:00:16 -08003115 m.Properties.VndkVersion = strings.TrimPrefix(variant, VendorVariationPrefix)
3116 squashVendorSrcs(m)
Inseob Kimeec88e12020-01-22 11:11:29 +09003117
3118 // Makefile shouldn't know vendor modules other than BOARD_VNDK_VERSION.
3119 // Hide other vendor variants to avoid collision.
3120 vndkVersion := ctx.DeviceConfig().VndkVersion()
3121 if vndkVersion != "current" && vndkVersion != "" && vndkVersion != m.Properties.VndkVersion {
3122 m.Properties.HideFromMake = true
3123 m.SkipInstall()
3124 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09003125 } else if strings.HasPrefix(variant, ProductVariationPrefix) {
3126 m.Properties.ImageVariationPrefix = ProductVariationPrefix
3127 m.Properties.VndkVersion = strings.TrimPrefix(variant, ProductVariationPrefix)
3128 squashVendorSrcs(m)
Dan Willemsen4416e5d2017-04-06 12:43:22 -07003129 }
3130}
3131
Jayant Chowdhary6e8115a2017-05-09 10:21:52 -07003132func getCurrentNdkPrebuiltVersion(ctx DepsContext) string {
Colin Cross6510f912017-11-29 00:27:14 -08003133 if ctx.Config().PlatformSdkVersionInt() > config.NdkMaxPrebuiltVersionInt {
Jayant Chowdhary6e8115a2017-05-09 10:21:52 -07003134 return strconv.Itoa(config.NdkMaxPrebuiltVersionInt)
3135 }
Colin Cross6510f912017-11-29 00:27:14 -08003136 return ctx.Config().PlatformSdkVersion()
Jayant Chowdhary6e8115a2017-05-09 10:21:52 -07003137}
3138
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003139func kytheExtractAllFactory() android.Singleton {
3140 return &kytheExtractAllSingleton{}
3141}
3142
3143type kytheExtractAllSingleton struct {
3144}
3145
3146func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3147 var xrefTargets android.Paths
3148 ctx.VisitAllModules(func(module android.Module) {
3149 if ccModule, ok := module.(xref); ok {
3150 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3151 }
3152 })
3153 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3154 if len(xrefTargets) > 0 {
3155 ctx.Build(pctx, android.BuildParams{
3156 Rule: blueprint.Phony,
3157 Output: android.PathForPhony(ctx, "xref_cxx"),
3158 Inputs: xrefTargets,
3159 //Default: true,
3160 })
3161 }
3162}
3163
Colin Cross06a931b2015-10-28 17:23:31 -07003164var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003165var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003166var BoolPtr = proptools.BoolPtr
3167var String = proptools.String
3168var StringPtr = proptools.StringPtr