blob: 7a7034f9f083eddc4122462d24020434ce952699 [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Colin Cross97ba0732015-03-23 17:50:24 -070027 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070028 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070029
Colin Cross635c3b02016-05-18 15:37:25 -070030 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070031 "android/soong/cc/config"
Colin Cross5049f022015-03-18 13:28:46 -070032 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080033)
34
Colin Cross463a90e2015-06-17 14:20:06 -070035func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000036 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070037
Paul Duffin036e7002019-12-19 19:16:28 +000038 pctx.Import("android/soong/cc/config")
39}
40
41func RegisterCCBuildComponents(ctx android.RegistrationContext) {
42 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
43
44 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000045 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090046 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070047 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010048 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070049 ctx.BottomUp("version_selector", versionSelectorMutator).Parallel()
50 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070051 ctx.BottomUp("begin", BeginMutator).Parallel()
Inseob Kimac1e9862019-12-09 18:15:47 +090052 ctx.BottomUp("sysprop_cc", SyspropMutator).Parallel()
Inseob Kimeec88e12020-01-22 11:11:29 +090053 ctx.BottomUp("vendor_snapshot", VendorSnapshotMutator).Parallel()
54 ctx.BottomUp("vendor_snapshot_source", VendorSnapshotSourceMutator).Parallel()
Jose Galmes6f843bc2020-12-11 13:36:29 -080055 ctx.BottomUp("recovery_snapshot", RecoverySnapshotMutator).Parallel()
56 ctx.BottomUp("recovery_snapshot_source", RecoverySnapshotSourceMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070057 })
Colin Cross16b23492016-01-06 14:41:07 -080058
Paul Duffin036e7002019-12-19 19:16:28 +000059 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Ivan Lozano3968d8f2020-12-14 11:27:52 -050060 ctx.TopDown("asan_deps", sanitizerDepsMutator(Asan))
61 ctx.BottomUp("asan", sanitizerMutator(Asan)).Parallel()
Colin Cross16b23492016-01-06 14:41:07 -080062
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070063 ctx.TopDown("hwasan_deps", sanitizerDepsMutator(hwasan))
64 ctx.BottomUp("hwasan", sanitizerMutator(hwasan)).Parallel()
65
Ivan Lozano3968d8f2020-12-14 11:27:52 -050066 ctx.TopDown("fuzzer_deps", sanitizerDepsMutator(Fuzzer))
67 ctx.BottomUp("fuzzer", sanitizerMutator(Fuzzer)).Parallel()
Mitch Phillipsbfeade62019-05-01 14:42:05 -070068
Jiyong Park1d1119f2019-07-29 21:27:18 +090069 // cfi mutator shouldn't run before sanitizers that return true for
70 // incompatibleWithCfi()
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000071 ctx.TopDown("cfi_deps", sanitizerDepsMutator(cfi))
72 ctx.BottomUp("cfi", sanitizerMutator(cfi)).Parallel()
73
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -080074 ctx.TopDown("scs_deps", sanitizerDepsMutator(scs))
75 ctx.BottomUp("scs", sanitizerMutator(scs)).Parallel()
76
Colin Cross1e676be2016-10-12 14:38:15 -070077 ctx.TopDown("tsan_deps", sanitizerDepsMutator(tsan))
78 ctx.BottomUp("tsan", sanitizerMutator(tsan)).Parallel()
Dan Willemsen581341d2017-02-09 16:16:31 -080079
Colin Cross0b908332019-06-19 23:00:20 -070080 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090081 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080082
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080083 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070084
85 ctx.TopDown("lto_deps", ltoDepsMutator)
86 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090087
Jooyung Han479ca172020-10-19 18:51:07 +090088 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090089 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070090 })
Colin Crossb98c8b02016-07-29 13:44:28 -070091
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080092 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
93 // sabi mutator needs to be run after apex mutator finishes.
94 ctx.TopDown("sabi_deps", sabiDepsMutator)
95 })
96
Colin Cross57898582020-10-29 18:25:19 -070097 ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070098}
99
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500100// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
101// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
102// edges to these modules.
103// This object is constructed in DepsMutator, by calling to various module delegates to set
104// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
105// dependencies.
106// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
107// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -0800108type Deps struct {
109 SharedLibs, LateSharedLibs []string
110 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800111 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800112 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700113
Chris Parsons79d66a52020-06-05 17:26:16 -0400114 // Used for data dependencies adjacent to tests
115 DataLibs []string
116
Yo Chiang219968c2020-09-22 18:45:04 +0800117 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
118 SystemSharedLibs []string
119
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500120 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800121 StaticUnwinderIfLegacy bool
122
Colin Cross5950f382016-12-13 12:50:57 -0800123 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700124
Colin Cross81413472016-04-11 14:37:39 -0700125 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700126
Dan Willemsenb40aab62016-04-20 14:21:14 -0700127 GeneratedSources []string
128 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900129 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700130
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700131 ReexportGeneratedHeaders []string
132
Colin Cross97ba0732015-03-23 17:50:24 -0700133 CrtBegin, CrtEnd string
Dan Willemsena0790e32018-10-12 00:24:23 -0700134
135 // Used for host bionic
136 LinkerFlagsFile string
137 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900138
139 // List of libs that need to be excluded for APEX variant
140 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700141}
142
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500143// PathDeps is a struct containing file paths to dependencies of a module.
144// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
145// It's used to construct flags for various build statements (such as for compiling and linking).
146// It is then passed to module decorator functions responsible for registering build statements
147// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800148type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700149 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900150 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700151 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900152 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700153 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700154 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700155
Colin Cross0de8a1e2020-09-18 14:15:30 -0700156 // Transitive static library dependencies of static libraries for use in ordering.
157 TranstiveStaticLibrariesForOrdering *android.DepSet
158
Colin Cross26c34ed2016-09-30 17:10:16 -0700159 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100160 Objs Objects
161 // Paths to .o files in dependencies that provide them. Note that these lists
162 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800163 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700164 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700165
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100166 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
167 // the libs from all whole_static_lib dependencies.
168 WholeStaticLibsFromPrebuilts android.Paths
169
Colin Cross26c34ed2016-09-30 17:10:16 -0700170 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700171 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900172 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700173
Inseob Kimd110f872019-12-06 13:15:38 +0900174 Flags []string
175 IncludeDirs android.Paths
176 SystemIncludeDirs android.Paths
177 ReexportedDirs android.Paths
178 ReexportedSystemDirs android.Paths
179 ReexportedFlags []string
180 ReexportedGeneratedHeaders android.Paths
181 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700182
Colin Cross26c34ed2016-09-30 17:10:16 -0700183 // Paths to crt*.o files
Colin Cross635c3b02016-05-18 15:37:25 -0700184 CrtBegin, CrtEnd android.OptionalPath
Dan Willemsena0790e32018-10-12 00:24:23 -0700185
186 // Path to the file container flags to use with the linker
187 LinkerFlagsFile android.OptionalPath
188
189 // Path to the dynamic linker binary
190 DynamicLinker android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700191}
192
Colin Cross4af21ed2019-11-04 09:37:55 -0800193// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
194// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
195// command line so they can be overridden by the local module flags).
196type LocalOrGlobalFlags struct {
197 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700198 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800199 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700200 CFlags []string // Flags that apply to C and C++ source files
201 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
202 ConlyFlags []string // Flags that apply to C source files
203 CppFlags []string // Flags that apply to C++ source files
204 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700205 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800206}
207
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500208// Flags contains various types of command line flags (and settings) for use in building build
209// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800210type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500211 // Local flags (which individual modules are responsible for). These may override global flags.
212 Local LocalOrGlobalFlags
213 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800214 Global LocalOrGlobalFlags
215
216 aidlFlags []string // Flags that apply to aidl source files
217 rsFlags []string // Flags that apply to renderscript source files
218 libFlags []string // Flags to add libraries early to the link order
219 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
220 TidyFlags []string // Flags that apply to clang-tidy
221 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700222
Colin Crossc3199482017-03-30 15:03:04 -0700223 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800224 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700225 SystemIncludeFlags []string
226
Oliver Nguyen04526782020-04-21 12:40:27 -0700227 Toolchain config.Toolchain
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500228 Tidy bool // True if clang-tidy is enabled.
229 GcovCoverage bool // True if coverage files should be generated.
230 SAbiDump bool // True if header abi dumps should be generated.
Oliver Nguyen04526782020-04-21 12:40:27 -0700231 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800232
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500233 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800234 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500235 // The target-device system path to the dynamic linker.
236 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800237
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700238 CFlagsDeps android.Paths // Files depended on by compiler flags
239 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800240
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500241 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700242 AssemblerWithCpp bool
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500243 // True if static libraries should be grouped (using `-Wl,--start-group` and `-Wl,--end-group`).
244 GroupStaticLibs bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800245
Colin Cross19878da2019-03-28 14:45:07 -0700246 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700247 protoC bool // Whether to use C instead of C++
248 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700249
250 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200251 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700252}
253
Colin Crossca860ac2016-01-04 14:34:37 -0800254// Properties used to compile all C or C++ modules
255type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700256 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800257 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700258
Colin Crossc511bc52020-04-07 16:50:32 +0000259 // Minimum sdk version supported when compiling against the ndk. Setting this property causes
260 // two variants to be built, one for the platform and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800261 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700262
Jooyung Han379660c2020-04-21 15:24:00 +0900263 // Minimum sdk version that the artifact should support when it runs as part of mainline modules(APEX).
264 Min_sdk_version *string
265
Colin Crossc511bc52020-04-07 16:50:32 +0000266 // If true, always create an sdk variant and don't create a platform variant.
267 Sdk_variant_only *bool
268
Jiyong Parkde866cb2018-12-07 23:08:36 +0900269 AndroidMkSharedLibs []string `blueprint:"mutated"`
270 AndroidMkStaticLibs []string `blueprint:"mutated"`
271 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
272 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700273 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900274 HideFromMake bool `blueprint:"mutated"`
275 PreventInstall bool `blueprint:"mutated"`
276 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700277
Yo Chiang219968c2020-09-22 18:45:04 +0800278 // Set by DepsMutator.
279 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
280
Justin Yun5f7f7e82019-11-18 19:52:14 +0900281 ImageVariationPrefix string `blueprint:"mutated"`
282 VndkVersion string `blueprint:"mutated"`
283 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800284
285 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
286 // file
287 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900288
Yifan Hong39143a92020-10-26 12:43:12 -0700289 // Make this module available when building for ramdisk.
290 // On device without a dedicated recovery partition, the module is only
291 // available after switching root into
292 // /first_stage_ramdisk. To expose the module before switching root, install
293 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800294 Ramdisk_available *bool
295
Yifan Hong39143a92020-10-26 12:43:12 -0700296 // Make this module available when building for vendor ramdisk.
297 // On device without a dedicated recovery partition, the module is only
298 // available after switching root into
299 // /first_stage_ramdisk. To expose the module before switching root, install
300 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700301 Vendor_ramdisk_available *bool
302
Jiyong Parkf9332f12018-02-01 00:54:12 +0900303 // Make this module available when building for recovery
304 Recovery_available *bool
305
Colin Crossae6c5202019-11-20 13:35:50 -0800306 // Set by imageMutator
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700307 CoreVariantNeeded bool `blueprint:"mutated"`
308 RamdiskVariantNeeded bool `blueprint:"mutated"`
309 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
310 RecoveryVariantNeeded bool `blueprint:"mutated"`
311 ExtraVariants []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900312
313 // Allows this module to use non-APEX version of libraries. Useful
314 // for building binaries that are started before APEXes are activated.
315 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900316
317 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
318 // see soong/cc/config/vndk.go
319 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900320
321 // Used by vendor snapshot to record dependencies from snapshot modules.
322 SnapshotSharedLibs []string `blueprint:"mutated"`
323 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000324
325 Installable *bool
Colin Crossc511bc52020-04-07 16:50:32 +0000326
327 // Set by factories of module types that can only be referenced from variants compiled against
328 // the SDK.
329 AlwaysSdk bool `blueprint:"mutated"`
330
331 // Variant is an SDK variant created by sdkMutator
332 IsSdkVariant bool `blueprint:"mutated"`
333 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
334 // variant to have a ".sdk" suffix.
335 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700336
337 // Normally Soong uses the directory structure to decide which modules
338 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800339 // different snapshots (vendor, recovery, etc.), but this property
340 // allows a partner to exclude a module normally thought of as a
341 // framework module from the vendor snapshot.
342 Exclude_from_vendor_snapshot *bool
343
344 // Normally Soong uses the directory structure to decide which modules
345 // should be included (framework) or excluded (non-framework) from the
346 // different snapshots (vendor, recovery, etc.), but this property
347 // allows a partner to exclude a module normally thought of as a
348 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800349 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900350
351 // List of APEXes that this module has private access to for testing purpose. The module
352 // can depend on libraries that are not exported by the APEXes and use private symbols
353 // from the exported libraries.
354 Test_for []string
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700355}
356
357type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900358 // whether this module should be allowed to be directly depended by other
359 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900360 // If set to true, two variants will be built separately, one like
361 // normal, and the other limited to the set of libraries and headers
362 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700363 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900364 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700365 // so it shouldn't have any unversioned runtime dependencies, or
366 // make assumptions about the system that may not be true in the
367 // future.
368 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900369 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900370 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900371 // The modules with vndk: {enabled: true} must define 'vendor_available'
372 // to either 'true' or 'false'. In this case, 'vendor_available: false' has
373 // a different meaning than that of non-VNDK modules.
374 // 'vendor_available: false' for a VNDK module means 'VNDK-private' that
375 // can only be depended on by VNDK libraries, not by non-VNDK vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900376 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700377 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
378 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900379
Justin Yun63e9ec72020-10-29 16:49:43 +0900380 // whether this module should be allowed to be directly depended by other
381 // modules with `product_specific: true` or `product_available: true`.
382 // If set to true, an additional product variant will be built separately
383 // that is limited to the set of libraries and headers that are exposed to
384 // /product modules.
385 //
386 // The product variant may be used with a different (newer) /system,
387 // so it shouldn't have any unversioned runtime dependencies, or
388 // make assumptions about the system that may not be true in the
389 // future.
390 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900391 // If set to false, this module becomes inaccessible from /product modules.
392 //
393 // Different from the 'vendor_available' property, the modules with
394 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
395 // library without 'product_available' may not be depended on by any other
396 // modules that has product variants including the product available VNDKs.
397 // However, for the modules with vndk: {enabled: true},
398 // 'product_available: false' creates the product variant that is available
399 // only for the other product available VNDK modules but not by non-VNDK
400 // product modules.
401 // In the case of the modules with vndk: {enabled: true}, if
402 // 'product_available' is defined, it must have the same value with the
403 // 'vendor_available'.
Justin Yun63e9ec72020-10-29 16:49:43 +0900404 //
405 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
406 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
407 Product_available *bool
408
Jiyong Park5fb8c102018-04-09 12:03:06 +0900409 // whether this module is capable of being loaded with other instance
410 // (possibly an older version) of the same module in the same process.
411 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
412 // can be double loaded in a vendor process if the library is also a
413 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
414 // explicitly marked as `double_loadable: true` by the owner, or the dependency
415 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
416 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800417
418 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
419 IsLLNDK bool `blueprint:"mutated"`
420
421 // IsLLNDKPrivate is set to true for the vendor variant of a cc_library module that has LLNDK
Justin Yunc0d8c492021-01-07 17:45:31 +0900422 // stubs and also sets llndk.private: true.
Colin Cross127bb8b2020-12-16 16:46:01 -0800423 IsLLNDKPrivate bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800424}
425
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500426// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
427// to understanding details about the type of the current module.
428// For example, one might call these functions to determine whether the current module is a static
429// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800430type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800431 static() bool
432 staticBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900433 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900434 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900435 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700436 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900437 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700438 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800439 sdkVersion() string
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700440 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700441 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800442 IsLlndk() bool
443 IsLlndkPublic() bool
444 isImplementationForLLNDKPublic() bool
445 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900446 isVndk() bool
447 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500448 IsVndkExt() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900449 inProduct() bool
450 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800451 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700452 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900453 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700454 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700455 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800456 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800457 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800458 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800459 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800460 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700461 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700462 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900463 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800464 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700465 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700466 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800467 isPreventInstall() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800468}
469
470type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700471 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800472 ModuleContextIntf
473}
474
475type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700476 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800477 ModuleContextIntf
478}
479
Colin Cross37047f12016-12-13 17:06:13 -0800480type DepsContext interface {
481 android.BottomUpMutatorContext
482 ModuleContextIntf
483}
484
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500485// feature represents additional (optional) steps to building cc-related modules, such as invocation
486// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800487type feature interface {
488 begin(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800489 deps(ctx DepsContext, deps Deps) Deps
Colin Crossca860ac2016-01-04 14:34:37 -0800490 flags(ctx ModuleContext, flags Flags) Flags
491 props() []interface{}
492}
493
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500494// compiler is the interface for a compiler helper object. Different module decorators may implement
495// this helper differently. For example, compiling a `cc_library` may use a different build
496// statement than building a `toolchain_library`.
Colin Crossca860ac2016-01-04 14:34:37 -0800497type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700498 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800499 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800500 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700501 compilerProps() []interface{}
502
Colin Cross76fada02016-07-27 10:31:13 -0700503 appendCflags([]string)
504 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700505 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800506}
507
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500508// linker is the interface for a linker decorator object. Individual module types can provide
509// their own implementation for this decorator, and thus specify custom logic regarding build
510// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800511type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700512 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800513 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700514 linkerFlags(ctx ModuleContext, flags Flags) Flags
515 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800516 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700517
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700518 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700519 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900520 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700521
522 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900523 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000524
525 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000526 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
527}
528
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500529// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000530type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500531 sharedLibs []string
532 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
533 // libc, libm, etc.)
534 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800535}
536
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500537// installer is the interface for an installer helper object. This helper is responsible for
538// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800539type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700540 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700541 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000542 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800543 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700544 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700545 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900546 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100547 makeUninstallable(mod *Module)
Colin Crossca860ac2016-01-04 14:34:37 -0800548}
549
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800550type xref interface {
551 XrefCcFiles() android.Paths
552}
553
Colin Cross6e511a92020-07-27 21:26:48 -0700554type libraryDependencyKind int
555
556const (
557 headerLibraryDependency = iota
558 sharedLibraryDependency
559 staticLibraryDependency
560)
561
562func (k libraryDependencyKind) String() string {
563 switch k {
564 case headerLibraryDependency:
565 return "headerLibraryDependency"
566 case sharedLibraryDependency:
567 return "sharedLibraryDependency"
568 case staticLibraryDependency:
569 return "staticLibraryDependency"
570 default:
571 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
572 }
573}
574
575type libraryDependencyOrder int
576
577const (
578 earlyLibraryDependency = -1
579 normalLibraryDependency = 0
580 lateLibraryDependency = 1
581)
582
583func (o libraryDependencyOrder) String() string {
584 switch o {
585 case earlyLibraryDependency:
586 return "earlyLibraryDependency"
587 case normalLibraryDependency:
588 return "normalLibraryDependency"
589 case lateLibraryDependency:
590 return "lateLibraryDependency"
591 default:
592 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
593 }
594}
595
596// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
597// tags that have a set of predefined tag objects that are reused for each dependency, a
598// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
599// That means that comparing a libraryDependencyTag for equality will only be equal if all
600// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
601// then check individual metadata fields instead.
602type libraryDependencyTag struct {
603 blueprint.BaseDependencyTag
604
605 // These are exported so that fmt.Printf("%#v") can call their String methods.
606 Kind libraryDependencyKind
607 Order libraryDependencyOrder
608
609 wholeStatic bool
610
611 reexportFlags bool
612 explicitlyVersioned bool
613 dataLib bool
614 ndk bool
615
616 staticUnwinder bool
617
618 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900619
Cindy Zhou18417cb2020-12-10 07:12:38 -0800620 // Whether or not this dependency should skip the apex dependency check
621 skipApexAllowedDependenciesCheck bool
622
Jiyong Parke3867542020-12-03 17:28:25 +0900623 // Whether or not this dependency has to be followed for the apex variants
624 excludeInApex bool
Colin Cross6e511a92020-07-27 21:26:48 -0700625}
626
627// header returns true if the libraryDependencyTag is tagging a header lib dependency.
628func (d libraryDependencyTag) header() bool {
629 return d.Kind == headerLibraryDependency
630}
631
632// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
633func (d libraryDependencyTag) shared() bool {
634 return d.Kind == sharedLibraryDependency
635}
636
637// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
638func (d libraryDependencyTag) static() bool {
639 return d.Kind == staticLibraryDependency
640}
641
Colin Crosse9fe2942020-11-10 18:12:15 -0800642// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
643// binaries or other shared libraries are installed as dependencies.
644func (d libraryDependencyTag) InstallDepNeeded() bool {
645 return d.shared()
646}
647
648var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
649
650// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700651// libraryDependencyTag. Each tag object is created globally and reused for multiple
652// dependencies (although since the object contains no references, assigning a tag to a
653// variable and modifying it will not modify the original). Users can compare the tag
654// returned by ctx.OtherModuleDependencyTag against the global original
655type dependencyTag struct {
656 blueprint.BaseDependencyTag
657 name string
658}
659
Colin Crosse9fe2942020-11-10 18:12:15 -0800660// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
661// libraryDependencyTag, but where the dependency needs to be installed when the parent is
662// installed.
663type installDependencyTag struct {
664 blueprint.BaseDependencyTag
665 android.InstallAlwaysNeededDependencyTag
666 name string
667}
668
Colin Crossc99deeb2016-04-11 15:06:20 -0700669var (
Colin Cross6e511a92020-07-27 21:26:48 -0700670 genSourceDepTag = dependencyTag{name: "gen source"}
671 genHeaderDepTag = dependencyTag{name: "gen header"}
672 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
673 objDepTag = dependencyTag{name: "obj"}
674 linkerFlagsDepTag = dependencyTag{name: "linker flags file"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900675 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700676 reuseObjTag = dependencyTag{name: "reuse objects"}
677 staticVariantTag = dependencyTag{name: "static variant"}
678 vndkExtDepTag = dependencyTag{name: "vndk extends"}
679 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800680 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700681 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700682 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Cross127bb8b2020-12-16 16:46:01 -0800683 llndkStubDepTag = dependencyTag{name: "llndk stub"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700684)
685
Colin Cross56a83212020-09-15 18:30:11 -0700686type copyDirectlyInAnyApexDependencyTag dependencyTag
687
688func (copyDirectlyInAnyApexDependencyTag) CopyDirectlyInAnyApex() {}
689
690var _ android.CopyDirectlyInAnyApexTag = copyDirectlyInAnyApexDependencyTag{}
691
Roland Levillainf89cd092019-07-29 16:22:59 +0100692func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700693 ccLibDepTag, ok := depTag.(libraryDependencyTag)
694 return ok && ccLibDepTag.shared()
695}
696
697func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
698 ccLibDepTag, ok := depTag.(libraryDependencyTag)
699 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100700}
701
Zach Johnson3df4e632020-11-06 11:56:27 -0800702func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
703 ccLibDepTag, ok := depTag.(libraryDependencyTag)
704 return ok && ccLibDepTag.header()
705}
706
Roland Levillainf89cd092019-07-29 16:22:59 +0100707func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800708 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100709}
710
711func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700712 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100713 return ok && ccDepTag == testPerSrcDepTag
714}
715
Colin Crossca860ac2016-01-04 14:34:37 -0800716// Module contains the properties and members used by all C/C++ module types, and implements
717// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500718// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
719// interface.
720//
721// To define a C/C++ related module, construct a new Module object and point its delegates to
722// type-specific structs. These delegates will be invoked to register module-specific build
723// statements which may be unique to the module type. For example, module.compiler.compile() should
724// be defined so as to register build statements which are responsible for compiling the module.
725//
726// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
727// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
728// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
729// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800730type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700731 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700732 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900733 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900734 android.SdkBase
Colin Crossc472d572015-03-17 15:06:21 -0700735
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700736 Properties BaseProperties
737 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700738
Colin Crossca860ac2016-01-04 14:34:37 -0800739 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700740 hod android.HostOrDeviceSupported
741 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700742
Paul Duffina0843f62019-12-13 19:50:38 +0000743 // Allowable SdkMemberTypes of this module type.
744 sdkMemberTypes []android.SdkMemberType
745
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500746 // decorator delegates, initialize before calling Init
747 // these may contain module-specific implementations, and effectively allow for custom
748 // type-specific logic. These members may reference different objects or the same object.
749 // Functions of these decorators will be invoked to initialize and register type-specific
750 // build statements.
Colin Crossb4ce0ec2016-09-13 13:41:39 -0700751 compiler compiler
752 linker linker
753 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500754
755 features []feature
756 stl *stl
757 sanitize *sanitize
758 coverage *coverage
759 sabi *sabi
760 vndkdep *vndkdep
761 lto *lto
762 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800763
Colin Cross31076b32020-10-23 17:22:06 -0700764 library libraryInterface
765
Colin Cross635c3b02016-05-18 15:37:25 -0700766 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800767
Colin Crossb98c8b02016-07-29 13:44:28 -0700768 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700769
770 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800771
772 // Flags used to compile this module
773 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700774
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800775 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700776 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900777
778 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800779 // Kythe (source file indexer) paths for this compilation module
780 kytheFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900781
782 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700783 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700784
785 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700786}
787
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500788func (c *Module) SetPreventInstall() {
789 c.Properties.PreventInstall = true
790}
791
792func (c *Module) SetHideFromMake() {
793 c.Properties.HideFromMake = true
794}
795
Ivan Lozano52767be2019-10-18 14:49:46 -0700796func (c *Module) Toc() android.OptionalPath {
797 if c.linker != nil {
798 if library, ok := c.linker.(libraryInterface); ok {
799 return library.toc()
800 }
801 }
802 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
803}
804
805func (c *Module) ApiLevel() string {
806 if c.linker != nil {
807 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700808 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700809 }
810 }
811 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
812}
813
814func (c *Module) Static() bool {
815 if c.linker != nil {
816 if library, ok := c.linker.(libraryInterface); ok {
817 return library.static()
818 }
819 }
820 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
821}
822
823func (c *Module) Shared() bool {
824 if c.linker != nil {
825 if library, ok := c.linker.(libraryInterface); ok {
826 return library.shared()
827 }
828 }
829 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
830}
831
832func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000833 if c.stl != nil {
834 return c.stl.Properties.SelectedStl
835 }
836 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700837}
838
839func (c *Module) ToolchainLibrary() bool {
840 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
841 return true
842 }
843 return false
844}
845
846func (c *Module) NdkPrebuiltStl() bool {
847 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
848 return true
849 }
850 return false
851}
852
853func (c *Module) StubDecorator() bool {
854 if _, ok := c.linker.(*stubDecorator); ok {
855 return true
856 }
857 return false
858}
859
860func (c *Module) SdkVersion() string {
861 return String(c.Properties.Sdk_version)
862}
863
Artur Satayev480e25b2020-04-27 18:53:18 +0100864func (c *Module) MinSdkVersion() string {
865 return String(c.Properties.Min_sdk_version)
866}
867
Dan Albert92fe7402020-07-15 13:33:30 -0700868func (c *Module) SplitPerApiLevel() bool {
Colin Cross1348ce32020-10-01 13:37:16 -0700869 if !c.canUseSdk() {
870 return false
871 }
Dan Albert92fe7402020-07-15 13:33:30 -0700872 if linker, ok := c.linker.(*objectLinker); ok {
873 return linker.isCrt()
874 }
875 return false
876}
877
Colin Crossc511bc52020-04-07 16:50:32 +0000878func (c *Module) AlwaysSdk() bool {
879 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
880}
881
Ivan Lozano183a3212019-10-18 14:18:45 -0700882func (c *Module) CcLibrary() bool {
883 if c.linker != nil {
884 if _, ok := c.linker.(*libraryDecorator); ok {
885 return true
886 }
Colin Crossd48fe732020-09-23 20:37:24 -0700887 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
888 return true
889 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700890 }
891 return false
892}
893
894func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -0700895 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700896 return true
897 }
898 return false
899}
900
Ivan Lozano2b262972019-11-21 12:30:50 -0800901func (c *Module) NonCcVariants() bool {
902 return false
903}
904
Ivan Lozano183a3212019-10-18 14:18:45 -0700905func (c *Module) SetStatic() {
906 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700907 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700908 library.setStatic()
909 return
910 }
911 }
912 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
913}
914
915func (c *Module) SetShared() {
916 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700917 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700918 library.setShared()
919 return
920 }
921 }
922 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
923}
924
925func (c *Module) BuildStaticVariant() bool {
926 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700927 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700928 return library.buildStatic()
929 }
930 }
931 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
932}
933
934func (c *Module) BuildSharedVariant() bool {
935 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700936 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700937 return library.buildShared()
938 }
939 }
940 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
941}
942
943func (c *Module) Module() android.Module {
944 return c
945}
946
Jiyong Parkc20eee32018-09-05 22:36:17 +0900947func (c *Module) OutputFile() android.OptionalPath {
948 return c.outputFile
949}
950
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400951func (c *Module) CoverageFiles() android.Paths {
952 if c.linker != nil {
953 if library, ok := c.linker.(libraryInterface); ok {
954 return library.objs().coverageFiles
955 }
956 }
957 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
958}
959
Ivan Lozano183a3212019-10-18 14:18:45 -0700960var _ LinkableInterface = (*Module)(nil)
961
Jiyong Park719b4462019-01-13 00:39:51 +0900962func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900963 if c.linker != nil {
964 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +0900965 }
966 return nil
967}
968
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900969func (c *Module) CoverageOutputFile() android.OptionalPath {
970 if c.linker != nil {
971 return c.linker.coverageOutputFilePath()
972 }
973 return android.OptionalPath{}
974}
975
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900976func (c *Module) RelativeInstallPath() string {
977 if c.installer != nil {
978 return c.installer.relativeInstallPath()
979 }
980 return ""
981}
982
Jooyung Han344d5432019-08-23 11:17:39 +0900983func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +0900984 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +0900985}
986
Colin Cross36242852017-06-23 15:06:31 -0700987func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -0700988 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -0800989 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -0700990 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800991 }
992 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -0700993 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800994 }
995 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -0700996 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800997 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700998 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -0700999 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001000 }
Colin Cross16b23492016-01-06 14:41:07 -08001001 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001002 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001003 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001004 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001005 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001006 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001007 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001008 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001009 }
Justin Yun8effde42017-06-23 19:24:43 +09001010 if c.vndkdep != nil {
1011 c.AddProperties(c.vndkdep.props()...)
1012 }
Stephen Craneba090d12017-05-09 15:44:35 -07001013 if c.lto != nil {
1014 c.AddProperties(c.lto.props()...)
1015 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001016 if c.pgo != nil {
1017 c.AddProperties(c.pgo.props()...)
1018 }
Colin Crossca860ac2016-01-04 14:34:37 -08001019 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001020 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001021 }
Colin Crossc472d572015-03-17 15:06:21 -07001022
Jiyong Park1613e552020-09-14 19:43:17 +09001023 c.Prefer32(func(ctx android.BaseModuleContext, base *android.ModuleBase, os android.OsType) bool {
Elliott Hughes79ae3412020-04-17 15:49:49 -07001024 // Windows builds always prefer 32-bit
Jiyong Park1613e552020-09-14 19:43:17 +09001025 return os == android.Windows
Colin Crossa9d8bee2018-10-02 13:59:46 -07001026 })
Colin Cross36242852017-06-23 15:06:31 -07001027 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001028 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001029 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001030 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001031
Colin Cross36242852017-06-23 15:06:31 -07001032 return c
Colin Crossc472d572015-03-17 15:06:21 -07001033}
1034
Colin Crossb916a382016-07-29 17:28:03 -07001035// Returns true for dependency roots (binaries)
1036// TODO(ccross): also handle dlopenable libraries
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001037func (c *Module) IsDependencyRoot() bool {
Colin Crossb916a382016-07-29 17:28:03 -07001038 if root, ok := c.linker.(interface {
1039 isDependencyRoot() bool
1040 }); ok {
1041 return root.isDependencyRoot()
1042 }
1043 return false
1044}
1045
Justin Yun5f7f7e82019-11-18 19:52:14 +09001046// Returns true if the module is using VNDK libraries instead of the libraries in /system/lib or /system/lib64.
1047// "product" and "vendor" variant modules return true for this function.
1048// When BOARD_VNDK_VERSION is set, vendor variants of "vendor_available: true", "vendor: true",
1049// "soc_specific: true" and more vendor installed modules are included here.
Justin Yun63e9ec72020-10-29 16:49:43 +09001050// When PRODUCT_PRODUCT_VNDK_VERSION is set, product variants of "product_available: true" or
Justin Yun5f7f7e82019-11-18 19:52:14 +09001051// "product_specific: true" modules are included here.
Ivan Lozano52767be2019-10-18 14:49:46 -07001052func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001053 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001054}
1055
Colin Crossc511bc52020-04-07 16:50:32 +00001056func (c *Module) canUseSdk() bool {
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001057 return c.Os() == android.Android && !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001058}
1059
1060func (c *Module) UseSdk() bool {
1061 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001062 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001063 }
1064 return false
1065}
1066
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001067func (c *Module) isCoverageVariant() bool {
1068 return c.coverage.Properties.IsCoverageVariant
1069}
1070
Colin Cross95f1ca02020-10-29 20:47:22 -07001071func (c *Module) IsNdk(config android.Config) bool {
1072 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001073}
1074
Colin Cross127bb8b2020-12-16 16:46:01 -08001075// isLLndk returns true for both LLNDK (public) and LLNDK-private libs.
1076func (c *Module) IsLlndk() bool {
1077 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001078}
1079
Colin Cross127bb8b2020-12-16 16:46:01 -08001080// IsLlndkPublic returns true only for LLNDK (public) libs.
1081func (c *Module) IsLlndkPublic() bool {
1082 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsLLNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001083}
1084
Colin Cross127bb8b2020-12-16 16:46:01 -08001085// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1086// and does not set llndk.vendor_available: false.
1087func (c *Module) isImplementationForLLNDKPublic() bool {
1088 library, _ := c.library.(*libraryDecorator)
1089 return library != nil && library.hasLLNDKStubs() &&
Justin Yunc0d8c492021-01-07 17:45:31 +09001090 (!Bool(library.Properties.Llndk.Private) ||
Colin Cross127bb8b2020-12-16 16:46:01 -08001091 // TODO(b/170784825): until the LLNDK properties are moved into the cc_library,
1092 // the non-Vendor variants of the cc_library don't know if the corresponding
Justin Yunc0d8c492021-01-07 17:45:31 +09001093 // llndk_library set private: true. Since libft2 is the only private LLNDK
1094 // library, hardcode it during the transition.
Colin Cross127bb8b2020-12-16 16:46:01 -08001095 c.BaseModuleName() != "libft2")
1096}
1097
Justin Yunfd9e8042020-12-23 18:23:14 +09001098// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001099func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001100 // Check if VNDK-core-private or VNDK-SP-private
1101 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001102 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001103 }
1104
1105 // Check if LLNDK-private
1106 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001107 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001108 }
1109
1110 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001111}
1112
Ivan Lozano52767be2019-10-18 14:49:46 -07001113func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001114 if vndkdep := c.vndkdep; vndkdep != nil {
1115 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001116 }
1117 return false
1118}
1119
Yi Kong7e53c572018-02-14 18:16:12 +08001120func (c *Module) isPgoCompile() bool {
1121 if pgo := c.pgo; pgo != nil {
1122 return pgo.Properties.PgoCompile
1123 }
1124 return false
1125}
1126
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001127func (c *Module) isNDKStubLibrary() bool {
1128 if _, ok := c.compiler.(*stubDecorator); ok {
1129 return true
1130 }
1131 return false
1132}
1133
Logan Chienf3511742017-10-31 18:04:35 +08001134func (c *Module) isVndkSp() bool {
1135 if vndkdep := c.vndkdep; vndkdep != nil {
1136 return vndkdep.isVndkSp()
1137 }
1138 return false
1139}
1140
Ivan Lozanof9e21722020-12-02 09:00:51 -05001141func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001142 if vndkdep := c.vndkdep; vndkdep != nil {
1143 return vndkdep.isVndkExt()
1144 }
1145 return false
1146}
1147
Ivan Lozano52767be2019-10-18 14:49:46 -07001148func (c *Module) MustUseVendorVariant() bool {
Jooyung Han097087b2019-10-22 19:32:18 +09001149 return c.isVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001150}
1151
Logan Chienf3511742017-10-31 18:04:35 +08001152func (c *Module) getVndkExtendsModuleName() string {
1153 if vndkdep := c.vndkdep; vndkdep != nil {
1154 return vndkdep.getVndkExtendsModuleName()
1155 }
1156 return ""
1157}
1158
Jiyong Park25fc6a92018-11-18 18:02:45 +09001159func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001160 if lib := c.library; lib != nil {
1161 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001162 }
1163 return false
1164}
1165
1166func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001167 if lib := c.library; lib != nil {
1168 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001169 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001170 return false
1171}
1172
Colin Cross0477b422020-10-13 18:43:54 -07001173// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1174// the implementation. If it is an implementation library it returns its own name.
1175func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1176 name := ctx.OtherModuleName(c)
1177 if versioned, ok := c.linker.(versionedInterface); ok {
1178 name = versioned.implementationModuleName(name)
1179 }
1180 return name
1181}
1182
Martin Stjernholm2856c662020-12-02 15:03:42 +00001183// Similar to ImplementationModuleName, but uses the Make variant of the module
1184// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1185// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1186// under the premise that the prebuilt module overrides its source counterpart
1187// if it is exposed to Make).
1188func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1189 name := c.BaseModuleName()
1190 if versioned, ok := c.linker.(versionedInterface); ok {
1191 name = versioned.implementationModuleName(name)
1192 }
1193 return name
1194}
1195
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001196func (c *Module) bootstrap() bool {
1197 return Bool(c.Properties.Bootstrap)
1198}
1199
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001200func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001201 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1202 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1203 return false
1204 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001205 return c.linker != nil && c.linker.nativeCoverage()
1206}
1207
Inseob Kim8471cda2019-11-15 09:59:12 +09001208func (c *Module) isSnapshotPrebuilt() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09001209 if p, ok := c.linker.(interface{ isSnapshotPrebuilt() bool }); ok {
1210 return p.isSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001211 }
1212 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001213}
1214
Bill Peckham945441c2020-08-31 16:07:58 -07001215func (c *Module) ExcludeFromVendorSnapshot() bool {
1216 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1217}
1218
Jose Galmesf7294582020-11-13 12:07:36 -08001219func (c *Module) ExcludeFromRecoverySnapshot() bool {
1220 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1221}
1222
Jiyong Parkf1194352019-02-25 11:05:47 +09001223func isBionic(name string) bool {
1224 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001225 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001226 return true
1227 }
1228 return false
1229}
1230
Martin Stjernholm279de572019-09-10 23:18:20 +01001231func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001232 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001233 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001234 }
1235 return isBionic(name)
1236}
1237
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001238func (c *Module) XrefCcFiles() android.Paths {
1239 return c.kytheFiles
1240}
1241
Colin Crossca860ac2016-01-04 14:34:37 -08001242type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001243 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001244 moduleContextImpl
1245}
1246
Colin Cross37047f12016-12-13 17:06:13 -08001247type depsContext struct {
1248 android.BottomUpMutatorContext
1249 moduleContextImpl
1250}
1251
Colin Crossca860ac2016-01-04 14:34:37 -08001252type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001253 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001254 moduleContextImpl
1255}
1256
1257type moduleContextImpl struct {
1258 mod *Module
1259 ctx BaseModuleContext
1260}
1261
Colin Crossb98c8b02016-07-29 13:44:28 -07001262func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001263 return ctx.mod.toolchain(ctx.ctx)
1264}
1265
1266func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001267 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001268}
1269
1270func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001271 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001272}
1273
Jiyong Park1d1119f2019-07-29 21:27:18 +09001274func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001275 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001276}
1277
Inseob Kim7f283f42020-06-01 21:53:49 +09001278func (ctx *moduleContextImpl) binary() bool {
1279 return ctx.mod.binary()
1280}
1281
Inseob Kim1042d292020-06-01 23:23:05 +09001282func (ctx *moduleContextImpl) object() bool {
1283 return ctx.mod.object()
1284}
1285
Jooyung Hanccce2f22020-03-07 03:45:53 +09001286func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001287 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001288}
1289
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001290func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001291 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001292}
1293
1294func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001295 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001296 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001297 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001298 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001299 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001300 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001301 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001302 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001303 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001304 }
1305 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001306}
1307
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001308func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001309 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001310}
Justin Yun8effde42017-06-23 19:24:43 +09001311
Colin Cross95f1ca02020-10-29 20:47:22 -07001312func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1313 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001314}
1315
Colin Cross127bb8b2020-12-16 16:46:01 -08001316func (ctx *moduleContextImpl) IsLlndk() bool {
1317 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001318}
1319
Colin Cross127bb8b2020-12-16 16:46:01 -08001320func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1321 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001322}
1323
Colin Cross127bb8b2020-12-16 16:46:01 -08001324func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1325 return ctx.mod.isImplementationForLLNDKPublic()
1326}
1327
1328func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1329 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001330}
1331
Logan Chienf3511742017-10-31 18:04:35 +08001332func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001333 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001334}
1335
Yi Kong7e53c572018-02-14 18:16:12 +08001336func (ctx *moduleContextImpl) isPgoCompile() bool {
1337 return ctx.mod.isPgoCompile()
1338}
1339
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001340func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1341 return ctx.mod.isNDKStubLibrary()
1342}
1343
Justin Yun8effde42017-06-23 19:24:43 +09001344func (ctx *moduleContextImpl) isVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001345 return ctx.mod.isVndkSp()
1346}
1347
Ivan Lozanof9e21722020-12-02 09:00:51 -05001348func (ctx *moduleContextImpl) IsVndkExt() bool {
1349 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001350}
1351
Vic Yangefd249e2018-11-12 20:19:56 -08001352func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001353 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001354}
1355
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001356func (ctx *moduleContextImpl) selectedStl() string {
1357 if stl := ctx.mod.stl; stl != nil {
1358 return stl.Properties.SelectedStl
1359 }
1360 return ""
1361}
1362
Ivan Lozanobd721262018-11-27 14:33:03 -08001363func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1364 return ctx.mod.linker.useClangLld(actx)
1365}
1366
Colin Crossce75d2c2016-10-06 16:12:58 -07001367func (ctx *moduleContextImpl) baseModuleName() string {
1368 return ctx.mod.ModuleBase.BaseModuleName()
1369}
1370
Logan Chienf3511742017-10-31 18:04:35 +08001371func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1372 return ctx.mod.getVndkExtendsModuleName()
1373}
1374
Logan Chiene274fc92019-12-03 11:18:32 -08001375func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001376 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001377}
1378
Colin Crosse07f2312020-08-13 11:24:56 -07001379func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001380 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001381}
1382
Dan Albertc8060532020-07-22 22:32:17 -07001383func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001384 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001385}
1386
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001387func (ctx *moduleContextImpl) bootstrap() bool {
1388 return ctx.mod.bootstrap()
1389}
1390
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001391func (ctx *moduleContextImpl) nativeCoverage() bool {
1392 return ctx.mod.nativeCoverage()
1393}
1394
Colin Cross56a83212020-09-15 18:30:11 -07001395func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1396 return ctx.mod.DirectlyInAnyApex()
1397}
1398
Colin Cross95b07f22020-12-16 11:06:50 -08001399func (ctx *moduleContextImpl) isPreventInstall() bool {
1400 return ctx.mod.Properties.PreventInstall
1401}
1402
Colin Cross635c3b02016-05-18 15:37:25 -07001403func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001404 return &Module{
1405 hod: hod,
1406 multilib: multilib,
1407 }
1408}
1409
Colin Cross635c3b02016-05-18 15:37:25 -07001410func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001411 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001412 module.features = []feature{
1413 &tidyFeature{},
1414 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001415 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001416 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001417 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001418 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001419 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001420 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001421 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001422 return module
1423}
1424
Colin Crossce75d2c2016-10-06 16:12:58 -07001425func (c *Module) Prebuilt() *android.Prebuilt {
1426 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1427 return p.prebuilt()
1428 }
1429 return nil
1430}
1431
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001432func (c *Module) IsPrebuilt() bool {
1433 return c.Prebuilt() != nil
1434}
1435
Colin Crossce75d2c2016-10-06 16:12:58 -07001436func (c *Module) Name() string {
1437 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001438 if p, ok := c.linker.(interface {
1439 Name(string) string
1440 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001441 name = p.Name(name)
1442 }
1443 return name
1444}
1445
Alex Light3d673592019-01-18 14:37:31 -08001446func (c *Module) Symlinks() []string {
1447 if p, ok := c.installer.(interface {
1448 symlinkList() []string
1449 }); ok {
1450 return p.symlinkList()
1451 }
1452 return nil
1453}
1454
Roland Levillainf89cd092019-07-29 16:22:59 +01001455func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1456 test, ok := c.linker.(testPerSrc)
1457 return ok && test.isAllTestsVariation()
1458}
1459
Chris Parsons216e10a2020-07-09 17:12:52 -04001460func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001461 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001462 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001463 }); ok {
1464 return p.dataPaths()
1465 }
1466 return nil
1467}
1468
Justin Yun5f7f7e82019-11-18 19:52:14 +09001469func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1470 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1471 // "current", it will append the VNDK version to the name suffix.
1472 var vndkVersion string
1473 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001474 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001475 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
1476 nameSuffix = productSuffix
1477 } else {
1478 vndkVersion = ctx.DeviceConfig().VndkVersion()
1479 nameSuffix = vendorSuffix
1480 }
1481 if vndkVersion == "current" {
1482 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1483 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001484 if c.Properties.VndkVersion != vndkVersion && c.Properties.VndkVersion != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001485 // add version suffix only if the module is using different vndk version than the
1486 // version in product or vendor partition.
1487 nameSuffix += "." + c.Properties.VndkVersion
1488 }
1489 return nameSuffix
1490}
1491
Colin Cross635c3b02016-05-18 15:37:25 -07001492func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Roland Levillainf2fad972019-06-28 15:41:19 +01001493 // Handle the case of a test module split by `test_per_src` mutator.
Roland Levillainf89cd092019-07-29 16:22:59 +01001494 //
1495 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1496 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1497 // module and return early, as this module does not produce an output file per se.
1498 if c.IsTestPerSrcAllTestsVariation() {
1499 c.outputFile = android.OptionalPath{}
1500 return
Roland Levillainf2fad972019-06-28 15:41:19 +01001501 }
1502
Colin Cross56a83212020-09-15 18:30:11 -07001503 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1504 if !apexInfo.IsForPlatform() {
1505 c.hideApexVariantFromMake = true
1506 }
1507
Ivan Lozanof9e21722020-12-02 09:00:51 -05001508 c.makeLinkType = GetMakeLinkType(actx, c)
Inseob Kim9516ee92019-05-09 10:56:13 +09001509
Inseob Kim64c43952019-08-26 16:52:35 +09001510 c.Properties.SubName = ""
1511
1512 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1513 c.Properties.SubName += nativeBridgeSuffix
1514 }
1515
Colin Cross127bb8b2020-12-16 16:46:01 -08001516 llndk := c.IsLlndk()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001517 _, llndkHeader := c.linker.(*llndkHeadersDecorator)
Justin Yun63e9ec72020-10-29 16:49:43 +09001518 if llndk || llndkHeader || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001519 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1520 // added for product variant only when we have vendor and product variants with core
1521 // variant. The suffix is not added for vendor-only or product-only module.
1522 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
1523 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001524 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1525 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
1526 c.Properties.SubName += vendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001527 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
1528 c.Properties.SubName += ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001529 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
1530 c.Properties.SubName += vendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001531 } else if c.InRecovery() && !c.OnlyInRecovery() {
Inseob Kim64c43952019-08-26 16:52:35 +09001532 c.Properties.SubName += recoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001533 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001534 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001535 if c.SplitPerApiLevel() {
1536 c.Properties.SubName += "." + c.SdkVersion()
1537 }
Inseob Kim64c43952019-08-26 16:52:35 +09001538 }
1539
Colin Crossca860ac2016-01-04 14:34:37 -08001540 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001541 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001542 moduleContextImpl: moduleContextImpl{
1543 mod: c,
1544 },
1545 }
1546 ctx.ctx = ctx
1547
Colin Crossf18e1102017-11-16 14:33:08 -08001548 deps := c.depsToPaths(ctx)
1549 if ctx.Failed() {
1550 return
1551 }
1552
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001553 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1554 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1555 }
1556
Colin Crossca860ac2016-01-04 14:34:37 -08001557 flags := Flags{
1558 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001559 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001560 }
Colin Crossca860ac2016-01-04 14:34:37 -08001561 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001562 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001563 }
1564 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001565 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001566 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001567 if c.stl != nil {
1568 flags = c.stl.flags(ctx, flags)
1569 }
Colin Cross16b23492016-01-06 14:41:07 -08001570 if c.sanitize != nil {
1571 flags = c.sanitize.flags(ctx, flags)
1572 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001573 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001574 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001575 }
Stephen Craneba090d12017-05-09 15:44:35 -07001576 if c.lto != nil {
1577 flags = c.lto.flags(ctx, flags)
1578 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001579 if c.pgo != nil {
1580 flags = c.pgo.flags(ctx, flags)
1581 }
Colin Crossca860ac2016-01-04 14:34:37 -08001582 for _, feature := range c.features {
1583 flags = feature.flags(ctx, flags)
1584 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001585 if ctx.Failed() {
1586 return
1587 }
1588
Colin Cross4af21ed2019-11-04 09:37:55 -08001589 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1590 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1591 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001592
Colin Cross4af21ed2019-11-04 09:37:55 -08001593 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001594
1595 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001596 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001597 }
1598 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001599 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001600 }
1601
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001602 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001603 // We need access to all the flags seen by a source file.
1604 if c.sabi != nil {
1605 flags = c.sabi.flags(ctx, flags)
1606 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001607
Colin Cross4af21ed2019-11-04 09:37:55 -08001608 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001609
Colin Crossca860ac2016-01-04 14:34:37 -08001610 // Optimization to reduce size of build.ninja
1611 // Replace the long list of flags for each file with a module-local variable
Colin Cross4af21ed2019-11-04 09:37:55 -08001612 ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))
1613 ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))
1614 ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))
1615 flags.Local.CFlags = []string{"$cflags"}
1616 flags.Local.CppFlags = []string{"$cppflags"}
1617 flags.Local.AsFlags = []string{"$asflags"}
Colin Crossca860ac2016-01-04 14:34:37 -08001618
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001619 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001620 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001621 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001622 if ctx.Failed() {
1623 return
1624 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001625 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001626 }
1627
Colin Crossca860ac2016-01-04 14:34:37 -08001628 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001629 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001630 if ctx.Failed() {
1631 return
1632 }
Colin Cross635c3b02016-05-18 15:37:25 -07001633 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001634
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09001635 // If a lib is directly included in any of the APEXes or is not available to the
1636 // platform (which is often the case when the stub is provided as a prebuilt),
1637 // unhide the stubs variant having the latest version gets visible to make. In
1638 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
1639 // force anything in the make world to link against the stubs library. (unless it
1640 // is explicitly referenced via .bootstrap suffix or the module is marked with
1641 // 'bootstrap: true').
1642 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
Ivan Lozano52767be2019-10-18 14:49:46 -07001643 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001644 c.IsStubs() && !c.InVendorRamdisk() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001645 c.Properties.HideFromMake = false // unhide
1646 // Note: this is still non-installable
1647 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001648
Jose Galmes6f843bc2020-12-11 13:36:29 -08001649 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1650 // RECOVERY_SNAPSHOT_VERSION is current.
1651 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Inseob Kimde5744a2020-12-02 13:14:28 +09001652 if shouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001653 i.collectHeadersForSnapshot(ctx)
1654 }
1655 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001656 }
Colin Cross5049f022015-03-18 13:28:46 -07001657
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001658 if !proptools.BoolDefault(c.Properties.Installable, true) {
1659 // If the module has been specifically configure to not be installed then
1660 // hide from make as otherwise it will break when running inside make
1661 // as the output path to install will not be specified. Not all uninstallable
1662 // modules can be hidden from make as some are needed for resolving make side
1663 // dependencies.
1664 c.HideFromMake()
1665 } else if !c.installable(apexInfo) {
1666 c.SkipInstall()
1667 }
1668
1669 // Still call c.installer.install though, the installs will be stored as PackageSpecs
1670 // to allow using the outputs in a genrule.
1671 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001672 c.installer.install(ctx, c.outputFile.Path())
1673 if ctx.Failed() {
1674 return
Colin Crossca860ac2016-01-04 14:34:37 -08001675 }
Dan Albertc403f7c2015-03-18 14:01:18 -07001676 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001677}
1678
Colin Cross0ea8ba82019-06-06 14:33:29 -07001679func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001680 if c.cachedToolchain == nil {
Colin Crossb98c8b02016-07-29 13:44:28 -07001681 c.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
Colin Cross3f40fa42015-01-30 17:27:36 -08001682 }
Colin Crossca860ac2016-01-04 14:34:37 -08001683 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001684}
1685
Colin Crossca860ac2016-01-04 14:34:37 -08001686func (c *Module) begin(ctx BaseModuleContext) {
1687 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001688 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001689 }
Colin Crossca860ac2016-01-04 14:34:37 -08001690 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001691 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001692 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001693 if c.stl != nil {
1694 c.stl.begin(ctx)
1695 }
Colin Cross16b23492016-01-06 14:41:07 -08001696 if c.sanitize != nil {
1697 c.sanitize.begin(ctx)
1698 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001699 if c.coverage != nil {
1700 c.coverage.begin(ctx)
1701 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001702 if c.sabi != nil {
1703 c.sabi.begin(ctx)
1704 }
Justin Yun8effde42017-06-23 19:24:43 +09001705 if c.vndkdep != nil {
1706 c.vndkdep.begin(ctx)
1707 }
Stephen Craneba090d12017-05-09 15:44:35 -07001708 if c.lto != nil {
1709 c.lto.begin(ctx)
1710 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001711 if c.pgo != nil {
1712 c.pgo.begin(ctx)
1713 }
Colin Crossca860ac2016-01-04 14:34:37 -08001714 for _, feature := range c.features {
1715 feature.begin(ctx)
1716 }
Dan Albert92fe7402020-07-15 13:33:30 -07001717 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001718 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001719 if err != nil {
1720 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001721 c.Properties.Sdk_version = nil
1722 } else {
1723 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001724 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001725 }
Colin Crossca860ac2016-01-04 14:34:37 -08001726}
1727
Colin Cross37047f12016-12-13 17:06:13 -08001728func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001729 deps := Deps{}
1730
1731 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001732 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001733 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001734 // Add the PGO dependency (the clang_rt.profile runtime library), which
1735 // sometimes depends on symbols from libgcc, before libgcc gets added
1736 // in linkerDeps().
Pirama Arumuga Nainar49b53d52017-10-04 16:47:29 -07001737 if c.pgo != nil {
1738 deps = c.pgo.deps(ctx, deps)
1739 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001740 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001741 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001742 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001743 if c.stl != nil {
1744 deps = c.stl.deps(ctx, deps)
1745 }
Colin Cross16b23492016-01-06 14:41:07 -08001746 if c.sanitize != nil {
1747 deps = c.sanitize.deps(ctx, deps)
1748 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001749 if c.coverage != nil {
1750 deps = c.coverage.deps(ctx, deps)
1751 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001752 if c.sabi != nil {
1753 deps = c.sabi.deps(ctx, deps)
1754 }
Justin Yun8effde42017-06-23 19:24:43 +09001755 if c.vndkdep != nil {
1756 deps = c.vndkdep.deps(ctx, deps)
1757 }
Stephen Craneba090d12017-05-09 15:44:35 -07001758 if c.lto != nil {
1759 deps = c.lto.deps(ctx, deps)
1760 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001761 for _, feature := range c.features {
1762 deps = feature.deps(ctx, deps)
1763 }
1764
Colin Crossb6715442017-10-24 11:13:31 -07001765 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1766 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1767 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1768 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1769 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1770 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001771 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001772
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001773 for _, lib := range deps.ReexportSharedLibHeaders {
1774 if !inList(lib, deps.SharedLibs) {
1775 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1776 }
1777 }
1778
1779 for _, lib := range deps.ReexportStaticLibHeaders {
1780 if !inList(lib, deps.StaticLibs) {
1781 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs: '%s'", lib)
1782 }
1783 }
1784
Colin Cross5950f382016-12-13 12:50:57 -08001785 for _, lib := range deps.ReexportHeaderLibHeaders {
1786 if !inList(lib, deps.HeaderLibs) {
1787 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1788 }
1789 }
1790
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001791 for _, gen := range deps.ReexportGeneratedHeaders {
1792 if !inList(gen, deps.GeneratedHeaders) {
1793 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1794 }
1795 }
1796
Colin Crossc99deeb2016-04-11 15:06:20 -07001797 return deps
1798}
1799
Dan Albert7e9d2952016-08-04 13:02:36 -07001800func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001801 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001802 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001803 moduleContextImpl: moduleContextImpl{
1804 mod: c,
1805 },
1806 }
1807 ctx.ctx = ctx
1808
Colin Crossca860ac2016-01-04 14:34:37 -08001809 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001810}
1811
Jiyong Park7ed9de32018-10-15 22:25:07 +09001812// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09001813func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001814 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1815 version := name[sharp+1:]
1816 libname := name[:sharp]
1817 return libname, version
1818 }
1819 return name, ""
1820}
1821
Dan Albert92fe7402020-07-15 13:33:30 -07001822func GetCrtVariations(ctx android.BottomUpMutatorContext,
1823 m LinkableInterface) []blueprint.Variation {
1824 if ctx.Os() != android.Android {
1825 return nil
1826 }
1827 if m.UseSdk() {
1828 return []blueprint.Variation{
1829 {Mutator: "sdk", Variation: "sdk"},
Colin Crossbbc941b2020-09-30 12:27:01 -07001830 {Mutator: "version", Variation: m.SdkVersion()},
Dan Albert92fe7402020-07-15 13:33:30 -07001831 }
1832 }
1833 return []blueprint.Variation{
1834 {Mutator: "sdk", Variation: ""},
1835 }
1836}
1837
Colin Crosse7257d22020-09-24 09:56:18 -07001838func (c *Module) addSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext,
1839 variations []blueprint.Variation, depTag libraryDependencyTag, name, version string, far bool) {
1840
1841 variations = append([]blueprint.Variation(nil), variations...)
1842
Colin Cross3146c5c2020-09-30 15:34:40 -07001843 if version != "" && CanBeOrLinkAgainstVersionVariants(c) {
Colin Crosse7257d22020-09-24 09:56:18 -07001844 // Version is explicitly specified. i.e. libFoo#30
1845 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
1846 depTag.explicitlyVersioned = true
1847 }
Colin Crosse7257d22020-09-24 09:56:18 -07001848
Colin Cross0de8a1e2020-09-18 14:15:30 -07001849 if far {
1850 ctx.AddFarVariationDependencies(variations, depTag, name)
1851 } else {
1852 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07001853 }
1854}
1855
Colin Cross1e676be2016-10-12 14:38:15 -07001856func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09001857 if !c.Enabled() {
1858 return
1859 }
1860
Colin Cross37047f12016-12-13 17:06:13 -08001861 ctx := &depsContext{
1862 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07001863 moduleContextImpl: moduleContextImpl{
1864 mod: c,
1865 },
1866 }
1867 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08001868
Colin Crossc99deeb2016-04-11 15:06:20 -07001869 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001870
Yo Chiang219968c2020-09-22 18:45:04 +08001871 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
1872
Dan Albert914449f2016-06-17 16:45:24 -07001873 variantNdkLibs := []string{}
1874 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07001875 if ctx.Os() == android.Android {
Inseob Kimeec88e12020-01-22 11:11:29 +09001876 // rewriteLibs takes a list of names of shared libraries and scans it for three types
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001877 // of names:
Dan Albert914449f2016-06-17 16:45:24 -07001878 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001879 // 1. Name of an NDK library that refers to a prebuilt module.
1880 // For each of these, it adds the name of the prebuilt module (which will be in
1881 // prebuilts/ndk) to the list of nonvariant libs.
1882 // 2. Name of an NDK library that refers to an ndk_library module.
1883 // For each of these, it adds the name of the ndk_library module to the list of
1884 // variant libs.
1885 // 3. Anything else (so anything that isn't an NDK library).
1886 // It adds these to the nonvariantLibs list.
Dan Albert914449f2016-06-17 16:45:24 -07001887 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001888 // The caller can then know to add the variantLibs dependencies differently from the
1889 // nonvariantLibs
Inseob Kim9516ee92019-05-09 10:56:13 +09001890
Inseob Kim9516ee92019-05-09 10:56:13 +09001891 vendorPublicLibraries := vendorPublicLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001892 vendorSnapshotSharedLibs := vendorSnapshotSharedLibs(actx.Config())
Jose Galmes6f843bc2020-12-11 13:36:29 -08001893 recoverySnapshotSharedLibs := recoverySnapshotSharedLibs(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001894
1895 rewriteVendorLibs := func(lib string) string {
Inseob Kimeec88e12020-01-22 11:11:29 +09001896 // only modules with BOARD_VNDK_VERSION uses snapshot.
1897 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1898 return lib
1899 }
1900
1901 if snapshot, ok := vendorSnapshotSharedLibs.get(lib, actx.Arch().ArchType); ok {
1902 return snapshot
1903 }
1904
1905 return lib
1906 }
1907
1908 rewriteLibs := func(list []string) (nonvariantLibs []string, variantLibs []string) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001909 variantLibs = []string{}
1910 nonvariantLibs = []string{}
Dan Albert914449f2016-06-17 16:45:24 -07001911 for _, entry := range list {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001912 // strip #version suffix out
Jiyong Park73c54ee2019-10-22 20:31:18 +09001913 name, _ := StubsLibNameAndVersion(entry)
Jose Galmes6f843bc2020-12-11 13:36:29 -08001914 if c.InRecovery() {
1915 recoverySnapshotVersion :=
1916 actx.DeviceConfig().RecoverySnapshotVersion()
1917 if recoverySnapshotVersion == "current" ||
1918 recoverySnapshotVersion == "" {
1919 nonvariantLibs = append(nonvariantLibs, name)
1920 } else if snapshot, ok := recoverySnapshotSharedLibs.get(
1921 name, actx.Arch().ArchType); ok {
1922 nonvariantLibs = append(nonvariantLibs, snapshot)
1923 } else {
1924 nonvariantLibs = append(nonvariantLibs, name)
1925 }
1926 } else if ctx.useSdk() && inList(name, *getNDKKnownLibs(ctx.Config())) {
Dan Albertde5aade2020-06-30 12:32:51 -07001927 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Inseob Kimeec88e12020-01-22 11:11:29 +09001928 } else if ctx.useVndk() {
1929 nonvariantLibs = append(nonvariantLibs, rewriteVendorLibs(entry))
Inseob Kim9516ee92019-05-09 10:56:13 +09001930 } else if (ctx.Platform() || ctx.ProductSpecific()) && inList(name, *vendorPublicLibraries) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001931 vendorPublicLib := name + vendorPublicLibrarySuffix
Jiyong Park374510b2018-03-19 18:23:01 +09001932 if actx.OtherModuleExists(vendorPublicLib) {
1933 nonvariantLibs = append(nonvariantLibs, vendorPublicLib)
1934 } else {
1935 // This can happen if vendor_public_library module is defined in a
1936 // namespace that isn't visible to the current module. In that case,
1937 // link to the original library.
Jiyong Park7ed9de32018-10-15 22:25:07 +09001938 nonvariantLibs = append(nonvariantLibs, name)
Jiyong Park374510b2018-03-19 18:23:01 +09001939 }
Dan Albert914449f2016-06-17 16:45:24 -07001940 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001941 // put name#version back
Dan Willemsen7cbf5f82017-03-28 00:08:30 -07001942 nonvariantLibs = append(nonvariantLibs, entry)
Dan Willemsen72d39932016-07-08 23:23:48 -07001943 }
1944 }
Dan Albert914449f2016-06-17 16:45:24 -07001945 return nonvariantLibs, variantLibs
Dan Willemsen72d39932016-07-08 23:23:48 -07001946 }
1947
Inseob Kimeec88e12020-01-22 11:11:29 +09001948 deps.SharedLibs, variantNdkLibs = rewriteLibs(deps.SharedLibs)
1949 deps.LateSharedLibs, variantLateNdkLibs = rewriteLibs(deps.LateSharedLibs)
1950 deps.ReexportSharedLibHeaders, _ = rewriteLibs(deps.ReexportSharedLibHeaders)
1951 if ctx.useVndk() {
1952 for idx, lib := range deps.RuntimeLibs {
1953 deps.RuntimeLibs[idx] = rewriteVendorLibs(lib)
1954 }
1955 }
Dan Willemsen72d39932016-07-08 23:23:48 -07001956 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001957
Inseob Kimeec88e12020-01-22 11:11:29 +09001958 rewriteSnapshotLibs := func(lib string, snapshotMap *snapshotMap) string {
1959 // only modules with BOARD_VNDK_VERSION uses snapshot.
1960 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1961 return lib
1962 }
1963
1964 if snapshot, ok := snapshotMap.get(lib, actx.Arch().ArchType); ok {
1965 return snapshot
1966 }
1967
1968 return lib
1969 }
1970
Jose Galmes6f843bc2020-12-11 13:36:29 -08001971 snapshotHeaderLibs := vendorSnapshotHeaderLibs(actx.Config())
1972 snapshotStaticLibs := vendorSnapshotStaticLibs(actx.Config())
1973 snapshotObjects := vendorSnapshotObjects(actx.Config())
1974
1975 if c.InRecovery() {
1976 rewriteSnapshotLibs = func(lib string, snapshotMap *snapshotMap) string {
1977 recoverySnapshotVersion :=
1978 actx.DeviceConfig().RecoverySnapshotVersion()
1979 if recoverySnapshotVersion == "current" ||
1980 recoverySnapshotVersion == "" {
1981 return lib
1982 } else if snapshot, ok := snapshotMap.get(lib, actx.Arch().ArchType); ok {
1983 return snapshot
1984 }
1985
1986 return lib
1987 }
1988
1989 snapshotHeaderLibs = recoverySnapshotHeaderLibs(actx.Config())
1990 snapshotStaticLibs = recoverySnapshotStaticLibs(actx.Config())
1991 snapshotObjects = recoverySnapshotObjects(actx.Config())
1992 }
1993
Colin Cross32ec36c2016-12-15 07:39:51 -08001994 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001995 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08001996 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001997 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08001998 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001999
Jose Galmes6f843bc2020-12-11 13:36:29 -08002000 lib = rewriteSnapshotLibs(lib, snapshotHeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002001
Jiyong Park1ad8e162020-12-01 23:40:09 +09002002 if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002003 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002004 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002005 } else {
2006 actx.AddVariationDependencies(nil, depTag, lib)
2007 }
2008 }
2009
Inseob Kim07def122020-11-23 14:43:02 +09002010 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
2011 // C++ implementation library and one Java implementation library. When a module links against
2012 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
2013 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
2014 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09002015 syspropImplLibraries := syspropImplLibraries(actx.Config())
2016
Jiyong Park5d1598f2019-02-25 22:14:17 +09002017 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002018 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09002019 if impl, ok := syspropImplLibraries[lib]; ok {
2020 lib = impl
2021 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002022
Jose Galmes6f843bc2020-12-11 13:36:29 -08002023 lib = rewriteSnapshotLibs(lib, snapshotStaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002024
Jiyong Park5d1598f2019-02-25 22:14:17 +09002025 actx.AddVariationDependencies([]blueprint.Variation{
2026 {Mutator: "link", Variation: "static"},
2027 }, depTag, lib)
2028 }
2029
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002030 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002031 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002032 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002033 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002034 }
Jiyong Parke3867542020-12-03 17:28:25 +09002035 if inList(lib, deps.ExcludeLibsForApex) {
2036 depTag.excludeInApex = true
2037 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002038
2039 if impl, ok := syspropImplLibraries[lib]; ok {
2040 lib = impl
2041 }
2042
Jose Galmes6f843bc2020-12-11 13:36:29 -08002043 lib = rewriteSnapshotLibs(lib, snapshotStaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002044
Dan Willemsen59339a22018-07-22 21:18:45 -07002045 actx.AddVariationDependencies([]blueprint.Variation{
2046 {Mutator: "link", Variation: "static"},
2047 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002048 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002049
Jooyung Han75568392020-03-20 04:29:24 +09002050 // staticUnwinderDep is treated as staticDep for Q apexes
2051 // so that native libraries/binaries are linked with static unwinder
2052 // because Q libc doesn't have unwinder APIs
2053 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002054 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002055 actx.AddVariationDependencies([]blueprint.Variation{
2056 {Mutator: "link", Variation: "static"},
Jose Galmes6f843bc2020-12-11 13:36:29 -08002057 }, depTag, rewriteSnapshotLibs(staticUnwinder(actx), snapshotStaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002058 }
2059
Inseob Kimeec88e12020-01-22 11:11:29 +09002060 for _, lib := range deps.LateStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002061 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
Inseob Kimeec88e12020-01-22 11:11:29 +09002062 actx.AddVariationDependencies([]blueprint.Variation{
2063 {Mutator: "link", Variation: "static"},
Jose Galmes6f843bc2020-12-11 13:36:29 -08002064 }, depTag, rewriteSnapshotLibs(lib, snapshotStaticLibs))
Inseob Kimeec88e12020-01-22 11:11:29 +09002065 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002066
Jiyong Park7ed9de32018-10-15 22:25:07 +09002067 // shared lib names without the #version suffix
2068 var sharedLibNames []string
2069
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002070 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002071 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002072 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002073 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002074 }
Jiyong Parke3867542020-12-03 17:28:25 +09002075 if inList(lib, deps.ExcludeLibsForApex) {
2076 depTag.excludeInApex = true
2077 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002078
2079 if impl, ok := syspropImplLibraries[lib]; ok {
2080 lib = impl
2081 }
2082
Jiyong Park73c54ee2019-10-22 20:31:18 +09002083 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002084 sharedLibNames = append(sharedLibNames, name)
2085
Colin Crosse7257d22020-09-24 09:56:18 -07002086 variations := []blueprint.Variation{
2087 {Mutator: "link", Variation: "shared"},
2088 }
2089 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002090 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002091
Jiyong Park7ed9de32018-10-15 22:25:07 +09002092 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002093 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002094 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2095 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2096 // linking against both the stubs lib and the non-stubs lib at the same time.
2097 continue
2098 }
Colin Cross6e511a92020-07-27 21:26:48 -07002099 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002100 variations := []blueprint.Variation{
2101 {Mutator: "link", Variation: "shared"},
2102 }
2103 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002104 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002105
Dan Willemsen59339a22018-07-22 21:18:45 -07002106 actx.AddVariationDependencies([]blueprint.Variation{
2107 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002108 }, dataLibDepTag, deps.DataLibs...)
2109
2110 actx.AddVariationDependencies([]blueprint.Variation{
2111 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002112 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002113
Colin Cross68861832016-07-08 10:41:41 -07002114 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002115
2116 for _, gen := range deps.GeneratedHeaders {
2117 depTag := genHeaderDepTag
2118 if inList(gen, deps.ReexportGeneratedHeaders) {
2119 depTag = genHeaderExportDepTag
2120 }
2121 actx.AddDependency(c, depTag, gen)
2122 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002123
Dan Albert92fe7402020-07-15 13:33:30 -07002124 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002125 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07002126 if deps.CrtBegin != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07002127 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Jose Galmes6f843bc2020-12-11 13:36:29 -08002128 rewriteSnapshotLibs(deps.CrtBegin, snapshotObjects))
Colin Crossca860ac2016-01-04 14:34:37 -08002129 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002130 if deps.CrtEnd != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07002131 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Jose Galmes6f843bc2020-12-11 13:36:29 -08002132 rewriteSnapshotLibs(deps.CrtEnd, snapshotObjects))
Colin Cross21b9a242015-03-24 14:15:58 -07002133 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002134 if deps.LinkerFlagsFile != "" {
2135 actx.AddDependency(c, linkerFlagsDepTag, deps.LinkerFlagsFile)
2136 }
2137 if deps.DynamicLinker != "" {
2138 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002139 }
Dan Albert914449f2016-06-17 16:45:24 -07002140
2141 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002142
2143 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002144 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002145 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002146 {Mutator: "link", Variation: "shared"},
2147 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002148
2149 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002150 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002151 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002152 {Mutator: "link", Variation: "shared"},
2153 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002154
2155 if vndkdep := c.vndkdep; vndkdep != nil {
2156 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002157 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002158 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002159 {Mutator: "link", Variation: "shared"},
2160 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08002161 }
2162 }
Colin Cross6362e272015-10-29 15:25:03 -07002163}
Colin Cross21b9a242015-03-24 14:15:58 -07002164
Colin Crosse40b4ea2018-10-02 22:25:58 -07002165func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002166 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2167 c.beginMutator(ctx)
2168 }
2169}
2170
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002171// Whether a module can link to another module, taking into
2172// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002173func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002174 tag blueprint.DependencyTag) {
2175
2176 switch t := tag.(type) {
2177 case dependencyTag:
2178 if t != vndkExtDepTag {
2179 return
2180 }
2181 case libraryDependencyTag:
2182 default:
2183 return
2184 }
2185
Ivan Lozanof9e21722020-12-02 09:00:51 -05002186 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002187 // Host code is not restricted
2188 return
2189 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002190
2191 // VNDK is cc.Module supported only for now.
2192 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002193 // Though allowed dependency is limited by the image mutator,
2194 // each vendor and product module needs to check link-type
2195 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002196 if ccTo, ok := to.(*Module); ok {
2197 if ccFrom.vndkdep != nil {
2198 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2199 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05002200 } else if linkableMod, ok := to.(LinkableInterface); ok {
2201 // Static libraries from other languages can be linked
2202 if !linkableMod.Static() {
2203 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
2204 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002205 } else {
2206 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002207 }
2208 return
2209 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002210 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002211 // Platform code can link to anything
2212 return
2213 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002214 if from.InRamdisk() {
2215 // Ramdisk code is not NDK
2216 return
2217 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002218 if from.InVendorRamdisk() {
2219 // Vendor ramdisk code is not NDK
2220 return
2221 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002222 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002223 // Recovery code is not NDK
2224 return
2225 }
Colin Cross31076b32020-10-23 17:22:06 -07002226 if c, ok := to.(*Module); ok {
2227 if c.ToolchainLibrary() {
2228 // These are always allowed
2229 return
2230 }
2231 if c.NdkPrebuiltStl() {
2232 // These are allowed, but they don't set sdk_version
2233 return
2234 }
2235 if c.StubDecorator() {
2236 // These aren't real libraries, but are the stub shared libraries that are included in
2237 // the NDK.
2238 return
2239 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002240 }
Logan Chien834b9a62019-01-14 15:39:03 +08002241
Ivan Lozano52767be2019-10-18 14:49:46 -07002242 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002243 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2244 // to link to libc++ (non-NDK and without sdk_version).
2245 return
2246 }
2247
Ivan Lozano52767be2019-10-18 14:49:46 -07002248 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002249 // NDK code linking to platform code is never okay.
2250 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002251 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002252 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002253 }
2254
2255 // At this point we know we have two NDK libraries, but we need to
2256 // check that we're not linking against anything built against a higher
2257 // API level, as it is only valid to link against older or equivalent
2258 // APIs.
2259
Inseob Kim01a28722018-04-11 09:48:45 +09002260 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002261 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002262 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002263 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002264 // Current can't be linked against by anything else.
2265 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002266 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002267 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002268 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002269 if err != nil {
2270 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002271 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002272 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002273 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002274 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002275 if err != nil {
2276 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002277 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002278 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002279 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002280
Inseob Kim01a28722018-04-11 09:48:45 +09002281 if toApi > fromApi {
2282 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002283 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002284 }
2285 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002286 }
Dan Albert202fe492017-12-15 13:56:59 -08002287
2288 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002289 fromStl := from.SelectedStl()
2290 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002291 if fromStl == "" || toStl == "" {
2292 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002293 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002294 // We can be permissive with the system "STL" since it is only the C++
2295 // ABI layer, but in the future we should make sure that everyone is
2296 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002297 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002298 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002299 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2300 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002301 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002302}
2303
Jooyung Han479ca172020-10-19 18:51:07 +09002304func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2305 if c, ok := ctx.Module().(*Module); ok {
2306 ctx.VisitDirectDeps(func(dep android.Module) {
2307 depTag := ctx.OtherModuleDependencyTag(dep)
2308 ccDep, ok := dep.(LinkableInterface)
2309 if ok {
2310 checkLinkType(ctx, c, ccDep, depTag)
2311 }
2312 })
2313 }
2314}
2315
Jiyong Park5fb8c102018-04-09 12:03:06 +09002316// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002317// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2318// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002319// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002320func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2321 check := func(child, parent android.Module) bool {
2322 to, ok := child.(*Module)
2323 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002324 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002325 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002326
Jooyung Hana70f0672019-01-18 15:20:43 +09002327 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2328 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002329 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002330
Jiyong Park1ad8e162020-12-01 23:40:09 +09002331 depTag := ctx.OtherModuleDependencyTag(child)
2332 if IsHeaderDepTag(depTag) {
2333 return false
2334 }
2335
Justin Yun63e9ec72020-10-29 16:49:43 +09002336 // Even if target lib has no vendor variant, keep checking dependency
2337 // graph in case it depends on vendor_available or product_available
2338 // but not double_loadable transtively.
2339 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002340 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002341 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002342
Colin Cross127bb8b2020-12-16 16:46:01 -08002343 if to.isVndkSp() || to.IsLlndk() || Bool(to.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002344 return false
2345 }
2346
2347 var stringPath []string
2348 for _, m := range ctx.GetWalkPath() {
2349 stringPath = append(stringPath, m.Name())
2350 }
2351 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2352 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
2353 "(dependency: %s)", ctx.OtherModuleName(to), strings.Join(stringPath, " -> "))
2354 return false
2355 }
2356 if module, ok := ctx.Module().(*Module); ok {
2357 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Colin Cross127bb8b2020-12-16 16:46:01 -08002358 if lib.hasLLNDKStubs() || Bool(module.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002359 ctx.WalkDeps(check)
2360 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002361 }
2362 }
2363}
2364
Colin Cross0de8a1e2020-09-18 14:15:30 -07002365// Returns the highest version which is <= maxSdkVersion.
2366// For example, with maxSdkVersion is 10 and versionList is [9,11]
2367// it returns 9 as string. The list of stubs must be in order from
2368// oldest to newest.
Chris Parsons3c27ca32020-11-20 12:42:07 -05002369func (c *Module) chooseSdkVersion(ctx android.PathContext, stubsInfo []SharedStubLibrary,
2370 maxSdkVersion android.ApiLevel) (SharedStubLibrary, error) {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002371
2372 for i := range stubsInfo {
2373 stubInfo := stubsInfo[len(stubsInfo)-i-1]
2374 var ver android.ApiLevel
2375 if stubInfo.Version == "" {
2376 ver = android.FutureApiLevel
2377 } else {
2378 var err error
2379 ver, err = android.ApiLevelFromUser(ctx, stubInfo.Version)
2380 if err != nil {
Chris Parsons3c27ca32020-11-20 12:42:07 -05002381 return SharedStubLibrary{}, err
Colin Cross0de8a1e2020-09-18 14:15:30 -07002382 }
2383 }
2384 if ver.LessThanOrEqualTo(maxSdkVersion) {
2385 return stubInfo, nil
2386 }
2387 }
2388 var versionList []string
2389 for _, stubInfo := range stubsInfo {
2390 versionList = append(versionList, stubInfo.Version)
2391 }
Chris Parsons3c27ca32020-11-20 12:42:07 -05002392 return SharedStubLibrary{}, fmt.Errorf("not found a version(<=%s) in versionList: %v", maxSdkVersion.String(), versionList)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002393}
2394
Colin Crossc99deeb2016-04-11 15:06:20 -07002395// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002396func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002397 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002398
Colin Cross0de8a1e2020-09-18 14:15:30 -07002399 var directStaticDeps []StaticLibraryInfo
2400 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002401
Colin Cross0de8a1e2020-09-18 14:15:30 -07002402 reexportExporter := func(exporter FlagExporterInfo) {
2403 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2404 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2405 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2406 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2407 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002408 }
2409
Jooyung Hande34d232020-07-23 13:04:15 +09002410 // For the dependency from platform to apex, use the latest stubs
2411 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002412 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2413 if !apexInfo.IsForPlatform() {
2414 c.apexSdkVersion = apexInfo.MinSdkVersion(ctx)
Jooyung Hande34d232020-07-23 13:04:15 +09002415 }
2416
2417 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2418 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2419 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2420 // (b/144430859)
2421 c.apexSdkVersion = android.FutureApiLevel
2422 }
2423
Colin Crossd11fcda2017-10-23 17:59:01 -07002424 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002425 depName := ctx.OtherModuleName(dep)
2426 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002427
Ivan Lozano52767be2019-10-18 14:49:46 -07002428 ccDep, ok := dep.(LinkableInterface)
2429 if !ok {
2430
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002431 // handling for a few module types that aren't cc Module but that are also supported
2432 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002433 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002434 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002435 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2436 genRule.GeneratedSourceFiles()...)
2437 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002438 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002439 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002440 // Support exported headers from a generated_sources dependency
2441 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002442 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002443 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002444 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002445 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002446 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002447 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002448 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002449 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002450 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2451 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002452 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002453 // 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 +09002454 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002455
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002456 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002457 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002458 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002459 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002460 case linkerFlagsDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002461 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002462 files := genRule.GeneratedSourceFiles()
2463 if len(files) == 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002464 depPaths.LinkerFlagsFile = android.OptionalPathForPath(files[0])
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002465 } else if len(files) > 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002466 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 -07002467 }
2468 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002469 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002470 }
Colin Crossca860ac2016-01-04 14:34:37 -08002471 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002472 return
2473 }
2474
Colin Crossfe17f6f2019-03-28 19:30:56 -07002475 if depTag == android.ProtoPluginDepTag {
2476 return
2477 }
2478
Colin Crossd11fcda2017-10-23 17:59:01 -07002479 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002480 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2481 return
2482 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002483 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002484 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2485 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002486 return
2487 }
2488
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002489 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002490 // Skip reused objects for stub libraries, they use their own stub object file instead.
2491 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2492 // version mutator, so the stubs variant is created from the shared variant that
2493 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002494 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002495 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2496 objs := staticAnalogue.ReuseObjects
2497 depPaths.Objs = depPaths.Objs.Append(objs)
2498 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2499 reexportExporter(depExporterInfo)
2500 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002501 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002502 }
2503
Colin Cross6e511a92020-07-27 21:26:48 -07002504 linkFile := ccDep.OutputFile()
2505
2506 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2507 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002508 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002509 return
2510 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002511
Jiyong Parke3867542020-12-03 17:28:25 +09002512 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2513 return
2514 }
2515
Colin Cross0de8a1e2020-09-18 14:15:30 -07002516 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002517
Colin Cross6e511a92020-07-27 21:26:48 -07002518 var ptr *android.Paths
2519 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002520
Colin Cross6e511a92020-07-27 21:26:48 -07002521 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002522
Colin Cross6e511a92020-07-27 21:26:48 -07002523 switch {
2524 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002525 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2526 if !ctx.Config().AllowMissingDependencies() {
2527 ctx.ModuleErrorf("module %q is not a header library", depName)
2528 } else {
2529 ctx.AddMissingDependencies([]string{depName})
2530 }
2531 return
2532 }
Colin Cross6e511a92020-07-27 21:26:48 -07002533 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002534 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2535 if !ctx.Config().AllowMissingDependencies() {
2536 ctx.ModuleErrorf("module %q is not a shared library", depName)
2537 } else {
2538 ctx.AddMissingDependencies([]string{depName})
2539 }
2540 return
2541 }
Jiyong Parke3867542020-12-03 17:28:25 +09002542
Colin Cross0de8a1e2020-09-18 14:15:30 -07002543 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
Chris Parsons3c27ca32020-11-20 12:42:07 -05002544 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002545
Chris Parsons3c27ca32020-11-20 12:42:07 -05002546 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002547 useStubs := false
Colin Cross31076b32020-10-23 17:22:06 -07002548
2549 if lib := moduleLibraryInterface(dep); lib.buildStubs() && c.UseVndk() { // LLNDK
Colin Cross0de8a1e2020-09-18 14:15:30 -07002550 if !apexInfo.IsForPlatform() {
2551 // For platform libraries, use current version of LLNDK
2552 // If this is for use_vendor apex we will apply the same rules
2553 // of apex sdk enforcement below to choose right version.
2554 useStubs = true
2555 }
2556 } else if apexInfo.IsForPlatform() {
2557 // If not building for APEX, use stubs only when it is from
2558 // an APEX (and not from platform)
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002559 // However, for host, ramdisk, vendor_ramdisk, recovery or bootstrap modules,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002560 // always link to non-stub variant
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09002561 useStubs = dep.(android.ApexModule).NotInPlatform() && !c.bootstrap()
Colin Cross0de8a1e2020-09-18 14:15:30 -07002562 // Another exception: if this module is bundled with an APEX, then
2563 // it is linked with the non-stub variant of a module in the APEX
2564 // as if this is part of the APEX.
2565 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2566 for _, apexContents := range testFor.ApexContents {
2567 if apexContents.DirectlyInApex(depName) {
2568 useStubs = false
2569 break
2570 }
2571 }
2572 } else {
2573 // If building for APEX, use stubs when the parent is in any APEX that
2574 // the child is not in.
2575 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
2576 }
2577
2578 // when to use (unspecified) stubs, check min_sdk_version and choose the right one
2579 if useStubs {
2580 sharedLibraryStubsInfo, err :=
Chris Parsons3c27ca32020-11-20 12:42:07 -05002581 c.chooseSdkVersion(ctx, sharedLibraryStubsInfo.SharedStubLibraries, c.apexSdkVersion)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002582 if err != nil {
2583 ctx.OtherModuleErrorf(dep, err.Error())
2584 return
2585 }
2586 sharedLibraryInfo = sharedLibraryStubsInfo.SharedLibraryInfo
2587 depExporterInfo = sharedLibraryStubsInfo.FlagExporterInfo
2588 }
2589 }
2590
Jiyong Park1ad8e162020-12-01 23:40:09 +09002591 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2592 // linkFile, depFile, and ptr.
2593 if c.IsStubs() {
2594 break
2595 }
2596
Colin Cross0de8a1e2020-09-18 14:15:30 -07002597 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2598 depFile = sharedLibraryInfo.TableOfContents
2599
Colin Cross6e511a92020-07-27 21:26:48 -07002600 ptr = &depPaths.SharedLibs
2601 switch libDepTag.Order {
2602 case earlyLibraryDependency:
2603 ptr = &depPaths.EarlySharedLibs
2604 depPtr = &depPaths.EarlySharedLibsDeps
2605 case normalLibraryDependency:
2606 ptr = &depPaths.SharedLibs
2607 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002608 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002609 case lateLibraryDependency:
2610 ptr = &depPaths.LateSharedLibs
2611 depPtr = &depPaths.LateSharedLibsDeps
2612 default:
2613 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002614 }
Colin Cross6e511a92020-07-27 21:26:48 -07002615 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002616 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2617 if !ctx.Config().AllowMissingDependencies() {
2618 ctx.ModuleErrorf("module %q is not a static library", depName)
2619 } else {
2620 ctx.AddMissingDependencies([]string{depName})
2621 }
2622 return
2623 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002624
2625 // Stubs lib doesn't link to the static lib dependencies. Don't set
2626 // linkFile, depFile, and ptr.
2627 if c.IsStubs() {
2628 break
2629 }
2630
Colin Cross0de8a1e2020-09-18 14:15:30 -07002631 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2632 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002633 if libDepTag.wholeStatic {
2634 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002635 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2636 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002637 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002638 // This case normally catches prebuilt static
2639 // libraries, but it can also occur when
2640 // AllowMissingDependencies is on and the
2641 // dependencies has no sources of its own
2642 // but has a whole_static_libs dependency
2643 // on a missing library. We want to depend
2644 // on the .a file so that there is something
2645 // in the dependency tree that contains the
2646 // error rule for the missing transitive
2647 // dependency.
2648 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002649 }
Colin Cross6e511a92020-07-27 21:26:48 -07002650 } else {
2651 switch libDepTag.Order {
2652 case earlyLibraryDependency:
2653 panic(fmt.Errorf("early static libs not suppported"))
2654 case normalLibraryDependency:
2655 // static dependencies will be handled separately so they can be ordered
2656 // using transitive dependencies.
2657 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002658 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002659 case lateLibraryDependency:
2660 ptr = &depPaths.LateStaticLibs
2661 default:
2662 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002663 }
2664 }
2665 }
2666
Colin Cross6e511a92020-07-27 21:26:48 -07002667 if libDepTag.static() && !libDepTag.wholeStatic {
2668 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2669 ctx.ModuleErrorf("module %q not a static library", depName)
2670 return
2671 }
Logan Chien43d34c32017-12-20 01:17:32 +08002672
Colin Cross6e511a92020-07-27 21:26:48 -07002673 // When combining coverage files for shared libraries and executables, coverage files
2674 // in static libraries act as if they were whole static libraries. The same goes for
2675 // source based Abi dump files.
2676 if c, ok := ccDep.(*Module); ok {
2677 staticLib := c.linker.(libraryInterface)
2678 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2679 staticLib.objs().coverageFiles...)
2680 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2681 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002682 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002683 // Handle non-CC modules here
2684 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002685 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002686 }
2687 }
2688
Colin Cross6e511a92020-07-27 21:26:48 -07002689 if ptr != nil {
2690 if !linkFile.Valid() {
2691 if !ctx.Config().AllowMissingDependencies() {
2692 ctx.ModuleErrorf("module %q missing output file", depName)
2693 } else {
2694 ctx.AddMissingDependencies([]string{depName})
2695 }
2696 return
2697 }
2698 *ptr = append(*ptr, linkFile.Path())
2699 }
2700
2701 if depPtr != nil {
2702 dep := depFile
2703 if !dep.Valid() {
2704 dep = linkFile
2705 }
2706 *depPtr = append(*depPtr, dep.Path())
2707 }
2708
Colin Cross0de8a1e2020-09-18 14:15:30 -07002709 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2710 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2711 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2712 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2713
2714 if libDepTag.reexportFlags {
2715 reexportExporter(depExporterInfo)
2716 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2717 // Re-exported shared library headers must be included as well since they can help us with type information
2718 // about template instantiations (instantiated from their headers).
2719 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2720 // scripts.
2721 c.sabi.Properties.ReexportedIncludes = append(
2722 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2723 }
2724
Colin Cross6e511a92020-07-27 21:26:48 -07002725 makeLibName := c.makeLibName(ctx, ccDep, depName) + libDepTag.makeSuffix
2726 switch {
2727 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002728 c.Properties.AndroidMkHeaderLibs = append(
2729 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002730 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002731 if lib := moduleLibraryInterface(dep); lib != nil {
2732 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002733 // Add the dependency to the APEX(es) providing the library so that
2734 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002735 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
2736 for _, an := range depApexInfo.InApexes {
Colin Cross6e511a92020-07-27 21:26:48 -07002737 c.Properties.ApexesProvidingSharedLibs = append(
2738 c.Properties.ApexesProvidingSharedLibs, an)
2739 }
2740 }
2741 }
2742
2743 // Note: the order of libs in this list is not important because
2744 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002745 c.Properties.AndroidMkSharedLibs = append(
2746 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002747 // Record baseLibName for snapshots.
2748 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, baseLibName(depName))
2749 case libDepTag.static():
2750 if libDepTag.wholeStatic {
2751 c.Properties.AndroidMkWholeStaticLibs = append(
2752 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2753 } else {
2754 c.Properties.AndroidMkStaticLibs = append(
2755 c.Properties.AndroidMkStaticLibs, makeLibName)
2756 }
2757 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002758 } else if !c.IsStubs() {
2759 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
2760
Colin Cross6e511a92020-07-27 21:26:48 -07002761 switch depTag {
2762 case runtimeDepTag:
2763 c.Properties.AndroidMkRuntimeLibs = append(
2764 c.Properties.AndroidMkRuntimeLibs, c.makeLibName(ctx, ccDep, depName)+libDepTag.makeSuffix)
2765 // Record baseLibName for snapshots.
2766 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, baseLibName(depName))
2767 case objDepTag:
2768 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2769 case CrtBeginDepTag:
2770 depPaths.CrtBegin = linkFile
2771 case CrtEndDepTag:
2772 depPaths.CrtEnd = linkFile
2773 case dynamicLinkerDepTag:
2774 depPaths.DynamicLinker = linkFile
2775 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002776 }
Colin Crossca860ac2016-01-04 14:34:37 -08002777 })
2778
Jeff Gaston294356f2017-09-27 17:05:30 -07002779 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002780 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2781 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2782 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002783
Colin Crossdd84e052017-05-17 13:44:16 -07002784 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002785 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002786 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2787 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002788 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002789 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2790 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002791 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002792 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002793 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002794
2795 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002796 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002797 }
Colin Crossdd84e052017-05-17 13:44:16 -07002798
Colin Crossca860ac2016-01-04 14:34:37 -08002799 return depPaths
2800}
2801
Colin Cross0de8a1e2020-09-18 14:15:30 -07002802// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
2803// to match the topological order of the dependency tree, including any static analogues of
2804// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
2805// of the transitive dependencies.
2806func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
2807 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
2808 var staticPaths android.Paths
2809 for _, staticDep := range staticDeps {
2810 staticPaths = append(staticPaths, staticDep.StaticLibrary)
2811 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
2812 }
2813 for _, sharedDep := range sharedDeps {
2814 if sharedDep.StaticAnalogue != nil {
2815 transitiveStaticLibsBuilder.Transitive(sharedDep.StaticAnalogue.TransitiveStaticLibrariesForOrdering)
2816 }
2817 }
2818 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
2819
2820 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
2821
2822 // reorder the dependencies based on transitive dependencies
2823 staticPaths = android.FirstUniquePaths(staticPaths)
2824 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
2825
2826 if len(orderedStaticPaths) != len(staticPaths) {
2827 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
2828 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
2829 }
2830
2831 return orderedStaticPaths, transitiveStaticLibs
2832}
2833
Colin Cross6e511a92020-07-27 21:26:48 -07002834// baseLibName trims known prefixes and suffixes
2835func baseLibName(depName string) string {
2836 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
2837 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00002838 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07002839 return libName
2840}
2841
2842func (c *Module) makeLibName(ctx android.ModuleContext, ccDep LinkableInterface, depName string) string {
2843 vendorSuffixModules := vendorSuffixModules(ctx.Config())
Jose Galmes6f843bc2020-12-11 13:36:29 -08002844 recoverySuffixModules := recoverySuffixModules(ctx.Config())
Colin Cross6e511a92020-07-27 21:26:48 -07002845 vendorPublicLibraries := vendorPublicLibraries(ctx.Config())
2846
2847 libName := baseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08002848 ccDepModule, _ := ccDep.(*Module)
2849 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Colin Cross6e511a92020-07-27 21:26:48 -07002850 isVendorPublicLib := inList(libName, *vendorPublicLibraries)
2851 bothVendorAndCoreVariantsExist := ccDep.HasVendorVariant() || isLLndk
2852
2853 if c, ok := ccDep.(*Module); ok {
2854 // Use base module name for snapshots when exporting to Makefile.
2855 if c.isSnapshotPrebuilt() {
2856 baseName := c.BaseModuleName()
2857
2858 if c.IsVndk() {
2859 return baseName + ".vendor"
2860 }
2861
Ivan Lozano3968d8f2020-12-14 11:27:52 -05002862 if c.InVendor() && vendorSuffixModules[baseName] {
Colin Cross6e511a92020-07-27 21:26:48 -07002863 return baseName + ".vendor"
Jose Galmes6f843bc2020-12-11 13:36:29 -08002864 } else if c.InRecovery() && recoverySuffixModules[baseName] {
2865 return baseName + ".recovery"
Colin Cross6e511a92020-07-27 21:26:48 -07002866 } else {
2867 return baseName
2868 }
2869 }
2870 }
2871
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002872 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
2873 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07002874 // The vendor module is a no-vendor-variant VNDK library. Depend on the
2875 // core module instead.
2876 return libName
2877 } else if c.UseVndk() && bothVendorAndCoreVariantsExist {
2878 // The vendor module in Make will have been renamed to not conflict with the core
2879 // module, so update the dependency name here accordingly.
2880 return libName + c.getNameSuffixWithVndkVersion(ctx)
2881 } else if (ctx.Platform() || ctx.ProductSpecific()) && isVendorPublicLib {
2882 return libName + vendorPublicLibrarySuffix
2883 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
2884 return libName + ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002885 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
2886 return libName + vendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002887 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
2888 return libName + recoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05002889 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Colin Cross6e511a92020-07-27 21:26:48 -07002890 return libName + nativeBridgeSuffix
2891 } else {
2892 return libName
2893 }
2894}
2895
Colin Crossca860ac2016-01-04 14:34:37 -08002896func (c *Module) InstallInData() bool {
2897 if c.installer == nil {
2898 return false
2899 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002900 return c.installer.inData()
2901}
2902
2903func (c *Module) InstallInSanitizerDir() bool {
2904 if c.installer == nil {
2905 return false
2906 }
2907 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07002908 return true
2909 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002910 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08002911}
2912
Yifan Hong1b3348d2020-01-21 15:53:22 -08002913func (c *Module) InstallInRamdisk() bool {
2914 return c.InRamdisk()
2915}
2916
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002917func (c *Module) InstallInVendorRamdisk() bool {
2918 return c.InVendorRamdisk()
2919}
2920
Jiyong Parkf9332f12018-02-01 00:54:12 +09002921func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07002922 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09002923}
2924
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002925func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002926 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002927 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002928 return
2929 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002930 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002931}
2932
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07002933func (c *Module) HostToolPath() android.OptionalPath {
2934 if c.installer == nil {
2935 return android.OptionalPath{}
2936 }
2937 return c.installer.hostToolPath()
2938}
2939
Nan Zhangd4e641b2017-07-12 12:55:28 -07002940func (c *Module) IntermPathForModuleOut() android.OptionalPath {
2941 return c.outputFile
2942}
2943
Colin Cross41955e82019-05-29 14:40:35 -07002944func (c *Module) OutputFiles(tag string) (android.Paths, error) {
2945 switch tag {
2946 case "":
2947 if c.outputFile.Valid() {
2948 return android.Paths{c.outputFile.Path()}, nil
2949 }
2950 return android.Paths{}, nil
2951 default:
2952 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002953 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002954}
2955
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00002956func (c *Module) static() bool {
2957 if static, ok := c.linker.(interface {
2958 static() bool
2959 }); ok {
2960 return static.static()
2961 }
2962 return false
2963}
2964
Jiyong Park379de2f2018-12-19 02:47:14 +09002965func (c *Module) staticBinary() bool {
2966 if static, ok := c.linker.(interface {
2967 staticBinary() bool
2968 }); ok {
2969 return static.staticBinary()
2970 }
2971 return false
2972}
2973
Ivan Lozano3968d8f2020-12-14 11:27:52 -05002974// Header returns true if the module is a header-only variant. (See cc/library.go header()).
2975func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09002976 if h, ok := c.linker.(interface {
2977 header() bool
2978 }); ok {
2979 return h.header()
2980 }
2981 return false
2982}
2983
Inseob Kim7f283f42020-06-01 21:53:49 +09002984func (c *Module) binary() bool {
2985 if b, ok := c.linker.(interface {
2986 binary() bool
2987 }); ok {
2988 return b.binary()
2989 }
2990 return false
2991}
2992
Inseob Kim1042d292020-06-01 23:23:05 +09002993func (c *Module) object() bool {
2994 if o, ok := c.linker.(interface {
2995 object() bool
2996 }); ok {
2997 return o.object()
2998 }
2999 return false
3000}
3001
Ivan Lozanof9e21722020-12-02 09:00:51 -05003002func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003003 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003004 if c.IsLlndk() {
3005 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003006 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003007 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003008 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003009 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003010 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003011 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003012 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003013 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003014 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003015 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003016 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003017 return "native:product"
3018 }
Jooyung Han38002912019-05-16 04:01:54 +09003019 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003020 } else if c.InRamdisk() {
3021 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003022 } else if c.InVendorRamdisk() {
3023 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003024 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003025 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003026 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003027 return "native:ndk:none:none"
3028 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3029 //family, link := getNdkStlFamilyAndLinkType(c)
3030 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003031 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003032 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003033 } else {
3034 return "native:platform"
3035 }
3036}
3037
Jiyong Park9d452992018-10-03 00:38:19 +09003038// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003039// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003040func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003041 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003042 // Stub libs and prebuilt libs in a versioned SDK are not
3043 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003044 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003045 } else if _, ok := c.linker.(testPerSrc); ok {
3046 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003047 }
3048 return false
3049}
3050
Jiyong Parka90ca002019-10-07 15:47:24 +09003051func (c *Module) AvailableFor(what string) bool {
3052 if linker, ok := c.linker.(interface {
3053 availableFor(string) bool
3054 }); ok {
3055 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3056 } else {
3057 return c.ApexModuleBase.AvailableFor(what)
3058 }
3059}
3060
Jiyong Park62304bb2020-04-13 16:19:48 +09003061func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003062 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003063}
3064
Colin Crossaede88c2020-08-11 12:17:01 -07003065func (c *Module) UniqueApexVariations() bool {
3066 if u, ok := c.compiler.(interface {
3067 uniqueApexVariations() bool
3068 }); ok {
3069 return u.uniqueApexVariations()
3070 } else {
3071 return false
3072 }
3073}
3074
Paul Duffin0cb37b92020-03-04 14:52:46 +00003075// Return true if the module is ever installable.
3076func (c *Module) EverInstallable() bool {
3077 return c.installer != nil &&
3078 // Check to see whether the module is actually ever installable.
3079 c.installer.everInstallable()
3080}
3081
Colin Cross56a83212020-09-15 18:30:11 -07003082func (c *Module) installable(apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003083 ret := c.EverInstallable() &&
3084 // Check to see whether the module has been configured to not be installed.
3085 proptools.BoolDefault(c.Properties.Installable, true) &&
3086 !c.Properties.PreventInstall && c.outputFile.Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003087
3088 // The platform variant doesn't need further condition. Apex variants however might not
3089 // be installable because it will likely to be included in the APEX and won't appear
3090 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003091 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003092 return ret
3093 }
3094
3095 // Special case for modules that are configured to be installed to /data, which includes
3096 // test modules. For these modules, both APEX and non-APEX variants are considered as
3097 // installable. This is because even the APEX variants won't be included in the APEX, but
3098 // will anyway be installed to /data/*.
3099 // See b/146995717
3100 if c.InstallInData() {
3101 return ret
3102 }
3103
3104 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003105}
3106
Logan Chien41eabe62019-04-10 13:33:58 +08003107func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3108 if c.linker != nil {
3109 if library, ok := c.linker.(*libraryDecorator); ok {
3110 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3111 }
3112 }
3113}
3114
Jiyong Park45bf82e2020-12-15 22:29:02 +09003115var _ android.ApexModule = (*Module)(nil)
3116
3117// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003118func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003119 depTag := ctx.OtherModuleDependencyTag(dep)
3120 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3121
3122 if cc, ok := dep.(*Module); ok {
3123 if cc.HasStubsVariants() {
3124 if isLibDepTag && libDepTag.shared() {
3125 // dynamic dep to a stubs lib crosses APEX boundary
3126 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003127 }
Colin Cross6e511a92020-07-27 21:26:48 -07003128 if IsRuntimeDepTag(depTag) {
3129 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003130 return false
3131 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003132 }
Colin Crossaac32222020-07-29 12:51:56 -07003133 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003134 // shared_lib dependency from a static lib is considered as crossing
3135 // the APEX boundary because the dependency doesn't actually is
3136 // linked; the dependency is used only during the compilation phase.
3137 return false
3138 }
Jiyong Parke3867542020-12-03 17:28:25 +09003139
3140 if isLibDepTag && libDepTag.excludeInApex {
3141 return false
3142 }
Colin Cross6e511a92020-07-27 21:26:48 -07003143 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003144 if depTag == stubImplDepTag || depTag == llndkStubDepTag {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003145 // We don't track beyond LLNDK or from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003146 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003147 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003148 if depTag == staticVariantTag {
3149 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3150 // actually mean that the static lib (and its dependencies) are copied into the
3151 // APEX.
3152 return false
3153 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003154 return true
3155}
3156
Jiyong Park45bf82e2020-12-15 22:29:02 +09003157// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003158func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3159 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003160 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3161 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3162 return nil
3163 }
3164 // b/154569636: set min_sdk_version correctly for toolchain_libraries
3165 if c.ToolchainLibrary() {
3166 return nil
3167 }
3168 // We don't check for prebuilt modules
3169 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3170 return nil
3171 }
3172 minSdkVersion := c.MinSdkVersion()
3173 if minSdkVersion == "apex_inherit" {
3174 return nil
3175 }
3176 if minSdkVersion == "" {
3177 // JNI libs within APK-in-APEX fall into here
3178 // Those are okay to set sdk_version instead
3179 // We don't have to check if this is a SDK variant because
3180 // non-SDK variant resets sdk_version, which works too.
3181 minSdkVersion = c.SdkVersion()
3182 }
Dan Albertc8060532020-07-22 22:32:17 -07003183 if minSdkVersion == "" {
3184 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3185 }
3186 // Not using nativeApiLevelFromUser because the context here is not
3187 // necessarily a native context.
3188 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003189 if err != nil {
3190 return err
3191 }
Dan Albertc8060532020-07-22 22:32:17 -07003192
3193 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003194 return fmt.Errorf("newer SDK(%v)", ver)
3195 }
3196 return nil
3197}
3198
Colin Cross2ba19d92015-05-07 15:44:20 -07003199//
Colin Crosscfad1192015-11-02 16:43:11 -08003200// Defaults
3201//
Colin Crossca860ac2016-01-04 14:34:37 -08003202type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003203 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003204 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003205 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003206}
3207
Patrice Arrudac249c712019-03-19 17:00:29 -07003208// cc_defaults provides a set of properties that can be inherited by other cc
3209// modules. A module can use the properties from a cc_defaults using
3210// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3211// merged (when possible) by prepending the default module's values to the
3212// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003213func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003214 return DefaultsFactory()
3215}
3216
Colin Cross36242852017-06-23 15:06:31 -07003217func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003218 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003219
Colin Cross36242852017-06-23 15:06:31 -07003220 module.AddProperties(props...)
3221 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003222 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003223 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003224 &BaseCompilerProperties{},
3225 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003226 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003227 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003228 &StaticProperties{},
3229 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003230 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003231 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003232 &TestProperties{},
3233 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003234 &BenchmarkProperties{},
Mitch Phillips4e4ab8a2019-09-13 17:32:50 -07003235 &FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003236 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003237 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003238 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003239 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003240 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003241 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003242 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003243 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003244 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003245 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003246 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003247 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3248 &RustBindgenClangProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003249 )
Colin Crosscfad1192015-11-02 16:43:11 -08003250
Jooyung Hancc372c52019-09-25 15:18:44 +09003251 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003252
3253 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003254}
3255
Jiyong Park2286afd2020-06-16 21:58:53 +09003256func (c *Module) IsSdkVariant() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07003257 return c.Properties.IsSdkVariant || c.AlwaysSdk()
Jiyong Park2286afd2020-06-16 21:58:53 +09003258}
3259
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003260func kytheExtractAllFactory() android.Singleton {
3261 return &kytheExtractAllSingleton{}
3262}
3263
3264type kytheExtractAllSingleton struct {
3265}
3266
3267func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3268 var xrefTargets android.Paths
3269 ctx.VisitAllModules(func(module android.Module) {
3270 if ccModule, ok := module.(xref); ok {
3271 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3272 }
3273 })
3274 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3275 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003276 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003277 }
3278}
3279
Colin Cross06a931b2015-10-28 17:23:31 -07003280var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003281var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003282var BoolPtr = proptools.BoolPtr
3283var String = proptools.String
3284var StringPtr = proptools.StringPtr