blob: f922ea5b549b066395c40e05c0d7bcc0f5768f0b [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Colin Cross97ba0732015-03-23 17:50:24 -070027 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070028 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070029
Colin Cross635c3b02016-05-18 15:37:25 -070030 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070031 "android/soong/cc/config"
Colin Cross5049f022015-03-18 13:28:46 -070032 "android/soong/genrule"
Colin Cross3f40fa42015-01-30 17:27:36 -080033)
34
Colin Cross463a90e2015-06-17 14:20:06 -070035func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000036 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070037
Paul Duffin036e7002019-12-19 19:16:28 +000038 pctx.Import("android/soong/cc/config")
39}
40
41func RegisterCCBuildComponents(ctx android.RegistrationContext) {
42 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
43
44 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000045 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090046 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070047 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010048 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070049 ctx.BottomUp("version_selector", versionSelectorMutator).Parallel()
50 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070051 ctx.BottomUp("begin", BeginMutator).Parallel()
Inseob Kimac1e9862019-12-09 18:15:47 +090052 ctx.BottomUp("sysprop_cc", SyspropMutator).Parallel()
Inseob Kimeec88e12020-01-22 11:11:29 +090053 ctx.BottomUp("vendor_snapshot", VendorSnapshotMutator).Parallel()
54 ctx.BottomUp("vendor_snapshot_source", VendorSnapshotSourceMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070055 })
Colin Cross16b23492016-01-06 14:41:07 -080056
Paul Duffin036e7002019-12-19 19:16:28 +000057 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Cross1e676be2016-10-12 14:38:15 -070058 ctx.TopDown("asan_deps", sanitizerDepsMutator(asan))
59 ctx.BottomUp("asan", sanitizerMutator(asan)).Parallel()
Colin Cross16b23492016-01-06 14:41:07 -080060
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070061 ctx.TopDown("hwasan_deps", sanitizerDepsMutator(hwasan))
62 ctx.BottomUp("hwasan", sanitizerMutator(hwasan)).Parallel()
63
Mitch Phillipsbfeade62019-05-01 14:42:05 -070064 ctx.TopDown("fuzzer_deps", sanitizerDepsMutator(fuzzer))
65 ctx.BottomUp("fuzzer", sanitizerMutator(fuzzer)).Parallel()
66
Jiyong Park1d1119f2019-07-29 21:27:18 +090067 // cfi mutator shouldn't run before sanitizers that return true for
68 // incompatibleWithCfi()
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000069 ctx.TopDown("cfi_deps", sanitizerDepsMutator(cfi))
70 ctx.BottomUp("cfi", sanitizerMutator(cfi)).Parallel()
71
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -080072 ctx.TopDown("scs_deps", sanitizerDepsMutator(scs))
73 ctx.BottomUp("scs", sanitizerMutator(scs)).Parallel()
74
Colin Cross1e676be2016-10-12 14:38:15 -070075 ctx.TopDown("tsan_deps", sanitizerDepsMutator(tsan))
76 ctx.BottomUp("tsan", sanitizerMutator(tsan)).Parallel()
Dan Willemsen581341d2017-02-09 16:16:31 -080077
Colin Cross0b908332019-06-19 23:00:20 -070078 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090079 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080080
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080081 ctx.BottomUp("coverage", coverageMutator).Parallel()
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -080082 ctx.TopDown("vndk_deps", sabiDepsMutator)
Stephen Craneba090d12017-05-09 15:44:35 -070083
84 ctx.TopDown("lto_deps", ltoDepsMutator)
85 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090086
Jooyung Han479ca172020-10-19 18:51:07 +090087 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090088 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070089 })
Colin Crossb98c8b02016-07-29 13:44:28 -070090
Colin Cross57898582020-10-29 18:25:19 -070091 ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070092}
93
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050094// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
95// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
96// edges to these modules.
97// This object is constructed in DepsMutator, by calling to various module delegates to set
98// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
99// dependencies.
100// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
101// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -0800102type Deps struct {
103 SharedLibs, LateSharedLibs []string
104 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -0800105 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800106 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700107
Chris Parsons79d66a52020-06-05 17:26:16 -0400108 // Used for data dependencies adjacent to tests
109 DataLibs []string
110
Yo Chiang219968c2020-09-22 18:45:04 +0800111 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
112 SystemSharedLibs []string
113
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500114 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800115 StaticUnwinderIfLegacy bool
116
Colin Cross5950f382016-12-13 12:50:57 -0800117 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700118
Colin Cross81413472016-04-11 14:37:39 -0700119 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700120
Dan Willemsenb40aab62016-04-20 14:21:14 -0700121 GeneratedSources []string
122 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900123 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700124
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700125 ReexportGeneratedHeaders []string
126
Colin Cross97ba0732015-03-23 17:50:24 -0700127 CrtBegin, CrtEnd string
Dan Willemsena0790e32018-10-12 00:24:23 -0700128
129 // Used for host bionic
130 LinkerFlagsFile string
131 DynamicLinker string
Colin Crossc472d572015-03-17 15:06:21 -0700132}
133
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500134// PathDeps is a struct containing file paths to dependencies of a module.
135// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
136// It's used to construct flags for various build statements (such as for compiling and linking).
137// It is then passed to module decorator functions responsible for registering build statements
138// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800139type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700140 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900141 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700142 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900143 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700144 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700145 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700146
Colin Cross0de8a1e2020-09-18 14:15:30 -0700147 // Transitive static library dependencies of static libraries for use in ordering.
148 TranstiveStaticLibrariesForOrdering *android.DepSet
149
Colin Cross26c34ed2016-09-30 17:10:16 -0700150 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100151 Objs Objects
152 // Paths to .o files in dependencies that provide them. Note that these lists
153 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800154 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700155 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700156
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100157 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
158 // the libs from all whole_static_lib dependencies.
159 WholeStaticLibsFromPrebuilts android.Paths
160
Colin Cross26c34ed2016-09-30 17:10:16 -0700161 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700162 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900163 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700164
Inseob Kimd110f872019-12-06 13:15:38 +0900165 Flags []string
166 IncludeDirs android.Paths
167 SystemIncludeDirs android.Paths
168 ReexportedDirs android.Paths
169 ReexportedSystemDirs android.Paths
170 ReexportedFlags []string
171 ReexportedGeneratedHeaders android.Paths
172 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700173
Colin Cross26c34ed2016-09-30 17:10:16 -0700174 // Paths to crt*.o files
Colin Cross635c3b02016-05-18 15:37:25 -0700175 CrtBegin, CrtEnd android.OptionalPath
Dan Willemsena0790e32018-10-12 00:24:23 -0700176
177 // Path to the file container flags to use with the linker
178 LinkerFlagsFile android.OptionalPath
179
180 // Path to the dynamic linker binary
181 DynamicLinker android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700182}
183
Colin Cross4af21ed2019-11-04 09:37:55 -0800184// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
185// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
186// command line so they can be overridden by the local module flags).
187type LocalOrGlobalFlags struct {
188 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700189 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800190 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700191 CFlags []string // Flags that apply to C and C++ source files
192 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
193 ConlyFlags []string // Flags that apply to C source files
194 CppFlags []string // Flags that apply to C++ source files
195 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700196 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800197}
198
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500199// Flags contains various types of command line flags (and settings) for use in building build
200// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800201type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500202 // Local flags (which individual modules are responsible for). These may override global flags.
203 Local LocalOrGlobalFlags
204 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800205 Global LocalOrGlobalFlags
206
207 aidlFlags []string // Flags that apply to aidl source files
208 rsFlags []string // Flags that apply to renderscript source files
209 libFlags []string // Flags to add libraries early to the link order
210 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
211 TidyFlags []string // Flags that apply to clang-tidy
212 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700213
Colin Crossc3199482017-03-30 15:03:04 -0700214 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800215 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700216 SystemIncludeFlags []string
217
Oliver Nguyen04526782020-04-21 12:40:27 -0700218 Toolchain config.Toolchain
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500219 Tidy bool // True if clang-tidy is enabled.
220 GcovCoverage bool // True if coverage files should be generated.
221 SAbiDump bool // True if header abi dumps should be generated.
Oliver Nguyen04526782020-04-21 12:40:27 -0700222 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800223
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500224 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800225 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500226 // The target-device system path to the dynamic linker.
227 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800228
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700229 CFlagsDeps android.Paths // Files depended on by compiler flags
230 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800231
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500232 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700233 AssemblerWithCpp bool
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500234 // True if static libraries should be grouped (using `-Wl,--start-group` and `-Wl,--end-group`).
235 GroupStaticLibs bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800236
Colin Cross19878da2019-03-28 14:45:07 -0700237 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700238 protoC bool // Whether to use C instead of C++
239 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700240
241 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200242 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700243}
244
Colin Crossca860ac2016-01-04 14:34:37 -0800245// Properties used to compile all C or C++ modules
246type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700247 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800248 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700249
Colin Crossc511bc52020-04-07 16:50:32 +0000250 // Minimum sdk version supported when compiling against the ndk. Setting this property causes
251 // two variants to be built, one for the platform and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800252 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700253
Jooyung Han379660c2020-04-21 15:24:00 +0900254 // Minimum sdk version that the artifact should support when it runs as part of mainline modules(APEX).
255 Min_sdk_version *string
256
Colin Crossc511bc52020-04-07 16:50:32 +0000257 // If true, always create an sdk variant and don't create a platform variant.
258 Sdk_variant_only *bool
259
Jiyong Parkde866cb2018-12-07 23:08:36 +0900260 AndroidMkSharedLibs []string `blueprint:"mutated"`
261 AndroidMkStaticLibs []string `blueprint:"mutated"`
262 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
263 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700264 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900265 HideFromMake bool `blueprint:"mutated"`
266 PreventInstall bool `blueprint:"mutated"`
267 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700268
Yo Chiang219968c2020-09-22 18:45:04 +0800269 // Set by DepsMutator.
270 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
271
Justin Yun5f7f7e82019-11-18 19:52:14 +0900272 ImageVariationPrefix string `blueprint:"mutated"`
273 VndkVersion string `blueprint:"mutated"`
274 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800275
276 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
277 // file
278 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900279
Yifan Hong39143a92020-10-26 12:43:12 -0700280 // Make this module available when building for ramdisk.
281 // On device without a dedicated recovery partition, the module is only
282 // available after switching root into
283 // /first_stage_ramdisk. To expose the module before switching root, install
284 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800285 Ramdisk_available *bool
286
Yifan Hong39143a92020-10-26 12:43:12 -0700287 // Make this module available when building for vendor ramdisk.
288 // On device without a dedicated recovery partition, the module is only
289 // available after switching root into
290 // /first_stage_ramdisk. To expose the module before switching root, install
291 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700292 Vendor_ramdisk_available *bool
293
Jiyong Parkf9332f12018-02-01 00:54:12 +0900294 // Make this module available when building for recovery
295 Recovery_available *bool
296
Colin Crossae6c5202019-11-20 13:35:50 -0800297 // Set by imageMutator
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700298 CoreVariantNeeded bool `blueprint:"mutated"`
299 RamdiskVariantNeeded bool `blueprint:"mutated"`
300 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
301 RecoveryVariantNeeded bool `blueprint:"mutated"`
302 ExtraVariants []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900303
304 // Allows this module to use non-APEX version of libraries. Useful
305 // for building binaries that are started before APEXes are activated.
306 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900307
308 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
309 // see soong/cc/config/vndk.go
310 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900311
312 // Used by vendor snapshot to record dependencies from snapshot modules.
313 SnapshotSharedLibs []string `blueprint:"mutated"`
314 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000315
316 Installable *bool
Colin Crossc511bc52020-04-07 16:50:32 +0000317
318 // Set by factories of module types that can only be referenced from variants compiled against
319 // the SDK.
320 AlwaysSdk bool `blueprint:"mutated"`
321
322 // Variant is an SDK variant created by sdkMutator
323 IsSdkVariant bool `blueprint:"mutated"`
324 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
325 // variant to have a ".sdk" suffix.
326 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700327
328 // Normally Soong uses the directory structure to decide which modules
329 // should be included (framework) or excluded (non-framework) from the
Jose Galmesf7294582020-11-13 12:07:36 -0800330 // different snapshots (vendor, recovery, etc.), but these properties
331 // allow a partner to exclude a module normally thought of as a
332 // framework module from a snapshot.
333 Exclude_from_vendor_snapshot *bool
334 Exclude_from_recovery_snapshot *bool
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700335}
336
337type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900338 // whether this module should be allowed to be directly depended by other
339 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900340 // If set to true, two variants will be built separately, one like
341 // normal, and the other limited to the set of libraries and headers
342 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700343 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900344 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700345 // so it shouldn't have any unversioned runtime dependencies, or
346 // make assumptions about the system that may not be true in the
347 // future.
348 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900349 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900350 //
351 // Default value is true when vndk: {enabled: true} or vendor: true.
352 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700353 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
354 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900355
Justin Yun63e9ec72020-10-29 16:49:43 +0900356 // whether this module should be allowed to be directly depended by other
357 // modules with `product_specific: true` or `product_available: true`.
358 // If set to true, an additional product variant will be built separately
359 // that is limited to the set of libraries and headers that are exposed to
360 // /product modules.
361 //
362 // The product variant may be used with a different (newer) /system,
363 // so it shouldn't have any unversioned runtime dependencies, or
364 // make assumptions about the system that may not be true in the
365 // future.
366 //
367 // It must be set to true by default for vndk: {enabled: true} modules.
368 //
369 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
370 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
371 Product_available *bool
372
Jiyong Park5fb8c102018-04-09 12:03:06 +0900373 // whether this module is capable of being loaded with other instance
374 // (possibly an older version) of the same module in the same process.
375 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
376 // can be double loaded in a vendor process if the library is also a
377 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
378 // explicitly marked as `double_loadable: true` by the owner, or the dependency
379 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
380 Double_loadable *bool
Colin Crossca860ac2016-01-04 14:34:37 -0800381}
382
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500383// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
384// to understanding details about the type of the current module.
385// For example, one might call these functions to determine whether the current module is a static
386// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800387type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800388 static() bool
389 staticBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900390 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900391 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900392 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700393 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900394 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700395 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800396 sdkVersion() string
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700397 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700398 isNdk(config android.Config) bool
Inseob Kim9516ee92019-05-09 10:56:13 +0900399 isLlndk(config android.Config) bool
400 isLlndkPublic(config android.Config) bool
401 isVndkPrivate(config android.Config) bool
Justin Yun8effde42017-06-23 19:24:43 +0900402 isVndk() bool
403 isVndkSp() bool
Logan Chienf3511742017-10-31 18:04:35 +0800404 isVndkExt() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900405 inProduct() bool
406 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800407 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700408 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900409 inRecovery() bool
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +0800410 shouldCreateSourceAbiDump() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700411 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700412 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800413 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800414 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800415 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800416 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800417 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700418 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700419 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900420 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800421 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700422 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700423 directlyInAnyApex() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800424}
425
426type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700427 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800428 ModuleContextIntf
429}
430
431type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700432 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800433 ModuleContextIntf
434}
435
Colin Cross37047f12016-12-13 17:06:13 -0800436type DepsContext interface {
437 android.BottomUpMutatorContext
438 ModuleContextIntf
439}
440
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500441// feature represents additional (optional) steps to building cc-related modules, such as invocation
442// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800443type feature interface {
444 begin(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800445 deps(ctx DepsContext, deps Deps) Deps
Colin Crossca860ac2016-01-04 14:34:37 -0800446 flags(ctx ModuleContext, flags Flags) Flags
447 props() []interface{}
448}
449
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500450// compiler is the interface for a compiler helper object. Different module decorators may implement
451// this helper differently. For example, compiling a `cc_library` may use a different build
452// statement than building a `toolchain_library`.
Colin Crossca860ac2016-01-04 14:34:37 -0800453type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700454 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800455 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800456 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700457 compilerProps() []interface{}
458
Colin Cross76fada02016-07-27 10:31:13 -0700459 appendCflags([]string)
460 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700461 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800462}
463
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500464// linker is the interface for a linker decorator object. Individual module types can provide
465// their own implementation for this decorator, and thus specify custom logic regarding build
466// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800467type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700468 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800469 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700470 linkerFlags(ctx ModuleContext, flags Flags) Flags
471 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800472 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700473
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700474 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700475 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900476 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700477
478 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900479 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000480
481 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000482 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
483}
484
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500485// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000486type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500487 sharedLibs []string
488 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
489 // libc, libm, etc.)
490 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800491}
492
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500493// installer is the interface for an installer helper object. This helper is responsible for
494// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800495type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700496 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700497 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000498 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800499 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700500 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700501 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900502 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100503 makeUninstallable(mod *Module)
Colin Crossca860ac2016-01-04 14:34:37 -0800504}
505
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800506type xref interface {
507 XrefCcFiles() android.Paths
508}
509
Colin Cross6e511a92020-07-27 21:26:48 -0700510type libraryDependencyKind int
511
512const (
513 headerLibraryDependency = iota
514 sharedLibraryDependency
515 staticLibraryDependency
516)
517
518func (k libraryDependencyKind) String() string {
519 switch k {
520 case headerLibraryDependency:
521 return "headerLibraryDependency"
522 case sharedLibraryDependency:
523 return "sharedLibraryDependency"
524 case staticLibraryDependency:
525 return "staticLibraryDependency"
526 default:
527 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
528 }
529}
530
531type libraryDependencyOrder int
532
533const (
534 earlyLibraryDependency = -1
535 normalLibraryDependency = 0
536 lateLibraryDependency = 1
537)
538
539func (o libraryDependencyOrder) String() string {
540 switch o {
541 case earlyLibraryDependency:
542 return "earlyLibraryDependency"
543 case normalLibraryDependency:
544 return "normalLibraryDependency"
545 case lateLibraryDependency:
546 return "lateLibraryDependency"
547 default:
548 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
549 }
550}
551
552// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
553// tags that have a set of predefined tag objects that are reused for each dependency, a
554// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
555// That means that comparing a libraryDependencyTag for equality will only be equal if all
556// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
557// then check individual metadata fields instead.
558type libraryDependencyTag struct {
559 blueprint.BaseDependencyTag
560
561 // These are exported so that fmt.Printf("%#v") can call their String methods.
562 Kind libraryDependencyKind
563 Order libraryDependencyOrder
564
565 wholeStatic bool
566
567 reexportFlags bool
568 explicitlyVersioned bool
569 dataLib bool
570 ndk bool
571
572 staticUnwinder bool
573
574 makeSuffix string
575}
576
577// header returns true if the libraryDependencyTag is tagging a header lib dependency.
578func (d libraryDependencyTag) header() bool {
579 return d.Kind == headerLibraryDependency
580}
581
582// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
583func (d libraryDependencyTag) shared() bool {
584 return d.Kind == sharedLibraryDependency
585}
586
587// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
588func (d libraryDependencyTag) static() bool {
589 return d.Kind == staticLibraryDependency
590}
591
Colin Crosse9fe2942020-11-10 18:12:15 -0800592// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
593// binaries or other shared libraries are installed as dependencies.
594func (d libraryDependencyTag) InstallDepNeeded() bool {
595 return d.shared()
596}
597
598var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
599
600// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700601// libraryDependencyTag. Each tag object is created globally and reused for multiple
602// dependencies (although since the object contains no references, assigning a tag to a
603// variable and modifying it will not modify the original). Users can compare the tag
604// returned by ctx.OtherModuleDependencyTag against the global original
605type dependencyTag struct {
606 blueprint.BaseDependencyTag
607 name string
608}
609
Colin Crosse9fe2942020-11-10 18:12:15 -0800610// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
611// libraryDependencyTag, but where the dependency needs to be installed when the parent is
612// installed.
613type installDependencyTag struct {
614 blueprint.BaseDependencyTag
615 android.InstallAlwaysNeededDependencyTag
616 name string
617}
618
Colin Crossc99deeb2016-04-11 15:06:20 -0700619var (
Colin Cross6e511a92020-07-27 21:26:48 -0700620 genSourceDepTag = dependencyTag{name: "gen source"}
621 genHeaderDepTag = dependencyTag{name: "gen header"}
622 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
623 objDepTag = dependencyTag{name: "obj"}
624 linkerFlagsDepTag = dependencyTag{name: "linker flags file"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900625 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700626 reuseObjTag = dependencyTag{name: "reuse objects"}
627 staticVariantTag = dependencyTag{name: "static variant"}
628 vndkExtDepTag = dependencyTag{name: "vndk extends"}
629 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800630 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700631 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700632 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700633)
634
Colin Cross56a83212020-09-15 18:30:11 -0700635type copyDirectlyInAnyApexDependencyTag dependencyTag
636
637func (copyDirectlyInAnyApexDependencyTag) CopyDirectlyInAnyApex() {}
638
639var _ android.CopyDirectlyInAnyApexTag = copyDirectlyInAnyApexDependencyTag{}
640
Roland Levillainf89cd092019-07-29 16:22:59 +0100641func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700642 ccLibDepTag, ok := depTag.(libraryDependencyTag)
643 return ok && ccLibDepTag.shared()
644}
645
646func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
647 ccLibDepTag, ok := depTag.(libraryDependencyTag)
648 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100649}
650
Zach Johnson3df4e632020-11-06 11:56:27 -0800651func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
652 ccLibDepTag, ok := depTag.(libraryDependencyTag)
653 return ok && ccLibDepTag.header()
654}
655
Roland Levillainf89cd092019-07-29 16:22:59 +0100656func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800657 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100658}
659
660func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700661 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100662 return ok && ccDepTag == testPerSrcDepTag
663}
664
Colin Crossca860ac2016-01-04 14:34:37 -0800665// Module contains the properties and members used by all C/C++ module types, and implements
666// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500667// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
668// interface.
669//
670// To define a C/C++ related module, construct a new Module object and point its delegates to
671// type-specific structs. These delegates will be invoked to register module-specific build
672// statements which may be unique to the module type. For example, module.compiler.compile() should
673// be defined so as to register build statements which are responsible for compiling the module.
674//
675// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
676// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
677// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
678// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800679type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700680 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -0700681 android.DefaultableModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +0900682 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900683 android.SdkBase
Colin Crossc472d572015-03-17 15:06:21 -0700684
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700685 Properties BaseProperties
686 VendorProperties VendorProperties
Colin Crossfa138792015-04-24 17:31:52 -0700687
Colin Crossca860ac2016-01-04 14:34:37 -0800688 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700689 hod android.HostOrDeviceSupported
690 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700691
Paul Duffina0843f62019-12-13 19:50:38 +0000692 // Allowable SdkMemberTypes of this module type.
693 sdkMemberTypes []android.SdkMemberType
694
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500695 // decorator delegates, initialize before calling Init
696 // these may contain module-specific implementations, and effectively allow for custom
697 // type-specific logic. These members may reference different objects or the same object.
698 // Functions of these decorators will be invoked to initialize and register type-specific
699 // build statements.
Colin Crossb4ce0ec2016-09-13 13:41:39 -0700700 compiler compiler
701 linker linker
702 installer installer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500703
704 features []feature
705 stl *stl
706 sanitize *sanitize
707 coverage *coverage
708 sabi *sabi
709 vndkdep *vndkdep
710 lto *lto
711 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800712
Colin Cross31076b32020-10-23 17:22:06 -0700713 library libraryInterface
714
Colin Cross635c3b02016-05-18 15:37:25 -0700715 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800716
Colin Crossb98c8b02016-07-29 13:44:28 -0700717 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700718
719 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800720
721 // Flags used to compile this module
722 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700723
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800724 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700725 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900726
727 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800728 // Kythe (source file indexer) paths for this compilation module
729 kytheFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900730
731 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700732 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700733
734 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700735}
736
Ivan Lozano52767be2019-10-18 14:49:46 -0700737func (c *Module) Toc() android.OptionalPath {
738 if c.linker != nil {
739 if library, ok := c.linker.(libraryInterface); ok {
740 return library.toc()
741 }
742 }
743 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
744}
745
746func (c *Module) ApiLevel() string {
747 if c.linker != nil {
748 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700749 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700750 }
751 }
752 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
753}
754
755func (c *Module) Static() bool {
756 if c.linker != nil {
757 if library, ok := c.linker.(libraryInterface); ok {
758 return library.static()
759 }
760 }
761 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
762}
763
764func (c *Module) Shared() bool {
765 if c.linker != nil {
766 if library, ok := c.linker.(libraryInterface); ok {
767 return library.shared()
768 }
769 }
770 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
771}
772
773func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000774 if c.stl != nil {
775 return c.stl.Properties.SelectedStl
776 }
777 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700778}
779
780func (c *Module) ToolchainLibrary() bool {
781 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
782 return true
783 }
784 return false
785}
786
787func (c *Module) NdkPrebuiltStl() bool {
788 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
789 return true
790 }
791 return false
792}
793
794func (c *Module) StubDecorator() bool {
795 if _, ok := c.linker.(*stubDecorator); ok {
796 return true
797 }
798 return false
799}
800
801func (c *Module) SdkVersion() string {
802 return String(c.Properties.Sdk_version)
803}
804
Artur Satayev480e25b2020-04-27 18:53:18 +0100805func (c *Module) MinSdkVersion() string {
806 return String(c.Properties.Min_sdk_version)
807}
808
Dan Albert92fe7402020-07-15 13:33:30 -0700809func (c *Module) SplitPerApiLevel() bool {
Colin Cross1348ce32020-10-01 13:37:16 -0700810 if !c.canUseSdk() {
811 return false
812 }
Dan Albert92fe7402020-07-15 13:33:30 -0700813 if linker, ok := c.linker.(*objectLinker); ok {
814 return linker.isCrt()
815 }
816 return false
817}
818
Colin Crossc511bc52020-04-07 16:50:32 +0000819func (c *Module) AlwaysSdk() bool {
820 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
821}
822
Ivan Lozano183a3212019-10-18 14:18:45 -0700823func (c *Module) CcLibrary() bool {
824 if c.linker != nil {
825 if _, ok := c.linker.(*libraryDecorator); ok {
826 return true
827 }
Colin Crossd48fe732020-09-23 20:37:24 -0700828 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
829 return true
830 }
Ivan Lozano183a3212019-10-18 14:18:45 -0700831 }
832 return false
833}
834
835func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -0700836 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700837 return true
838 }
839 return false
840}
841
Ivan Lozano2b262972019-11-21 12:30:50 -0800842func (c *Module) NonCcVariants() bool {
843 return false
844}
845
Ivan Lozano183a3212019-10-18 14:18:45 -0700846func (c *Module) SetStatic() {
847 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700848 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700849 library.setStatic()
850 return
851 }
852 }
853 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
854}
855
856func (c *Module) SetShared() {
857 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700858 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700859 library.setShared()
860 return
861 }
862 }
863 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
864}
865
866func (c *Module) BuildStaticVariant() bool {
867 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700868 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700869 return library.buildStatic()
870 }
871 }
872 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
873}
874
875func (c *Module) BuildSharedVariant() bool {
876 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -0700877 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -0700878 return library.buildShared()
879 }
880 }
881 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
882}
883
884func (c *Module) Module() android.Module {
885 return c
886}
887
Jiyong Parkc20eee32018-09-05 22:36:17 +0900888func (c *Module) OutputFile() android.OptionalPath {
889 return c.outputFile
890}
891
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400892func (c *Module) CoverageFiles() android.Paths {
893 if c.linker != nil {
894 if library, ok := c.linker.(libraryInterface); ok {
895 return library.objs().coverageFiles
896 }
897 }
898 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
899}
900
Ivan Lozano183a3212019-10-18 14:18:45 -0700901var _ LinkableInterface = (*Module)(nil)
902
Jiyong Park719b4462019-01-13 00:39:51 +0900903func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900904 if c.linker != nil {
905 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +0900906 }
907 return nil
908}
909
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900910func (c *Module) CoverageOutputFile() android.OptionalPath {
911 if c.linker != nil {
912 return c.linker.coverageOutputFilePath()
913 }
914 return android.OptionalPath{}
915}
916
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900917func (c *Module) RelativeInstallPath() string {
918 if c.installer != nil {
919 return c.installer.relativeInstallPath()
920 }
921 return ""
922}
923
Jooyung Han344d5432019-08-23 11:17:39 +0900924func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +0900925 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +0900926}
927
Colin Cross36242852017-06-23 15:06:31 -0700928func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -0700929 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -0800930 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -0700931 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800932 }
933 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -0700934 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800935 }
936 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -0700937 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800938 }
Colin Crossa8e07cc2016-04-04 15:07:06 -0700939 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -0700940 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -0700941 }
Colin Cross16b23492016-01-06 14:41:07 -0800942 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -0700943 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -0800944 }
Dan Willemsen581341d2017-02-09 16:16:31 -0800945 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -0700946 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -0800947 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800948 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -0700949 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -0800950 }
Justin Yun8effde42017-06-23 19:24:43 +0900951 if c.vndkdep != nil {
952 c.AddProperties(c.vndkdep.props()...)
953 }
Stephen Craneba090d12017-05-09 15:44:35 -0700954 if c.lto != nil {
955 c.AddProperties(c.lto.props()...)
956 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700957 if c.pgo != nil {
958 c.AddProperties(c.pgo.props()...)
959 }
Colin Crossca860ac2016-01-04 14:34:37 -0800960 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -0700961 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -0800962 }
Colin Crossc472d572015-03-17 15:06:21 -0700963
Jiyong Park1613e552020-09-14 19:43:17 +0900964 c.Prefer32(func(ctx android.BaseModuleContext, base *android.ModuleBase, os android.OsType) bool {
Elliott Hughes79ae3412020-04-17 15:49:49 -0700965 // Windows builds always prefer 32-bit
Jiyong Park1613e552020-09-14 19:43:17 +0900966 return os == android.Windows
Colin Crossa9d8bee2018-10-02 13:59:46 -0700967 })
Colin Cross36242852017-06-23 15:06:31 -0700968 android.InitAndroidArchModule(c, c.hod, c.multilib)
Jiyong Park7916bfc2019-09-30 19:13:12 +0900969 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +0900970 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +0900971 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +0900972
Colin Cross36242852017-06-23 15:06:31 -0700973 return c
Colin Crossc472d572015-03-17 15:06:21 -0700974}
975
Colin Crossb916a382016-07-29 17:28:03 -0700976// Returns true for dependency roots (binaries)
977// TODO(ccross): also handle dlopenable libraries
978func (c *Module) isDependencyRoot() bool {
979 if root, ok := c.linker.(interface {
980 isDependencyRoot() bool
981 }); ok {
982 return root.isDependencyRoot()
983 }
984 return false
985}
986
Justin Yun5f7f7e82019-11-18 19:52:14 +0900987// Returns true if the module is using VNDK libraries instead of the libraries in /system/lib or /system/lib64.
988// "product" and "vendor" variant modules return true for this function.
989// When BOARD_VNDK_VERSION is set, vendor variants of "vendor_available: true", "vendor: true",
990// "soc_specific: true" and more vendor installed modules are included here.
Justin Yun63e9ec72020-10-29 16:49:43 +0900991// When PRODUCT_PRODUCT_VNDK_VERSION is set, product variants of "product_available: true" or
Justin Yun5f7f7e82019-11-18 19:52:14 +0900992// "product_specific: true" modules are included here.
Ivan Lozano52767be2019-10-18 14:49:46 -0700993func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +0900994 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700995}
996
Colin Crossc511bc52020-04-07 16:50:32 +0000997func (c *Module) canUseSdk() bool {
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700998 return c.Os() == android.Android && !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +0000999}
1000
1001func (c *Module) UseSdk() bool {
1002 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001003 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001004 }
1005 return false
1006}
1007
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001008func (c *Module) isCoverageVariant() bool {
1009 return c.coverage.Properties.IsCoverageVariant
1010}
1011
Colin Cross95f1ca02020-10-29 20:47:22 -07001012func (c *Module) IsNdk(config android.Config) bool {
1013 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001014}
1015
Inseob Kim9516ee92019-05-09 10:56:13 +09001016func (c *Module) isLlndk(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001017 // Returns true for both LLNDK (public) and LLNDK-private libs.
Jooyung Han0302a842019-10-30 18:43:49 +09001018 return isLlndkLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001019}
1020
Inseob Kim9516ee92019-05-09 10:56:13 +09001021func (c *Module) isLlndkPublic(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001022 // Returns true only for LLNDK (public) libs.
Jooyung Han0302a842019-10-30 18:43:49 +09001023 name := c.BaseModuleName()
1024 return isLlndkLibrary(name, config) && !isVndkPrivateLibrary(name, config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001025}
1026
Inseob Kim9516ee92019-05-09 10:56:13 +09001027func (c *Module) isVndkPrivate(config android.Config) bool {
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001028 // Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Jooyung Han0302a842019-10-30 18:43:49 +09001029 return isVndkPrivateLibrary(c.BaseModuleName(), config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001030}
1031
Ivan Lozano52767be2019-10-18 14:49:46 -07001032func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001033 if vndkdep := c.vndkdep; vndkdep != nil {
1034 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001035 }
1036 return false
1037}
1038
Yi Kong7e53c572018-02-14 18:16:12 +08001039func (c *Module) isPgoCompile() bool {
1040 if pgo := c.pgo; pgo != nil {
1041 return pgo.Properties.PgoCompile
1042 }
1043 return false
1044}
1045
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001046func (c *Module) isNDKStubLibrary() bool {
1047 if _, ok := c.compiler.(*stubDecorator); ok {
1048 return true
1049 }
1050 return false
1051}
1052
Logan Chienf3511742017-10-31 18:04:35 +08001053func (c *Module) isVndkSp() bool {
1054 if vndkdep := c.vndkdep; vndkdep != nil {
1055 return vndkdep.isVndkSp()
1056 }
1057 return false
1058}
1059
1060func (c *Module) isVndkExt() bool {
1061 if vndkdep := c.vndkdep; vndkdep != nil {
1062 return vndkdep.isVndkExt()
1063 }
1064 return false
1065}
1066
Ivan Lozano52767be2019-10-18 14:49:46 -07001067func (c *Module) MustUseVendorVariant() bool {
Jooyung Han097087b2019-10-22 19:32:18 +09001068 return c.isVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001069}
1070
Logan Chienf3511742017-10-31 18:04:35 +08001071func (c *Module) getVndkExtendsModuleName() string {
1072 if vndkdep := c.vndkdep; vndkdep != nil {
1073 return vndkdep.getVndkExtendsModuleName()
1074 }
1075 return ""
1076}
1077
Jiyong Park25fc6a92018-11-18 18:02:45 +09001078func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001079 if lib := c.library; lib != nil {
1080 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001081 }
1082 return false
1083}
1084
1085func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001086 if lib := c.library; lib != nil {
1087 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001088 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001089 return false
1090}
1091
Colin Cross0477b422020-10-13 18:43:54 -07001092// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1093// the implementation. If it is an implementation library it returns its own name.
1094func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1095 name := ctx.OtherModuleName(c)
1096 if versioned, ok := c.linker.(versionedInterface); ok {
1097 name = versioned.implementationModuleName(name)
1098 }
1099 return name
1100}
1101
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001102func (c *Module) bootstrap() bool {
1103 return Bool(c.Properties.Bootstrap)
1104}
1105
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001106func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001107 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1108 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1109 return false
1110 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001111 return c.linker != nil && c.linker.nativeCoverage()
1112}
1113
Inseob Kim8471cda2019-11-15 09:59:12 +09001114func (c *Module) isSnapshotPrebuilt() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09001115 if p, ok := c.linker.(interface{ isSnapshotPrebuilt() bool }); ok {
1116 return p.isSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001117 }
1118 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001119}
1120
Bill Peckham945441c2020-08-31 16:07:58 -07001121func (c *Module) ExcludeFromVendorSnapshot() bool {
1122 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1123}
1124
Jose Galmesf7294582020-11-13 12:07:36 -08001125func (c *Module) ExcludeFromRecoverySnapshot() bool {
1126 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1127}
1128
Jiyong Parkf1194352019-02-25 11:05:47 +09001129func isBionic(name string) bool {
1130 switch name {
Martin Stjernholm203489b2019-11-11 15:33:27 +00001131 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001132 return true
1133 }
1134 return false
1135}
1136
Martin Stjernholm279de572019-09-10 23:18:20 +01001137func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001138 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001139 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001140 }
1141 return isBionic(name)
1142}
1143
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001144func (c *Module) XrefCcFiles() android.Paths {
1145 return c.kytheFiles
1146}
1147
Colin Crossca860ac2016-01-04 14:34:37 -08001148type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001149 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001150 moduleContextImpl
1151}
1152
Colin Cross37047f12016-12-13 17:06:13 -08001153type depsContext struct {
1154 android.BottomUpMutatorContext
1155 moduleContextImpl
1156}
1157
Colin Crossca860ac2016-01-04 14:34:37 -08001158type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001159 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001160 moduleContextImpl
1161}
1162
1163type moduleContextImpl struct {
1164 mod *Module
1165 ctx BaseModuleContext
1166}
1167
Colin Crossb98c8b02016-07-29 13:44:28 -07001168func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001169 return ctx.mod.toolchain(ctx.ctx)
1170}
1171
1172func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001173 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001174}
1175
1176func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001177 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001178}
1179
Jiyong Park1d1119f2019-07-29 21:27:18 +09001180func (ctx *moduleContextImpl) header() bool {
1181 return ctx.mod.header()
1182}
1183
Inseob Kim7f283f42020-06-01 21:53:49 +09001184func (ctx *moduleContextImpl) binary() bool {
1185 return ctx.mod.binary()
1186}
1187
Inseob Kim1042d292020-06-01 23:23:05 +09001188func (ctx *moduleContextImpl) object() bool {
1189 return ctx.mod.object()
1190}
1191
Jooyung Hanccce2f22020-03-07 03:45:53 +09001192func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001193 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001194}
1195
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001196func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001197 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001198}
1199
1200func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001201 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001202 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001203 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001204 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001205 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001206 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001207 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001208 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001209 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001210 }
1211 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001212}
1213
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001214func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001215 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001216}
Justin Yun8effde42017-06-23 19:24:43 +09001217
Colin Cross95f1ca02020-10-29 20:47:22 -07001218func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1219 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001220}
1221
Inseob Kim9516ee92019-05-09 10:56:13 +09001222func (ctx *moduleContextImpl) isLlndk(config android.Config) bool {
1223 return ctx.mod.isLlndk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001224}
1225
Inseob Kim9516ee92019-05-09 10:56:13 +09001226func (ctx *moduleContextImpl) isLlndkPublic(config android.Config) bool {
1227 return ctx.mod.isLlndkPublic(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001228}
1229
Inseob Kim9516ee92019-05-09 10:56:13 +09001230func (ctx *moduleContextImpl) isVndkPrivate(config android.Config) bool {
1231 return ctx.mod.isVndkPrivate(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001232}
1233
Logan Chienf3511742017-10-31 18:04:35 +08001234func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001235 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001236}
1237
Yi Kong7e53c572018-02-14 18:16:12 +08001238func (ctx *moduleContextImpl) isPgoCompile() bool {
1239 return ctx.mod.isPgoCompile()
1240}
1241
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001242func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1243 return ctx.mod.isNDKStubLibrary()
1244}
1245
Justin Yun8effde42017-06-23 19:24:43 +09001246func (ctx *moduleContextImpl) isVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001247 return ctx.mod.isVndkSp()
1248}
1249
1250func (ctx *moduleContextImpl) isVndkExt() bool {
1251 return ctx.mod.isVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001252}
1253
Vic Yangefd249e2018-11-12 20:19:56 -08001254func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001255 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001256}
1257
Logan Chien2f2b8902018-07-10 15:01:19 +08001258// Check whether ABI dumps should be created for this module.
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001259func (ctx *moduleContextImpl) shouldCreateSourceAbiDump() bool {
Logan Chien2f2b8902018-07-10 15:01:19 +08001260 if ctx.ctx.Config().IsEnvTrue("SKIP_ABI_CHECKS") {
1261 return false
Jayant Chowdharyea0a2e12018-03-01 19:12:16 -08001262 }
Doug Hornc32c6b02019-01-17 14:44:05 -08001263
Hsin-Yi Chenf81bb652020-04-07 21:42:19 +08001264 // Coverage builds have extra symbols.
1265 if ctx.mod.isCoverageVariant() {
1266 return false
1267 }
1268
Doug Hornc32c6b02019-01-17 14:44:05 -08001269 if ctx.ctx.Fuchsia() {
1270 return false
1271 }
1272
Logan Chien2f2b8902018-07-10 15:01:19 +08001273 if sanitize := ctx.mod.sanitize; sanitize != nil {
1274 if !sanitize.isVariantOnProductionDevice() {
1275 return false
1276 }
1277 }
1278 if !ctx.ctx.Device() {
1279 // Host modules do not need ABI dumps.
1280 return false
1281 }
Colin Cross31076b32020-10-23 17:22:06 -07001282 if ctx.isNDKStubLibrary() {
Hsin-Yi Chenf6a95462019-06-25 14:46:52 +08001283 // Stubs do not need ABI dumps.
1284 return false
1285 }
Colin Cross31076b32020-10-23 17:22:06 -07001286 if lib := ctx.mod.library; lib != nil && lib.buildStubs() {
1287 // Stubs do not need ABI dumps.
1288 return false
1289 }
1290
Hsin-Yi Chenaf17d742019-07-29 17:46:59 +08001291 return true
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001292}
1293
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001294func (ctx *moduleContextImpl) selectedStl() string {
1295 if stl := ctx.mod.stl; stl != nil {
1296 return stl.Properties.SelectedStl
1297 }
1298 return ""
1299}
1300
Ivan Lozanobd721262018-11-27 14:33:03 -08001301func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1302 return ctx.mod.linker.useClangLld(actx)
1303}
1304
Colin Crossce75d2c2016-10-06 16:12:58 -07001305func (ctx *moduleContextImpl) baseModuleName() string {
1306 return ctx.mod.ModuleBase.BaseModuleName()
1307}
1308
Logan Chienf3511742017-10-31 18:04:35 +08001309func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1310 return ctx.mod.getVndkExtendsModuleName()
1311}
1312
Logan Chiene274fc92019-12-03 11:18:32 -08001313func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001314 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001315}
1316
Colin Crosse07f2312020-08-13 11:24:56 -07001317func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001318 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001319}
1320
Dan Albertc8060532020-07-22 22:32:17 -07001321func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001322 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001323}
1324
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001325func (ctx *moduleContextImpl) bootstrap() bool {
1326 return ctx.mod.bootstrap()
1327}
1328
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001329func (ctx *moduleContextImpl) nativeCoverage() bool {
1330 return ctx.mod.nativeCoverage()
1331}
1332
Colin Cross56a83212020-09-15 18:30:11 -07001333func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1334 return ctx.mod.DirectlyInAnyApex()
1335}
1336
Colin Cross635c3b02016-05-18 15:37:25 -07001337func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001338 return &Module{
1339 hod: hod,
1340 multilib: multilib,
1341 }
1342}
1343
Colin Cross635c3b02016-05-18 15:37:25 -07001344func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001345 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001346 module.features = []feature{
1347 &tidyFeature{},
1348 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001349 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001350 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001351 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001352 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001353 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001354 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001355 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001356 return module
1357}
1358
Colin Crossce75d2c2016-10-06 16:12:58 -07001359func (c *Module) Prebuilt() *android.Prebuilt {
1360 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1361 return p.prebuilt()
1362 }
1363 return nil
1364}
1365
1366func (c *Module) Name() string {
1367 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001368 if p, ok := c.linker.(interface {
1369 Name(string) string
1370 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001371 name = p.Name(name)
1372 }
1373 return name
1374}
1375
Alex Light3d673592019-01-18 14:37:31 -08001376func (c *Module) Symlinks() []string {
1377 if p, ok := c.installer.(interface {
1378 symlinkList() []string
1379 }); ok {
1380 return p.symlinkList()
1381 }
1382 return nil
1383}
1384
Roland Levillainf89cd092019-07-29 16:22:59 +01001385func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1386 test, ok := c.linker.(testPerSrc)
1387 return ok && test.isAllTestsVariation()
1388}
1389
Chris Parsons216e10a2020-07-09 17:12:52 -04001390func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001391 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001392 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001393 }); ok {
1394 return p.dataPaths()
1395 }
1396 return nil
1397}
1398
Justin Yun5f7f7e82019-11-18 19:52:14 +09001399func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1400 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1401 // "current", it will append the VNDK version to the name suffix.
1402 var vndkVersion string
1403 var nameSuffix string
1404 if c.inProduct() {
1405 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
1406 nameSuffix = productSuffix
1407 } else {
1408 vndkVersion = ctx.DeviceConfig().VndkVersion()
1409 nameSuffix = vendorSuffix
1410 }
1411 if vndkVersion == "current" {
1412 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1413 }
1414 if c.Properties.VndkVersion != vndkVersion {
1415 // add version suffix only if the module is using different vndk version than the
1416 // version in product or vendor partition.
1417 nameSuffix += "." + c.Properties.VndkVersion
1418 }
1419 return nameSuffix
1420}
1421
Colin Cross635c3b02016-05-18 15:37:25 -07001422func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Roland Levillainf2fad972019-06-28 15:41:19 +01001423 // Handle the case of a test module split by `test_per_src` mutator.
Roland Levillainf89cd092019-07-29 16:22:59 +01001424 //
1425 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1426 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1427 // module and return early, as this module does not produce an output file per se.
1428 if c.IsTestPerSrcAllTestsVariation() {
1429 c.outputFile = android.OptionalPath{}
1430 return
Roland Levillainf2fad972019-06-28 15:41:19 +01001431 }
1432
Colin Cross56a83212020-09-15 18:30:11 -07001433 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1434 if !apexInfo.IsForPlatform() {
1435 c.hideApexVariantFromMake = true
1436 }
1437
Jooyung Han38002912019-05-16 04:01:54 +09001438 c.makeLinkType = c.getMakeLinkType(actx)
Inseob Kim9516ee92019-05-09 10:56:13 +09001439
Inseob Kim64c43952019-08-26 16:52:35 +09001440 c.Properties.SubName = ""
1441
1442 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1443 c.Properties.SubName += nativeBridgeSuffix
1444 }
1445
Justin Yun5f7f7e82019-11-18 19:52:14 +09001446 _, llndk := c.linker.(*llndkStubDecorator)
1447 _, llndkHeader := c.linker.(*llndkHeadersDecorator)
Justin Yun63e9ec72020-10-29 16:49:43 +09001448 if llndk || llndkHeader || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001449 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1450 // added for product variant only when we have vendor and product variants with core
1451 // variant. The suffix is not added for vendor-only or product-only module.
1452 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
1453 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001454 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1455 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
1456 c.Properties.SubName += vendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001457 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
1458 c.Properties.SubName += ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001459 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
1460 c.Properties.SubName += vendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001461 } else if c.InRecovery() && !c.OnlyInRecovery() {
Inseob Kim64c43952019-08-26 16:52:35 +09001462 c.Properties.SubName += recoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001463 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001464 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001465 if c.SplitPerApiLevel() {
1466 c.Properties.SubName += "." + c.SdkVersion()
1467 }
Inseob Kim64c43952019-08-26 16:52:35 +09001468 }
1469
Colin Crossca860ac2016-01-04 14:34:37 -08001470 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001471 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001472 moduleContextImpl: moduleContextImpl{
1473 mod: c,
1474 },
1475 }
1476 ctx.ctx = ctx
1477
Colin Crossf18e1102017-11-16 14:33:08 -08001478 deps := c.depsToPaths(ctx)
1479 if ctx.Failed() {
1480 return
1481 }
1482
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001483 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1484 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1485 }
1486
Colin Crossca860ac2016-01-04 14:34:37 -08001487 flags := Flags{
1488 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001489 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001490 }
Colin Crossca860ac2016-01-04 14:34:37 -08001491 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001492 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001493 }
1494 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001495 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001496 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001497 if c.stl != nil {
1498 flags = c.stl.flags(ctx, flags)
1499 }
Colin Cross16b23492016-01-06 14:41:07 -08001500 if c.sanitize != nil {
1501 flags = c.sanitize.flags(ctx, flags)
1502 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001503 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001504 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001505 }
Stephen Craneba090d12017-05-09 15:44:35 -07001506 if c.lto != nil {
1507 flags = c.lto.flags(ctx, flags)
1508 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001509 if c.pgo != nil {
1510 flags = c.pgo.flags(ctx, flags)
1511 }
Colin Crossca860ac2016-01-04 14:34:37 -08001512 for _, feature := range c.features {
1513 flags = feature.flags(ctx, flags)
1514 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001515 if ctx.Failed() {
1516 return
1517 }
1518
Colin Cross4af21ed2019-11-04 09:37:55 -08001519 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1520 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1521 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001522
Colin Cross4af21ed2019-11-04 09:37:55 -08001523 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001524
1525 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001526 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001527 }
1528 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001529 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001530 }
1531
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001532 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001533 // We need access to all the flags seen by a source file.
1534 if c.sabi != nil {
1535 flags = c.sabi.flags(ctx, flags)
1536 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001537
Colin Cross4af21ed2019-11-04 09:37:55 -08001538 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001539
Colin Crossca860ac2016-01-04 14:34:37 -08001540 // Optimization to reduce size of build.ninja
1541 // Replace the long list of flags for each file with a module-local variable
Colin Cross4af21ed2019-11-04 09:37:55 -08001542 ctx.Variable(pctx, "cflags", strings.Join(flags.Local.CFlags, " "))
1543 ctx.Variable(pctx, "cppflags", strings.Join(flags.Local.CppFlags, " "))
1544 ctx.Variable(pctx, "asflags", strings.Join(flags.Local.AsFlags, " "))
1545 flags.Local.CFlags = []string{"$cflags"}
1546 flags.Local.CppFlags = []string{"$cppflags"}
1547 flags.Local.AsFlags = []string{"$asflags"}
Colin Crossca860ac2016-01-04 14:34:37 -08001548
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001549 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001550 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001551 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001552 if ctx.Failed() {
1553 return
1554 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001555 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001556 }
1557
Colin Crossca860ac2016-01-04 14:34:37 -08001558 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001559 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001560 if ctx.Failed() {
1561 return
1562 }
Colin Cross635c3b02016-05-18 15:37:25 -07001563 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001564
1565 // If a lib is directly included in any of the APEXes, unhide the stubs
1566 // variant having the latest version gets visible to make. In addition,
1567 // the non-stubs variant is renamed to <libname>.bootstrap. This is to
1568 // force anything in the make world to link against the stubs library.
1569 // (unless it is explicitly referenced via .bootstrap suffix or the
1570 // module is marked with 'bootstrap: true').
Colin Cross56a83212020-09-15 18:30:11 -07001571 if c.HasStubsVariants() && c.AnyVariantDirectlyInAnyApex() && !c.InRamdisk() &&
Ivan Lozano52767be2019-10-18 14:49:46 -07001572 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001573 c.IsStubs() && !c.InVendorRamdisk() {
Jiyong Parkb0788572018-12-20 22:10:17 +09001574 c.Properties.HideFromMake = false // unhide
1575 // Note: this is still non-installable
1576 }
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001577
1578 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current.
1579 if i, ok := c.linker.(snapshotLibraryInterface); ok && ctx.DeviceConfig().VndkVersion() == "current" {
Colin Cross56a83212020-09-15 18:30:11 -07001580 if isSnapshotAware(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001581 i.collectHeadersForSnapshot(ctx)
1582 }
1583 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001584 }
Colin Cross5049f022015-03-18 13:28:46 -07001585
Colin Cross56a83212020-09-15 18:30:11 -07001586 if c.installable(apexInfo) {
Colin Crossce75d2c2016-10-06 16:12:58 -07001587 c.installer.install(ctx, c.outputFile.Path())
1588 if ctx.Failed() {
1589 return
Colin Crossca860ac2016-01-04 14:34:37 -08001590 }
Paul Duffin0cb37b92020-03-04 14:52:46 +00001591 } else if !proptools.BoolDefault(c.Properties.Installable, true) {
1592 // If the module has been specifically configure to not be installed then
1593 // skip the installation as otherwise it will break when running inside make
1594 // as the output path to install will not be specified. Not all uninstallable
1595 // modules can skip installation as some are needed for resolving make side
1596 // dependencies.
1597 c.SkipInstall()
Dan Albertc403f7c2015-03-18 14:01:18 -07001598 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001599}
1600
Colin Cross0ea8ba82019-06-06 14:33:29 -07001601func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001602 if c.cachedToolchain == nil {
Colin Crossb98c8b02016-07-29 13:44:28 -07001603 c.cachedToolchain = config.FindToolchain(ctx.Os(), ctx.Arch())
Colin Cross3f40fa42015-01-30 17:27:36 -08001604 }
Colin Crossca860ac2016-01-04 14:34:37 -08001605 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001606}
1607
Colin Crossca860ac2016-01-04 14:34:37 -08001608func (c *Module) begin(ctx BaseModuleContext) {
1609 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001610 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001611 }
Colin Crossca860ac2016-01-04 14:34:37 -08001612 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001613 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001614 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001615 if c.stl != nil {
1616 c.stl.begin(ctx)
1617 }
Colin Cross16b23492016-01-06 14:41:07 -08001618 if c.sanitize != nil {
1619 c.sanitize.begin(ctx)
1620 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001621 if c.coverage != nil {
1622 c.coverage.begin(ctx)
1623 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001624 if c.sabi != nil {
1625 c.sabi.begin(ctx)
1626 }
Justin Yun8effde42017-06-23 19:24:43 +09001627 if c.vndkdep != nil {
1628 c.vndkdep.begin(ctx)
1629 }
Stephen Craneba090d12017-05-09 15:44:35 -07001630 if c.lto != nil {
1631 c.lto.begin(ctx)
1632 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001633 if c.pgo != nil {
1634 c.pgo.begin(ctx)
1635 }
Colin Crossca860ac2016-01-04 14:34:37 -08001636 for _, feature := range c.features {
1637 feature.begin(ctx)
1638 }
Dan Albert92fe7402020-07-15 13:33:30 -07001639 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001640 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001641 if err != nil {
1642 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001643 c.Properties.Sdk_version = nil
1644 } else {
1645 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001646 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001647 }
Colin Crossca860ac2016-01-04 14:34:37 -08001648}
1649
Colin Cross37047f12016-12-13 17:06:13 -08001650func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001651 deps := Deps{}
1652
1653 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001654 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001655 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001656 // Add the PGO dependency (the clang_rt.profile runtime library), which
1657 // sometimes depends on symbols from libgcc, before libgcc gets added
1658 // in linkerDeps().
Pirama Arumuga Nainar49b53d52017-10-04 16:47:29 -07001659 if c.pgo != nil {
1660 deps = c.pgo.deps(ctx, deps)
1661 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001662 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001663 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001664 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001665 if c.stl != nil {
1666 deps = c.stl.deps(ctx, deps)
1667 }
Colin Cross16b23492016-01-06 14:41:07 -08001668 if c.sanitize != nil {
1669 deps = c.sanitize.deps(ctx, deps)
1670 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001671 if c.coverage != nil {
1672 deps = c.coverage.deps(ctx, deps)
1673 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001674 if c.sabi != nil {
1675 deps = c.sabi.deps(ctx, deps)
1676 }
Justin Yun8effde42017-06-23 19:24:43 +09001677 if c.vndkdep != nil {
1678 deps = c.vndkdep.deps(ctx, deps)
1679 }
Stephen Craneba090d12017-05-09 15:44:35 -07001680 if c.lto != nil {
1681 deps = c.lto.deps(ctx, deps)
1682 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001683 for _, feature := range c.features {
1684 deps = feature.deps(ctx, deps)
1685 }
1686
Colin Crossb6715442017-10-24 11:13:31 -07001687 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1688 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1689 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1690 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1691 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1692 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001693 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001694
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001695 for _, lib := range deps.ReexportSharedLibHeaders {
1696 if !inList(lib, deps.SharedLibs) {
1697 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1698 }
1699 }
1700
1701 for _, lib := range deps.ReexportStaticLibHeaders {
1702 if !inList(lib, deps.StaticLibs) {
1703 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs: '%s'", lib)
1704 }
1705 }
1706
Colin Cross5950f382016-12-13 12:50:57 -08001707 for _, lib := range deps.ReexportHeaderLibHeaders {
1708 if !inList(lib, deps.HeaderLibs) {
1709 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1710 }
1711 }
1712
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001713 for _, gen := range deps.ReexportGeneratedHeaders {
1714 if !inList(gen, deps.GeneratedHeaders) {
1715 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1716 }
1717 }
1718
Colin Crossc99deeb2016-04-11 15:06:20 -07001719 return deps
1720}
1721
Dan Albert7e9d2952016-08-04 13:02:36 -07001722func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001723 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001724 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001725 moduleContextImpl: moduleContextImpl{
1726 mod: c,
1727 },
1728 }
1729 ctx.ctx = ctx
1730
Colin Crossca860ac2016-01-04 14:34:37 -08001731 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001732}
1733
Jiyong Park7ed9de32018-10-15 22:25:07 +09001734// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09001735func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001736 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
1737 version := name[sharp+1:]
1738 libname := name[:sharp]
1739 return libname, version
1740 }
1741 return name, ""
1742}
1743
Dan Albert92fe7402020-07-15 13:33:30 -07001744func GetCrtVariations(ctx android.BottomUpMutatorContext,
1745 m LinkableInterface) []blueprint.Variation {
1746 if ctx.Os() != android.Android {
1747 return nil
1748 }
1749 if m.UseSdk() {
1750 return []blueprint.Variation{
1751 {Mutator: "sdk", Variation: "sdk"},
Colin Crossbbc941b2020-09-30 12:27:01 -07001752 {Mutator: "version", Variation: m.SdkVersion()},
Dan Albert92fe7402020-07-15 13:33:30 -07001753 }
1754 }
1755 return []blueprint.Variation{
1756 {Mutator: "sdk", Variation: ""},
1757 }
1758}
1759
Colin Crosse7257d22020-09-24 09:56:18 -07001760func (c *Module) addSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext,
1761 variations []blueprint.Variation, depTag libraryDependencyTag, name, version string, far bool) {
1762
1763 variations = append([]blueprint.Variation(nil), variations...)
1764
Colin Cross3146c5c2020-09-30 15:34:40 -07001765 if version != "" && CanBeOrLinkAgainstVersionVariants(c) {
Colin Crosse7257d22020-09-24 09:56:18 -07001766 // Version is explicitly specified. i.e. libFoo#30
1767 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
1768 depTag.explicitlyVersioned = true
1769 }
Colin Crosse7257d22020-09-24 09:56:18 -07001770
Colin Cross0de8a1e2020-09-18 14:15:30 -07001771 if far {
1772 ctx.AddFarVariationDependencies(variations, depTag, name)
1773 } else {
1774 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07001775 }
1776}
1777
Colin Cross1e676be2016-10-12 14:38:15 -07001778func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09001779 if !c.Enabled() {
1780 return
1781 }
1782
Colin Cross37047f12016-12-13 17:06:13 -08001783 ctx := &depsContext{
1784 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07001785 moduleContextImpl: moduleContextImpl{
1786 mod: c,
1787 },
1788 }
1789 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08001790
Colin Crossc99deeb2016-04-11 15:06:20 -07001791 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001792
Yo Chiang219968c2020-09-22 18:45:04 +08001793 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
1794
Dan Albert914449f2016-06-17 16:45:24 -07001795 variantNdkLibs := []string{}
1796 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07001797 if ctx.Os() == android.Android {
Inseob Kimeec88e12020-01-22 11:11:29 +09001798 // rewriteLibs takes a list of names of shared libraries and scans it for three types
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001799 // of names:
Dan Albert914449f2016-06-17 16:45:24 -07001800 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001801 // 1. Name of an NDK library that refers to a prebuilt module.
1802 // For each of these, it adds the name of the prebuilt module (which will be in
1803 // prebuilts/ndk) to the list of nonvariant libs.
1804 // 2. Name of an NDK library that refers to an ndk_library module.
1805 // For each of these, it adds the name of the ndk_library module to the list of
1806 // variant libs.
1807 // 3. Anything else (so anything that isn't an NDK library).
1808 // It adds these to the nonvariantLibs list.
Dan Albert914449f2016-06-17 16:45:24 -07001809 //
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001810 // The caller can then know to add the variantLibs dependencies differently from the
1811 // nonvariantLibs
Inseob Kim9516ee92019-05-09 10:56:13 +09001812
Inseob Kim9516ee92019-05-09 10:56:13 +09001813 vendorPublicLibraries := vendorPublicLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001814 vendorSnapshotSharedLibs := vendorSnapshotSharedLibs(actx.Config())
1815
1816 rewriteVendorLibs := func(lib string) string {
1817 if isLlndkLibrary(lib, ctx.Config()) {
1818 return lib + llndkLibrarySuffix
1819 }
1820
1821 // only modules with BOARD_VNDK_VERSION uses snapshot.
1822 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1823 return lib
1824 }
1825
1826 if snapshot, ok := vendorSnapshotSharedLibs.get(lib, actx.Arch().ArchType); ok {
1827 return snapshot
1828 }
1829
1830 return lib
1831 }
1832
1833 rewriteLibs := func(list []string) (nonvariantLibs []string, variantLibs []string) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001834 variantLibs = []string{}
1835 nonvariantLibs = []string{}
Dan Albert914449f2016-06-17 16:45:24 -07001836 for _, entry := range list {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001837 // strip #version suffix out
Jiyong Park73c54ee2019-10-22 20:31:18 +09001838 name, _ := StubsLibNameAndVersion(entry)
Colin Cross95f1ca02020-10-29 20:47:22 -07001839 if ctx.useSdk() && inList(name, *getNDKKnownLibs(ctx.Config())) {
Dan Albertde5aade2020-06-30 12:32:51 -07001840 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
Inseob Kimeec88e12020-01-22 11:11:29 +09001841 } else if ctx.useVndk() {
1842 nonvariantLibs = append(nonvariantLibs, rewriteVendorLibs(entry))
Inseob Kim9516ee92019-05-09 10:56:13 +09001843 } else if (ctx.Platform() || ctx.ProductSpecific()) && inList(name, *vendorPublicLibraries) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001844 vendorPublicLib := name + vendorPublicLibrarySuffix
Jiyong Park374510b2018-03-19 18:23:01 +09001845 if actx.OtherModuleExists(vendorPublicLib) {
1846 nonvariantLibs = append(nonvariantLibs, vendorPublicLib)
1847 } else {
1848 // This can happen if vendor_public_library module is defined in a
1849 // namespace that isn't visible to the current module. In that case,
1850 // link to the original library.
Jiyong Park7ed9de32018-10-15 22:25:07 +09001851 nonvariantLibs = append(nonvariantLibs, name)
Jiyong Park374510b2018-03-19 18:23:01 +09001852 }
Dan Albert914449f2016-06-17 16:45:24 -07001853 } else {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001854 // put name#version back
Dan Willemsen7cbf5f82017-03-28 00:08:30 -07001855 nonvariantLibs = append(nonvariantLibs, entry)
Dan Willemsen72d39932016-07-08 23:23:48 -07001856 }
1857 }
Dan Albert914449f2016-06-17 16:45:24 -07001858 return nonvariantLibs, variantLibs
Dan Willemsen72d39932016-07-08 23:23:48 -07001859 }
1860
Inseob Kimeec88e12020-01-22 11:11:29 +09001861 deps.SharedLibs, variantNdkLibs = rewriteLibs(deps.SharedLibs)
1862 deps.LateSharedLibs, variantLateNdkLibs = rewriteLibs(deps.LateSharedLibs)
1863 deps.ReexportSharedLibHeaders, _ = rewriteLibs(deps.ReexportSharedLibHeaders)
1864 if ctx.useVndk() {
1865 for idx, lib := range deps.RuntimeLibs {
1866 deps.RuntimeLibs[idx] = rewriteVendorLibs(lib)
1867 }
1868 }
Dan Willemsen72d39932016-07-08 23:23:48 -07001869 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001870
Jiyong Park7e636d02019-01-28 16:16:54 +09001871 buildStubs := false
Colin Crossc88c2722020-09-28 17:32:47 -07001872 if versioned, ok := c.linker.(versionedInterface); ok {
1873 if versioned.buildStubs() {
1874 buildStubs = true
Colin Crossd48fe732020-09-23 20:37:24 -07001875 }
Jiyong Park7ed9de32018-10-15 22:25:07 +09001876 }
1877
Inseob Kimeec88e12020-01-22 11:11:29 +09001878 rewriteSnapshotLibs := func(lib string, snapshotMap *snapshotMap) string {
1879 // only modules with BOARD_VNDK_VERSION uses snapshot.
1880 if c.VndkVersion() != actx.DeviceConfig().VndkVersion() {
1881 return lib
1882 }
1883
1884 if snapshot, ok := snapshotMap.get(lib, actx.Arch().ArchType); ok {
1885 return snapshot
1886 }
1887
1888 return lib
1889 }
1890
1891 vendorSnapshotHeaderLibs := vendorSnapshotHeaderLibs(actx.Config())
Colin Cross32ec36c2016-12-15 07:39:51 -08001892 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001893 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08001894 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001895 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08001896 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001897
1898 lib = rewriteSnapshotLibs(lib, vendorSnapshotHeaderLibs)
1899
Jiyong Park7e636d02019-01-28 16:16:54 +09001900 if buildStubs {
Colin Cross7228ecd2019-11-18 16:00:16 -08001901 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07001902 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09001903 } else {
1904 actx.AddVariationDependencies(nil, depTag, lib)
1905 }
1906 }
1907
1908 if buildStubs {
1909 // Stubs lib does not have dependency to other static/shared libraries.
1910 // Don't proceed.
1911 return
Colin Cross32ec36c2016-12-15 07:39:51 -08001912 }
Colin Cross5950f382016-12-13 12:50:57 -08001913
Inseob Kim07def122020-11-23 14:43:02 +09001914 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
1915 // C++ implementation library and one Java implementation library. When a module links against
1916 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
1917 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
1918 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09001919 syspropImplLibraries := syspropImplLibraries(actx.Config())
Inseob Kimeec88e12020-01-22 11:11:29 +09001920 vendorSnapshotStaticLibs := vendorSnapshotStaticLibs(actx.Config())
Inseob Kimc0907f12019-02-08 21:00:45 +09001921
Jiyong Park5d1598f2019-02-25 22:14:17 +09001922 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001923 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09001924 if impl, ok := syspropImplLibraries[lib]; ok {
1925 lib = impl
1926 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001927
1928 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1929
Jiyong Park5d1598f2019-02-25 22:14:17 +09001930 actx.AddVariationDependencies([]blueprint.Variation{
1931 {Mutator: "link", Variation: "static"},
1932 }, depTag, lib)
1933 }
1934
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001935 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001936 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001937 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001938 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001939 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001940
1941 if impl, ok := syspropImplLibraries[lib]; ok {
1942 lib = impl
1943 }
1944
Inseob Kimeec88e12020-01-22 11:11:29 +09001945 lib = rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs)
1946
Dan Willemsen59339a22018-07-22 21:18:45 -07001947 actx.AddVariationDependencies([]blueprint.Variation{
1948 {Mutator: "link", Variation: "static"},
1949 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001950 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001951
Jooyung Han75568392020-03-20 04:29:24 +09001952 // staticUnwinderDep is treated as staticDep for Q apexes
1953 // so that native libraries/binaries are linked with static unwinder
1954 // because Q libc doesn't have unwinder APIs
1955 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07001956 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08001957 actx.AddVariationDependencies([]blueprint.Variation{
1958 {Mutator: "link", Variation: "static"},
Colin Cross6e511a92020-07-27 21:26:48 -07001959 }, depTag, rewriteSnapshotLibs(staticUnwinder(actx), vendorSnapshotStaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08001960 }
1961
Inseob Kimeec88e12020-01-22 11:11:29 +09001962 for _, lib := range deps.LateStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001963 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
Inseob Kimeec88e12020-01-22 11:11:29 +09001964 actx.AddVariationDependencies([]blueprint.Variation{
1965 {Mutator: "link", Variation: "static"},
Colin Cross6e511a92020-07-27 21:26:48 -07001966 }, depTag, rewriteSnapshotLibs(lib, vendorSnapshotStaticLibs))
Inseob Kimeec88e12020-01-22 11:11:29 +09001967 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001968
Jiyong Park7ed9de32018-10-15 22:25:07 +09001969 // shared lib names without the #version suffix
1970 var sharedLibNames []string
1971
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001972 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07001973 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001974 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07001975 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001976 }
Inseob Kimc0907f12019-02-08 21:00:45 +09001977
1978 if impl, ok := syspropImplLibraries[lib]; ok {
1979 lib = impl
1980 }
1981
Jiyong Park73c54ee2019-10-22 20:31:18 +09001982 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09001983 sharedLibNames = append(sharedLibNames, name)
1984
Colin Crosse7257d22020-09-24 09:56:18 -07001985 variations := []blueprint.Variation{
1986 {Mutator: "link", Variation: "shared"},
1987 }
1988 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001989 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001990
Jiyong Park7ed9de32018-10-15 22:25:07 +09001991 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09001992 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09001993 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
1994 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
1995 // linking against both the stubs lib and the non-stubs lib at the same time.
1996 continue
1997 }
Colin Cross6e511a92020-07-27 21:26:48 -07001998 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07001999 variations := []blueprint.Variation{
2000 {Mutator: "link", Variation: "shared"},
2001 }
2002 c.addSharedLibDependenciesWithVersions(ctx, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002003 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002004
Dan Willemsen59339a22018-07-22 21:18:45 -07002005 actx.AddVariationDependencies([]blueprint.Variation{
2006 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002007 }, dataLibDepTag, deps.DataLibs...)
2008
2009 actx.AddVariationDependencies([]blueprint.Variation{
2010 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002011 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002012
Colin Cross68861832016-07-08 10:41:41 -07002013 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002014
2015 for _, gen := range deps.GeneratedHeaders {
2016 depTag := genHeaderDepTag
2017 if inList(gen, deps.ReexportGeneratedHeaders) {
2018 depTag = genHeaderExportDepTag
2019 }
2020 actx.AddDependency(c, depTag, gen)
2021 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002022
Inseob Kim1042d292020-06-01 23:23:05 +09002023 vendorSnapshotObjects := vendorSnapshotObjects(actx.Config())
2024
Dan Albert92fe7402020-07-15 13:33:30 -07002025 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002026 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc99deeb2016-04-11 15:06:20 -07002027 if deps.CrtBegin != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07002028 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
2029 rewriteSnapshotLibs(deps.CrtBegin, vendorSnapshotObjects))
Colin Crossca860ac2016-01-04 14:34:37 -08002030 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002031 if deps.CrtEnd != "" {
Dan Albert92fe7402020-07-15 13:33:30 -07002032 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
2033 rewriteSnapshotLibs(deps.CrtEnd, vendorSnapshotObjects))
Colin Cross21b9a242015-03-24 14:15:58 -07002034 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002035 if deps.LinkerFlagsFile != "" {
2036 actx.AddDependency(c, linkerFlagsDepTag, deps.LinkerFlagsFile)
2037 }
2038 if deps.DynamicLinker != "" {
2039 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002040 }
Dan Albert914449f2016-06-17 16:45:24 -07002041
2042 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002043
2044 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002045 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002046 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002047 {Mutator: "link", Variation: "shared"},
2048 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002049
2050 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002051 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002052 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002053 {Mutator: "link", Variation: "shared"},
2054 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002055
2056 if vndkdep := c.vndkdep; vndkdep != nil {
2057 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002058 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002059 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002060 {Mutator: "link", Variation: "shared"},
2061 }, vndkExtDepTag, vndkdep.getVndkExtendsModuleName())
Logan Chienf3511742017-10-31 18:04:35 +08002062 }
2063 }
Colin Cross6362e272015-10-29 15:25:03 -07002064}
Colin Cross21b9a242015-03-24 14:15:58 -07002065
Colin Crosse40b4ea2018-10-02 22:25:58 -07002066func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002067 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2068 c.beginMutator(ctx)
2069 }
2070}
2071
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002072// Whether a module can link to another module, taking into
2073// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002074func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002075 tag blueprint.DependencyTag) {
2076
2077 switch t := tag.(type) {
2078 case dependencyTag:
2079 if t != vndkExtDepTag {
2080 return
2081 }
2082 case libraryDependencyTag:
2083 default:
2084 return
2085 }
2086
Ivan Lozano52767be2019-10-18 14:49:46 -07002087 if from.Module().Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002088 // Host code is not restricted
2089 return
2090 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002091
2092 // VNDK is cc.Module supported only for now.
2093 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002094 // Though allowed dependency is limited by the image mutator,
2095 // each vendor and product module needs to check link-type
2096 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002097 if ccTo, ok := to.(*Module); ok {
2098 if ccFrom.vndkdep != nil {
2099 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2100 }
2101 } else {
2102 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002103 }
2104 return
2105 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002106 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002107 // Platform code can link to anything
2108 return
2109 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002110 if from.InRamdisk() {
2111 // Ramdisk code is not NDK
2112 return
2113 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002114 if from.InVendorRamdisk() {
2115 // Vendor ramdisk code is not NDK
2116 return
2117 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002118 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002119 // Recovery code is not NDK
2120 return
2121 }
Colin Cross31076b32020-10-23 17:22:06 -07002122 if c, ok := to.(*Module); ok {
2123 if c.ToolchainLibrary() {
2124 // These are always allowed
2125 return
2126 }
2127 if c.NdkPrebuiltStl() {
2128 // These are allowed, but they don't set sdk_version
2129 return
2130 }
2131 if c.StubDecorator() {
2132 // These aren't real libraries, but are the stub shared libraries that are included in
2133 // the NDK.
2134 return
2135 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002136 }
Logan Chien834b9a62019-01-14 15:39:03 +08002137
Ivan Lozano52767be2019-10-18 14:49:46 -07002138 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002139 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2140 // to link to libc++ (non-NDK and without sdk_version).
2141 return
2142 }
2143
Ivan Lozano52767be2019-10-18 14:49:46 -07002144 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002145 // NDK code linking to platform code is never okay.
2146 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002147 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002148 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002149 }
2150
2151 // At this point we know we have two NDK libraries, but we need to
2152 // check that we're not linking against anything built against a higher
2153 // API level, as it is only valid to link against older or equivalent
2154 // APIs.
2155
Inseob Kim01a28722018-04-11 09:48:45 +09002156 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002157 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002158 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002159 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002160 // Current can't be linked against by anything else.
2161 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002162 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002163 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002164 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002165 if err != nil {
2166 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002167 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002168 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002169 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002170 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002171 if err != nil {
2172 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002173 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002174 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002175 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002176
Inseob Kim01a28722018-04-11 09:48:45 +09002177 if toApi > fromApi {
2178 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002179 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002180 }
2181 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002182 }
Dan Albert202fe492017-12-15 13:56:59 -08002183
2184 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002185 fromStl := from.SelectedStl()
2186 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002187 if fromStl == "" || toStl == "" {
2188 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002189 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002190 // We can be permissive with the system "STL" since it is only the C++
2191 // ABI layer, but in the future we should make sure that everyone is
2192 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002193 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002194 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002195 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2196 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002197 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002198}
2199
Jooyung Han479ca172020-10-19 18:51:07 +09002200func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2201 if c, ok := ctx.Module().(*Module); ok {
2202 ctx.VisitDirectDeps(func(dep android.Module) {
2203 depTag := ctx.OtherModuleDependencyTag(dep)
2204 ccDep, ok := dep.(LinkableInterface)
2205 if ok {
2206 checkLinkType(ctx, c, ccDep, depTag)
2207 }
2208 })
2209 }
2210}
2211
Jiyong Park5fb8c102018-04-09 12:03:06 +09002212// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002213// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2214// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002215// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002216func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2217 check := func(child, parent android.Module) bool {
2218 to, ok := child.(*Module)
2219 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002220 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002221 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002222
Jooyung Hana70f0672019-01-18 15:20:43 +09002223 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2224 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002225 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002226
Justin Yun63e9ec72020-10-29 16:49:43 +09002227 // Even if target lib has no vendor variant, keep checking dependency
2228 // graph in case it depends on vendor_available or product_available
2229 // but not double_loadable transtively.
2230 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002231 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002232 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002233
Jooyung Han0302a842019-10-30 18:43:49 +09002234 if to.isVndkSp() || to.isLlndk(ctx.Config()) || Bool(to.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002235 return false
2236 }
2237
2238 var stringPath []string
2239 for _, m := range ctx.GetWalkPath() {
2240 stringPath = append(stringPath, m.Name())
2241 }
2242 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2243 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
2244 "(dependency: %s)", ctx.OtherModuleName(to), strings.Join(stringPath, " -> "))
2245 return false
2246 }
2247 if module, ok := ctx.Module().(*Module); ok {
2248 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jooyung Han0302a842019-10-30 18:43:49 +09002249 if module.isLlndk(ctx.Config()) || Bool(module.VendorProperties.Double_loadable) {
Jooyung Hana70f0672019-01-18 15:20:43 +09002250 ctx.WalkDeps(check)
2251 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002252 }
2253 }
2254}
2255
Colin Cross0de8a1e2020-09-18 14:15:30 -07002256// Returns the highest version which is <= maxSdkVersion.
2257// For example, with maxSdkVersion is 10 and versionList is [9,11]
2258// it returns 9 as string. The list of stubs must be in order from
2259// oldest to newest.
2260func (c *Module) chooseSdkVersion(ctx android.PathContext, stubsInfo []SharedLibraryStubsInfo,
2261 maxSdkVersion android.ApiLevel) (SharedLibraryStubsInfo, error) {
2262
2263 for i := range stubsInfo {
2264 stubInfo := stubsInfo[len(stubsInfo)-i-1]
2265 var ver android.ApiLevel
2266 if stubInfo.Version == "" {
2267 ver = android.FutureApiLevel
2268 } else {
2269 var err error
2270 ver, err = android.ApiLevelFromUser(ctx, stubInfo.Version)
2271 if err != nil {
2272 return SharedLibraryStubsInfo{}, err
2273 }
2274 }
2275 if ver.LessThanOrEqualTo(maxSdkVersion) {
2276 return stubInfo, nil
2277 }
2278 }
2279 var versionList []string
2280 for _, stubInfo := range stubsInfo {
2281 versionList = append(versionList, stubInfo.Version)
2282 }
2283 return SharedLibraryStubsInfo{}, fmt.Errorf("not found a version(<=%s) in versionList: %v", maxSdkVersion.String(), versionList)
2284}
2285
Colin Crossc99deeb2016-04-11 15:06:20 -07002286// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002287func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002288 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002289
Colin Cross0de8a1e2020-09-18 14:15:30 -07002290 var directStaticDeps []StaticLibraryInfo
2291 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002292
Colin Cross0de8a1e2020-09-18 14:15:30 -07002293 reexportExporter := func(exporter FlagExporterInfo) {
2294 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2295 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2296 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2297 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2298 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002299 }
2300
Jooyung Hande34d232020-07-23 13:04:15 +09002301 // For the dependency from platform to apex, use the latest stubs
2302 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002303 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2304 if !apexInfo.IsForPlatform() {
2305 c.apexSdkVersion = apexInfo.MinSdkVersion(ctx)
Jooyung Hande34d232020-07-23 13:04:15 +09002306 }
2307
2308 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2309 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2310 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2311 // (b/144430859)
2312 c.apexSdkVersion = android.FutureApiLevel
2313 }
2314
Colin Crossd11fcda2017-10-23 17:59:01 -07002315 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002316 depName := ctx.OtherModuleName(dep)
2317 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002318
Ivan Lozano52767be2019-10-18 14:49:46 -07002319 ccDep, ok := dep.(LinkableInterface)
2320 if !ok {
2321
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002322 // handling for a few module types that aren't cc Module but that are also supported
2323 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002324 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002325 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002326 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2327 genRule.GeneratedSourceFiles()...)
2328 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002329 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002330 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002331 // Support exported headers from a generated_sources dependency
2332 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002333 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002334 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002335 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002336 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002337 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002338 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002339 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002340 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002341 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2342 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002343 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002344 // 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 +09002345 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002346
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002347 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002348 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002349 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002350 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002351 case linkerFlagsDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002352 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002353 files := genRule.GeneratedSourceFiles()
2354 if len(files) == 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002355 depPaths.LinkerFlagsFile = android.OptionalPathForPath(files[0])
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002356 } else if len(files) > 1 {
Dan Willemsena0790e32018-10-12 00:24:23 -07002357 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 -07002358 }
2359 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002360 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002361 }
Colin Crossca860ac2016-01-04 14:34:37 -08002362 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002363 return
2364 }
2365
Colin Crossfe17f6f2019-03-28 19:30:56 -07002366 if depTag == android.ProtoPluginDepTag {
2367 return
2368 }
Jooyung Han61b66e92020-03-21 14:21:46 +00002369 if depTag == llndkImplDep {
2370 return
2371 }
Colin Crossfe17f6f2019-03-28 19:30:56 -07002372
Colin Crossd11fcda2017-10-23 17:59:01 -07002373 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002374 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2375 return
2376 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002377 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002378 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2379 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002380 return
2381 }
2382
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002383 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002384 // Skip reused objects for stub libraries, they use their own stub object file instead.
2385 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2386 // version mutator, so the stubs variant is created from the shared variant that
2387 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002388 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002389 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2390 objs := staticAnalogue.ReuseObjects
2391 depPaths.Objs = depPaths.Objs.Append(objs)
2392 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2393 reexportExporter(depExporterInfo)
2394 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002395 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002396 }
2397
Colin Cross6e511a92020-07-27 21:26:48 -07002398 linkFile := ccDep.OutputFile()
2399
2400 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2401 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002402 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002403 return
2404 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002405
Colin Cross0de8a1e2020-09-18 14:15:30 -07002406 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002407
Colin Cross6e511a92020-07-27 21:26:48 -07002408 var ptr *android.Paths
2409 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002410
Colin Cross6e511a92020-07-27 21:26:48 -07002411 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002412
Colin Cross6e511a92020-07-27 21:26:48 -07002413 switch {
2414 case libDepTag.header():
2415 // nothing
2416 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002417 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2418 if !ctx.Config().AllowMissingDependencies() {
2419 ctx.ModuleErrorf("module %q is not a shared library", depName)
2420 } else {
2421 ctx.AddMissingDependencies([]string{depName})
2422 }
2423 return
2424 }
2425 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
2426 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryImplementationStubsInfoProvider).(SharedLibraryImplementationStubsInfo)
2427
2428 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedLibraryStubsInfos) > 0 {
2429 useStubs := false
Colin Cross31076b32020-10-23 17:22:06 -07002430
2431 if lib := moduleLibraryInterface(dep); lib.buildStubs() && c.UseVndk() { // LLNDK
Colin Cross0de8a1e2020-09-18 14:15:30 -07002432 if !apexInfo.IsForPlatform() {
2433 // For platform libraries, use current version of LLNDK
2434 // If this is for use_vendor apex we will apply the same rules
2435 // of apex sdk enforcement below to choose right version.
2436 useStubs = true
2437 }
2438 } else if apexInfo.IsForPlatform() {
2439 // If not building for APEX, use stubs only when it is from
2440 // an APEX (and not from platform)
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002441 // However, for host, ramdisk, vendor_ramdisk, recovery or bootstrap modules,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002442 // always link to non-stub variant
2443 useStubs = dep.(android.ApexModule).AnyVariantDirectlyInAnyApex() && !c.bootstrap()
2444 // Another exception: if this module is bundled with an APEX, then
2445 // it is linked with the non-stub variant of a module in the APEX
2446 // as if this is part of the APEX.
2447 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2448 for _, apexContents := range testFor.ApexContents {
2449 if apexContents.DirectlyInApex(depName) {
2450 useStubs = false
2451 break
2452 }
2453 }
2454 } else {
2455 // If building for APEX, use stubs when the parent is in any APEX that
2456 // the child is not in.
2457 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
2458 }
2459
2460 // when to use (unspecified) stubs, check min_sdk_version and choose the right one
2461 if useStubs {
2462 sharedLibraryStubsInfo, err :=
2463 c.chooseSdkVersion(ctx, sharedLibraryStubsInfo.SharedLibraryStubsInfos, c.apexSdkVersion)
2464 if err != nil {
2465 ctx.OtherModuleErrorf(dep, err.Error())
2466 return
2467 }
2468 sharedLibraryInfo = sharedLibraryStubsInfo.SharedLibraryInfo
2469 depExporterInfo = sharedLibraryStubsInfo.FlagExporterInfo
2470 }
2471 }
2472
2473 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2474 depFile = sharedLibraryInfo.TableOfContents
2475
Colin Cross6e511a92020-07-27 21:26:48 -07002476 ptr = &depPaths.SharedLibs
2477 switch libDepTag.Order {
2478 case earlyLibraryDependency:
2479 ptr = &depPaths.EarlySharedLibs
2480 depPtr = &depPaths.EarlySharedLibsDeps
2481 case normalLibraryDependency:
2482 ptr = &depPaths.SharedLibs
2483 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002484 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002485 case lateLibraryDependency:
2486 ptr = &depPaths.LateSharedLibs
2487 depPtr = &depPaths.LateSharedLibsDeps
2488 default:
2489 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002490 }
Colin Cross6e511a92020-07-27 21:26:48 -07002491 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002492 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2493 if !ctx.Config().AllowMissingDependencies() {
2494 ctx.ModuleErrorf("module %q is not a static library", depName)
2495 } else {
2496 ctx.AddMissingDependencies([]string{depName})
2497 }
2498 return
2499 }
2500 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2501 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002502 if libDepTag.wholeStatic {
2503 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002504 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2505 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002506 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002507 // This case normally catches prebuilt static
2508 // libraries, but it can also occur when
2509 // AllowMissingDependencies is on and the
2510 // dependencies has no sources of its own
2511 // but has a whole_static_libs dependency
2512 // on a missing library. We want to depend
2513 // on the .a file so that there is something
2514 // in the dependency tree that contains the
2515 // error rule for the missing transitive
2516 // dependency.
2517 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002518 }
Colin Cross6e511a92020-07-27 21:26:48 -07002519 } else {
2520 switch libDepTag.Order {
2521 case earlyLibraryDependency:
2522 panic(fmt.Errorf("early static libs not suppported"))
2523 case normalLibraryDependency:
2524 // static dependencies will be handled separately so they can be ordered
2525 // using transitive dependencies.
2526 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002527 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002528 case lateLibraryDependency:
2529 ptr = &depPaths.LateStaticLibs
2530 default:
2531 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002532 }
2533 }
2534 }
2535
Colin Cross6e511a92020-07-27 21:26:48 -07002536 if libDepTag.static() && !libDepTag.wholeStatic {
2537 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2538 ctx.ModuleErrorf("module %q not a static library", depName)
2539 return
2540 }
Logan Chien43d34c32017-12-20 01:17:32 +08002541
Colin Cross6e511a92020-07-27 21:26:48 -07002542 // When combining coverage files for shared libraries and executables, coverage files
2543 // in static libraries act as if they were whole static libraries. The same goes for
2544 // source based Abi dump files.
2545 if c, ok := ccDep.(*Module); ok {
2546 staticLib := c.linker.(libraryInterface)
2547 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2548 staticLib.objs().coverageFiles...)
2549 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2550 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002551 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002552 // Handle non-CC modules here
2553 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002554 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002555 }
2556 }
2557
Colin Cross6e511a92020-07-27 21:26:48 -07002558 if ptr != nil {
2559 if !linkFile.Valid() {
2560 if !ctx.Config().AllowMissingDependencies() {
2561 ctx.ModuleErrorf("module %q missing output file", depName)
2562 } else {
2563 ctx.AddMissingDependencies([]string{depName})
2564 }
2565 return
2566 }
2567 *ptr = append(*ptr, linkFile.Path())
2568 }
2569
2570 if depPtr != nil {
2571 dep := depFile
2572 if !dep.Valid() {
2573 dep = linkFile
2574 }
2575 *depPtr = append(*depPtr, dep.Path())
2576 }
2577
Colin Cross0de8a1e2020-09-18 14:15:30 -07002578 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2579 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2580 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2581 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2582
2583 if libDepTag.reexportFlags {
2584 reexportExporter(depExporterInfo)
2585 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2586 // Re-exported shared library headers must be included as well since they can help us with type information
2587 // about template instantiations (instantiated from their headers).
2588 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2589 // scripts.
2590 c.sabi.Properties.ReexportedIncludes = append(
2591 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2592 }
2593
Colin Cross6e511a92020-07-27 21:26:48 -07002594 makeLibName := c.makeLibName(ctx, ccDep, depName) + libDepTag.makeSuffix
2595 switch {
2596 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002597 c.Properties.AndroidMkHeaderLibs = append(
2598 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002599 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002600 if lib := moduleLibraryInterface(dep); lib != nil {
2601 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002602 // Add the dependency to the APEX(es) providing the library so that
2603 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002604 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
2605 for _, an := range depApexInfo.InApexes {
Colin Cross6e511a92020-07-27 21:26:48 -07002606 c.Properties.ApexesProvidingSharedLibs = append(
2607 c.Properties.ApexesProvidingSharedLibs, an)
2608 }
2609 }
2610 }
2611
2612 // Note: the order of libs in this list is not important because
2613 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002614 c.Properties.AndroidMkSharedLibs = append(
2615 c.Properties.AndroidMkSharedLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002616 // Record baseLibName for snapshots.
2617 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, baseLibName(depName))
2618 case libDepTag.static():
2619 if libDepTag.wholeStatic {
2620 c.Properties.AndroidMkWholeStaticLibs = append(
2621 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2622 } else {
2623 c.Properties.AndroidMkStaticLibs = append(
2624 c.Properties.AndroidMkStaticLibs, makeLibName)
2625 }
2626 }
2627 } else {
2628 switch depTag {
2629 case runtimeDepTag:
2630 c.Properties.AndroidMkRuntimeLibs = append(
2631 c.Properties.AndroidMkRuntimeLibs, c.makeLibName(ctx, ccDep, depName)+libDepTag.makeSuffix)
2632 // Record baseLibName for snapshots.
2633 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, baseLibName(depName))
2634 case objDepTag:
2635 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2636 case CrtBeginDepTag:
2637 depPaths.CrtBegin = linkFile
2638 case CrtEndDepTag:
2639 depPaths.CrtEnd = linkFile
2640 case dynamicLinkerDepTag:
2641 depPaths.DynamicLinker = linkFile
2642 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002643 }
Colin Crossca860ac2016-01-04 14:34:37 -08002644 })
2645
Jeff Gaston294356f2017-09-27 17:05:30 -07002646 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002647 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2648 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2649 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002650
Colin Crossdd84e052017-05-17 13:44:16 -07002651 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002652 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002653 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2654 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002655 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002656 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2657 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002658 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002659 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002660 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002661
2662 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002663 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002664 }
Colin Crossdd84e052017-05-17 13:44:16 -07002665
Colin Crossca860ac2016-01-04 14:34:37 -08002666 return depPaths
2667}
2668
Colin Cross0de8a1e2020-09-18 14:15:30 -07002669// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
2670// to match the topological order of the dependency tree, including any static analogues of
2671// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
2672// of the transitive dependencies.
2673func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
2674 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
2675 var staticPaths android.Paths
2676 for _, staticDep := range staticDeps {
2677 staticPaths = append(staticPaths, staticDep.StaticLibrary)
2678 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
2679 }
2680 for _, sharedDep := range sharedDeps {
2681 if sharedDep.StaticAnalogue != nil {
2682 transitiveStaticLibsBuilder.Transitive(sharedDep.StaticAnalogue.TransitiveStaticLibrariesForOrdering)
2683 }
2684 }
2685 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
2686
2687 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
2688
2689 // reorder the dependencies based on transitive dependencies
2690 staticPaths = android.FirstUniquePaths(staticPaths)
2691 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
2692
2693 if len(orderedStaticPaths) != len(staticPaths) {
2694 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
2695 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
2696 }
2697
2698 return orderedStaticPaths, transitiveStaticLibs
2699}
2700
Colin Cross6e511a92020-07-27 21:26:48 -07002701// baseLibName trims known prefixes and suffixes
2702func baseLibName(depName string) string {
2703 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
2704 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
2705 libName = strings.TrimPrefix(libName, "prebuilt_")
2706 return libName
2707}
2708
2709func (c *Module) makeLibName(ctx android.ModuleContext, ccDep LinkableInterface, depName string) string {
2710 vendorSuffixModules := vendorSuffixModules(ctx.Config())
2711 vendorPublicLibraries := vendorPublicLibraries(ctx.Config())
2712
2713 libName := baseLibName(depName)
2714 isLLndk := isLlndkLibrary(libName, ctx.Config())
2715 isVendorPublicLib := inList(libName, *vendorPublicLibraries)
2716 bothVendorAndCoreVariantsExist := ccDep.HasVendorVariant() || isLLndk
2717
2718 if c, ok := ccDep.(*Module); ok {
2719 // Use base module name for snapshots when exporting to Makefile.
2720 if c.isSnapshotPrebuilt() {
2721 baseName := c.BaseModuleName()
2722
2723 if c.IsVndk() {
2724 return baseName + ".vendor"
2725 }
2726
2727 if vendorSuffixModules[baseName] {
2728 return baseName + ".vendor"
2729 } else {
2730 return baseName
2731 }
2732 }
2733 }
2734
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002735 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
2736 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07002737 // The vendor module is a no-vendor-variant VNDK library. Depend on the
2738 // core module instead.
2739 return libName
2740 } else if c.UseVndk() && bothVendorAndCoreVariantsExist {
2741 // The vendor module in Make will have been renamed to not conflict with the core
2742 // module, so update the dependency name here accordingly.
2743 return libName + c.getNameSuffixWithVndkVersion(ctx)
2744 } else if (ctx.Platform() || ctx.ProductSpecific()) && isVendorPublicLib {
2745 return libName + vendorPublicLibrarySuffix
2746 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
2747 return libName + ramdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002748 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
2749 return libName + vendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002750 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
2751 return libName + recoverySuffix
2752 } else if ccDep.Module().Target().NativeBridge == android.NativeBridgeEnabled {
2753 return libName + nativeBridgeSuffix
2754 } else {
2755 return libName
2756 }
2757}
2758
Colin Crossca860ac2016-01-04 14:34:37 -08002759func (c *Module) InstallInData() bool {
2760 if c.installer == nil {
2761 return false
2762 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002763 return c.installer.inData()
2764}
2765
2766func (c *Module) InstallInSanitizerDir() bool {
2767 if c.installer == nil {
2768 return false
2769 }
2770 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07002771 return true
2772 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07002773 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08002774}
2775
Yifan Hong1b3348d2020-01-21 15:53:22 -08002776func (c *Module) InstallInRamdisk() bool {
2777 return c.InRamdisk()
2778}
2779
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002780func (c *Module) InstallInVendorRamdisk() bool {
2781 return c.InVendorRamdisk()
2782}
2783
Jiyong Parkf9332f12018-02-01 00:54:12 +09002784func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07002785 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09002786}
2787
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002788func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002789 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002790 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002791 return
2792 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01002793 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01002794}
2795
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07002796func (c *Module) HostToolPath() android.OptionalPath {
2797 if c.installer == nil {
2798 return android.OptionalPath{}
2799 }
2800 return c.installer.hostToolPath()
2801}
2802
Nan Zhangd4e641b2017-07-12 12:55:28 -07002803func (c *Module) IntermPathForModuleOut() android.OptionalPath {
2804 return c.outputFile
2805}
2806
Colin Cross41955e82019-05-29 14:40:35 -07002807func (c *Module) OutputFiles(tag string) (android.Paths, error) {
2808 switch tag {
2809 case "":
2810 if c.outputFile.Valid() {
2811 return android.Paths{c.outputFile.Path()}, nil
2812 }
2813 return android.Paths{}, nil
2814 default:
2815 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002816 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07002817}
2818
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00002819func (c *Module) static() bool {
2820 if static, ok := c.linker.(interface {
2821 static() bool
2822 }); ok {
2823 return static.static()
2824 }
2825 return false
2826}
2827
Jiyong Park379de2f2018-12-19 02:47:14 +09002828func (c *Module) staticBinary() bool {
2829 if static, ok := c.linker.(interface {
2830 staticBinary() bool
2831 }); ok {
2832 return static.staticBinary()
2833 }
2834 return false
2835}
2836
Jiyong Park1d1119f2019-07-29 21:27:18 +09002837func (c *Module) header() bool {
2838 if h, ok := c.linker.(interface {
2839 header() bool
2840 }); ok {
2841 return h.header()
2842 }
2843 return false
2844}
2845
Inseob Kim7f283f42020-06-01 21:53:49 +09002846func (c *Module) binary() bool {
2847 if b, ok := c.linker.(interface {
2848 binary() bool
2849 }); ok {
2850 return b.binary()
2851 }
2852 return false
2853}
2854
Inseob Kim1042d292020-06-01 23:23:05 +09002855func (c *Module) object() bool {
2856 if o, ok := c.linker.(interface {
2857 object() bool
2858 }); ok {
2859 return o.object()
2860 }
2861 return false
2862}
2863
Jooyung Han38002912019-05-16 04:01:54 +09002864func (c *Module) getMakeLinkType(actx android.ModuleContext) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07002865 if c.UseVndk() {
Jooyung Han38002912019-05-16 04:01:54 +09002866 if lib, ok := c.linker.(*llndkStubDecorator); ok {
2867 if Bool(lib.Properties.Vendor_available) {
Colin Crossb60190a2018-09-04 16:28:17 -07002868 return "native:vndk"
2869 }
Jooyung Han38002912019-05-16 04:01:54 +09002870 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07002871 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002872 if c.IsVndk() && !c.isVndkExt() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002873 // Product_available, if defined, must have the same value with Vendor_available.
Jooyung Han38002912019-05-16 04:01:54 +09002874 if Bool(c.VendorProperties.Vendor_available) {
2875 return "native:vndk"
2876 }
2877 return "native:vndk_private"
2878 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09002879 if c.inProduct() {
2880 return "native:product"
2881 }
Jooyung Han38002912019-05-16 04:01:54 +09002882 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08002883 } else if c.InRamdisk() {
2884 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002885 } else if c.InVendorRamdisk() {
2886 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07002887 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07002888 return "native:recovery"
2889 } else if c.Target().Os == android.Android && String(c.Properties.Sdk_version) != "" {
2890 return "native:ndk:none:none"
2891 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
2892 //family, link := getNdkStlFamilyAndLinkType(c)
2893 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07002894 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08002895 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07002896 } else {
2897 return "native:platform"
2898 }
2899}
2900
Jiyong Park9d452992018-10-03 00:38:19 +09002901// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01002902// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09002903func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07002904 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09002905 // Stub libs and prebuilt libs in a versioned SDK are not
2906 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07002907 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01002908 } else if _, ok := c.linker.(testPerSrc); ok {
2909 return true
Jiyong Park9d452992018-10-03 00:38:19 +09002910 }
2911 return false
2912}
2913
Jiyong Parka90ca002019-10-07 15:47:24 +09002914func (c *Module) AvailableFor(what string) bool {
2915 if linker, ok := c.linker.(interface {
2916 availableFor(string) bool
2917 }); ok {
2918 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
2919 } else {
2920 return c.ApexModuleBase.AvailableFor(what)
2921 }
2922}
2923
Jiyong Park62304bb2020-04-13 16:19:48 +09002924func (c *Module) TestFor() []string {
2925 if test, ok := c.linker.(interface {
2926 testFor() []string
2927 }); ok {
2928 return test.testFor()
2929 } else {
2930 return c.ApexModuleBase.TestFor()
2931 }
2932}
2933
Colin Crossaede88c2020-08-11 12:17:01 -07002934func (c *Module) UniqueApexVariations() bool {
2935 if u, ok := c.compiler.(interface {
2936 uniqueApexVariations() bool
2937 }); ok {
2938 return u.uniqueApexVariations()
2939 } else {
2940 return false
2941 }
2942}
2943
Paul Duffin0cb37b92020-03-04 14:52:46 +00002944// Return true if the module is ever installable.
2945func (c *Module) EverInstallable() bool {
2946 return c.installer != nil &&
2947 // Check to see whether the module is actually ever installable.
2948 c.installer.everInstallable()
2949}
2950
Colin Cross56a83212020-09-15 18:30:11 -07002951func (c *Module) installable(apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00002952 ret := c.EverInstallable() &&
2953 // Check to see whether the module has been configured to not be installed.
2954 proptools.BoolDefault(c.Properties.Installable, true) &&
2955 !c.Properties.PreventInstall && c.outputFile.Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09002956
2957 // The platform variant doesn't need further condition. Apex variants however might not
2958 // be installable because it will likely to be included in the APEX and won't appear
2959 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07002960 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09002961 return ret
2962 }
2963
2964 // Special case for modules that are configured to be installed to /data, which includes
2965 // test modules. For these modules, both APEX and non-APEX variants are considered as
2966 // installable. This is because even the APEX variants won't be included in the APEX, but
2967 // will anyway be installed to /data/*.
2968 // See b/146995717
2969 if c.InstallInData() {
2970 return ret
2971 }
2972
2973 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09002974}
2975
Logan Chien41eabe62019-04-10 13:33:58 +08002976func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
2977 if c.linker != nil {
2978 if library, ok := c.linker.(*libraryDecorator); ok {
2979 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
2980 }
2981 }
2982}
2983
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002984func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07002985 depTag := ctx.OtherModuleDependencyTag(dep)
2986 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
2987
2988 if cc, ok := dep.(*Module); ok {
2989 if cc.HasStubsVariants() {
2990 if isLibDepTag && libDepTag.shared() {
2991 // dynamic dep to a stubs lib crosses APEX boundary
2992 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002993 }
Colin Cross6e511a92020-07-27 21:26:48 -07002994 if IsRuntimeDepTag(depTag) {
2995 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09002996 return false
2997 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09002998 }
Colin Crossaac32222020-07-29 12:51:56 -07002999 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003000 // shared_lib dependency from a static lib is considered as crossing
3001 // the APEX boundary because the dependency doesn't actually is
3002 // linked; the dependency is used only during the compilation phase.
3003 return false
3004 }
3005 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003006 if depTag == stubImplDepTag || depTag == llndkImplDep {
3007 // We don't track beyond LLNDK or from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003008 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003009 }
3010 return true
3011}
3012
Dan Albertc8060532020-07-22 22:32:17 -07003013func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3014 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003015 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3016 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3017 return nil
3018 }
3019 // b/154569636: set min_sdk_version correctly for toolchain_libraries
3020 if c.ToolchainLibrary() {
3021 return nil
3022 }
3023 // We don't check for prebuilt modules
3024 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3025 return nil
3026 }
3027 minSdkVersion := c.MinSdkVersion()
3028 if minSdkVersion == "apex_inherit" {
3029 return nil
3030 }
3031 if minSdkVersion == "" {
3032 // JNI libs within APK-in-APEX fall into here
3033 // Those are okay to set sdk_version instead
3034 // We don't have to check if this is a SDK variant because
3035 // non-SDK variant resets sdk_version, which works too.
3036 minSdkVersion = c.SdkVersion()
3037 }
Dan Albertc8060532020-07-22 22:32:17 -07003038 if minSdkVersion == "" {
3039 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3040 }
3041 // Not using nativeApiLevelFromUser because the context here is not
3042 // necessarily a native context.
3043 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003044 if err != nil {
3045 return err
3046 }
Dan Albertc8060532020-07-22 22:32:17 -07003047
3048 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003049 return fmt.Errorf("newer SDK(%v)", ver)
3050 }
3051 return nil
3052}
3053
Colin Cross2ba19d92015-05-07 15:44:20 -07003054//
Colin Crosscfad1192015-11-02 16:43:11 -08003055// Defaults
3056//
Colin Crossca860ac2016-01-04 14:34:37 -08003057type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003058 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003059 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003060 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003061}
3062
Patrice Arrudac249c712019-03-19 17:00:29 -07003063// cc_defaults provides a set of properties that can be inherited by other cc
3064// modules. A module can use the properties from a cc_defaults using
3065// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3066// merged (when possible) by prepending the default module's values to the
3067// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003068func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003069 return DefaultsFactory()
3070}
3071
Colin Cross36242852017-06-23 15:06:31 -07003072func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003073 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003074
Colin Cross36242852017-06-23 15:06:31 -07003075 module.AddProperties(props...)
3076 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003077 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003078 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003079 &BaseCompilerProperties{},
3080 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003081 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003082 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003083 &StaticProperties{},
3084 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003085 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003086 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003087 &TestProperties{},
3088 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003089 &BenchmarkProperties{},
Mitch Phillips4e4ab8a2019-09-13 17:32:50 -07003090 &FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003091 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003092 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003093 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003094 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003095 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003096 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003097 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003098 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003099 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003100 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003101 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003102 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3103 &RustBindgenClangProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003104 )
Colin Crosscfad1192015-11-02 16:43:11 -08003105
Jooyung Hancc372c52019-09-25 15:18:44 +09003106 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003107
3108 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003109}
3110
Jiyong Park2286afd2020-06-16 21:58:53 +09003111func (c *Module) IsSdkVariant() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07003112 return c.Properties.IsSdkVariant || c.AlwaysSdk()
Jiyong Park2286afd2020-06-16 21:58:53 +09003113}
3114
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003115func kytheExtractAllFactory() android.Singleton {
3116 return &kytheExtractAllSingleton{}
3117}
3118
3119type kytheExtractAllSingleton struct {
3120}
3121
3122func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3123 var xrefTargets android.Paths
3124 ctx.VisitAllModules(func(module android.Module) {
3125 if ccModule, ok := module.(xref); ok {
3126 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3127 }
3128 })
3129 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3130 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003131 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003132 }
3133}
3134
Colin Cross06a931b2015-10-28 17:23:31 -07003135var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003136var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003137var BoolPtr = proptools.BoolPtr
3138var String = proptools.String
3139var StringPtr = proptools.StringPtr