blob: 113620cc1c254706f66b03b5fd6e104b1d8739cb [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"
hamzehc0a671f2021-07-22 12:05:08 -070032 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070033 "android/soong/genrule"
Rob Seymour925aa092021-08-10 20:42:03 +000034 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080035)
36
Colin Cross463a90e2015-06-17 14:20:06 -070037func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000038 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070039
Paul Duffin036e7002019-12-19 19:16:28 +000040 pctx.Import("android/soong/cc/config")
41}
42
43func RegisterCCBuildComponents(ctx android.RegistrationContext) {
44 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
45
46 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000047 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090048 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070049 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010050 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070051 ctx.BottomUp("version_selector", versionSelectorMutator).Parallel()
52 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070053 ctx.BottomUp("begin", BeginMutator).Parallel()
Inseob Kimac1e9862019-12-09 18:15:47 +090054 ctx.BottomUp("sysprop_cc", SyspropMutator).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) {
Liz Kammer75db9312021-07-07 16:41:50 -040058 for _, san := range Sanitizers {
59 san.registerMutators(ctx)
60 }
Dan Willemsen581341d2017-02-09 16:16:31 -080061
Colin Cross0b908332019-06-19 23:00:20 -070062 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090063 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080064
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080065 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070066
67 ctx.TopDown("lto_deps", ltoDepsMutator)
68 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090069
Jooyung Han479ca172020-10-19 18:51:07 +090070 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090071 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070072 })
Colin Crossb98c8b02016-07-29 13:44:28 -070073
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080074 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
75 // sabi mutator needs to be run after apex mutator finishes.
76 ctx.TopDown("sabi_deps", sabiDepsMutator)
77 })
78
Colin Cross57898582020-10-29 18:25:19 -070079 ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070080}
81
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050082// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
83// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
84// edges to these modules.
85// This object is constructed in DepsMutator, by calling to various module delegates to set
86// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
87// dependencies.
88// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
89// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080090type Deps struct {
91 SharedLibs, LateSharedLibs []string
92 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080093 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +080094 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -070095
Chris Parsons79d66a52020-06-05 17:26:16 -040096 // Used for data dependencies adjacent to tests
97 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -070098 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -040099
Yo Chiang219968c2020-09-22 18:45:04 +0800100 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
101 SystemSharedLibs []string
102
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500103 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800104 StaticUnwinderIfLegacy bool
105
Colin Cross5950f382016-12-13 12:50:57 -0800106 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700107
Colin Cross81413472016-04-11 14:37:39 -0700108 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700109
Dan Willemsenb40aab62016-04-20 14:21:14 -0700110 GeneratedSources []string
111 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900112 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700113
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700114 ReexportGeneratedHeaders []string
115
Colin Crossc465efd2021-06-11 18:00:04 -0700116 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700117
118 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700119 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900120
121 // List of libs that need to be excluded for APEX variant
122 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700123}
124
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500125// PathDeps is a struct containing file paths to dependencies of a module.
126// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
127// It's used to construct flags for various build statements (such as for compiling and linking).
128// It is then passed to module decorator functions responsible for registering build statements
129// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800130type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700131 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900132 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700133 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900134 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700135 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700136 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700137
Colin Cross0de8a1e2020-09-18 14:15:30 -0700138 // Transitive static library dependencies of static libraries for use in ordering.
139 TranstiveStaticLibrariesForOrdering *android.DepSet
140
Colin Cross26c34ed2016-09-30 17:10:16 -0700141 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100142 Objs Objects
143 // Paths to .o files in dependencies that provide them. Note that these lists
144 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800145 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700146 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700147
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100148 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
149 // the libs from all whole_static_lib dependencies.
150 WholeStaticLibsFromPrebuilts android.Paths
151
Colin Cross26c34ed2016-09-30 17:10:16 -0700152 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700153 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900154 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700155
Inseob Kimd110f872019-12-06 13:15:38 +0900156 Flags []string
157 IncludeDirs android.Paths
158 SystemIncludeDirs android.Paths
159 ReexportedDirs android.Paths
160 ReexportedSystemDirs android.Paths
161 ReexportedFlags []string
162 ReexportedGeneratedHeaders android.Paths
163 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700164
Colin Cross26c34ed2016-09-30 17:10:16 -0700165 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700166 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700167
Dan Willemsena0790e32018-10-12 00:24:23 -0700168 // Path to the dynamic linker binary
169 DynamicLinker android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700170}
171
Colin Cross4af21ed2019-11-04 09:37:55 -0800172// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
173// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
174// command line so they can be overridden by the local module flags).
175type LocalOrGlobalFlags struct {
176 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700177 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800178 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700179 CFlags []string // Flags that apply to C and C++ source files
180 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
181 ConlyFlags []string // Flags that apply to C source files
182 CppFlags []string // Flags that apply to C++ source files
183 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700184 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800185}
186
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500187// Flags contains various types of command line flags (and settings) for use in building build
188// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800189type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500190 // Local flags (which individual modules are responsible for). These may override global flags.
191 Local LocalOrGlobalFlags
192 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800193 Global LocalOrGlobalFlags
194
195 aidlFlags []string // Flags that apply to aidl source files
196 rsFlags []string // Flags that apply to renderscript source files
197 libFlags []string // Flags to add libraries early to the link order
198 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
199 TidyFlags []string // Flags that apply to clang-tidy
200 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700201
Colin Crossc3199482017-03-30 15:03:04 -0700202 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800203 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700204 SystemIncludeFlags []string
205
Oliver Nguyen04526782020-04-21 12:40:27 -0700206 Toolchain config.Toolchain
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500207 Tidy bool // True if clang-tidy is enabled.
208 GcovCoverage bool // True if coverage files should be generated.
209 SAbiDump bool // True if header abi dumps should be generated.
Oliver Nguyen04526782020-04-21 12:40:27 -0700210 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800211
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500212 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800213 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500214 // The target-device system path to the dynamic linker.
215 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800216
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700217 CFlagsDeps android.Paths // Files depended on by compiler flags
218 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800219
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500220 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700221 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800222
Colin Cross19878da2019-03-28 14:45:07 -0700223 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700224 protoC bool // Whether to use C instead of C++
225 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700226
227 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200228 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700229}
230
Colin Crossca860ac2016-01-04 14:34:37 -0800231// Properties used to compile all C or C++ modules
232type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700233 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800234 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700235
Jiyong Parkb35a8192020-08-10 15:59:36 +0900236 // The API level that this module is built against. The APIs of this API level will be
237 // visible at build time, but use of any APIs newer than min_sdk_version will render the
238 // module unloadable on older devices. In the future it will be possible to weakly-link new
239 // APIs, making the behavior match Java: such modules will load on older devices, but
240 // calling new APIs on devices that do not support them will result in a crash.
241 //
242 // This property has the same behavior as sdk_version does for Java modules. For those
243 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
244 // does for Java code.
245 //
246 // In addition, setting this property causes two variants to be built, one for the platform
247 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800248 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700249
Jiyong Parkb35a8192020-08-10 15:59:36 +0900250 // Minimum OS API level supported by this C or C++ module. This property becomes the value
251 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
252 // this property is also used to ensure that the min_sdk_version of the containing module is
253 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
254 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
255 // min_sdk_version of the containing APEX. When the module
256 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900257 Min_sdk_version *string
258
Colin Crossc511bc52020-04-07 16:50:32 +0000259 // If true, always create an sdk variant and don't create a platform variant.
260 Sdk_variant_only *bool
261
Jiyong Parkde866cb2018-12-07 23:08:36 +0900262 AndroidMkSharedLibs []string `blueprint:"mutated"`
263 AndroidMkStaticLibs []string `blueprint:"mutated"`
264 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
265 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700266 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900267 HideFromMake bool `blueprint:"mutated"`
268 PreventInstall bool `blueprint:"mutated"`
269 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700270
Yo Chiang219968c2020-09-22 18:45:04 +0800271 // Set by DepsMutator.
272 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
273
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200274 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900275 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200276
277 // The VNDK version this module is built against. If empty, the module is not
278 // build against the VNDK.
279 VndkVersion string `blueprint:"mutated"`
280
281 // Suffix for the name of Android.mk entries generated by this module
282 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800283
284 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
285 // file
286 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900287
Yifan Hong39143a92020-10-26 12:43:12 -0700288 // Make this module available when building for ramdisk.
289 // On device without a dedicated recovery partition, the module is only
290 // available after switching root into
291 // /first_stage_ramdisk. To expose the module before switching root, install
292 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800293 Ramdisk_available *bool
294
Yifan Hong39143a92020-10-26 12:43:12 -0700295 // Make this module available when building for vendor ramdisk.
296 // On device without a dedicated recovery partition, the module is only
297 // available after switching root into
298 // /first_stage_ramdisk. To expose the module before switching root, install
299 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700300 Vendor_ramdisk_available *bool
301
Jiyong Parkf9332f12018-02-01 00:54:12 +0900302 // Make this module available when building for recovery
303 Recovery_available *bool
304
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200305 // Used by imageMutator, set by ImageMutatorBegin()
306 CoreVariantNeeded bool `blueprint:"mutated"`
307 RamdiskVariantNeeded bool `blueprint:"mutated"`
308 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
309 RecoveryVariantNeeded bool `blueprint:"mutated"`
310
311 // A list of variations for the "image" mutator of the form
312 //<image name> '.' <version char>, for example, 'vendor.S'
313 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900314
315 // Allows this module to use non-APEX version of libraries. Useful
316 // for building binaries that are started before APEXes are activated.
317 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900318
319 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
320 // see soong/cc/config/vndk.go
321 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900322
323 // Used by vendor snapshot to record dependencies from snapshot modules.
324 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900325 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900326 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000327
Colin Cross1bc94122021-10-28 13:25:54 -0700328 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000329
330 // Set by factories of module types that can only be referenced from variants compiled against
331 // the SDK.
332 AlwaysSdk bool `blueprint:"mutated"`
333
334 // Variant is an SDK variant created by sdkMutator
335 IsSdkVariant bool `blueprint:"mutated"`
336 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
337 // variant to have a ".sdk" suffix.
338 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700339
340 // Normally Soong uses the directory structure to decide which modules
341 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800342 // different snapshots (vendor, recovery, etc.), but this property
343 // allows a partner to exclude a module normally thought of as a
344 // framework module from the vendor snapshot.
345 Exclude_from_vendor_snapshot *bool
346
347 // Normally Soong uses the directory structure to decide which modules
348 // should be included (framework) or excluded (non-framework) from the
349 // different snapshots (vendor, recovery, etc.), but this property
350 // allows a partner to exclude a module normally thought of as a
351 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800352 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900353
354 // List of APEXes that this module has private access to for testing purpose. The module
355 // can depend on libraries that are not exported by the APEXes and use private symbols
356 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000357 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800358
359 Target struct {
360 Platform struct {
361 // List of modules required by the core variant.
362 Required []string `android:"arch_variant"`
363
364 // List of modules not required by the core variant.
365 Exclude_required []string `android:"arch_variant"`
366 } `android:"arch_variant"`
367
368 Recovery struct {
369 // List of modules required by the recovery variant.
370 Required []string `android:"arch_variant"`
371
372 // List of modules not required by the recovery variant.
373 Exclude_required []string `android:"arch_variant"`
374 } `android:"arch_variant"`
375 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700376}
377
378type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900379 // whether this module should be allowed to be directly depended by other
380 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900381 // If set to true, two variants will be built separately, one like
382 // normal, and the other limited to the set of libraries and headers
383 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700384 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900385 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700386 // so it shouldn't have any unversioned runtime dependencies, or
387 // make assumptions about the system that may not be true in the
388 // future.
389 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900390 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900391 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900392 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900393 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900394 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700395 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
396 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900397
Justin Yunebcf0c52021-01-08 18:00:19 +0900398 // This is the same as the "vendor_available" except that the install path
399 // of the vendor variant is /odm or /vendor/odm.
400 // By replacing "vendor_available: true" with "odm_available: true", the
401 // module will install its vendor variant to the /odm partition or /vendor/odm.
402 // As the modules with "odm_available: true" still create the vendor variants,
403 // they can link to the other vendor modules as the vendor_available modules do.
404 // Also, the vendor modules can link to odm_available modules.
405 //
406 // It may not be used for VNDK modules.
407 Odm_available *bool
408
Justin Yun63e9ec72020-10-29 16:49:43 +0900409 // whether this module should be allowed to be directly depended by other
410 // modules with `product_specific: true` or `product_available: true`.
411 // If set to true, an additional product variant will be built separately
412 // that is limited to the set of libraries and headers that are exposed to
413 // /product modules.
414 //
415 // The product variant may be used with a different (newer) /system,
416 // so it shouldn't have any unversioned runtime dependencies, or
417 // make assumptions about the system that may not be true in the
418 // future.
419 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900420 // If set to false, this module becomes inaccessible from /product modules.
421 //
422 // Different from the 'vendor_available' property, the modules with
423 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
424 // library without 'product_available' may not be depended on by any other
425 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900426 //
427 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
428 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
429 Product_available *bool
430
Jiyong Park5fb8c102018-04-09 12:03:06 +0900431 // whether this module is capable of being loaded with other instance
432 // (possibly an older version) of the same module in the same process.
433 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
434 // can be double loaded in a vendor process if the library is also a
435 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
436 // explicitly marked as `double_loadable: true` by the owner, or the dependency
437 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
438 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800439
440 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
441 IsLLNDK bool `blueprint:"mutated"`
442
Colin Cross78212242021-01-06 14:51:30 -0800443 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
444 // set and the module is not listed in VndkMustUseVendorVariantList.
445 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
446
447 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
448 IsVNDKCore bool `blueprint:"mutated"`
449
450 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
451 IsVNDKSP bool `blueprint:"mutated"`
452
453 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
454 // module sets the llndk.private property.
455 IsVNDKPrivate bool `blueprint:"mutated"`
456
457 // IsVNDKProduct is set if a VNDK module sets the product_available property.
458 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700459
460 // IsVendorPublicLibrary is set for the core and product variants of a library that has
461 // vendor_public_library stubs.
462 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800463}
464
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500465// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
466// to understanding details about the type of the current module.
467// For example, one might call these functions to determine whether the current module is a static
468// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800469type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800470 static() bool
471 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700472 testBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900473 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900474 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900475 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700476 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900477 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700478 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800479 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900480 minSdkVersion() string
481 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700482 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700483 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800484 IsLlndk() bool
485 IsLlndkPublic() bool
486 isImplementationForLLNDKPublic() bool
487 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900488 isVndk() bool
489 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500490 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700491 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900492 inProduct() bool
493 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800494 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700495 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900496 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700497 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700498 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800499 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800500 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800501 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800502 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800503 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700504 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700505 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900506 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800507 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700508 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700509 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800510 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800511 isCfiAssemblySupportEnabled() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800512}
513
514type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700515 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800516 ModuleContextIntf
517}
518
519type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700520 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800521 ModuleContextIntf
522}
523
Colin Cross37047f12016-12-13 17:06:13 -0800524type DepsContext interface {
525 android.BottomUpMutatorContext
526 ModuleContextIntf
527}
528
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500529// feature represents additional (optional) steps to building cc-related modules, such as invocation
530// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800531type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800532 flags(ctx ModuleContext, flags Flags) Flags
533 props() []interface{}
534}
535
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500536// compiler is the interface for a compiler helper object. Different module decorators may implement
537// this helper differently. For example, compiling a `cc_library` may use a different build
538// statement than building a `toolchain_library`.
Colin Crossca860ac2016-01-04 14:34:37 -0800539type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700540 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800541 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800542 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700543 compilerProps() []interface{}
544
Colin Cross76fada02016-07-27 10:31:13 -0700545 appendCflags([]string)
546 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700547 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800548}
549
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500550// linker is the interface for a linker decorator object. Individual module types can provide
551// their own implementation for this decorator, and thus specify custom logic regarding build
552// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800553type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700554 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800555 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700556 linkerFlags(ctx ModuleContext, flags Flags) Flags
557 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800558 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700559
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700560 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700561 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900562 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700563
564 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900565 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000566
567 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000568 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
569}
570
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500571// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000572type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500573 sharedLibs []string
574 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
575 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700576 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800577}
578
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500579// installer is the interface for an installer helper object. This helper is responsible for
580// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800581type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700582 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700583 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000584 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800585 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700586 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700587 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900588 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100589 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900590 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800591}
592
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800593type xref interface {
594 XrefCcFiles() android.Paths
595}
596
Colin Cross6e511a92020-07-27 21:26:48 -0700597type libraryDependencyKind int
598
599const (
600 headerLibraryDependency = iota
601 sharedLibraryDependency
602 staticLibraryDependency
603)
604
605func (k libraryDependencyKind) String() string {
606 switch k {
607 case headerLibraryDependency:
608 return "headerLibraryDependency"
609 case sharedLibraryDependency:
610 return "sharedLibraryDependency"
611 case staticLibraryDependency:
612 return "staticLibraryDependency"
613 default:
614 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
615 }
616}
617
618type libraryDependencyOrder int
619
620const (
621 earlyLibraryDependency = -1
622 normalLibraryDependency = 0
623 lateLibraryDependency = 1
624)
625
626func (o libraryDependencyOrder) String() string {
627 switch o {
628 case earlyLibraryDependency:
629 return "earlyLibraryDependency"
630 case normalLibraryDependency:
631 return "normalLibraryDependency"
632 case lateLibraryDependency:
633 return "lateLibraryDependency"
634 default:
635 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
636 }
637}
638
639// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
640// tags that have a set of predefined tag objects that are reused for each dependency, a
641// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
642// That means that comparing a libraryDependencyTag for equality will only be equal if all
643// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
644// then check individual metadata fields instead.
645type libraryDependencyTag struct {
646 blueprint.BaseDependencyTag
647
648 // These are exported so that fmt.Printf("%#v") can call their String methods.
649 Kind libraryDependencyKind
650 Order libraryDependencyOrder
651
652 wholeStatic bool
653
654 reexportFlags bool
655 explicitlyVersioned bool
656 dataLib bool
657 ndk bool
658
659 staticUnwinder bool
660
661 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900662
Cindy Zhou18417cb2020-12-10 07:12:38 -0800663 // Whether or not this dependency should skip the apex dependency check
664 skipApexAllowedDependenciesCheck bool
665
Jiyong Parke3867542020-12-03 17:28:25 +0900666 // Whether or not this dependency has to be followed for the apex variants
667 excludeInApex bool
Colin Cross6e511a92020-07-27 21:26:48 -0700668}
669
670// header returns true if the libraryDependencyTag is tagging a header lib dependency.
671func (d libraryDependencyTag) header() bool {
672 return d.Kind == headerLibraryDependency
673}
674
675// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
676func (d libraryDependencyTag) shared() bool {
677 return d.Kind == sharedLibraryDependency
678}
679
680// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
681func (d libraryDependencyTag) static() bool {
682 return d.Kind == staticLibraryDependency
683}
684
Colin Crosse9fe2942020-11-10 18:12:15 -0800685// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
686// binaries or other shared libraries are installed as dependencies.
687func (d libraryDependencyTag) InstallDepNeeded() bool {
688 return d.shared()
689}
690
691var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
692
693// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700694// libraryDependencyTag. Each tag object is created globally and reused for multiple
695// dependencies (although since the object contains no references, assigning a tag to a
696// variable and modifying it will not modify the original). Users can compare the tag
697// returned by ctx.OtherModuleDependencyTag against the global original
698type dependencyTag struct {
699 blueprint.BaseDependencyTag
700 name string
701}
702
Colin Crosse9fe2942020-11-10 18:12:15 -0800703// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
704// libraryDependencyTag, but where the dependency needs to be installed when the parent is
705// installed.
706type installDependencyTag struct {
707 blueprint.BaseDependencyTag
708 android.InstallAlwaysNeededDependencyTag
709 name string
710}
711
Colin Crossc99deeb2016-04-11 15:06:20 -0700712var (
Colin Cross6e511a92020-07-27 21:26:48 -0700713 genSourceDepTag = dependencyTag{name: "gen source"}
714 genHeaderDepTag = dependencyTag{name: "gen header"}
715 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
716 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900717 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700718 reuseObjTag = dependencyTag{name: "reuse objects"}
719 staticVariantTag = dependencyTag{name: "static variant"}
720 vndkExtDepTag = dependencyTag{name: "vndk extends"}
721 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700722 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800723 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700724 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700725 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700726)
727
Roland Levillainf89cd092019-07-29 16:22:59 +0100728func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700729 ccLibDepTag, ok := depTag.(libraryDependencyTag)
730 return ok && ccLibDepTag.shared()
731}
732
733func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
734 ccLibDepTag, ok := depTag.(libraryDependencyTag)
735 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100736}
737
Zach Johnson3df4e632020-11-06 11:56:27 -0800738func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
739 ccLibDepTag, ok := depTag.(libraryDependencyTag)
740 return ok && ccLibDepTag.header()
741}
742
Roland Levillainf89cd092019-07-29 16:22:59 +0100743func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800744 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100745}
746
747func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700748 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100749 return ok && ccDepTag == testPerSrcDepTag
750}
751
Colin Crossca860ac2016-01-04 14:34:37 -0800752// Module contains the properties and members used by all C/C++ module types, and implements
753// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500754// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
755// interface.
756//
757// To define a C/C++ related module, construct a new Module object and point its delegates to
758// type-specific structs. These delegates will be invoked to register module-specific build
759// statements which may be unique to the module type. For example, module.compiler.compile() should
760// be defined so as to register build statements which are responsible for compiling the module.
761//
762// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
763// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
764// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
765// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800766type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700767 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700768
Jiyong Parkd1063c12019-07-17 20:08:41 +0900769 android.SdkBase
Liz Kammerea6666f2021-02-17 10:17:28 -0500770 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700771
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700772 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700773 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700774
Colin Crossca860ac2016-01-04 14:34:37 -0800775 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700776 hod android.HostOrDeviceSupported
777 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700778
Paul Duffina0843f62019-12-13 19:50:38 +0000779 // Allowable SdkMemberTypes of this module type.
780 sdkMemberTypes []android.SdkMemberType
781
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500782 // decorator delegates, initialize before calling Init
783 // these may contain module-specific implementations, and effectively allow for custom
784 // type-specific logic. These members may reference different objects or the same object.
785 // Functions of these decorators will be invoked to initialize and register type-specific
786 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500787 compiler compiler
788 linker linker
789 installer installer
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux0d990452021-08-11 16:46:13 +0000790 bazelHandler android.BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500791
792 features []feature
793 stl *stl
794 sanitize *sanitize
795 coverage *coverage
796 sabi *sabi
797 vndkdep *vndkdep
798 lto *lto
799 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800800
Colin Cross31076b32020-10-23 17:22:06 -0700801 library libraryInterface
802
Colin Cross635c3b02016-05-18 15:37:25 -0700803 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800804
Colin Crossb98c8b02016-07-29 13:44:28 -0700805 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700806
807 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800808
809 // Flags used to compile this module
810 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700811
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800812 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700813 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900814
815 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800816 // Kythe (source file indexer) paths for this compilation module
817 kytheFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900818
819 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700820 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700821
822 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700823}
824
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200825func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400826 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
827 if b, ok := c.compiler.(*baseCompiler); ok {
828 hasAidl = b.hasSrcExt(".aidl")
829 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
830 hasProto = b.hasSrcExt(".proto")
831 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
832 hasSysprop = b.hasSrcExt(".sysprop")
833 hasWinMsg = b.hasSrcExt(".mc")
834 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
835 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200836 c.AndroidModuleBase().AddJSONData(d)
837 (*d)["Cc"] = map[string]interface{}{
838 "SdkVersion": c.SdkVersion(),
839 "MinSdkVersion": c.MinSdkVersion(),
840 "VndkVersion": c.VndkVersion(),
841 "ProductSpecific": c.ProductSpecific(),
842 "SocSpecific": c.SocSpecific(),
843 "DeviceSpecific": c.DeviceSpecific(),
844 "InProduct": c.InProduct(),
845 "InVendor": c.InVendor(),
846 "InRamdisk": c.InRamdisk(),
847 "InVendorRamdisk": c.InVendorRamdisk(),
848 "InRecovery": c.InRecovery(),
849 "VendorAvailable": c.VendorAvailable(),
850 "ProductAvailable": c.ProductAvailable(),
851 "RamdiskAvailable": c.RamdiskAvailable(),
852 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
853 "RecoveryAvailable": c.RecoveryAvailable(),
854 "OdmAvailable": c.OdmAvailable(),
855 "InstallInData": c.InstallInData(),
856 "InstallInRamdisk": c.InstallInRamdisk(),
857 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
858 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
859 "InstallInRecovery": c.InstallInRecovery(),
860 "InstallInRoot": c.InstallInRoot(),
861 "IsVndk": c.IsVndk(),
862 "IsVndkExt": c.IsVndkExt(),
863 "IsVndkPrivate": c.IsVndkPrivate(),
864 "IsVndkSp": c.IsVndkSp(),
865 "IsLlndk": c.IsLlndk(),
866 "IsLlndkPublic": c.IsLlndkPublic(),
867 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
868 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
869 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
870 "ApexSdkVersion": c.apexSdkVersion,
871 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400872 "AidlSrcs": hasAidl,
873 "LexSrcs": hasLex,
874 "ProtoSrcs": hasProto,
875 "RenderscriptSrcs": hasRenderscript,
876 "SyspropSrcs": hasSysprop,
877 "WinMsgSrcs": hasWinMsg,
878 "YaccSrsc": hasYacc,
879 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200880 }
881}
882
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500883func (c *Module) SetPreventInstall() {
884 c.Properties.PreventInstall = true
885}
886
887func (c *Module) SetHideFromMake() {
888 c.Properties.HideFromMake = true
889}
890
Ivan Lozanod7586b62021-04-01 09:49:36 -0400891func (c *Module) HiddenFromMake() bool {
892 return c.Properties.HideFromMake
893}
894
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800895func (c *Module) RequiredModuleNames() []string {
896 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
897 if c.ImageVariation().Variation == android.CoreVariation {
898 required = append(required, c.Properties.Target.Platform.Required...)
899 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
900 } else if c.InRecovery() {
901 required = append(required, c.Properties.Target.Recovery.Required...)
902 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
903 }
904 return android.FirstUniqueStrings(required)
905}
906
Ivan Lozano52767be2019-10-18 14:49:46 -0700907func (c *Module) Toc() android.OptionalPath {
908 if c.linker != nil {
909 if library, ok := c.linker.(libraryInterface); ok {
910 return library.toc()
911 }
912 }
913 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
914}
915
916func (c *Module) ApiLevel() string {
917 if c.linker != nil {
918 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700919 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700920 }
921 }
922 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
923}
924
925func (c *Module) Static() bool {
926 if c.linker != nil {
927 if library, ok := c.linker.(libraryInterface); ok {
928 return library.static()
929 }
930 }
931 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
932}
933
934func (c *Module) Shared() bool {
935 if c.linker != nil {
936 if library, ok := c.linker.(libraryInterface); ok {
937 return library.shared()
938 }
939 }
940 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
941}
942
943func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000944 if c.stl != nil {
945 return c.stl.Properties.SelectedStl
946 }
947 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700948}
949
950func (c *Module) ToolchainLibrary() bool {
951 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
952 return true
953 }
954 return false
955}
956
957func (c *Module) NdkPrebuiltStl() bool {
958 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
959 return true
960 }
961 return false
962}
963
964func (c *Module) StubDecorator() bool {
965 if _, ok := c.linker.(*stubDecorator); ok {
966 return true
967 }
968 return false
969}
970
971func (c *Module) SdkVersion() string {
972 return String(c.Properties.Sdk_version)
973}
974
Artur Satayev480e25b2020-04-27 18:53:18 +0100975func (c *Module) MinSdkVersion() string {
976 return String(c.Properties.Min_sdk_version)
977}
978
Jiyong Park5df7bd32021-08-25 16:18:46 +0900979func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -0700980 if linker, ok := c.linker.(*objectLinker); ok {
981 return linker.isCrt()
982 }
983 return false
984}
985
Jiyong Park5df7bd32021-08-25 16:18:46 +0900986func (c *Module) SplitPerApiLevel() bool {
987 return c.canUseSdk() && c.isCrt()
988}
989
Colin Crossc511bc52020-04-07 16:50:32 +0000990func (c *Module) AlwaysSdk() bool {
991 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
992}
993
Ivan Lozano183a3212019-10-18 14:18:45 -0700994func (c *Module) CcLibrary() bool {
995 if c.linker != nil {
996 if _, ok := c.linker.(*libraryDecorator); ok {
997 return true
998 }
Colin Crossd48fe732020-09-23 20:37:24 -0700999 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1000 return true
1001 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001002 }
1003 return false
1004}
1005
1006func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001007 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001008 return true
1009 }
1010 return false
1011}
1012
Ivan Lozano2b262972019-11-21 12:30:50 -08001013func (c *Module) NonCcVariants() bool {
1014 return false
1015}
1016
Ivan Lozano183a3212019-10-18 14:18:45 -07001017func (c *Module) SetStatic() {
1018 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001019 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001020 library.setStatic()
1021 return
1022 }
1023 }
1024 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1025}
1026
1027func (c *Module) SetShared() {
1028 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001029 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001030 library.setShared()
1031 return
1032 }
1033 }
1034 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1035}
1036
1037func (c *Module) BuildStaticVariant() bool {
1038 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001039 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001040 return library.buildStatic()
1041 }
1042 }
1043 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1044}
1045
1046func (c *Module) BuildSharedVariant() bool {
1047 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001048 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001049 return library.buildShared()
1050 }
1051 }
1052 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1053}
1054
1055func (c *Module) Module() android.Module {
1056 return c
1057}
1058
Jiyong Parkc20eee32018-09-05 22:36:17 +09001059func (c *Module) OutputFile() android.OptionalPath {
1060 return c.outputFile
1061}
1062
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001063func (c *Module) CoverageFiles() android.Paths {
1064 if c.linker != nil {
1065 if library, ok := c.linker.(libraryInterface); ok {
1066 return library.objs().coverageFiles
1067 }
1068 }
1069 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1070}
1071
Ivan Lozano183a3212019-10-18 14:18:45 -07001072var _ LinkableInterface = (*Module)(nil)
1073
Jiyong Park719b4462019-01-13 00:39:51 +09001074func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001075 if c.linker != nil {
1076 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001077 }
1078 return nil
1079}
1080
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001081func (c *Module) CoverageOutputFile() android.OptionalPath {
1082 if c.linker != nil {
1083 return c.linker.coverageOutputFilePath()
1084 }
1085 return android.OptionalPath{}
1086}
1087
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001088func (c *Module) RelativeInstallPath() string {
1089 if c.installer != nil {
1090 return c.installer.relativeInstallPath()
1091 }
1092 return ""
1093}
1094
Jooyung Han344d5432019-08-23 11:17:39 +09001095func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001096 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001097}
1098
Colin Cross36242852017-06-23 15:06:31 -07001099func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001100 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001101 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001102 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001103 }
1104 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001105 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001106 }
1107 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001108 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001109 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001110 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001111 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001112 }
Colin Cross16b23492016-01-06 14:41:07 -08001113 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001114 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001115 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001116 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001117 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001118 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001119 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001120 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001121 }
Justin Yun8effde42017-06-23 19:24:43 +09001122 if c.vndkdep != nil {
1123 c.AddProperties(c.vndkdep.props()...)
1124 }
Stephen Craneba090d12017-05-09 15:44:35 -07001125 if c.lto != nil {
1126 c.AddProperties(c.lto.props()...)
1127 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001128 if c.pgo != nil {
1129 c.AddProperties(c.pgo.props()...)
1130 }
Colin Crossca860ac2016-01-04 14:34:37 -08001131 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001132 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001133 }
Colin Crossc472d572015-03-17 15:06:21 -07001134
Colin Cross36242852017-06-23 15:06:31 -07001135 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerea6666f2021-02-17 10:17:28 -05001136 android.InitBazelModule(c)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001137 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001138 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001139 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001140
Colin Cross36242852017-06-23 15:06:31 -07001141 return c
Colin Crossc472d572015-03-17 15:06:21 -07001142}
1143
Ivan Lozano52767be2019-10-18 14:49:46 -07001144func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001145 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001146}
1147
Colin Crossc511bc52020-04-07 16:50:32 +00001148func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001149 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1150 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001151}
1152
1153func (c *Module) UseSdk() bool {
1154 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001155 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001156 }
1157 return false
1158}
1159
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001160func (c *Module) isCoverageVariant() bool {
1161 return c.coverage.Properties.IsCoverageVariant
1162}
1163
Colin Cross95f1ca02020-10-29 20:47:22 -07001164func (c *Module) IsNdk(config android.Config) bool {
1165 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001166}
1167
Colin Cross127bb8b2020-12-16 16:46:01 -08001168func (c *Module) IsLlndk() bool {
1169 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001170}
1171
Colin Cross127bb8b2020-12-16 16:46:01 -08001172func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001173 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001174}
1175
Colin Cross1f3f1302021-04-26 18:37:44 -07001176func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001177 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001178 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001179}
1180
Colin Cross5271fea2021-04-27 13:06:04 -07001181func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1182 lib := moduleLibraryInterface(m)
1183 return lib != nil && (lib.hasVendorPublicLibrary())
1184}
1185
1186// IsVendorPublicLibrary returns true for vendor public libraries.
1187func (c *Module) IsVendorPublicLibrary() bool {
1188 return c.VendorProperties.IsVendorPublicLibrary
1189}
1190
Ivan Lozanod7586b62021-04-01 09:49:36 -04001191func (c *Module) HasLlndkStubs() bool {
1192 lib := moduleLibraryInterface(c)
1193 return lib != nil && lib.hasLLNDKStubs()
1194}
1195
1196func (c *Module) StubsVersion() string {
1197 if lib, ok := c.linker.(versionedInterface); ok {
1198 return lib.stubsVersion()
1199 }
1200 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1201}
1202
Colin Cross127bb8b2020-12-16 16:46:01 -08001203// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1204// and does not set llndk.vendor_available: false.
1205func (c *Module) isImplementationForLLNDKPublic() bool {
1206 library, _ := c.library.(*libraryDecorator)
1207 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001208 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001209}
1210
Justin Yunfd9e8042020-12-23 18:23:14 +09001211// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001212func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001213 // Check if VNDK-core-private or VNDK-SP-private
1214 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001215 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001216 }
1217
1218 // Check if LLNDK-private
1219 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001220 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001221 }
1222
1223 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001224}
1225
Ivan Lozano52767be2019-10-18 14:49:46 -07001226func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001227 if vndkdep := c.vndkdep; vndkdep != nil {
1228 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001229 }
1230 return false
1231}
1232
Yi Kong7e53c572018-02-14 18:16:12 +08001233func (c *Module) isPgoCompile() bool {
1234 if pgo := c.pgo; pgo != nil {
1235 return pgo.Properties.PgoCompile
1236 }
1237 return false
1238}
1239
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001240func (c *Module) isNDKStubLibrary() bool {
1241 if _, ok := c.compiler.(*stubDecorator); ok {
1242 return true
1243 }
1244 return false
1245}
1246
Ivan Lozanod7586b62021-04-01 09:49:36 -04001247func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001248 if vndkdep := c.vndkdep; vndkdep != nil {
1249 return vndkdep.isVndkSp()
1250 }
1251 return false
1252}
1253
Ivan Lozanof9e21722020-12-02 09:00:51 -05001254func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001255 if vndkdep := c.vndkdep; vndkdep != nil {
1256 return vndkdep.isVndkExt()
1257 }
1258 return false
1259}
1260
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001261func (c *Module) SubName() string {
1262 return c.Properties.SubName
1263}
1264
Ivan Lozano52767be2019-10-18 14:49:46 -07001265func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001266 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001267}
1268
Logan Chienf3511742017-10-31 18:04:35 +08001269func (c *Module) getVndkExtendsModuleName() string {
1270 if vndkdep := c.vndkdep; vndkdep != nil {
1271 return vndkdep.getVndkExtendsModuleName()
1272 }
1273 return ""
1274}
1275
Jiyong Park25fc6a92018-11-18 18:02:45 +09001276func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001277 if lib := c.library; lib != nil {
1278 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001279 }
1280 return false
1281}
1282
1283func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001284 if lib := c.library; lib != nil {
1285 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001286 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001287 return false
1288}
1289
Colin Cross0477b422020-10-13 18:43:54 -07001290// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1291// the implementation. If it is an implementation library it returns its own name.
1292func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1293 name := ctx.OtherModuleName(c)
1294 if versioned, ok := c.linker.(versionedInterface); ok {
1295 name = versioned.implementationModuleName(name)
1296 }
1297 return name
1298}
1299
Martin Stjernholm2856c662020-12-02 15:03:42 +00001300// Similar to ImplementationModuleName, but uses the Make variant of the module
1301// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1302// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1303// under the premise that the prebuilt module overrides its source counterpart
1304// if it is exposed to Make).
1305func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1306 name := c.BaseModuleName()
1307 if versioned, ok := c.linker.(versionedInterface); ok {
1308 name = versioned.implementationModuleName(name)
1309 }
1310 return name
1311}
1312
Jiyong Park7d55b612021-06-11 17:22:09 +09001313func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001314 return Bool(c.Properties.Bootstrap)
1315}
1316
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001317func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001318 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1319 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1320 return false
1321 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001322 return c.linker != nil && c.linker.nativeCoverage()
1323}
1324
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001325func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001326 if p, ok := c.linker.(SnapshotInterface); ok {
1327 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001328 }
1329 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001330}
1331
Bill Peckham945441c2020-08-31 16:07:58 -07001332func (c *Module) ExcludeFromVendorSnapshot() bool {
1333 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1334}
1335
Jose Galmesf7294582020-11-13 12:07:36 -08001336func (c *Module) ExcludeFromRecoverySnapshot() bool {
1337 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1338}
1339
Jiyong Parkf1194352019-02-25 11:05:47 +09001340func isBionic(name string) bool {
1341 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001342 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001343 return true
1344 }
1345 return false
1346}
1347
Martin Stjernholm279de572019-09-10 23:18:20 +01001348func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001349 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001350 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001351 }
1352 return isBionic(name)
1353}
1354
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001355func (c *Module) XrefCcFiles() android.Paths {
1356 return c.kytheFiles
1357}
1358
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001359func (c *Module) isCfiAssemblySupportEnabled() bool {
1360 return c.sanitize != nil &&
1361 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1362}
1363
Inseob Kim800d1142021-06-14 12:03:51 +09001364func (c *Module) InstallInRoot() bool {
1365 return c.installer != nil && c.installer.installInRoot()
1366}
1367
Colin Crossacfcc1f2021-10-25 15:40:32 -07001368func (c *Module) InstallBypassMake() bool { return true }
1369
Colin Crossca860ac2016-01-04 14:34:37 -08001370type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001371 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001372 moduleContextImpl
1373}
1374
Colin Cross37047f12016-12-13 17:06:13 -08001375type depsContext struct {
1376 android.BottomUpMutatorContext
1377 moduleContextImpl
1378}
1379
Colin Crossca860ac2016-01-04 14:34:37 -08001380type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001381 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001382 moduleContextImpl
1383}
1384
1385type moduleContextImpl struct {
1386 mod *Module
1387 ctx BaseModuleContext
1388}
1389
Colin Crossb98c8b02016-07-29 13:44:28 -07001390func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001391 return ctx.mod.toolchain(ctx.ctx)
1392}
1393
1394func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001395 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001396}
1397
1398func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001399 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001400}
1401
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001402func (ctx *moduleContextImpl) testBinary() bool {
1403 return ctx.mod.testBinary()
1404}
1405
Jiyong Park1d1119f2019-07-29 21:27:18 +09001406func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001407 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001408}
1409
Inseob Kim7f283f42020-06-01 21:53:49 +09001410func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001411 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001412}
1413
Inseob Kim1042d292020-06-01 23:23:05 +09001414func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001415 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001416}
1417
Jooyung Hanccce2f22020-03-07 03:45:53 +09001418func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001419 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001420}
1421
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001422func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001423 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001424}
1425
1426func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001427 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001428 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001429 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001430 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001431 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001432 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001433 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001434 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001435 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001436 }
1437 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001438}
1439
Jiyong Parkb35a8192020-08-10 15:59:36 +09001440func (ctx *moduleContextImpl) minSdkVersion() string {
1441 ver := ctx.mod.MinSdkVersion()
1442 if ver == "apex_inherit" && !ctx.isForPlatform() {
1443 ver = ctx.apexSdkVersion().String()
1444 }
1445 if ver == "apex_inherit" || ver == "" {
1446 ver = ctx.sdkVersion()
1447 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001448 // For crt objects, the meaning of min_sdk_version is very different from other types of
1449 // module. For them, min_sdk_version defines the oldest version that the build system will
1450 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1451 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1452 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001453 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1454 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1455 // support such an old version. The version is set to the later version in case when the
1456 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1457 // it's for an APEX.
1458 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1459 if ctx.isForPlatform() {
1460 ver = strconv.Itoa(android.FutureApiLevelInt)
1461 } else { // for apex
1462 ver = ctx.apexSdkVersion().String()
1463 if ver == "" { // in case when min_sdk_version was not set by the APEX
1464 ver = ctx.sdkVersion()
1465 }
1466 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001467 }
1468
Jiyong Parkb35a8192020-08-10 15:59:36 +09001469 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1470 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1471 minSdkVersionInt, err2 := strconv.Atoi(ver)
1472 if err == nil && err2 == nil {
1473 if sdkVersionInt < minSdkVersionInt {
1474 return strconv.Itoa(sdkVersionInt)
1475 }
1476 }
1477 return ver
1478}
1479
1480func (ctx *moduleContextImpl) isSdkVariant() bool {
1481 return ctx.mod.IsSdkVariant()
1482}
1483
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001484func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001485 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001486}
Justin Yun8effde42017-06-23 19:24:43 +09001487
Colin Cross95f1ca02020-10-29 20:47:22 -07001488func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1489 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001490}
1491
Colin Cross127bb8b2020-12-16 16:46:01 -08001492func (ctx *moduleContextImpl) IsLlndk() bool {
1493 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001494}
1495
Colin Cross127bb8b2020-12-16 16:46:01 -08001496func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1497 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001498}
1499
Colin Cross127bb8b2020-12-16 16:46:01 -08001500func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1501 return ctx.mod.isImplementationForLLNDKPublic()
1502}
1503
1504func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1505 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001506}
1507
Logan Chienf3511742017-10-31 18:04:35 +08001508func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001509 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001510}
1511
Yi Kong7e53c572018-02-14 18:16:12 +08001512func (ctx *moduleContextImpl) isPgoCompile() bool {
1513 return ctx.mod.isPgoCompile()
1514}
1515
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001516func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1517 return ctx.mod.isNDKStubLibrary()
1518}
1519
Justin Yun8effde42017-06-23 19:24:43 +09001520func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001521 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001522}
1523
Ivan Lozanof9e21722020-12-02 09:00:51 -05001524func (ctx *moduleContextImpl) IsVndkExt() bool {
1525 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001526}
1527
Colin Cross5271fea2021-04-27 13:06:04 -07001528func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1529 return ctx.mod.IsVendorPublicLibrary()
1530}
1531
Vic Yangefd249e2018-11-12 20:19:56 -08001532func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001533 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001534}
1535
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001536func (ctx *moduleContextImpl) selectedStl() string {
1537 if stl := ctx.mod.stl; stl != nil {
1538 return stl.Properties.SelectedStl
1539 }
1540 return ""
1541}
1542
Ivan Lozanobd721262018-11-27 14:33:03 -08001543func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1544 return ctx.mod.linker.useClangLld(actx)
1545}
1546
Colin Crossce75d2c2016-10-06 16:12:58 -07001547func (ctx *moduleContextImpl) baseModuleName() string {
1548 return ctx.mod.ModuleBase.BaseModuleName()
1549}
1550
Logan Chienf3511742017-10-31 18:04:35 +08001551func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1552 return ctx.mod.getVndkExtendsModuleName()
1553}
1554
Logan Chiene274fc92019-12-03 11:18:32 -08001555func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001556 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001557}
1558
Colin Crosse07f2312020-08-13 11:24:56 -07001559func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001560 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001561}
1562
Dan Albertc8060532020-07-22 22:32:17 -07001563func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001564 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001565}
1566
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001567func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001568 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001569}
1570
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001571func (ctx *moduleContextImpl) nativeCoverage() bool {
1572 return ctx.mod.nativeCoverage()
1573}
1574
Colin Cross56a83212020-09-15 18:30:11 -07001575func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1576 return ctx.mod.DirectlyInAnyApex()
1577}
1578
Colin Cross95b07f22020-12-16 11:06:50 -08001579func (ctx *moduleContextImpl) isPreventInstall() bool {
1580 return ctx.mod.Properties.PreventInstall
1581}
1582
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001583func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1584 return ctx.mod.isCfiAssemblySupportEnabled()
1585}
1586
Colin Cross635c3b02016-05-18 15:37:25 -07001587func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001588 return &Module{
1589 hod: hod,
1590 multilib: multilib,
1591 }
1592}
1593
Colin Cross635c3b02016-05-18 15:37:25 -07001594func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001595 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001596 module.features = []feature{
1597 &tidyFeature{},
1598 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001599 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001600 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001601 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001602 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001603 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001604 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001605 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001606 return module
1607}
1608
Colin Crossce75d2c2016-10-06 16:12:58 -07001609func (c *Module) Prebuilt() *android.Prebuilt {
1610 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1611 return p.prebuilt()
1612 }
1613 return nil
1614}
1615
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001616func (c *Module) IsPrebuilt() bool {
1617 return c.Prebuilt() != nil
1618}
1619
Colin Crossce75d2c2016-10-06 16:12:58 -07001620func (c *Module) Name() string {
1621 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001622 if p, ok := c.linker.(interface {
1623 Name(string) string
1624 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001625 name = p.Name(name)
1626 }
1627 return name
1628}
1629
Alex Light3d673592019-01-18 14:37:31 -08001630func (c *Module) Symlinks() []string {
1631 if p, ok := c.installer.(interface {
1632 symlinkList() []string
1633 }); ok {
1634 return p.symlinkList()
1635 }
1636 return nil
1637}
1638
Roland Levillainf89cd092019-07-29 16:22:59 +01001639func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1640 test, ok := c.linker.(testPerSrc)
1641 return ok && test.isAllTestsVariation()
1642}
1643
Chris Parsons216e10a2020-07-09 17:12:52 -04001644func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001645 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001646 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001647 }); ok {
1648 return p.dataPaths()
1649 }
1650 return nil
1651}
1652
Justin Yun5f7f7e82019-11-18 19:52:14 +09001653func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1654 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1655 // "current", it will append the VNDK version to the name suffix.
1656 var vndkVersion string
1657 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001658 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001659 if c.ProductSpecific() {
1660 // If the module is product specific with 'product_specific: true',
1661 // do not add a name suffix because it is a base module.
1662 return ""
1663 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001664 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001665 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001666 } else {
1667 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001668 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001669 }
1670 if vndkVersion == "current" {
1671 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1672 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001673 if c.Properties.VndkVersion != vndkVersion && c.Properties.VndkVersion != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001674 // add version suffix only if the module is using different vndk version than the
1675 // version in product or vendor partition.
1676 nameSuffix += "." + c.Properties.VndkVersion
1677 }
1678 return nameSuffix
1679}
1680
Chris Parsons8d6e4332021-02-22 16:13:50 -05001681func (c *Module) setSubnameProperty(actx android.ModuleContext) {
Inseob Kim64c43952019-08-26 16:52:35 +09001682 c.Properties.SubName = ""
1683
1684 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07001685 c.Properties.SubName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001686 }
1687
Colin Cross127bb8b2020-12-16 16:46:01 -08001688 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001689 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001690 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1691 // added for product variant only when we have vendor and product variants with core
1692 // variant. The suffix is not added for vendor-only or product-only module.
1693 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
Colin Cross5271fea2021-04-27 13:06:04 -07001694 } else if c.IsVendorPublicLibrary() {
1695 c.Properties.SubName += vendorPublicLibrarySuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001696 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001697 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1698 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001699 c.Properties.SubName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001700 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07001701 c.Properties.SubName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001702 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001703 c.Properties.SubName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001704 } else if c.InRecovery() && !c.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08001705 c.Properties.SubName += RecoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001706 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001707 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001708 if c.SplitPerApiLevel() {
1709 c.Properties.SubName += "." + c.SdkVersion()
1710 }
Inseob Kim64c43952019-08-26 16:52:35 +09001711 }
Chris Parsons8d6e4332021-02-22 16:13:50 -05001712}
1713
1714// Returns true if Bazel was successfully used for the analysis of this module.
1715func (c *Module) maybeGenerateBazelActions(actx android.ModuleContext) bool {
Liz Kammerbdc60992021-02-24 16:55:11 -05001716 bazelModuleLabel := c.GetBazelLabel(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001717 bazelActionsUsed := false
Chris Parsons18266212021-09-23 13:42:38 -04001718 // Mixed builds mode is disabled for modules outside of device OS.
1719 // TODO(b/200841190): Support non-device OS in mixed builds.
Chris Parsons494eef32021-11-09 10:29:52 -05001720 if c.MixedBuildsEnabled(actx) && c.bazelHandler != nil {
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux0d990452021-08-11 16:46:13 +00001721 bazelActionsUsed = c.bazelHandler.GenerateBazelBuildActions(actx, bazelModuleLabel)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001722 }
1723 return bazelActionsUsed
1724}
1725
1726func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
1727 // TODO(cparsons): Any logic in this method occurring prior to querying Bazel should be
1728 // requested from Bazel instead.
1729
1730 // Handle the case of a test module split by `test_per_src` mutator.
1731 //
1732 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1733 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1734 // module and return early, as this module does not produce an output file per se.
1735 if c.IsTestPerSrcAllTestsVariation() {
1736 c.outputFile = android.OptionalPath{}
1737 return
1738 }
1739
1740 c.setSubnameProperty(actx)
1741 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1742 if !apexInfo.IsForPlatform() {
1743 c.hideApexVariantFromMake = true
1744 }
1745
Chris Parsonseefc9e62021-04-02 17:36:47 -04001746 c.makeLinkType = GetMakeLinkType(actx, c)
1747
Colin Crossca860ac2016-01-04 14:34:37 -08001748 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001749 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001750 moduleContextImpl: moduleContextImpl{
1751 mod: c,
1752 },
1753 }
1754 ctx.ctx = ctx
1755
Chris Parsons94a0bba2021-06-04 15:03:47 -04001756 if c.maybeGenerateBazelActions(actx) {
1757 c.maybeInstall(ctx, apexInfo)
1758 return
1759 }
1760
Colin Crossf18e1102017-11-16 14:33:08 -08001761 deps := c.depsToPaths(ctx)
1762 if ctx.Failed() {
1763 return
1764 }
1765
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001766 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1767 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1768 }
1769
Colin Crossca860ac2016-01-04 14:34:37 -08001770 flags := Flags{
1771 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001772 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001773 }
Colin Crossca860ac2016-01-04 14:34:37 -08001774 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001775 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001776 }
1777 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001778 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001779 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001780 if c.stl != nil {
1781 flags = c.stl.flags(ctx, flags)
1782 }
Colin Cross16b23492016-01-06 14:41:07 -08001783 if c.sanitize != nil {
1784 flags = c.sanitize.flags(ctx, flags)
1785 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001786 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001787 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001788 }
Stephen Craneba090d12017-05-09 15:44:35 -07001789 if c.lto != nil {
1790 flags = c.lto.flags(ctx, flags)
1791 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001792 if c.pgo != nil {
1793 flags = c.pgo.flags(ctx, flags)
1794 }
Colin Crossca860ac2016-01-04 14:34:37 -08001795 for _, feature := range c.features {
1796 flags = feature.flags(ctx, flags)
1797 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001798 if ctx.Failed() {
1799 return
1800 }
1801
Colin Cross4af21ed2019-11-04 09:37:55 -08001802 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1803 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1804 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001805
Colin Cross4af21ed2019-11-04 09:37:55 -08001806 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001807
1808 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001809 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001810 }
1811 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001812 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001813 }
1814
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001815 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001816 // We need access to all the flags seen by a source file.
1817 if c.sabi != nil {
1818 flags = c.sabi.flags(ctx, flags)
1819 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001820
Colin Cross4af21ed2019-11-04 09:37:55 -08001821 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001822
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001823 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001824 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001825 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001826 if ctx.Failed() {
1827 return
1828 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001829 c.kytheFiles = objs.kytheFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001830 }
1831
Colin Crossca860ac2016-01-04 14:34:37 -08001832 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001833 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001834 if ctx.Failed() {
1835 return
1836 }
Colin Cross635c3b02016-05-18 15:37:25 -07001837 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001838
Chris Parsons94a0bba2021-06-04 15:03:47 -04001839 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001840
Jose Galmes6f843bc2020-12-11 13:36:29 -08001841 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1842 // RECOVERY_SNAPSHOT_VERSION is current.
1843 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001844 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001845 i.collectHeadersForSnapshot(ctx)
1846 }
1847 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001848 }
Colin Cross5049f022015-03-18 13:28:46 -07001849
Chris Parsons94a0bba2021-06-04 15:03:47 -04001850 c.maybeInstall(ctx, apexInfo)
1851}
1852
1853func (c *Module) maybeUnhideFromMake() {
1854 // If a lib is directly included in any of the APEXes or is not available to the
1855 // platform (which is often the case when the stub is provided as a prebuilt),
1856 // unhide the stubs variant having the latest version gets visible to make. In
1857 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
1858 // force anything in the make world to link against the stubs library. (unless it
1859 // is explicitly referenced via .bootstrap suffix or the module is marked with
1860 // 'bootstrap: true').
1861 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
1862 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
1863 c.IsStubs() && !c.InVendorRamdisk() {
1864 c.Properties.HideFromMake = false // unhide
1865 // Note: this is still non-installable
1866 }
1867}
1868
1869func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07001870 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001871 // If the module has been specifically configure to not be installed then
1872 // hide from make as otherwise it will break when running inside make
1873 // as the output path to install will not be specified. Not all uninstallable
1874 // modules can be hidden from make as some are needed for resolving make side
1875 // dependencies.
1876 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04001877 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001878 c.SkipInstall()
1879 }
1880
1881 // Still call c.installer.install though, the installs will be stored as PackageSpecs
1882 // to allow using the outputs in a genrule.
1883 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001884 c.installer.install(ctx, c.outputFile.Path())
1885 if ctx.Failed() {
1886 return
Colin Crossca860ac2016-01-04 14:34:37 -08001887 }
Dan Albertc403f7c2015-03-18 14:01:18 -07001888 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001889}
1890
Colin Cross0ea8ba82019-06-06 14:33:29 -07001891func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001892 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05001893 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08001894 }
Colin Crossca860ac2016-01-04 14:34:37 -08001895 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001896}
1897
Colin Crossca860ac2016-01-04 14:34:37 -08001898func (c *Module) begin(ctx BaseModuleContext) {
1899 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001900 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001901 }
Colin Crossca860ac2016-01-04 14:34:37 -08001902 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001903 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001904 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001905 if c.stl != nil {
1906 c.stl.begin(ctx)
1907 }
Colin Cross16b23492016-01-06 14:41:07 -08001908 if c.sanitize != nil {
1909 c.sanitize.begin(ctx)
1910 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001911 if c.coverage != nil {
1912 c.coverage.begin(ctx)
1913 }
Stephen Craneba090d12017-05-09 15:44:35 -07001914 if c.lto != nil {
1915 c.lto.begin(ctx)
1916 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001917 if c.pgo != nil {
1918 c.pgo.begin(ctx)
1919 }
Dan Albert92fe7402020-07-15 13:33:30 -07001920 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001921 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001922 if err != nil {
1923 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001924 c.Properties.Sdk_version = nil
1925 } else {
1926 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001927 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001928 }
Colin Crossca860ac2016-01-04 14:34:37 -08001929}
1930
Colin Cross37047f12016-12-13 17:06:13 -08001931func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001932 deps := Deps{}
1933
1934 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001935 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001936 }
1937 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001938 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001939 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001940 if c.stl != nil {
1941 deps = c.stl.deps(ctx, deps)
1942 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001943 if c.coverage != nil {
1944 deps = c.coverage.deps(ctx, deps)
1945 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001946
Colin Crossb6715442017-10-24 11:13:31 -07001947 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1948 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1949 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1950 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1951 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1952 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001953 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001954
Liz Kammer356f7d42021-01-26 09:18:53 -05001955 // In Bazel conversion mode, we dependency and build validations will occur in Bazel, so there is
1956 // no need to do so in Soong.
1957 if ctx.BazelConversionMode() {
1958 return deps
1959 }
1960
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001961 for _, lib := range deps.ReexportSharedLibHeaders {
1962 if !inList(lib, deps.SharedLibs) {
1963 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1964 }
1965 }
1966
1967 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00001968 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
1969 ctx.PropertyErrorf("export_static_lib_headers", "Static library not in static_libs or whole_static_libs: '%s'", lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001970 }
1971 }
1972
Colin Cross5950f382016-12-13 12:50:57 -08001973 for _, lib := range deps.ReexportHeaderLibHeaders {
1974 if !inList(lib, deps.HeaderLibs) {
1975 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
1976 }
1977 }
1978
Dan Willemsenb3454ab2016-09-28 17:34:58 -07001979 for _, gen := range deps.ReexportGeneratedHeaders {
1980 if !inList(gen, deps.GeneratedHeaders) {
1981 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
1982 }
1983 }
1984
Colin Crossc99deeb2016-04-11 15:06:20 -07001985 return deps
1986}
1987
Dan Albert7e9d2952016-08-04 13:02:36 -07001988func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08001989 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001990 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001991 moduleContextImpl: moduleContextImpl{
1992 mod: c,
1993 },
1994 }
1995 ctx.ctx = ctx
1996
Colin Crossca860ac2016-01-04 14:34:37 -08001997 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07001998}
1999
Jiyong Park7ed9de32018-10-15 22:25:07 +09002000// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002001func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002002 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2003 version := name[sharp+1:]
2004 libname := name[:sharp]
2005 return libname, version
2006 }
2007 return name, ""
2008}
2009
Dan Albert92fe7402020-07-15 13:33:30 -07002010func GetCrtVariations(ctx android.BottomUpMutatorContext,
2011 m LinkableInterface) []blueprint.Variation {
2012 if ctx.Os() != android.Android {
2013 return nil
2014 }
2015 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002016 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2017 minSdkVersion := m.MinSdkVersion()
2018 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2019 minSdkVersion = m.SdkVersion()
2020 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002021 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2022 if err != nil {
2023 ctx.PropertyErrorf("min_sdk_version", err.Error())
2024 }
Dan Albert92fe7402020-07-15 13:33:30 -07002025 return []blueprint.Variation{
2026 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002027 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002028 }
2029 }
2030 return []blueprint.Variation{
2031 {Mutator: "sdk", Variation: ""},
2032 }
2033}
2034
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002035func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2036 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002037
2038 variations = append([]blueprint.Variation(nil), variations...)
2039
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002040 if version != "" && CanBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002041 // Version is explicitly specified. i.e. libFoo#30
2042 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002043 if tag, ok := depTag.(libraryDependencyTag); ok {
2044 tag.explicitlyVersioned = true
2045 } else {
2046 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2047 }
Colin Crosse7257d22020-09-24 09:56:18 -07002048 }
Colin Crosse7257d22020-09-24 09:56:18 -07002049
Colin Cross0de8a1e2020-09-18 14:15:30 -07002050 if far {
2051 ctx.AddFarVariationDependencies(variations, depTag, name)
2052 } else {
2053 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002054 }
2055}
2056
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002057func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002058 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002059 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002060 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002061 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2062 // between the modules in the snapshot and the snapshot itself.
2063 var snapshotModule []blueprint.Module
2064 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2065 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2066 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2067 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2068 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002069 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002070 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2071 *snapshotInfo = &snapshot
2072 // republish the snapshot for use in later mutators on this module
2073 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002074 }
2075 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002076 if *snapshotInfo == nil {
2077 *snapshotInfo = &SnapshotInfo{}
2078 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002079 return **snapshotInfo
2080}
2081
2082func RewriteSnapshotLib(lib string, snapshotMap map[string]string) string {
2083 if snapshot, ok := snapshotMap[lib]; ok {
2084 return snapshot
2085 }
2086
2087 return lib
2088}
2089
2090// RewriteLibs takes a list of names of shared libraries and scans it for three types
2091// of names:
2092//
2093// 1. Name of an NDK library that refers to a prebuilt module.
2094// For each of these, it adds the name of the prebuilt module (which will be in
2095// prebuilts/ndk) to the list of nonvariant libs.
2096// 2. Name of an NDK library that refers to an ndk_library module.
2097// For each of these, it adds the name of the ndk_library module to the list of
2098// variant libs.
2099// 3. Anything else (so anything that isn't an NDK library).
2100// It adds these to the nonvariantLibs list.
2101//
2102// The caller can then know to add the variantLibs dependencies differently from the
2103// nonvariantLibs
2104func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2105 variantLibs = []string{}
2106
2107 nonvariantLibs = []string{}
2108 for _, entry := range list {
2109 // strip #version suffix out
2110 name, _ := StubsLibNameAndVersion(entry)
2111 if c.InRecovery() {
2112 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2113 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2114 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2115 } else if c.UseVndk() {
2116 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2117 } else {
2118 // put name#version back
2119 nonvariantLibs = append(nonvariantLibs, entry)
2120 }
2121 }
2122 return nonvariantLibs, variantLibs
2123}
2124
Colin Cross1e676be2016-10-12 14:38:15 -07002125func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002126 if !c.Enabled() {
2127 return
2128 }
2129
Colin Cross37047f12016-12-13 17:06:13 -08002130 ctx := &depsContext{
2131 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002132 moduleContextImpl: moduleContextImpl{
2133 mod: c,
2134 },
2135 }
2136 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002137
Colin Crossc99deeb2016-04-11 15:06:20 -07002138 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002139
Yo Chiang219968c2020-09-22 18:45:04 +08002140 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2141
Colin Crosse0edaf92021-01-11 17:31:17 -08002142 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002143
Dan Albert914449f2016-06-17 16:45:24 -07002144 variantNdkLibs := []string{}
2145 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002146 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002147 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2148 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2149 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002150
2151 for idx, lib := range deps.RuntimeLibs {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002152 deps.RuntimeLibs[idx] = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002153 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002154 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002155
Colin Cross32ec36c2016-12-15 07:39:51 -08002156 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002157 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002158 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002159 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002160 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002161
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002162 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002163
Jiyong Park1ad8e162020-12-01 23:40:09 +09002164 if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002165 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002166 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002167 } else {
2168 actx.AddVariationDependencies(nil, depTag, lib)
2169 }
2170 }
2171
Dan Albertf1d14c72020-07-30 14:32:55 -07002172 if c.isNDKStubLibrary() {
2173 // NDK stubs depend on their implementation because the ABI dumps are
2174 // generated from the implementation library.
2175 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2176 c.ImageVariation(),
2177 blueprint.Variation{Mutator: "link", Variation: "shared"},
2178 ), stubImplementation, c.BaseModuleName())
2179 }
2180
Inseob Kim07def122020-11-23 14:43:02 +09002181 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
2182 // C++ implementation library and one Java implementation library. When a module links against
2183 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
2184 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
2185 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09002186 syspropImplLibraries := syspropImplLibraries(actx.Config())
2187
Jiyong Park5d1598f2019-02-25 22:14:17 +09002188 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002189 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09002190 if impl, ok := syspropImplLibraries[lib]; ok {
2191 lib = impl
2192 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002193
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002194 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002195
Jiyong Park5d1598f2019-02-25 22:14:17 +09002196 actx.AddVariationDependencies([]blueprint.Variation{
2197 {Mutator: "link", Variation: "static"},
2198 }, depTag, lib)
2199 }
2200
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002201 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002202 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002203 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002204 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002205 }
Jiyong Parke3867542020-12-03 17:28:25 +09002206 if inList(lib, deps.ExcludeLibsForApex) {
2207 depTag.excludeInApex = true
2208 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002209
2210 if impl, ok := syspropImplLibraries[lib]; ok {
2211 lib = impl
2212 }
2213
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002214 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002215
Dan Willemsen59339a22018-07-22 21:18:45 -07002216 actx.AddVariationDependencies([]blueprint.Variation{
2217 {Mutator: "link", Variation: "static"},
2218 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002219 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002220
Jooyung Han75568392020-03-20 04:29:24 +09002221 // staticUnwinderDep is treated as staticDep for Q apexes
2222 // so that native libraries/binaries are linked with static unwinder
2223 // because Q libc doesn't have unwinder APIs
2224 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002225 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002226 actx.AddVariationDependencies([]blueprint.Variation{
2227 {Mutator: "link", Variation: "static"},
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002228 }, depTag, RewriteSnapshotLib(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002229 }
2230
Jiyong Park7ed9de32018-10-15 22:25:07 +09002231 // shared lib names without the #version suffix
2232 var sharedLibNames []string
2233
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002234 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002235 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002236 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002237 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002238 }
Jiyong Parke3867542020-12-03 17:28:25 +09002239 if inList(lib, deps.ExcludeLibsForApex) {
2240 depTag.excludeInApex = true
2241 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002242
2243 if impl, ok := syspropImplLibraries[lib]; ok {
2244 lib = impl
2245 }
2246
Jiyong Park73c54ee2019-10-22 20:31:18 +09002247 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002248 sharedLibNames = append(sharedLibNames, name)
2249
Colin Crosse7257d22020-09-24 09:56:18 -07002250 variations := []blueprint.Variation{
2251 {Mutator: "link", Variation: "shared"},
2252 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002253 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002254 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002255
Colin Crossfe9acfe2021-06-14 16:13:03 -07002256 for _, lib := range deps.LateStaticLibs {
2257 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2258 actx.AddVariationDependencies([]blueprint.Variation{
2259 {Mutator: "link", Variation: "static"},
2260 }, depTag, RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
2261 }
2262
Jiyong Park7ed9de32018-10-15 22:25:07 +09002263 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002264 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002265 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2266 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2267 // linking against both the stubs lib and the non-stubs lib at the same time.
2268 continue
2269 }
Colin Cross6e511a92020-07-27 21:26:48 -07002270 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002271 variations := []blueprint.Variation{
2272 {Mutator: "link", Variation: "shared"},
2273 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002274 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002275 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002276
Dan Willemsen59339a22018-07-22 21:18:45 -07002277 actx.AddVariationDependencies([]blueprint.Variation{
2278 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002279 }, dataLibDepTag, deps.DataLibs...)
2280
Colin Crossc8caa062021-09-24 16:50:14 -07002281 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2282
Chris Parsons79d66a52020-06-05 17:26:16 -04002283 actx.AddVariationDependencies([]blueprint.Variation{
2284 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002285 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002286
Colin Cross68861832016-07-08 10:41:41 -07002287 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002288
2289 for _, gen := range deps.GeneratedHeaders {
2290 depTag := genHeaderDepTag
2291 if inList(gen, deps.ReexportGeneratedHeaders) {
2292 depTag = genHeaderExportDepTag
2293 }
2294 actx.AddDependency(c, depTag, gen)
2295 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002296
Dan Albert92fe7402020-07-15 13:33:30 -07002297 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002298 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002299 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002300 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002301 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002302 }
Colin Crossc465efd2021-06-11 18:00:04 -07002303 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002304 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002305 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002306 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002307 if deps.DynamicLinker != "" {
2308 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002309 }
Dan Albert914449f2016-06-17 16:45:24 -07002310
2311 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002312
2313 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002314 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002315 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002316 {Mutator: "link", Variation: "shared"},
2317 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002318
2319 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002320 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002321 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002322 {Mutator: "link", Variation: "shared"},
2323 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002324
2325 if vndkdep := c.vndkdep; vndkdep != nil {
2326 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002327 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002328 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002329 {Mutator: "link", Variation: "shared"},
Justin Yun27b95722021-07-28 17:04:44 +09002330 }, vndkExtDepTag, RewriteSnapshotLib(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002331 }
2332 }
Colin Cross6362e272015-10-29 15:25:03 -07002333}
Colin Cross21b9a242015-03-24 14:15:58 -07002334
Colin Crosse40b4ea2018-10-02 22:25:58 -07002335func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002336 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2337 c.beginMutator(ctx)
2338 }
2339}
2340
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002341// Whether a module can link to another module, taking into
2342// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002343func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002344 tag blueprint.DependencyTag) {
2345
2346 switch t := tag.(type) {
2347 case dependencyTag:
2348 if t != vndkExtDepTag {
2349 return
2350 }
2351 case libraryDependencyTag:
2352 default:
2353 return
2354 }
2355
Ivan Lozanof9e21722020-12-02 09:00:51 -05002356 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002357 // Host code is not restricted
2358 return
2359 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002360
2361 // VNDK is cc.Module supported only for now.
2362 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002363 // Though allowed dependency is limited by the image mutator,
2364 // each vendor and product module needs to check link-type
2365 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002366 if ccTo, ok := to.(*Module); ok {
2367 if ccFrom.vndkdep != nil {
2368 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2369 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002370 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002371 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002372 }
2373 return
2374 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002375 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002376 // Platform code can link to anything
2377 return
2378 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002379 if from.InRamdisk() {
2380 // Ramdisk code is not NDK
2381 return
2382 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002383 if from.InVendorRamdisk() {
2384 // Vendor ramdisk code is not NDK
2385 return
2386 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002387 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002388 // Recovery code is not NDK
2389 return
2390 }
Colin Cross31076b32020-10-23 17:22:06 -07002391 if c, ok := to.(*Module); ok {
2392 if c.ToolchainLibrary() {
2393 // These are always allowed
2394 return
2395 }
2396 if c.NdkPrebuiltStl() {
2397 // These are allowed, but they don't set sdk_version
2398 return
2399 }
2400 if c.StubDecorator() {
2401 // These aren't real libraries, but are the stub shared libraries that are included in
2402 // the NDK.
2403 return
2404 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002405 }
Logan Chien834b9a62019-01-14 15:39:03 +08002406
Ivan Lozano52767be2019-10-18 14:49:46 -07002407 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002408 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2409 // to link to libc++ (non-NDK and without sdk_version).
2410 return
2411 }
2412
Ivan Lozano52767be2019-10-18 14:49:46 -07002413 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002414 // NDK code linking to platform code is never okay.
2415 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002416 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002417 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002418 }
2419
2420 // At this point we know we have two NDK libraries, but we need to
2421 // check that we're not linking against anything built against a higher
2422 // API level, as it is only valid to link against older or equivalent
2423 // APIs.
2424
Inseob Kim01a28722018-04-11 09:48:45 +09002425 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002426 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002427 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002428 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002429 // Current can't be linked against by anything else.
2430 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002431 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002432 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002433 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002434 if err != nil {
2435 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002436 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002437 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002438 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002439 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002440 if err != nil {
2441 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002442 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002443 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002444 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002445
Inseob Kim01a28722018-04-11 09:48:45 +09002446 if toApi > fromApi {
2447 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002448 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002449 }
2450 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002451 }
Dan Albert202fe492017-12-15 13:56:59 -08002452
2453 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002454 fromStl := from.SelectedStl()
2455 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002456 if fromStl == "" || toStl == "" {
2457 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002458 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002459 // We can be permissive with the system "STL" since it is only the C++
2460 // ABI layer, but in the future we should make sure that everyone is
2461 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002462 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002463 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002464 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2465 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002466 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002467}
2468
Jooyung Han479ca172020-10-19 18:51:07 +09002469func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2470 if c, ok := ctx.Module().(*Module); ok {
2471 ctx.VisitDirectDeps(func(dep android.Module) {
2472 depTag := ctx.OtherModuleDependencyTag(dep)
2473 ccDep, ok := dep.(LinkableInterface)
2474 if ok {
2475 checkLinkType(ctx, c, ccDep, depTag)
2476 }
2477 })
2478 }
2479}
2480
Jiyong Park5fb8c102018-04-09 12:03:06 +09002481// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002482// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2483// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002484// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002485func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2486 check := func(child, parent android.Module) bool {
2487 to, ok := child.(*Module)
2488 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002489 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002490 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002491
Jooyung Hana70f0672019-01-18 15:20:43 +09002492 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2493 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002494 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002495
Jiyong Park0474e1f2021-01-14 14:26:06 +09002496 // These dependencies are not excercised at runtime. Tracking these will give us
2497 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002498 depTag := ctx.OtherModuleDependencyTag(child)
2499 if IsHeaderDepTag(depTag) {
2500 return false
2501 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002502 if depTag == staticVariantTag {
2503 return false
2504 }
2505 if depTag == stubImplDepTag {
2506 return false
2507 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002508
Justin Yun63e9ec72020-10-29 16:49:43 +09002509 // Even if target lib has no vendor variant, keep checking dependency
2510 // graph in case it depends on vendor_available or product_available
2511 // but not double_loadable transtively.
2512 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002513 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002514 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002515
Jiyong Park0474e1f2021-01-14 14:26:06 +09002516 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2517 // one.
2518 if Bool(to.VendorProperties.Double_loadable) {
2519 return true
2520 }
2521
Ivan Lozanod7586b62021-04-01 09:49:36 -04002522 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002523 return false
2524 }
2525
Jooyung Hana70f0672019-01-18 15:20:43 +09002526 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2527 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002528 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002529 return false
2530 }
2531 if module, ok := ctx.Module().(*Module); ok {
2532 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002533 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002534 ctx.WalkDeps(check)
2535 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002536 }
2537 }
2538}
2539
Colin Crossc99deeb2016-04-11 15:06:20 -07002540// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002541func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002542 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002543
Colin Cross0de8a1e2020-09-18 14:15:30 -07002544 var directStaticDeps []StaticLibraryInfo
2545 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002546
Colin Cross0de8a1e2020-09-18 14:15:30 -07002547 reexportExporter := func(exporter FlagExporterInfo) {
2548 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2549 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2550 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2551 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2552 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002553 }
2554
Jooyung Hande34d232020-07-23 13:04:15 +09002555 // For the dependency from platform to apex, use the latest stubs
2556 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002557 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2558 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002559 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002560 }
2561
2562 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2563 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2564 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2565 // (b/144430859)
2566 c.apexSdkVersion = android.FutureApiLevel
2567 }
2568
Colin Crossd11fcda2017-10-23 17:59:01 -07002569 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002570 depName := ctx.OtherModuleName(dep)
2571 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002572
Ivan Lozano52767be2019-10-18 14:49:46 -07002573 ccDep, ok := dep.(LinkableInterface)
2574 if !ok {
2575
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002576 // handling for a few module types that aren't cc Module but that are also supported
2577 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002578 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002579 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002580 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2581 genRule.GeneratedSourceFiles()...)
2582 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002583 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002584 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002585 // Support exported headers from a generated_sources dependency
2586 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002587 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002588 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002589 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002590 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002591 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002592 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002593 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002594 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002595 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2596 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002597 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002598 // 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 +09002599 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002600
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002601 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002602 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002603 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002604 }
Colin Crosscef792e2021-06-11 18:01:26 -07002605 case CrtBeginDepTag:
2606 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2607 case CrtEndDepTag:
2608 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002609 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002610 return
2611 }
2612
Colin Crossfe17f6f2019-03-28 19:30:56 -07002613 if depTag == android.ProtoPluginDepTag {
2614 return
2615 }
2616
Colin Crossd11fcda2017-10-23 17:59:01 -07002617 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002618 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2619 return
2620 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002621 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002622 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2623 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002624 return
2625 }
2626
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002627 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002628 // Skip reused objects for stub libraries, they use their own stub object file instead.
2629 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2630 // version mutator, so the stubs variant is created from the shared variant that
2631 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002632 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002633 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2634 objs := staticAnalogue.ReuseObjects
2635 depPaths.Objs = depPaths.Objs.Append(objs)
2636 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2637 reexportExporter(depExporterInfo)
2638 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002639 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002640 }
2641
Colin Cross6e511a92020-07-27 21:26:48 -07002642 linkFile := ccDep.OutputFile()
2643
2644 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2645 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002646 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002647 return
2648 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002649
Jiyong Parke3867542020-12-03 17:28:25 +09002650 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2651 return
2652 }
2653
Colin Cross0de8a1e2020-09-18 14:15:30 -07002654 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002655
Colin Cross6e511a92020-07-27 21:26:48 -07002656 var ptr *android.Paths
2657 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002658
Colin Cross6e511a92020-07-27 21:26:48 -07002659 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002660
Colin Cross6e511a92020-07-27 21:26:48 -07002661 switch {
2662 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002663 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2664 if !ctx.Config().AllowMissingDependencies() {
2665 ctx.ModuleErrorf("module %q is not a header library", depName)
2666 } else {
2667 ctx.AddMissingDependencies([]string{depName})
2668 }
2669 return
2670 }
Colin Cross6e511a92020-07-27 21:26:48 -07002671 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002672 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2673 if !ctx.Config().AllowMissingDependencies() {
2674 ctx.ModuleErrorf("module %q is not a shared library", depName)
2675 } else {
2676 ctx.AddMissingDependencies([]string{depName})
2677 }
2678 return
2679 }
Jiyong Parke3867542020-12-03 17:28:25 +09002680
Jiyong Park7d55b612021-06-11 17:22:09 +09002681 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
2682 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002683
Jiyong Park1ad8e162020-12-01 23:40:09 +09002684 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2685 // linkFile, depFile, and ptr.
2686 if c.IsStubs() {
2687 break
2688 }
2689
Colin Cross0de8a1e2020-09-18 14:15:30 -07002690 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2691 depFile = sharedLibraryInfo.TableOfContents
2692
Colin Cross6e511a92020-07-27 21:26:48 -07002693 ptr = &depPaths.SharedLibs
2694 switch libDepTag.Order {
2695 case earlyLibraryDependency:
2696 ptr = &depPaths.EarlySharedLibs
2697 depPtr = &depPaths.EarlySharedLibsDeps
2698 case normalLibraryDependency:
2699 ptr = &depPaths.SharedLibs
2700 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002701 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002702 case lateLibraryDependency:
2703 ptr = &depPaths.LateSharedLibs
2704 depPtr = &depPaths.LateSharedLibsDeps
2705 default:
2706 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002707 }
Colin Cross6e511a92020-07-27 21:26:48 -07002708 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002709 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2710 if !ctx.Config().AllowMissingDependencies() {
2711 ctx.ModuleErrorf("module %q is not a static library", depName)
2712 } else {
2713 ctx.AddMissingDependencies([]string{depName})
2714 }
2715 return
2716 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002717
2718 // Stubs lib doesn't link to the static lib dependencies. Don't set
2719 // linkFile, depFile, and ptr.
2720 if c.IsStubs() {
2721 break
2722 }
2723
Colin Cross0de8a1e2020-09-18 14:15:30 -07002724 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2725 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002726 if libDepTag.wholeStatic {
2727 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002728 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2729 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002730 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002731 // This case normally catches prebuilt static
2732 // libraries, but it can also occur when
2733 // AllowMissingDependencies is on and the
2734 // dependencies has no sources of its own
2735 // but has a whole_static_libs dependency
2736 // on a missing library. We want to depend
2737 // on the .a file so that there is something
2738 // in the dependency tree that contains the
2739 // error rule for the missing transitive
2740 // dependency.
2741 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002742 }
Colin Cross6e511a92020-07-27 21:26:48 -07002743 } else {
2744 switch libDepTag.Order {
2745 case earlyLibraryDependency:
2746 panic(fmt.Errorf("early static libs not suppported"))
2747 case normalLibraryDependency:
2748 // static dependencies will be handled separately so they can be ordered
2749 // using transitive dependencies.
2750 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002751 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002752 case lateLibraryDependency:
2753 ptr = &depPaths.LateStaticLibs
2754 default:
2755 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002756 }
2757 }
2758 }
2759
Colin Cross6e511a92020-07-27 21:26:48 -07002760 if libDepTag.static() && !libDepTag.wholeStatic {
2761 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2762 ctx.ModuleErrorf("module %q not a static library", depName)
2763 return
2764 }
Logan Chien43d34c32017-12-20 01:17:32 +08002765
Colin Cross6e511a92020-07-27 21:26:48 -07002766 // When combining coverage files for shared libraries and executables, coverage files
2767 // in static libraries act as if they were whole static libraries. The same goes for
2768 // source based Abi dump files.
2769 if c, ok := ccDep.(*Module); ok {
2770 staticLib := c.linker.(libraryInterface)
2771 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2772 staticLib.objs().coverageFiles...)
2773 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2774 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002775 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002776 // Handle non-CC modules here
2777 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002778 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002779 }
2780 }
2781
Colin Cross6e511a92020-07-27 21:26:48 -07002782 if ptr != nil {
2783 if !linkFile.Valid() {
2784 if !ctx.Config().AllowMissingDependencies() {
2785 ctx.ModuleErrorf("module %q missing output file", depName)
2786 } else {
2787 ctx.AddMissingDependencies([]string{depName})
2788 }
2789 return
2790 }
2791 *ptr = append(*ptr, linkFile.Path())
2792 }
2793
2794 if depPtr != nil {
2795 dep := depFile
2796 if !dep.Valid() {
2797 dep = linkFile
2798 }
2799 *depPtr = append(*depPtr, dep.Path())
2800 }
2801
Colin Cross0de8a1e2020-09-18 14:15:30 -07002802 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2803 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2804 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2805 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2806
2807 if libDepTag.reexportFlags {
2808 reexportExporter(depExporterInfo)
2809 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2810 // Re-exported shared library headers must be included as well since they can help us with type information
2811 // about template instantiations (instantiated from their headers).
2812 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2813 // scripts.
2814 c.sabi.Properties.ReexportedIncludes = append(
2815 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2816 }
2817
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002818 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002819 switch {
2820 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002821 c.Properties.AndroidMkHeaderLibs = append(
2822 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002823 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002824 if lib := moduleLibraryInterface(dep); lib != nil {
2825 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002826 // Add the dependency to the APEX(es) providing the library so that
2827 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002828 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09002829 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07002830 c.Properties.ApexesProvidingSharedLibs = append(
2831 c.Properties.ApexesProvidingSharedLibs, an)
2832 }
2833 }
2834 }
2835
2836 // Note: the order of libs in this list is not important because
2837 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002838 c.Properties.AndroidMkSharedLibs = append(
2839 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002840 // Record BaseLibName for snapshots.
2841 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002842 case libDepTag.static():
2843 if libDepTag.wholeStatic {
2844 c.Properties.AndroidMkWholeStaticLibs = append(
2845 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2846 } else {
2847 c.Properties.AndroidMkStaticLibs = append(
2848 c.Properties.AndroidMkStaticLibs, makeLibName)
2849 }
Justin Yun5e035862021-06-29 20:50:37 +09002850 // Record BaseLibName for snapshots.
2851 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002852 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002853 } else if !c.IsStubs() {
2854 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
2855
Colin Cross6e511a92020-07-27 21:26:48 -07002856 switch depTag {
2857 case runtimeDepTag:
2858 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002859 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002860 // Record BaseLibName for snapshots.
2861 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002862 case objDepTag:
2863 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2864 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002865 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002866 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002867 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002868 case dynamicLinkerDepTag:
2869 depPaths.DynamicLinker = linkFile
2870 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002871 }
Colin Crossca860ac2016-01-04 14:34:37 -08002872 })
2873
Jeff Gaston294356f2017-09-27 17:05:30 -07002874 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002875 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2876 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2877 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002878
Colin Crossdd84e052017-05-17 13:44:16 -07002879 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002880 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002881 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2882 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002883 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002884 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2885 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002886 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002887 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002888 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002889
2890 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002891 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002892 }
Colin Crossdd84e052017-05-17 13:44:16 -07002893
Colin Crossca860ac2016-01-04 14:34:37 -08002894 return depPaths
2895}
2896
Jiyong Park7d55b612021-06-11 17:22:09 +09002897// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
2898// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
2899// dependency. The stub variant is selected when the dependency crosses a boundary where each side
2900// has different level of updatability. For example, if a library foo in an APEX depends on a
2901// library bar which provides stable interface and exists in the platform, foo uses the stub variant
2902// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
2903// same APEX as foo, the non-stub variant of bar is used.
2904func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
2905 depName := ctx.OtherModuleName(dep)
2906 depTag := ctx.OtherModuleDependencyTag(dep)
2907 libDepTag, ok := depTag.(libraryDependencyTag)
2908 if !ok || !libDepTag.shared() {
2909 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2910 }
2911
2912 thisModule, ok := ctx.Module().(android.ApexModule)
2913 if !ok {
2914 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
2915 }
2916
2917 useVndk := false
2918 bootstrap := false
2919 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
2920 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
2921 } else {
2922 useVndk = linkable.UseVndk()
2923 bootstrap = linkable.Bootstrap()
2924 }
2925
2926 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
2927 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2928 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
2929 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2930
2931 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
2932 useStubs := false
2933
2934 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
2935 if !apexInfo.IsForPlatform() {
2936 // For platform libraries, use current version of LLNDK
2937 // If this is for use_vendor apex we will apply the same rules
2938 // of apex sdk enforcement below to choose right version.
2939 useStubs = true
2940 }
Jiyong Park9477c262021-06-22 20:23:05 +09002941 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
2942 // If not building for APEX or the containing APEX allows the use of
2943 // platform APIs, use stubs only when it is from an APEX (and not from
2944 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
2945 // bootstrap modules, always link to non-stub variant
Jiyong Park7d55b612021-06-11 17:22:09 +09002946 useStubs = dep.(android.ApexModule).NotInPlatform() && !bootstrap
2947 if useStubs {
2948 // Another exception: if this module is a test for an APEX, then
2949 // it is linked with the non-stub variant of a module in the APEX
2950 // as if this is part of the APEX.
2951 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2952 for _, apexContents := range testFor.ApexContents {
2953 if apexContents.DirectlyInApex(depName) {
2954 useStubs = false
2955 break
2956 }
2957 }
2958 }
2959 if useStubs {
2960 // Yet another exception: If this module and the dependency are
2961 // available to the same APEXes then skip stubs between their
2962 // platform variants. This complements the test_for case above,
2963 // which avoids the stubs on a direct APEX library dependency, by
2964 // avoiding stubs for indirect test dependencies as well.
2965 //
2966 // TODO(b/183882457): This doesn't work if the two libraries have
2967 // only partially overlapping apex_available. For that test_for
2968 // modules would need to be split into APEX variants and resolved
2969 // separately for each APEX they have access to.
2970 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
2971 useStubs = false
2972 }
2973 }
2974 } else {
2975 // If building for APEX, use stubs when the parent is in any APEX that
2976 // the child is not in.
2977 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
2978 }
2979
2980 // when to use (unspecified) stubs, use the latest one.
2981 if useStubs {
2982 stubs := sharedLibraryStubsInfo.SharedStubLibraries
2983 toUse := stubs[len(stubs)-1]
2984 sharedLibraryInfo = toUse.SharedLibraryInfo
2985 depExporterInfo = toUse.FlagExporterInfo
2986 }
2987 }
2988 return sharedLibraryInfo, depExporterInfo
2989}
2990
Colin Cross0de8a1e2020-09-18 14:15:30 -07002991// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
2992// to match the topological order of the dependency tree, including any static analogues of
2993// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
2994// of the transitive dependencies.
2995func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
2996 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
2997 var staticPaths android.Paths
2998 for _, staticDep := range staticDeps {
2999 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3000 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3001 }
3002 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003003 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3004 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003005 }
3006 }
3007 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3008
3009 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3010
3011 // reorder the dependencies based on transitive dependencies
3012 staticPaths = android.FirstUniquePaths(staticPaths)
3013 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3014
3015 if len(orderedStaticPaths) != len(staticPaths) {
3016 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3017 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3018 }
3019
3020 return orderedStaticPaths, transitiveStaticLibs
3021}
3022
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003023// BaseLibName trims known prefixes and suffixes
3024func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003025 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3026 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003027 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003028 return libName
3029}
3030
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003031func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003032 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003033 ccDepModule, _ := ccDep.(*Module)
3034 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003035 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003036
Justin Yuncbca3732021-02-03 19:24:13 +09003037 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003038 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07003039 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003040 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003041 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003042
Ivan Lozanod1dec542021-05-26 15:33:11 -04003043 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003044 }
3045 }
3046
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003047 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3048 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003049 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3050 // core module instead.
3051 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003052 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003053 // The vendor and product modules in Make will have been renamed to not conflict with the
3054 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003055 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003056 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003057 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003058 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003059 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003060 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003061 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003062 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003063 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003064 } else {
3065 return libName
3066 }
3067}
3068
Colin Crossca860ac2016-01-04 14:34:37 -08003069func (c *Module) InstallInData() bool {
3070 if c.installer == nil {
3071 return false
3072 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003073 return c.installer.inData()
3074}
3075
3076func (c *Module) InstallInSanitizerDir() bool {
3077 if c.installer == nil {
3078 return false
3079 }
3080 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003081 return true
3082 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003083 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003084}
3085
Yifan Hong1b3348d2020-01-21 15:53:22 -08003086func (c *Module) InstallInRamdisk() bool {
3087 return c.InRamdisk()
3088}
3089
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003090func (c *Module) InstallInVendorRamdisk() bool {
3091 return c.InVendorRamdisk()
3092}
3093
Jiyong Parkf9332f12018-02-01 00:54:12 +09003094func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003095 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003096}
3097
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003098func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003099 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003100 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003101 return
3102 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003103 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003104}
3105
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003106func (c *Module) HostToolPath() android.OptionalPath {
3107 if c.installer == nil {
3108 return android.OptionalPath{}
3109 }
3110 return c.installer.hostToolPath()
3111}
3112
Nan Zhangd4e641b2017-07-12 12:55:28 -07003113func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3114 return c.outputFile
3115}
3116
Colin Cross41955e82019-05-29 14:40:35 -07003117func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3118 switch tag {
3119 case "":
3120 if c.outputFile.Valid() {
3121 return android.Paths{c.outputFile.Path()}, nil
3122 }
3123 return android.Paths{}, nil
3124 default:
3125 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003126 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003127}
3128
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003129func (c *Module) static() bool {
3130 if static, ok := c.linker.(interface {
3131 static() bool
3132 }); ok {
3133 return static.static()
3134 }
3135 return false
3136}
3137
Jiyong Park379de2f2018-12-19 02:47:14 +09003138func (c *Module) staticBinary() bool {
3139 if static, ok := c.linker.(interface {
3140 staticBinary() bool
3141 }); ok {
3142 return static.staticBinary()
3143 }
3144 return false
3145}
3146
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003147func (c *Module) testBinary() bool {
3148 if test, ok := c.linker.(interface {
3149 testBinary() bool
3150 }); ok {
3151 return test.testBinary()
3152 }
3153 return false
3154}
3155
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003156// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3157func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003158 if h, ok := c.linker.(interface {
3159 header() bool
3160 }); ok {
3161 return h.header()
3162 }
3163 return false
3164}
3165
Ivan Lozanod7586b62021-04-01 09:49:36 -04003166func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003167 if b, ok := c.linker.(interface {
3168 binary() bool
3169 }); ok {
3170 return b.binary()
3171 }
3172 return false
3173}
3174
Justin Yun5e035862021-06-29 20:50:37 +09003175func (c *Module) StaticExecutable() bool {
3176 if b, ok := c.linker.(*binaryDecorator); ok {
3177 return b.static()
3178 }
3179 return false
3180}
3181
Ivan Lozanod7586b62021-04-01 09:49:36 -04003182func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003183 if o, ok := c.linker.(interface {
3184 object() bool
3185 }); ok {
3186 return o.object()
3187 }
3188 return false
3189}
3190
Ivan Lozanof9e21722020-12-02 09:00:51 -05003191func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003192 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003193 if c.IsLlndk() {
3194 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003195 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003196 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003197 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003198 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003199 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003200 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003201 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003202 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003203 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003204 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003205 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003206 return "native:product"
3207 }
Jooyung Han38002912019-05-16 04:01:54 +09003208 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003209 } else if c.InRamdisk() {
3210 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003211 } else if c.InVendorRamdisk() {
3212 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003213 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003214 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003215 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003216 return "native:ndk:none:none"
3217 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3218 //family, link := getNdkStlFamilyAndLinkType(c)
3219 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003220 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003221 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003222 } else {
3223 return "native:platform"
3224 }
3225}
3226
Jiyong Park9d452992018-10-03 00:38:19 +09003227// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003228// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003229func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003230 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003231 // Stub libs and prebuilt libs in a versioned SDK are not
3232 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003233 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003234 } else if _, ok := c.linker.(testPerSrc); ok {
3235 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003236 }
3237 return false
3238}
3239
Jiyong Parka90ca002019-10-07 15:47:24 +09003240func (c *Module) AvailableFor(what string) bool {
3241 if linker, ok := c.linker.(interface {
3242 availableFor(string) bool
3243 }); ok {
3244 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3245 } else {
3246 return c.ApexModuleBase.AvailableFor(what)
3247 }
3248}
3249
Jiyong Park62304bb2020-04-13 16:19:48 +09003250func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003251 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003252}
3253
Paul Duffin0cb37b92020-03-04 14:52:46 +00003254func (c *Module) EverInstallable() bool {
3255 return c.installer != nil &&
3256 // Check to see whether the module is actually ever installable.
3257 c.installer.everInstallable()
3258}
3259
Ivan Lozanod7586b62021-04-01 09:49:36 -04003260func (c *Module) PreventInstall() bool {
3261 return c.Properties.PreventInstall
3262}
3263
3264func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003265 if c.library != nil {
3266 if i := c.library.installable(); i != nil {
3267 return i
3268 }
3269 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003270 return c.Properties.Installable
3271}
3272
3273func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003274 ret := c.EverInstallable() &&
3275 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003276 proptools.BoolDefault(c.Installable(), true) &&
3277 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003278
3279 // The platform variant doesn't need further condition. Apex variants however might not
3280 // be installable because it will likely to be included in the APEX and won't appear
3281 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003282 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003283 return ret
3284 }
3285
3286 // Special case for modules that are configured to be installed to /data, which includes
3287 // test modules. For these modules, both APEX and non-APEX variants are considered as
3288 // installable. This is because even the APEX variants won't be included in the APEX, but
3289 // will anyway be installed to /data/*.
3290 // See b/146995717
3291 if c.InstallInData() {
3292 return ret
3293 }
3294
3295 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003296}
3297
Logan Chien41eabe62019-04-10 13:33:58 +08003298func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3299 if c.linker != nil {
3300 if library, ok := c.linker.(*libraryDecorator); ok {
3301 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3302 }
3303 }
3304}
3305
Jiyong Park45bf82e2020-12-15 22:29:02 +09003306var _ android.ApexModule = (*Module)(nil)
3307
3308// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003309func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003310 depTag := ctx.OtherModuleDependencyTag(dep)
3311 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3312
3313 if cc, ok := dep.(*Module); ok {
3314 if cc.HasStubsVariants() {
3315 if isLibDepTag && libDepTag.shared() {
3316 // dynamic dep to a stubs lib crosses APEX boundary
3317 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003318 }
Colin Cross6e511a92020-07-27 21:26:48 -07003319 if IsRuntimeDepTag(depTag) {
3320 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003321 return false
3322 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003323 }
Zhijun Heec285872021-04-24 10:47:08 -07003324 if cc.IsLlndk() {
3325 return false
3326 }
Colin Crossaac32222020-07-29 12:51:56 -07003327 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003328 // shared_lib dependency from a static lib is considered as crossing
3329 // the APEX boundary because the dependency doesn't actually is
3330 // linked; the dependency is used only during the compilation phase.
3331 return false
3332 }
Jiyong Parke3867542020-12-03 17:28:25 +09003333
3334 if isLibDepTag && libDepTag.excludeInApex {
3335 return false
3336 }
Colin Cross6e511a92020-07-27 21:26:48 -07003337 }
Colin Crossc1b36442021-05-06 13:42:48 -07003338 if depTag == stubImplDepTag {
3339 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003340 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003341 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003342 if depTag == staticVariantTag {
3343 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3344 // actually mean that the static lib (and its dependencies) are copied into the
3345 // APEX.
3346 return false
3347 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003348 return true
3349}
3350
Jiyong Park45bf82e2020-12-15 22:29:02 +09003351// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003352func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3353 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003354 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3355 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3356 return nil
3357 }
3358 // b/154569636: set min_sdk_version correctly for toolchain_libraries
3359 if c.ToolchainLibrary() {
3360 return nil
3361 }
3362 // We don't check for prebuilt modules
3363 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3364 return nil
3365 }
3366 minSdkVersion := c.MinSdkVersion()
3367 if minSdkVersion == "apex_inherit" {
3368 return nil
3369 }
3370 if minSdkVersion == "" {
3371 // JNI libs within APK-in-APEX fall into here
3372 // Those are okay to set sdk_version instead
3373 // We don't have to check if this is a SDK variant because
3374 // non-SDK variant resets sdk_version, which works too.
3375 minSdkVersion = c.SdkVersion()
3376 }
Dan Albertc8060532020-07-22 22:32:17 -07003377 if minSdkVersion == "" {
3378 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3379 }
3380 // Not using nativeApiLevelFromUser because the context here is not
3381 // necessarily a native context.
3382 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003383 if err != nil {
3384 return err
3385 }
Dan Albertc8060532020-07-22 22:32:17 -07003386
3387 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003388 return fmt.Errorf("newer SDK(%v)", ver)
3389 }
3390 return nil
3391}
3392
Paul Duffinb5769c12021-05-12 16:16:51 +01003393// Implements android.ApexModule
3394func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3395 // stub libraries and native bridge libraries are always available to platform
3396 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3397}
3398
Rob Seymour925aa092021-08-10 20:42:03 +00003399var _ snapshot.RelativeInstallPath = (*Module)(nil)
3400
Colin Cross2ba19d92015-05-07 15:44:20 -07003401//
Colin Crosscfad1192015-11-02 16:43:11 -08003402// Defaults
3403//
Colin Crossca860ac2016-01-04 14:34:37 -08003404type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003405 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003406 android.DefaultsModuleBase
Liz Kammer3cf52112021-03-31 15:42:03 -04003407 // Included to support setting bazel_module.label for multiple Soong modules to the same Bazel
3408 // target. This is primarily useful for modules that were architecture specific and instead are
3409 // handled in Bazel as a select().
3410 android.BazelModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003411 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003412}
3413
Patrice Arrudac249c712019-03-19 17:00:29 -07003414// cc_defaults provides a set of properties that can be inherited by other cc
3415// modules. A module can use the properties from a cc_defaults using
3416// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3417// merged (when possible) by prepending the default module's values to the
3418// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003419func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003420 return DefaultsFactory()
3421}
3422
Colin Cross36242852017-06-23 15:06:31 -07003423func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003424 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003425
Colin Cross36242852017-06-23 15:06:31 -07003426 module.AddProperties(props...)
3427 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003428 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003429 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003430 &BaseCompilerProperties{},
3431 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003432 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003433 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003434 &StaticProperties{},
3435 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003436 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003437 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003438 &TestProperties{},
3439 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003440 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003441 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003442 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003443 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003444 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003445 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003446 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003447 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003448 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003449 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003450 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003451 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003452 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003453 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3454 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003455 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003456 )
Colin Crosscfad1192015-11-02 16:43:11 -08003457
Liz Kammer3cf52112021-03-31 15:42:03 -04003458 // Bazel module must be initialized _before_ Defaults to be included in cc_defaults module.
3459 android.InitBazelModule(module)
Jooyung Hancc372c52019-09-25 15:18:44 +09003460 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003461
3462 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003463}
3464
Jiyong Park2286afd2020-06-16 21:58:53 +09003465func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003466 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003467}
3468
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003469func kytheExtractAllFactory() android.Singleton {
3470 return &kytheExtractAllSingleton{}
3471}
3472
3473type kytheExtractAllSingleton struct {
3474}
3475
3476func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3477 var xrefTargets android.Paths
3478 ctx.VisitAllModules(func(module android.Module) {
3479 if ccModule, ok := module.(xref); ok {
3480 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3481 }
3482 })
3483 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3484 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003485 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003486 }
3487}
3488
Colin Cross06a931b2015-10-28 17:23:31 -07003489var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003490var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003491var BoolPtr = proptools.BoolPtr
3492var String = proptools.String
3493var StringPtr = proptools.StringPtr