blob: f7b4ac28d25f2aeeac526b50f505780595ebdcdf [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", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070052 ctx.BottomUp("begin", BeginMutator).Parallel()
Inseob Kimac1e9862019-12-09 18:15:47 +090053 ctx.BottomUp("sysprop_cc", SyspropMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070054 })
Colin Cross16b23492016-01-06 14:41:07 -080055
Paul Duffin036e7002019-12-19 19:16:28 +000056 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040057 for _, san := range Sanitizers {
58 san.registerMutators(ctx)
59 }
Dan Willemsen581341d2017-02-09 16:16:31 -080060
Colin Cross0b908332019-06-19 23:00:20 -070061 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090062 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080063
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080064 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070065
Yi Kongeb8efc92021-12-09 18:06:29 +080066 ctx.TopDown("afdo_deps", afdoDepsMutator)
67 ctx.BottomUp("afdo", afdoMutator).Parallel()
68
Stephen Craneba090d12017-05-09 15:44:35 -070069 ctx.TopDown("lto_deps", ltoDepsMutator)
70 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090071
Jooyung Han479ca172020-10-19 18:51:07 +090072 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090073 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070074 })
Colin Crossb98c8b02016-07-29 13:44:28 -070075
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080076 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
77 // sabi mutator needs to be run after apex mutator finishes.
78 ctx.TopDown("sabi_deps", sabiDepsMutator)
79 })
80
Colin Cross57898582020-10-29 18:25:19 -070081 ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070082}
83
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050084// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
85// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
86// edges to these modules.
87// This object is constructed in DepsMutator, by calling to various module delegates to set
88// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
89// dependencies.
90// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
91// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080092type Deps struct {
93 SharedLibs, LateSharedLibs []string
94 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080095 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +080096 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -070097
Chris Parsons79d66a52020-06-05 17:26:16 -040098 // Used for data dependencies adjacent to tests
99 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700100 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400101
Yo Chiang219968c2020-09-22 18:45:04 +0800102 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
103 SystemSharedLibs []string
104
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500105 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800106 StaticUnwinderIfLegacy bool
107
Colin Cross5950f382016-12-13 12:50:57 -0800108 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700109
Colin Cross81413472016-04-11 14:37:39 -0700110 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700111
Dan Willemsenb40aab62016-04-20 14:21:14 -0700112 GeneratedSources []string
113 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900114 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700115
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700116 ReexportGeneratedHeaders []string
117
Colin Crossc465efd2021-06-11 18:00:04 -0700118 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700119
120 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700121 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900122
123 // List of libs that need to be excluded for APEX variant
124 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700125}
126
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500127// PathDeps is a struct containing file paths to dependencies of a module.
128// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
129// It's used to construct flags for various build statements (such as for compiling and linking).
130// It is then passed to module decorator functions responsible for registering build statements
131// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800132type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700133 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900134 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700135 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900136 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700137 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700138 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700139
Colin Cross0de8a1e2020-09-18 14:15:30 -0700140 // Transitive static library dependencies of static libraries for use in ordering.
141 TranstiveStaticLibrariesForOrdering *android.DepSet
142
Colin Cross26c34ed2016-09-30 17:10:16 -0700143 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100144 Objs Objects
145 // Paths to .o files in dependencies that provide them. Note that these lists
146 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800147 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700148 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700149
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100150 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
151 // the libs from all whole_static_lib dependencies.
152 WholeStaticLibsFromPrebuilts android.Paths
153
Colin Cross26c34ed2016-09-30 17:10:16 -0700154 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700155 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900156 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700157
Inseob Kimd110f872019-12-06 13:15:38 +0900158 Flags []string
159 IncludeDirs android.Paths
160 SystemIncludeDirs android.Paths
161 ReexportedDirs android.Paths
162 ReexportedSystemDirs android.Paths
163 ReexportedFlags []string
164 ReexportedGeneratedHeaders android.Paths
165 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700166
Colin Cross26c34ed2016-09-30 17:10:16 -0700167 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700168 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700169
Dan Willemsena0790e32018-10-12 00:24:23 -0700170 // Path to the dynamic linker binary
171 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700172
173 // For Darwin builds, the path to the second architecture's output that should
174 // be combined with this architectures's output into a FAT MachO file.
175 DarwinSecondArchOutput android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700176}
177
Colin Cross4af21ed2019-11-04 09:37:55 -0800178// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
179// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
180// command line so they can be overridden by the local module flags).
181type LocalOrGlobalFlags struct {
182 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700183 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800184 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700185 CFlags []string // Flags that apply to C and C++ source files
186 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
187 ConlyFlags []string // Flags that apply to C source files
188 CppFlags []string // Flags that apply to C++ source files
189 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700190 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800191}
192
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500193// Flags contains various types of command line flags (and settings) for use in building build
194// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800195type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500196 // Local flags (which individual modules are responsible for). These may override global flags.
197 Local LocalOrGlobalFlags
198 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800199 Global LocalOrGlobalFlags
200
201 aidlFlags []string // Flags that apply to aidl source files
202 rsFlags []string // Flags that apply to renderscript source files
203 libFlags []string // Flags to add libraries early to the link order
204 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
205 TidyFlags []string // Flags that apply to clang-tidy
206 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700207
Colin Crossc3199482017-03-30 15:03:04 -0700208 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800209 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700210 SystemIncludeFlags []string
211
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800212 Toolchain config.Toolchain
213 Tidy bool // True if ninja .tidy rules should be generated.
214 NeedTidyFiles bool // True if module link should depend on .tidy files
215 GcovCoverage bool // True if coverage files should be generated.
216 SAbiDump bool // True if header abi dumps should be generated.
217 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800218
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500219 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800220 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500221 // The target-device system path to the dynamic linker.
222 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800223
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700224 CFlagsDeps android.Paths // Files depended on by compiler flags
225 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800226
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500227 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700228 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800229
Colin Cross19878da2019-03-28 14:45:07 -0700230 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700231 protoC bool // Whether to use C instead of C++
232 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700233
234 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200235 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700236}
237
Colin Crossca860ac2016-01-04 14:34:37 -0800238// Properties used to compile all C or C++ modules
239type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700240 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800241 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700242
Jiyong Parkb35a8192020-08-10 15:59:36 +0900243 // The API level that this module is built against. The APIs of this API level will be
244 // visible at build time, but use of any APIs newer than min_sdk_version will render the
245 // module unloadable on older devices. In the future it will be possible to weakly-link new
246 // APIs, making the behavior match Java: such modules will load on older devices, but
247 // calling new APIs on devices that do not support them will result in a crash.
248 //
249 // This property has the same behavior as sdk_version does for Java modules. For those
250 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
251 // does for Java code.
252 //
253 // In addition, setting this property causes two variants to be built, one for the platform
254 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800255 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700256
Jiyong Parkb35a8192020-08-10 15:59:36 +0900257 // Minimum OS API level supported by this C or C++ module. This property becomes the value
258 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
259 // this property is also used to ensure that the min_sdk_version of the containing module is
260 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
261 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
262 // min_sdk_version of the containing APEX. When the module
263 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900264 Min_sdk_version *string
265
Colin Crossc511bc52020-04-07 16:50:32 +0000266 // If true, always create an sdk variant and don't create a platform variant.
267 Sdk_variant_only *bool
268
Jiyong Parkde866cb2018-12-07 23:08:36 +0900269 AndroidMkSharedLibs []string `blueprint:"mutated"`
270 AndroidMkStaticLibs []string `blueprint:"mutated"`
271 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
272 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700273 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900274 HideFromMake bool `blueprint:"mutated"`
275 PreventInstall bool `blueprint:"mutated"`
276 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700277
Yo Chiang219968c2020-09-22 18:45:04 +0800278 // Set by DepsMutator.
279 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
280
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200281 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900282 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200283
284 // The VNDK version this module is built against. If empty, the module is not
285 // build against the VNDK.
286 VndkVersion string `blueprint:"mutated"`
287
288 // Suffix for the name of Android.mk entries generated by this module
289 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800290
291 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
292 // file
293 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900294
Yifan Hong39143a92020-10-26 12:43:12 -0700295 // Make this module available when building for 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 Hong1b3348d2020-01-21 15:53:22 -0800300 Ramdisk_available *bool
301
Yifan Hong39143a92020-10-26 12:43:12 -0700302 // Make this module available when building for vendor ramdisk.
303 // On device without a dedicated recovery partition, the module is only
304 // available after switching root into
305 // /first_stage_ramdisk. To expose the module before switching root, install
306 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700307 Vendor_ramdisk_available *bool
308
Jiyong Parkf9332f12018-02-01 00:54:12 +0900309 // Make this module available when building for recovery
310 Recovery_available *bool
311
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200312 // Used by imageMutator, set by ImageMutatorBegin()
313 CoreVariantNeeded bool `blueprint:"mutated"`
314 RamdiskVariantNeeded bool `blueprint:"mutated"`
315 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
316 RecoveryVariantNeeded bool `blueprint:"mutated"`
317
318 // A list of variations for the "image" mutator of the form
319 //<image name> '.' <version char>, for example, 'vendor.S'
320 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900321
322 // Allows this module to use non-APEX version of libraries. Useful
323 // for building binaries that are started before APEXes are activated.
324 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900325
326 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
327 // see soong/cc/config/vndk.go
328 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900329
330 // Used by vendor snapshot to record dependencies from snapshot modules.
331 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900332 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900333 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000334
Colin Cross1bc94122021-10-28 13:25:54 -0700335 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000336
337 // Set by factories of module types that can only be referenced from variants compiled against
338 // the SDK.
339 AlwaysSdk bool `blueprint:"mutated"`
340
341 // Variant is an SDK variant created by sdkMutator
342 IsSdkVariant bool `blueprint:"mutated"`
343 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
344 // variant to have a ".sdk" suffix.
345 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700346
347 // Normally Soong uses the directory structure to decide which modules
348 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800349 // 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 vendor snapshot.
352 Exclude_from_vendor_snapshot *bool
353
354 // Normally Soong uses the directory structure to decide which modules
355 // should be included (framework) or excluded (non-framework) from the
356 // different snapshots (vendor, recovery, etc.), but this property
357 // allows a partner to exclude a module normally thought of as a
358 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800359 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900360
361 // List of APEXes that this module has private access to for testing purpose. The module
362 // can depend on libraries that are not exported by the APEXes and use private symbols
363 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000364 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800365
366 Target struct {
367 Platform struct {
368 // List of modules required by the core variant.
369 Required []string `android:"arch_variant"`
370
371 // List of modules not required by the core variant.
372 Exclude_required []string `android:"arch_variant"`
373 } `android:"arch_variant"`
374
375 Recovery struct {
376 // List of modules required by the recovery variant.
377 Required []string `android:"arch_variant"`
378
379 // List of modules not required by the recovery variant.
380 Exclude_required []string `android:"arch_variant"`
381 } `android:"arch_variant"`
382 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700383}
384
385type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900386 // whether this module should be allowed to be directly depended by other
387 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900388 // If set to true, two variants will be built separately, one like
389 // normal, and the other limited to the set of libraries and headers
390 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700391 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900392 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700393 // so it shouldn't have any unversioned runtime dependencies, or
394 // make assumptions about the system that may not be true in the
395 // future.
396 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900397 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900398 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900399 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900400 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900401 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700402 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
403 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900404
Justin Yunebcf0c52021-01-08 18:00:19 +0900405 // This is the same as the "vendor_available" except that the install path
406 // of the vendor variant is /odm or /vendor/odm.
407 // By replacing "vendor_available: true" with "odm_available: true", the
408 // module will install its vendor variant to the /odm partition or /vendor/odm.
409 // As the modules with "odm_available: true" still create the vendor variants,
410 // they can link to the other vendor modules as the vendor_available modules do.
411 // Also, the vendor modules can link to odm_available modules.
412 //
413 // It may not be used for VNDK modules.
414 Odm_available *bool
415
Justin Yun63e9ec72020-10-29 16:49:43 +0900416 // whether this module should be allowed to be directly depended by other
417 // modules with `product_specific: true` or `product_available: true`.
418 // If set to true, an additional product variant will be built separately
419 // that is limited to the set of libraries and headers that are exposed to
420 // /product modules.
421 //
422 // The product variant may be used with a different (newer) /system,
423 // so it shouldn't have any unversioned runtime dependencies, or
424 // make assumptions about the system that may not be true in the
425 // future.
426 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900427 // If set to false, this module becomes inaccessible from /product modules.
428 //
429 // Different from the 'vendor_available' property, the modules with
430 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
431 // library without 'product_available' may not be depended on by any other
432 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900433 //
434 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
435 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
436 Product_available *bool
437
Jiyong Park5fb8c102018-04-09 12:03:06 +0900438 // whether this module is capable of being loaded with other instance
439 // (possibly an older version) of the same module in the same process.
440 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
441 // can be double loaded in a vendor process if the library is also a
442 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
443 // explicitly marked as `double_loadable: true` by the owner, or the dependency
444 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
445 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800446
447 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
448 IsLLNDK bool `blueprint:"mutated"`
449
Colin Cross78212242021-01-06 14:51:30 -0800450 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
451 // set and the module is not listed in VndkMustUseVendorVariantList.
452 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
453
454 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
455 IsVNDKCore bool `blueprint:"mutated"`
456
457 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
458 IsVNDKSP bool `blueprint:"mutated"`
459
460 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
461 // module sets the llndk.private property.
462 IsVNDKPrivate bool `blueprint:"mutated"`
463
464 // IsVNDKProduct is set if a VNDK module sets the product_available property.
465 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700466
467 // IsVendorPublicLibrary is set for the core and product variants of a library that has
468 // vendor_public_library stubs.
469 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800470}
471
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500472// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
473// to understanding details about the type of the current module.
474// For example, one might call these functions to determine whether the current module is a static
475// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800476type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800477 static() bool
478 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700479 testBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900480 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900481 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900482 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700483 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900484 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700485 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800486 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900487 minSdkVersion() string
488 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700489 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700490 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800491 IsLlndk() bool
492 IsLlndkPublic() bool
493 isImplementationForLLNDKPublic() bool
494 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900495 isVndk() bool
496 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500497 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700498 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900499 inProduct() bool
500 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800501 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700502 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900503 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700504 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700505 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800506 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800507 isAfdoCompile() bool
Yi Kong7e53c572018-02-14 18:16:12 +0800508 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800509 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800510 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800511 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700512 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700513 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900514 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800515 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700516 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700517 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800518 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800519 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800520 getSharedFlags() *SharedFlags
521}
522
523type SharedFlags struct {
524 numSharedFlags int
525 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800526}
527
528type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700529 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800530 ModuleContextIntf
531}
532
533type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700534 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800535 ModuleContextIntf
536}
537
Colin Cross37047f12016-12-13 17:06:13 -0800538type DepsContext interface {
539 android.BottomUpMutatorContext
540 ModuleContextIntf
541}
542
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500543// feature represents additional (optional) steps to building cc-related modules, such as invocation
544// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800545type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800546 flags(ctx ModuleContext, flags Flags) Flags
547 props() []interface{}
548}
549
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500550// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500551// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800552type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700553 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800554 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800555 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700556 compilerProps() []interface{}
557
Colin Cross76fada02016-07-27 10:31:13 -0700558 appendCflags([]string)
559 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700560 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800561}
562
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500563// linker is the interface for a linker decorator object. Individual module types can provide
564// their own implementation for this decorator, and thus specify custom logic regarding build
565// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800566type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700567 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800568 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700569 linkerFlags(ctx ModuleContext, flags Flags) Flags
570 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800571 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700572
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700573 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700574 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900575 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700576
577 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900578 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000579
580 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000581 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
582}
583
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500584// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000585type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500586 sharedLibs []string
587 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
588 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700589 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800590}
591
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500592// installer is the interface for an installer helper object. This helper is responsible for
593// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800594type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700595 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700596 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000597 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800598 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700599 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700600 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900601 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100602 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900603 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800604}
605
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800606type xref interface {
607 XrefCcFiles() android.Paths
608}
609
Colin Cross6e511a92020-07-27 21:26:48 -0700610type libraryDependencyKind int
611
612const (
613 headerLibraryDependency = iota
614 sharedLibraryDependency
615 staticLibraryDependency
616)
617
618func (k libraryDependencyKind) String() string {
619 switch k {
620 case headerLibraryDependency:
621 return "headerLibraryDependency"
622 case sharedLibraryDependency:
623 return "sharedLibraryDependency"
624 case staticLibraryDependency:
625 return "staticLibraryDependency"
626 default:
627 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
628 }
629}
630
631type libraryDependencyOrder int
632
633const (
634 earlyLibraryDependency = -1
635 normalLibraryDependency = 0
636 lateLibraryDependency = 1
637)
638
639func (o libraryDependencyOrder) String() string {
640 switch o {
641 case earlyLibraryDependency:
642 return "earlyLibraryDependency"
643 case normalLibraryDependency:
644 return "normalLibraryDependency"
645 case lateLibraryDependency:
646 return "lateLibraryDependency"
647 default:
648 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
649 }
650}
651
652// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
653// tags that have a set of predefined tag objects that are reused for each dependency, a
654// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
655// That means that comparing a libraryDependencyTag for equality will only be equal if all
656// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
657// then check individual metadata fields instead.
658type libraryDependencyTag struct {
659 blueprint.BaseDependencyTag
660
661 // These are exported so that fmt.Printf("%#v") can call their String methods.
662 Kind libraryDependencyKind
663 Order libraryDependencyOrder
664
665 wholeStatic bool
666
667 reexportFlags bool
668 explicitlyVersioned bool
669 dataLib bool
670 ndk bool
671
672 staticUnwinder bool
673
674 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900675
Cindy Zhou18417cb2020-12-10 07:12:38 -0800676 // Whether or not this dependency should skip the apex dependency check
677 skipApexAllowedDependenciesCheck bool
678
Jiyong Parke3867542020-12-03 17:28:25 +0900679 // Whether or not this dependency has to be followed for the apex variants
680 excludeInApex bool
Colin Cross6e511a92020-07-27 21:26:48 -0700681}
682
683// header returns true if the libraryDependencyTag is tagging a header lib dependency.
684func (d libraryDependencyTag) header() bool {
685 return d.Kind == headerLibraryDependency
686}
687
688// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
689func (d libraryDependencyTag) shared() bool {
690 return d.Kind == sharedLibraryDependency
691}
692
693// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
694func (d libraryDependencyTag) static() bool {
695 return d.Kind == staticLibraryDependency
696}
697
Colin Cross65cb3142021-12-10 23:05:02 +0000698func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
699 if d.shared() {
700 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
701 }
702 return nil
703}
704
705var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
706
Colin Crosse9fe2942020-11-10 18:12:15 -0800707// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
708// binaries or other shared libraries are installed as dependencies.
709func (d libraryDependencyTag) InstallDepNeeded() bool {
710 return d.shared()
711}
712
713var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
714
715// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700716// libraryDependencyTag. Each tag object is created globally and reused for multiple
717// dependencies (although since the object contains no references, assigning a tag to a
718// variable and modifying it will not modify the original). Users can compare the tag
719// returned by ctx.OtherModuleDependencyTag against the global original
720type dependencyTag struct {
721 blueprint.BaseDependencyTag
722 name string
723}
724
Colin Crosse9fe2942020-11-10 18:12:15 -0800725// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
726// libraryDependencyTag, but where the dependency needs to be installed when the parent is
727// installed.
728type installDependencyTag struct {
729 blueprint.BaseDependencyTag
730 android.InstallAlwaysNeededDependencyTag
731 name string
732}
733
Colin Crossc99deeb2016-04-11 15:06:20 -0700734var (
Colin Cross6e511a92020-07-27 21:26:48 -0700735 genSourceDepTag = dependencyTag{name: "gen source"}
736 genHeaderDepTag = dependencyTag{name: "gen header"}
737 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
738 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900739 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700740 reuseObjTag = dependencyTag{name: "reuse objects"}
741 staticVariantTag = dependencyTag{name: "static variant"}
742 vndkExtDepTag = dependencyTag{name: "vndk extends"}
743 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700744 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800745 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700746 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700747 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700748)
749
Roland Levillainf89cd092019-07-29 16:22:59 +0100750func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700751 ccLibDepTag, ok := depTag.(libraryDependencyTag)
752 return ok && ccLibDepTag.shared()
753}
754
755func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
756 ccLibDepTag, ok := depTag.(libraryDependencyTag)
757 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100758}
759
Zach Johnson3df4e632020-11-06 11:56:27 -0800760func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
761 ccLibDepTag, ok := depTag.(libraryDependencyTag)
762 return ok && ccLibDepTag.header()
763}
764
Roland Levillainf89cd092019-07-29 16:22:59 +0100765func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800766 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100767}
768
769func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700770 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100771 return ok && ccDepTag == testPerSrcDepTag
772}
773
Colin Crossca860ac2016-01-04 14:34:37 -0800774// Module contains the properties and members used by all C/C++ module types, and implements
775// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500776// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
777// interface.
778//
779// To define a C/C++ related module, construct a new Module object and point its delegates to
780// type-specific structs. These delegates will be invoked to register module-specific build
781// statements which may be unique to the module type. For example, module.compiler.compile() should
782// be defined so as to register build statements which are responsible for compiling the module.
783//
784// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
785// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
786// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
787// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800788type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700789 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700790
Jiyong Parkd1063c12019-07-17 20:08:41 +0900791 android.SdkBase
Liz Kammerea6666f2021-02-17 10:17:28 -0500792 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700793
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700794 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700795 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700796
Colin Crossca860ac2016-01-04 14:34:37 -0800797 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400798 hod android.HostOrDeviceSupported
799 multilib android.Multilib
800 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700801
Paul Duffina0843f62019-12-13 19:50:38 +0000802 // Allowable SdkMemberTypes of this module type.
803 sdkMemberTypes []android.SdkMemberType
804
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500805 // decorator delegates, initialize before calling Init
806 // these may contain module-specific implementations, and effectively allow for custom
807 // type-specific logic. These members may reference different objects or the same object.
808 // Functions of these decorators will be invoked to initialize and register type-specific
809 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500810 compiler compiler
811 linker linker
812 installer installer
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux0d990452021-08-11 16:46:13 +0000813 bazelHandler android.BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500814
815 features []feature
816 stl *stl
817 sanitize *sanitize
818 coverage *coverage
819 sabi *sabi
820 vndkdep *vndkdep
821 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800822 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500823 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800824
Colin Cross31076b32020-10-23 17:22:06 -0700825 library libraryInterface
826
Colin Cross635c3b02016-05-18 15:37:25 -0700827 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800828
Colin Crossb98c8b02016-07-29 13:44:28 -0700829 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700830
831 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800832
833 // Flags used to compile this module
834 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700835
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800836 // Shared flags among build rules of this module
837 sharedFlags SharedFlags
838
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800839 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700840 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900841
842 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800843 // Kythe (source file indexer) paths for this compilation module
844 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700845 // Object .o file output paths for this compilation module
846 objFiles android.Paths
847 // Tidy .tidy file output paths for this compilation module
848 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900849
850 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700851 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700852
853 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700854}
855
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200856func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400857 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
858 if b, ok := c.compiler.(*baseCompiler); ok {
859 hasAidl = b.hasSrcExt(".aidl")
860 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
861 hasProto = b.hasSrcExt(".proto")
862 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
863 hasSysprop = b.hasSrcExt(".sysprop")
864 hasWinMsg = b.hasSrcExt(".mc")
865 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
866 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200867 c.AndroidModuleBase().AddJSONData(d)
868 (*d)["Cc"] = map[string]interface{}{
869 "SdkVersion": c.SdkVersion(),
870 "MinSdkVersion": c.MinSdkVersion(),
871 "VndkVersion": c.VndkVersion(),
872 "ProductSpecific": c.ProductSpecific(),
873 "SocSpecific": c.SocSpecific(),
874 "DeviceSpecific": c.DeviceSpecific(),
875 "InProduct": c.InProduct(),
876 "InVendor": c.InVendor(),
877 "InRamdisk": c.InRamdisk(),
878 "InVendorRamdisk": c.InVendorRamdisk(),
879 "InRecovery": c.InRecovery(),
880 "VendorAvailable": c.VendorAvailable(),
881 "ProductAvailable": c.ProductAvailable(),
882 "RamdiskAvailable": c.RamdiskAvailable(),
883 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
884 "RecoveryAvailable": c.RecoveryAvailable(),
885 "OdmAvailable": c.OdmAvailable(),
886 "InstallInData": c.InstallInData(),
887 "InstallInRamdisk": c.InstallInRamdisk(),
888 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
889 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
890 "InstallInRecovery": c.InstallInRecovery(),
891 "InstallInRoot": c.InstallInRoot(),
892 "IsVndk": c.IsVndk(),
893 "IsVndkExt": c.IsVndkExt(),
894 "IsVndkPrivate": c.IsVndkPrivate(),
895 "IsVndkSp": c.IsVndkSp(),
896 "IsLlndk": c.IsLlndk(),
897 "IsLlndkPublic": c.IsLlndkPublic(),
898 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
899 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
900 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
901 "ApexSdkVersion": c.apexSdkVersion,
902 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400903 "AidlSrcs": hasAidl,
904 "LexSrcs": hasLex,
905 "ProtoSrcs": hasProto,
906 "RenderscriptSrcs": hasRenderscript,
907 "SyspropSrcs": hasSysprop,
908 "WinMsgSrcs": hasWinMsg,
909 "YaccSrsc": hasYacc,
910 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200911 }
912}
913
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500914func (c *Module) SetPreventInstall() {
915 c.Properties.PreventInstall = true
916}
917
918func (c *Module) SetHideFromMake() {
919 c.Properties.HideFromMake = true
920}
921
Ivan Lozanod7586b62021-04-01 09:49:36 -0400922func (c *Module) HiddenFromMake() bool {
923 return c.Properties.HideFromMake
924}
925
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800926func (c *Module) RequiredModuleNames() []string {
927 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
928 if c.ImageVariation().Variation == android.CoreVariation {
929 required = append(required, c.Properties.Target.Platform.Required...)
930 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
931 } else if c.InRecovery() {
932 required = append(required, c.Properties.Target.Recovery.Required...)
933 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
934 }
935 return android.FirstUniqueStrings(required)
936}
937
Ivan Lozano52767be2019-10-18 14:49:46 -0700938func (c *Module) Toc() android.OptionalPath {
939 if c.linker != nil {
940 if library, ok := c.linker.(libraryInterface); ok {
941 return library.toc()
942 }
943 }
944 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
945}
946
947func (c *Module) ApiLevel() string {
948 if c.linker != nil {
949 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700950 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700951 }
952 }
953 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
954}
955
956func (c *Module) Static() bool {
957 if c.linker != nil {
958 if library, ok := c.linker.(libraryInterface); ok {
959 return library.static()
960 }
961 }
962 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
963}
964
965func (c *Module) Shared() bool {
966 if c.linker != nil {
967 if library, ok := c.linker.(libraryInterface); ok {
968 return library.shared()
969 }
970 }
971 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
972}
973
974func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000975 if c.stl != nil {
976 return c.stl.Properties.SelectedStl
977 }
978 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700979}
980
Ivan Lozano52767be2019-10-18 14:49:46 -0700981func (c *Module) NdkPrebuiltStl() bool {
982 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
983 return true
984 }
985 return false
986}
987
988func (c *Module) StubDecorator() bool {
989 if _, ok := c.linker.(*stubDecorator); ok {
990 return true
991 }
992 return false
993}
994
995func (c *Module) SdkVersion() string {
996 return String(c.Properties.Sdk_version)
997}
998
Artur Satayev480e25b2020-04-27 18:53:18 +0100999func (c *Module) MinSdkVersion() string {
1000 return String(c.Properties.Min_sdk_version)
1001}
1002
Jiyong Park5df7bd32021-08-25 16:18:46 +09001003func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001004 if linker, ok := c.linker.(*objectLinker); ok {
1005 return linker.isCrt()
1006 }
1007 return false
1008}
1009
Jiyong Park5df7bd32021-08-25 16:18:46 +09001010func (c *Module) SplitPerApiLevel() bool {
1011 return c.canUseSdk() && c.isCrt()
1012}
1013
Colin Crossc511bc52020-04-07 16:50:32 +00001014func (c *Module) AlwaysSdk() bool {
1015 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1016}
1017
Ivan Lozano183a3212019-10-18 14:18:45 -07001018func (c *Module) CcLibrary() bool {
1019 if c.linker != nil {
1020 if _, ok := c.linker.(*libraryDecorator); ok {
1021 return true
1022 }
Colin Crossd48fe732020-09-23 20:37:24 -07001023 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1024 return true
1025 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001026 }
1027 return false
1028}
1029
1030func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001031 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001032 return true
1033 }
1034 return false
1035}
1036
Ivan Lozano2b262972019-11-21 12:30:50 -08001037func (c *Module) NonCcVariants() bool {
1038 return false
1039}
1040
Ivan Lozano183a3212019-10-18 14:18:45 -07001041func (c *Module) SetStatic() {
1042 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001043 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001044 library.setStatic()
1045 return
1046 }
1047 }
1048 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1049}
1050
1051func (c *Module) SetShared() {
1052 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001053 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001054 library.setShared()
1055 return
1056 }
1057 }
1058 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1059}
1060
1061func (c *Module) BuildStaticVariant() bool {
1062 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001063 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001064 return library.buildStatic()
1065 }
1066 }
1067 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1068}
1069
1070func (c *Module) BuildSharedVariant() bool {
1071 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001072 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001073 return library.buildShared()
1074 }
1075 }
1076 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1077}
1078
1079func (c *Module) Module() android.Module {
1080 return c
1081}
1082
Jiyong Parkc20eee32018-09-05 22:36:17 +09001083func (c *Module) OutputFile() android.OptionalPath {
1084 return c.outputFile
1085}
1086
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001087func (c *Module) CoverageFiles() android.Paths {
1088 if c.linker != nil {
1089 if library, ok := c.linker.(libraryInterface); ok {
1090 return library.objs().coverageFiles
1091 }
1092 }
1093 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1094}
1095
Ivan Lozano183a3212019-10-18 14:18:45 -07001096var _ LinkableInterface = (*Module)(nil)
1097
Jiyong Park719b4462019-01-13 00:39:51 +09001098func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001099 if c.linker != nil {
1100 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001101 }
1102 return nil
1103}
1104
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001105func (c *Module) CoverageOutputFile() android.OptionalPath {
1106 if c.linker != nil {
1107 return c.linker.coverageOutputFilePath()
1108 }
1109 return android.OptionalPath{}
1110}
1111
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001112func (c *Module) RelativeInstallPath() string {
1113 if c.installer != nil {
1114 return c.installer.relativeInstallPath()
1115 }
1116 return ""
1117}
1118
Jooyung Han344d5432019-08-23 11:17:39 +09001119func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001120 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001121}
1122
Colin Cross36242852017-06-23 15:06:31 -07001123func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001124 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001125 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001126 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001127 }
1128 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001129 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001130 }
1131 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001132 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001133 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001134 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001135 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001136 }
Colin Cross16b23492016-01-06 14:41:07 -08001137 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001138 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001139 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001140 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001141 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001142 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001143 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001144 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001145 }
Justin Yun8effde42017-06-23 19:24:43 +09001146 if c.vndkdep != nil {
1147 c.AddProperties(c.vndkdep.props()...)
1148 }
Stephen Craneba090d12017-05-09 15:44:35 -07001149 if c.lto != nil {
1150 c.AddProperties(c.lto.props()...)
1151 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001152 if c.afdo != nil {
1153 c.AddProperties(c.afdo.props()...)
1154 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001155 if c.pgo != nil {
1156 c.AddProperties(c.pgo.props()...)
1157 }
Colin Crossca860ac2016-01-04 14:34:37 -08001158 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001159 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001160 }
Colin Crossc472d572015-03-17 15:06:21 -07001161
Colin Cross36242852017-06-23 15:06:31 -07001162 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001163 if c.bazelable {
1164 android.InitBazelModule(c)
1165 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001166 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001167 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001168 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001169
Colin Cross36242852017-06-23 15:06:31 -07001170 return c
Colin Crossc472d572015-03-17 15:06:21 -07001171}
1172
Ivan Lozano52767be2019-10-18 14:49:46 -07001173func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001174 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001175}
1176
Colin Crossc511bc52020-04-07 16:50:32 +00001177func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001178 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1179 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001180}
1181
1182func (c *Module) UseSdk() bool {
1183 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001184 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001185 }
1186 return false
1187}
1188
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001189func (c *Module) isCoverageVariant() bool {
1190 return c.coverage.Properties.IsCoverageVariant
1191}
1192
Colin Cross95f1ca02020-10-29 20:47:22 -07001193func (c *Module) IsNdk(config android.Config) bool {
1194 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001195}
1196
Colin Cross127bb8b2020-12-16 16:46:01 -08001197func (c *Module) IsLlndk() bool {
1198 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001199}
1200
Colin Cross127bb8b2020-12-16 16:46:01 -08001201func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001202 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001203}
1204
Colin Cross1f3f1302021-04-26 18:37:44 -07001205func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001206 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001207 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001208}
1209
Colin Cross5271fea2021-04-27 13:06:04 -07001210func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1211 lib := moduleLibraryInterface(m)
1212 return lib != nil && (lib.hasVendorPublicLibrary())
1213}
1214
1215// IsVendorPublicLibrary returns true for vendor public libraries.
1216func (c *Module) IsVendorPublicLibrary() bool {
1217 return c.VendorProperties.IsVendorPublicLibrary
1218}
1219
Ivan Lozanod7586b62021-04-01 09:49:36 -04001220func (c *Module) HasLlndkStubs() bool {
1221 lib := moduleLibraryInterface(c)
1222 return lib != nil && lib.hasLLNDKStubs()
1223}
1224
1225func (c *Module) StubsVersion() string {
1226 if lib, ok := c.linker.(versionedInterface); ok {
1227 return lib.stubsVersion()
1228 }
1229 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1230}
1231
Colin Cross127bb8b2020-12-16 16:46:01 -08001232// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1233// and does not set llndk.vendor_available: false.
1234func (c *Module) isImplementationForLLNDKPublic() bool {
1235 library, _ := c.library.(*libraryDecorator)
1236 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001237 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001238}
1239
Justin Yunfd9e8042020-12-23 18:23:14 +09001240// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001241func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001242 // Check if VNDK-core-private or VNDK-SP-private
1243 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001244 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001245 }
1246
1247 // Check if LLNDK-private
1248 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001249 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001250 }
1251
1252 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001253}
1254
Ivan Lozano52767be2019-10-18 14:49:46 -07001255func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001256 if vndkdep := c.vndkdep; vndkdep != nil {
1257 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001258 }
1259 return false
1260}
1261
Yi Kong4ef54592022-02-14 20:00:10 +08001262func (c *Module) isAfdoCompile() bool {
1263 if afdo := c.afdo; afdo != nil {
1264 return afdo.Properties.AfdoTarget != nil
1265 }
1266 return false
1267}
1268
Yi Kong7e53c572018-02-14 18:16:12 +08001269func (c *Module) isPgoCompile() bool {
1270 if pgo := c.pgo; pgo != nil {
1271 return pgo.Properties.PgoCompile
1272 }
1273 return false
1274}
1275
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001276func (c *Module) isNDKStubLibrary() bool {
1277 if _, ok := c.compiler.(*stubDecorator); ok {
1278 return true
1279 }
1280 return false
1281}
1282
Ivan Lozanod7586b62021-04-01 09:49:36 -04001283func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001284 if vndkdep := c.vndkdep; vndkdep != nil {
1285 return vndkdep.isVndkSp()
1286 }
1287 return false
1288}
1289
Ivan Lozanof9e21722020-12-02 09:00:51 -05001290func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001291 if vndkdep := c.vndkdep; vndkdep != nil {
1292 return vndkdep.isVndkExt()
1293 }
1294 return false
1295}
1296
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001297func (c *Module) SubName() string {
1298 return c.Properties.SubName
1299}
1300
Ivan Lozano52767be2019-10-18 14:49:46 -07001301func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001302 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001303}
1304
Logan Chienf3511742017-10-31 18:04:35 +08001305func (c *Module) getVndkExtendsModuleName() string {
1306 if vndkdep := c.vndkdep; vndkdep != nil {
1307 return vndkdep.getVndkExtendsModuleName()
1308 }
1309 return ""
1310}
1311
Jiyong Park25fc6a92018-11-18 18:02:45 +09001312func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001313 if lib := c.library; lib != nil {
1314 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001315 }
1316 return false
1317}
1318
1319func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001320 if lib := c.library; lib != nil {
1321 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001322 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001323 return false
1324}
1325
Colin Cross0477b422020-10-13 18:43:54 -07001326// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1327// the implementation. If it is an implementation library it returns its own name.
1328func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1329 name := ctx.OtherModuleName(c)
1330 if versioned, ok := c.linker.(versionedInterface); ok {
1331 name = versioned.implementationModuleName(name)
1332 }
1333 return name
1334}
1335
Martin Stjernholm2856c662020-12-02 15:03:42 +00001336// Similar to ImplementationModuleName, but uses the Make variant of the module
1337// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1338// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1339// under the premise that the prebuilt module overrides its source counterpart
1340// if it is exposed to Make).
1341func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1342 name := c.BaseModuleName()
1343 if versioned, ok := c.linker.(versionedInterface); ok {
1344 name = versioned.implementationModuleName(name)
1345 }
1346 return name
1347}
1348
Jiyong Park7d55b612021-06-11 17:22:09 +09001349func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001350 return Bool(c.Properties.Bootstrap)
1351}
1352
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001353func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001354 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1355 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1356 return false
1357 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001358 return c.linker != nil && c.linker.nativeCoverage()
1359}
1360
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001361func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001362 if p, ok := c.linker.(SnapshotInterface); ok {
1363 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001364 }
1365 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001366}
1367
Bill Peckham945441c2020-08-31 16:07:58 -07001368func (c *Module) ExcludeFromVendorSnapshot() bool {
1369 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1370}
1371
Jose Galmesf7294582020-11-13 12:07:36 -08001372func (c *Module) ExcludeFromRecoverySnapshot() bool {
1373 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1374}
1375
Jiyong Parkf1194352019-02-25 11:05:47 +09001376func isBionic(name string) bool {
1377 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001378 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001379 return true
1380 }
1381 return false
1382}
1383
Martin Stjernholm279de572019-09-10 23:18:20 +01001384func InstallToBootstrap(name string, config android.Config) bool {
Colin Cross4c4c1be2022-02-10 11:41:18 -08001385 if name == "libclang_rt.hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001386 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001387 }
1388 return isBionic(name)
1389}
1390
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001391func (c *Module) XrefCcFiles() android.Paths {
1392 return c.kytheFiles
1393}
1394
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001395func (c *Module) isCfiAssemblySupportEnabled() bool {
1396 return c.sanitize != nil &&
1397 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1398}
1399
Inseob Kim800d1142021-06-14 12:03:51 +09001400func (c *Module) InstallInRoot() bool {
1401 return c.installer != nil && c.installer.installInRoot()
1402}
1403
Colin Crossca860ac2016-01-04 14:34:37 -08001404type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001405 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001406 moduleContextImpl
1407}
1408
Colin Cross37047f12016-12-13 17:06:13 -08001409type depsContext struct {
1410 android.BottomUpMutatorContext
1411 moduleContextImpl
1412}
1413
Colin Crossca860ac2016-01-04 14:34:37 -08001414type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001415 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001416 moduleContextImpl
1417}
1418
1419type moduleContextImpl struct {
1420 mod *Module
1421 ctx BaseModuleContext
1422}
1423
Colin Crossb98c8b02016-07-29 13:44:28 -07001424func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001425 return ctx.mod.toolchain(ctx.ctx)
1426}
1427
1428func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001429 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001430}
1431
1432func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001433 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001434}
1435
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001436func (ctx *moduleContextImpl) testBinary() bool {
1437 return ctx.mod.testBinary()
1438}
1439
Jiyong Park1d1119f2019-07-29 21:27:18 +09001440func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001441 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001442}
1443
Inseob Kim7f283f42020-06-01 21:53:49 +09001444func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001445 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001446}
1447
Inseob Kim1042d292020-06-01 23:23:05 +09001448func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001449 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001450}
1451
Jooyung Hanccce2f22020-03-07 03:45:53 +09001452func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001453 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001454}
1455
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001456func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001457 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001458}
1459
1460func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001461 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001462 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001463 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001464 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001465 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001466 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001467 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001468 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001469 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001470 }
1471 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001472}
1473
Jiyong Parkb35a8192020-08-10 15:59:36 +09001474func (ctx *moduleContextImpl) minSdkVersion() string {
1475 ver := ctx.mod.MinSdkVersion()
1476 if ver == "apex_inherit" && !ctx.isForPlatform() {
1477 ver = ctx.apexSdkVersion().String()
1478 }
1479 if ver == "apex_inherit" || ver == "" {
1480 ver = ctx.sdkVersion()
1481 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001482 // For crt objects, the meaning of min_sdk_version is very different from other types of
1483 // module. For them, min_sdk_version defines the oldest version that the build system will
1484 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1485 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1486 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001487 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1488 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1489 // support such an old version. The version is set to the later version in case when the
1490 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1491 // it's for an APEX.
1492 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1493 if ctx.isForPlatform() {
1494 ver = strconv.Itoa(android.FutureApiLevelInt)
1495 } else { // for apex
1496 ver = ctx.apexSdkVersion().String()
1497 if ver == "" { // in case when min_sdk_version was not set by the APEX
1498 ver = ctx.sdkVersion()
1499 }
1500 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001501 }
1502
Jiyong Parkb35a8192020-08-10 15:59:36 +09001503 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1504 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1505 minSdkVersionInt, err2 := strconv.Atoi(ver)
1506 if err == nil && err2 == nil {
1507 if sdkVersionInt < minSdkVersionInt {
1508 return strconv.Itoa(sdkVersionInt)
1509 }
1510 }
1511 return ver
1512}
1513
1514func (ctx *moduleContextImpl) isSdkVariant() bool {
1515 return ctx.mod.IsSdkVariant()
1516}
1517
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001518func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001519 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001520}
Justin Yun8effde42017-06-23 19:24:43 +09001521
Colin Cross95f1ca02020-10-29 20:47:22 -07001522func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1523 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001524}
1525
Colin Cross127bb8b2020-12-16 16:46:01 -08001526func (ctx *moduleContextImpl) IsLlndk() bool {
1527 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001528}
1529
Colin Cross127bb8b2020-12-16 16:46:01 -08001530func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1531 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001532}
1533
Colin Cross127bb8b2020-12-16 16:46:01 -08001534func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1535 return ctx.mod.isImplementationForLLNDKPublic()
1536}
1537
1538func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1539 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001540}
1541
Logan Chienf3511742017-10-31 18:04:35 +08001542func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001543 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001544}
1545
Yi Kong4ef54592022-02-14 20:00:10 +08001546func (ctx *moduleContextImpl) isAfdoCompile() bool {
1547 return ctx.mod.isAfdoCompile()
1548}
1549
Yi Kong7e53c572018-02-14 18:16:12 +08001550func (ctx *moduleContextImpl) isPgoCompile() bool {
1551 return ctx.mod.isPgoCompile()
1552}
1553
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001554func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1555 return ctx.mod.isNDKStubLibrary()
1556}
1557
Justin Yun8effde42017-06-23 19:24:43 +09001558func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001559 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001560}
1561
Ivan Lozanof9e21722020-12-02 09:00:51 -05001562func (ctx *moduleContextImpl) IsVndkExt() bool {
1563 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001564}
1565
Colin Cross5271fea2021-04-27 13:06:04 -07001566func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1567 return ctx.mod.IsVendorPublicLibrary()
1568}
1569
Vic Yangefd249e2018-11-12 20:19:56 -08001570func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001571 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001572}
1573
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001574func (ctx *moduleContextImpl) selectedStl() string {
1575 if stl := ctx.mod.stl; stl != nil {
1576 return stl.Properties.SelectedStl
1577 }
1578 return ""
1579}
1580
Ivan Lozanobd721262018-11-27 14:33:03 -08001581func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1582 return ctx.mod.linker.useClangLld(actx)
1583}
1584
Colin Crossce75d2c2016-10-06 16:12:58 -07001585func (ctx *moduleContextImpl) baseModuleName() string {
1586 return ctx.mod.ModuleBase.BaseModuleName()
1587}
1588
Logan Chienf3511742017-10-31 18:04:35 +08001589func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1590 return ctx.mod.getVndkExtendsModuleName()
1591}
1592
Logan Chiene274fc92019-12-03 11:18:32 -08001593func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001594 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001595}
1596
Colin Crosse07f2312020-08-13 11:24:56 -07001597func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001598 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001599}
1600
Dan Albertc8060532020-07-22 22:32:17 -07001601func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001602 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001603}
1604
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001605func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001606 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001607}
1608
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001609func (ctx *moduleContextImpl) nativeCoverage() bool {
1610 return ctx.mod.nativeCoverage()
1611}
1612
Colin Cross56a83212020-09-15 18:30:11 -07001613func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1614 return ctx.mod.DirectlyInAnyApex()
1615}
1616
Colin Cross95b07f22020-12-16 11:06:50 -08001617func (ctx *moduleContextImpl) isPreventInstall() bool {
1618 return ctx.mod.Properties.PreventInstall
1619}
1620
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001621func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1622 shared := &ctx.mod.sharedFlags
1623 if shared.flagsMap == nil {
1624 shared.numSharedFlags = 0
1625 shared.flagsMap = make(map[string]string)
1626 }
1627 return shared
1628}
1629
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001630func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1631 return ctx.mod.isCfiAssemblySupportEnabled()
1632}
1633
Colin Cross635c3b02016-05-18 15:37:25 -07001634func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001635 return &Module{
1636 hod: hod,
1637 multilib: multilib,
1638 }
1639}
1640
Colin Cross635c3b02016-05-18 15:37:25 -07001641func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001642 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001643 module.features = []feature{
1644 &tidyFeature{},
1645 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001646 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001647 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001648 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001649 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001650 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001651 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001652 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001653 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001654 return module
1655}
1656
Colin Crossce75d2c2016-10-06 16:12:58 -07001657func (c *Module) Prebuilt() *android.Prebuilt {
1658 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1659 return p.prebuilt()
1660 }
1661 return nil
1662}
1663
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001664func (c *Module) IsPrebuilt() bool {
1665 return c.Prebuilt() != nil
1666}
1667
Colin Crossce75d2c2016-10-06 16:12:58 -07001668func (c *Module) Name() string {
1669 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001670 if p, ok := c.linker.(interface {
1671 Name(string) string
1672 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001673 name = p.Name(name)
1674 }
1675 return name
1676}
1677
Alex Light3d673592019-01-18 14:37:31 -08001678func (c *Module) Symlinks() []string {
1679 if p, ok := c.installer.(interface {
1680 symlinkList() []string
1681 }); ok {
1682 return p.symlinkList()
1683 }
1684 return nil
1685}
1686
Roland Levillainf89cd092019-07-29 16:22:59 +01001687func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1688 test, ok := c.linker.(testPerSrc)
1689 return ok && test.isAllTestsVariation()
1690}
1691
Chris Parsons216e10a2020-07-09 17:12:52 -04001692func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001693 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001694 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001695 }); ok {
1696 return p.dataPaths()
1697 }
1698 return nil
1699}
1700
Justin Yun5f7f7e82019-11-18 19:52:14 +09001701func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1702 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1703 // "current", it will append the VNDK version to the name suffix.
1704 var vndkVersion string
1705 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001706 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001707 if c.ProductSpecific() {
1708 // If the module is product specific with 'product_specific: true',
1709 // do not add a name suffix because it is a base module.
1710 return ""
1711 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001712 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001713 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001714 } else {
1715 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001716 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001717 }
1718 if vndkVersion == "current" {
1719 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1720 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001721 if c.Properties.VndkVersion != vndkVersion && c.Properties.VndkVersion != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001722 // add version suffix only if the module is using different vndk version than the
1723 // version in product or vendor partition.
1724 nameSuffix += "." + c.Properties.VndkVersion
1725 }
1726 return nameSuffix
1727}
1728
Chris Parsons8d6e4332021-02-22 16:13:50 -05001729func (c *Module) setSubnameProperty(actx android.ModuleContext) {
Inseob Kim64c43952019-08-26 16:52:35 +09001730 c.Properties.SubName = ""
1731
1732 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07001733 c.Properties.SubName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001734 }
1735
Colin Cross127bb8b2020-12-16 16:46:01 -08001736 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001737 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001738 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1739 // added for product variant only when we have vendor and product variants with core
1740 // variant. The suffix is not added for vendor-only or product-only module.
1741 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
Colin Cross5271fea2021-04-27 13:06:04 -07001742 } else if c.IsVendorPublicLibrary() {
1743 c.Properties.SubName += vendorPublicLibrarySuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001744 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001745 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1746 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001747 c.Properties.SubName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001748 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07001749 c.Properties.SubName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001750 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001751 c.Properties.SubName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001752 } else if c.InRecovery() && !c.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08001753 c.Properties.SubName += RecoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001754 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001755 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001756 if c.SplitPerApiLevel() {
1757 c.Properties.SubName += "." + c.SdkVersion()
1758 }
Inseob Kim64c43952019-08-26 16:52:35 +09001759 }
Chris Parsons8d6e4332021-02-22 16:13:50 -05001760}
1761
1762// Returns true if Bazel was successfully used for the analysis of this module.
1763func (c *Module) maybeGenerateBazelActions(actx android.ModuleContext) bool {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001764 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001765 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001766 // cc_library is a special case in bp2build; two targets are generated -- one for each
1767 // of the shared and static variants. The shared variant keeps the module name, but the
1768 // static variant uses a different suffixed name.
1769 bazelModuleLabel = bazelLabelForStaticModule(actx, c)
1770 } else {
1771 bazelModuleLabel = c.GetBazelLabel(actx, c)
1772 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05001773
Chris Parsons8d6e4332021-02-22 16:13:50 -05001774 bazelActionsUsed := false
Chris Parsons18266212021-09-23 13:42:38 -04001775 // Mixed builds mode is disabled for modules outside of device OS.
1776 // TODO(b/200841190): Support non-device OS in mixed builds.
Chris Parsons494eef32021-11-09 10:29:52 -05001777 if c.MixedBuildsEnabled(actx) && c.bazelHandler != nil {
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux0d990452021-08-11 16:46:13 +00001778 bazelActionsUsed = c.bazelHandler.GenerateBazelBuildActions(actx, bazelModuleLabel)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001779 }
1780 return bazelActionsUsed
1781}
1782
1783func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
1784 // TODO(cparsons): Any logic in this method occurring prior to querying Bazel should be
1785 // requested from Bazel instead.
1786
1787 // Handle the case of a test module split by `test_per_src` mutator.
1788 //
1789 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1790 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1791 // module and return early, as this module does not produce an output file per se.
1792 if c.IsTestPerSrcAllTestsVariation() {
1793 c.outputFile = android.OptionalPath{}
1794 return
1795 }
1796
1797 c.setSubnameProperty(actx)
1798 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1799 if !apexInfo.IsForPlatform() {
1800 c.hideApexVariantFromMake = true
1801 }
1802
Chris Parsonseefc9e62021-04-02 17:36:47 -04001803 c.makeLinkType = GetMakeLinkType(actx, c)
1804
Colin Crossca860ac2016-01-04 14:34:37 -08001805 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001806 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001807 moduleContextImpl: moduleContextImpl{
1808 mod: c,
1809 },
1810 }
1811 ctx.ctx = ctx
1812
Chris Parsons94a0bba2021-06-04 15:03:47 -04001813 if c.maybeGenerateBazelActions(actx) {
1814 c.maybeInstall(ctx, apexInfo)
1815 return
1816 }
1817
Colin Crossf18e1102017-11-16 14:33:08 -08001818 deps := c.depsToPaths(ctx)
1819 if ctx.Failed() {
1820 return
1821 }
1822
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001823 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1824 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1825 }
1826
Colin Crossca860ac2016-01-04 14:34:37 -08001827 flags := Flags{
1828 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001829 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001830 }
Colin Crossca860ac2016-01-04 14:34:37 -08001831 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001832 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001833 }
1834 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001835 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001836 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001837 if c.stl != nil {
1838 flags = c.stl.flags(ctx, flags)
1839 }
Colin Cross16b23492016-01-06 14:41:07 -08001840 if c.sanitize != nil {
1841 flags = c.sanitize.flags(ctx, flags)
1842 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001843 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001844 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001845 }
Stephen Craneba090d12017-05-09 15:44:35 -07001846 if c.lto != nil {
1847 flags = c.lto.flags(ctx, flags)
1848 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001849 if c.afdo != nil {
1850 flags = c.afdo.flags(ctx, flags)
1851 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001852 if c.pgo != nil {
1853 flags = c.pgo.flags(ctx, flags)
1854 }
Colin Crossca860ac2016-01-04 14:34:37 -08001855 for _, feature := range c.features {
1856 flags = feature.flags(ctx, flags)
1857 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001858 if ctx.Failed() {
1859 return
1860 }
1861
Colin Cross4af21ed2019-11-04 09:37:55 -08001862 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1863 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1864 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001865
Colin Cross4af21ed2019-11-04 09:37:55 -08001866 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001867
1868 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001869 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001870 }
1871 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001872 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001873 }
1874
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001875 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001876 // We need access to all the flags seen by a source file.
1877 if c.sabi != nil {
1878 flags = c.sabi.flags(ctx, flags)
1879 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001880
Colin Cross4af21ed2019-11-04 09:37:55 -08001881 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001882
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001883 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001884 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001885 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001886 if ctx.Failed() {
1887 return
1888 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001889 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07001890 c.objFiles = objs.objFiles
1891 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001892 }
1893
Colin Crossca860ac2016-01-04 14:34:37 -08001894 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001895 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001896 if ctx.Failed() {
1897 return
1898 }
Colin Cross635c3b02016-05-18 15:37:25 -07001899 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001900
Chris Parsons94a0bba2021-06-04 15:03:47 -04001901 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001902
Jose Galmes6f843bc2020-12-11 13:36:29 -08001903 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1904 // RECOVERY_SNAPSHOT_VERSION is current.
1905 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001906 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001907 i.collectHeadersForSnapshot(ctx)
1908 }
1909 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001910 }
Colin Cross5049f022015-03-18 13:28:46 -07001911
Chris Parsons94a0bba2021-06-04 15:03:47 -04001912 c.maybeInstall(ctx, apexInfo)
1913}
1914
1915func (c *Module) maybeUnhideFromMake() {
1916 // If a lib is directly included in any of the APEXes or is not available to the
1917 // platform (which is often the case when the stub is provided as a prebuilt),
1918 // unhide the stubs variant having the latest version gets visible to make. In
1919 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
1920 // force anything in the make world to link against the stubs library. (unless it
1921 // is explicitly referenced via .bootstrap suffix or the module is marked with
1922 // 'bootstrap: true').
1923 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
1924 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
1925 c.IsStubs() && !c.InVendorRamdisk() {
1926 c.Properties.HideFromMake = false // unhide
1927 // Note: this is still non-installable
1928 }
1929}
1930
1931func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07001932 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001933 // If the module has been specifically configure to not be installed then
1934 // hide from make as otherwise it will break when running inside make
1935 // as the output path to install will not be specified. Not all uninstallable
1936 // modules can be hidden from make as some are needed for resolving make side
1937 // dependencies.
1938 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04001939 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001940 c.SkipInstall()
1941 }
1942
1943 // Still call c.installer.install though, the installs will be stored as PackageSpecs
1944 // to allow using the outputs in a genrule.
1945 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001946 c.installer.install(ctx, c.outputFile.Path())
1947 if ctx.Failed() {
1948 return
Colin Crossca860ac2016-01-04 14:34:37 -08001949 }
Dan Albertc403f7c2015-03-18 14:01:18 -07001950 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001951}
1952
Colin Cross0ea8ba82019-06-06 14:33:29 -07001953func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001954 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05001955 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08001956 }
Colin Crossca860ac2016-01-04 14:34:37 -08001957 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001958}
1959
Colin Crossca860ac2016-01-04 14:34:37 -08001960func (c *Module) begin(ctx BaseModuleContext) {
1961 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001962 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001963 }
Colin Crossca860ac2016-01-04 14:34:37 -08001964 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001965 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001966 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001967 if c.stl != nil {
1968 c.stl.begin(ctx)
1969 }
Colin Cross16b23492016-01-06 14:41:07 -08001970 if c.sanitize != nil {
1971 c.sanitize.begin(ctx)
1972 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001973 if c.coverage != nil {
1974 c.coverage.begin(ctx)
1975 }
Stephen Craneba090d12017-05-09 15:44:35 -07001976 if c.lto != nil {
1977 c.lto.begin(ctx)
1978 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001979 if c.afdo != nil {
1980 c.afdo.begin(ctx)
1981 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001982 if c.pgo != nil {
1983 c.pgo.begin(ctx)
1984 }
Dan Albert92fe7402020-07-15 13:33:30 -07001985 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001986 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001987 if err != nil {
1988 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001989 c.Properties.Sdk_version = nil
1990 } else {
1991 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001992 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001993 }
Colin Crossca860ac2016-01-04 14:34:37 -08001994}
1995
Colin Cross37047f12016-12-13 17:06:13 -08001996func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001997 deps := Deps{}
1998
1999 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002000 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002001 }
2002 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002003 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002004 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002005 if c.stl != nil {
2006 deps = c.stl.deps(ctx, deps)
2007 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002008 if c.coverage != nil {
2009 deps = c.coverage.deps(ctx, deps)
2010 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002011
Colin Crossb6715442017-10-24 11:13:31 -07002012 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2013 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2014 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2015 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2016 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2017 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002018 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002019
Liz Kammer356f7d42021-01-26 09:18:53 -05002020 // In Bazel conversion mode, we dependency and build validations will occur in Bazel, so there is
2021 // no need to do so in Soong.
2022 if ctx.BazelConversionMode() {
2023 return deps
2024 }
2025
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002026 for _, lib := range deps.ReexportSharedLibHeaders {
2027 if !inList(lib, deps.SharedLibs) {
2028 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2029 }
2030 }
2031
2032 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002033 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2034 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 -07002035 }
2036 }
2037
Colin Cross5950f382016-12-13 12:50:57 -08002038 for _, lib := range deps.ReexportHeaderLibHeaders {
2039 if !inList(lib, deps.HeaderLibs) {
2040 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2041 }
2042 }
2043
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002044 for _, gen := range deps.ReexportGeneratedHeaders {
2045 if !inList(gen, deps.GeneratedHeaders) {
2046 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2047 }
2048 }
2049
Colin Crossc99deeb2016-04-11 15:06:20 -07002050 return deps
2051}
2052
Dan Albert7e9d2952016-08-04 13:02:36 -07002053func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002054 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002055 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002056 moduleContextImpl: moduleContextImpl{
2057 mod: c,
2058 },
2059 }
2060 ctx.ctx = ctx
2061
Colin Crossca860ac2016-01-04 14:34:37 -08002062 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002063}
2064
Jiyong Park7ed9de32018-10-15 22:25:07 +09002065// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002066func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002067 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2068 version := name[sharp+1:]
2069 libname := name[:sharp]
2070 return libname, version
2071 }
2072 return name, ""
2073}
2074
Dan Albert92fe7402020-07-15 13:33:30 -07002075func GetCrtVariations(ctx android.BottomUpMutatorContext,
2076 m LinkableInterface) []blueprint.Variation {
2077 if ctx.Os() != android.Android {
2078 return nil
2079 }
2080 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002081 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2082 minSdkVersion := m.MinSdkVersion()
2083 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2084 minSdkVersion = m.SdkVersion()
2085 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002086 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2087 if err != nil {
2088 ctx.PropertyErrorf("min_sdk_version", err.Error())
2089 }
Dan Albert92fe7402020-07-15 13:33:30 -07002090 return []blueprint.Variation{
2091 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002092 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002093 }
2094 }
2095 return []blueprint.Variation{
2096 {Mutator: "sdk", Variation: ""},
2097 }
2098}
2099
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002100func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2101 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002102
2103 variations = append([]blueprint.Variation(nil), variations...)
2104
Liz Kammer23942242022-04-08 15:41:00 -04002105 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002106 // Version is explicitly specified. i.e. libFoo#30
2107 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002108 if tag, ok := depTag.(libraryDependencyTag); ok {
2109 tag.explicitlyVersioned = true
2110 } else {
2111 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2112 }
Colin Crosse7257d22020-09-24 09:56:18 -07002113 }
Colin Crosse7257d22020-09-24 09:56:18 -07002114
Colin Cross0de8a1e2020-09-18 14:15:30 -07002115 if far {
2116 ctx.AddFarVariationDependencies(variations, depTag, name)
2117 } else {
2118 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002119 }
2120}
2121
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002122func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002123 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002124 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002125 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002126 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2127 // between the modules in the snapshot and the snapshot itself.
2128 var snapshotModule []blueprint.Module
2129 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2130 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2131 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2132 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2133 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002134 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002135 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2136 *snapshotInfo = &snapshot
2137 // republish the snapshot for use in later mutators on this module
2138 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002139 }
2140 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002141 if *snapshotInfo == nil {
2142 *snapshotInfo = &SnapshotInfo{}
2143 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002144 return **snapshotInfo
2145}
2146
2147func RewriteSnapshotLib(lib string, snapshotMap map[string]string) string {
2148 if snapshot, ok := snapshotMap[lib]; ok {
2149 return snapshot
2150 }
2151
2152 return lib
2153}
2154
2155// RewriteLibs takes a list of names of shared libraries and scans it for three types
2156// of names:
2157//
2158// 1. Name of an NDK library that refers to a prebuilt module.
2159// For each of these, it adds the name of the prebuilt module (which will be in
2160// prebuilts/ndk) to the list of nonvariant libs.
2161// 2. Name of an NDK library that refers to an ndk_library module.
2162// For each of these, it adds the name of the ndk_library module to the list of
2163// variant libs.
2164// 3. Anything else (so anything that isn't an NDK library).
2165// It adds these to the nonvariantLibs list.
2166//
2167// The caller can then know to add the variantLibs dependencies differently from the
2168// nonvariantLibs
2169func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2170 variantLibs = []string{}
2171
2172 nonvariantLibs = []string{}
2173 for _, entry := range list {
2174 // strip #version suffix out
2175 name, _ := StubsLibNameAndVersion(entry)
2176 if c.InRecovery() {
2177 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2178 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2179 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2180 } else if c.UseVndk() {
2181 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2182 } else {
2183 // put name#version back
2184 nonvariantLibs = append(nonvariantLibs, entry)
2185 }
2186 }
2187 return nonvariantLibs, variantLibs
2188}
2189
Colin Cross1e676be2016-10-12 14:38:15 -07002190func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002191 if !c.Enabled() {
2192 return
2193 }
2194
Colin Cross37047f12016-12-13 17:06:13 -08002195 ctx := &depsContext{
2196 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002197 moduleContextImpl: moduleContextImpl{
2198 mod: c,
2199 },
2200 }
2201 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002202
Colin Crossc99deeb2016-04-11 15:06:20 -07002203 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002204
Yo Chiang219968c2020-09-22 18:45:04 +08002205 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2206
Colin Crosse0edaf92021-01-11 17:31:17 -08002207 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002208
Dan Albert914449f2016-06-17 16:45:24 -07002209 variantNdkLibs := []string{}
2210 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002211 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002212 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2213 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2214 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002215
2216 for idx, lib := range deps.RuntimeLibs {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002217 deps.RuntimeLibs[idx] = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002218 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002219 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002220
Colin Cross32ec36c2016-12-15 07:39:51 -08002221 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002222 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002223 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002224 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002225 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002226
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002227 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002228
Jiyong Park1ad8e162020-12-01 23:40:09 +09002229 if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002230 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002231 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002232 } else {
2233 actx.AddVariationDependencies(nil, depTag, lib)
2234 }
2235 }
2236
Dan Albertf1d14c72020-07-30 14:32:55 -07002237 if c.isNDKStubLibrary() {
2238 // NDK stubs depend on their implementation because the ABI dumps are
2239 // generated from the implementation library.
2240 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2241 c.ImageVariation(),
2242 blueprint.Variation{Mutator: "link", Variation: "shared"},
2243 ), stubImplementation, c.BaseModuleName())
2244 }
2245
Inseob Kim07def122020-11-23 14:43:02 +09002246 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
2247 // C++ implementation library and one Java implementation library. When a module links against
2248 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
2249 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
2250 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09002251 syspropImplLibraries := syspropImplLibraries(actx.Config())
2252
Jiyong Park5d1598f2019-02-25 22:14:17 +09002253 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002254 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09002255 if impl, ok := syspropImplLibraries[lib]; ok {
2256 lib = impl
2257 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002258
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002259 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002260
Jiyong Park5d1598f2019-02-25 22:14:17 +09002261 actx.AddVariationDependencies([]blueprint.Variation{
2262 {Mutator: "link", Variation: "static"},
2263 }, depTag, lib)
2264 }
2265
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002266 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002267 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002268 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002269 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002270 }
Jiyong Parke3867542020-12-03 17:28:25 +09002271 if inList(lib, deps.ExcludeLibsForApex) {
2272 depTag.excludeInApex = true
2273 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002274
2275 if impl, ok := syspropImplLibraries[lib]; ok {
2276 lib = impl
2277 }
2278
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002279 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002280
Dan Willemsen59339a22018-07-22 21:18:45 -07002281 actx.AddVariationDependencies([]blueprint.Variation{
2282 {Mutator: "link", Variation: "static"},
2283 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002284 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002285
Jooyung Han75568392020-03-20 04:29:24 +09002286 // staticUnwinderDep is treated as staticDep for Q apexes
2287 // so that native libraries/binaries are linked with static unwinder
2288 // because Q libc doesn't have unwinder APIs
2289 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002290 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002291 actx.AddVariationDependencies([]blueprint.Variation{
2292 {Mutator: "link", Variation: "static"},
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002293 }, depTag, RewriteSnapshotLib(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002294 }
2295
Jiyong Park7ed9de32018-10-15 22:25:07 +09002296 // shared lib names without the #version suffix
2297 var sharedLibNames []string
2298
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002299 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002300 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002301 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002302 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002303 }
Jiyong Parke3867542020-12-03 17:28:25 +09002304 if inList(lib, deps.ExcludeLibsForApex) {
2305 depTag.excludeInApex = true
2306 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002307
2308 if impl, ok := syspropImplLibraries[lib]; ok {
2309 lib = impl
2310 }
2311
Jiyong Park73c54ee2019-10-22 20:31:18 +09002312 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002313 sharedLibNames = append(sharedLibNames, name)
2314
Colin Crosse7257d22020-09-24 09:56:18 -07002315 variations := []blueprint.Variation{
2316 {Mutator: "link", Variation: "shared"},
2317 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002318 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002319 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002320
Colin Crossfe9acfe2021-06-14 16:13:03 -07002321 for _, lib := range deps.LateStaticLibs {
2322 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2323 actx.AddVariationDependencies([]blueprint.Variation{
2324 {Mutator: "link", Variation: "static"},
2325 }, depTag, RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
2326 }
2327
Jiyong Park7ed9de32018-10-15 22:25:07 +09002328 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002329 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002330 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2331 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2332 // linking against both the stubs lib and the non-stubs lib at the same time.
2333 continue
2334 }
Colin Cross6e511a92020-07-27 21:26:48 -07002335 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002336 variations := []blueprint.Variation{
2337 {Mutator: "link", Variation: "shared"},
2338 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002339 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002340 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002341
Dan Willemsen59339a22018-07-22 21:18:45 -07002342 actx.AddVariationDependencies([]blueprint.Variation{
2343 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002344 }, dataLibDepTag, deps.DataLibs...)
2345
Colin Crossc8caa062021-09-24 16:50:14 -07002346 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2347
Chris Parsons79d66a52020-06-05 17:26:16 -04002348 actx.AddVariationDependencies([]blueprint.Variation{
2349 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002350 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002351
Colin Cross68861832016-07-08 10:41:41 -07002352 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002353
2354 for _, gen := range deps.GeneratedHeaders {
2355 depTag := genHeaderDepTag
2356 if inList(gen, deps.ReexportGeneratedHeaders) {
2357 depTag = genHeaderExportDepTag
2358 }
2359 actx.AddDependency(c, depTag, gen)
2360 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002361
Dan Albert92fe7402020-07-15 13:33:30 -07002362 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002363 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002364 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002365 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002366 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002367 }
Colin Crossc465efd2021-06-11 18:00:04 -07002368 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002369 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002370 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002371 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002372 if deps.DynamicLinker != "" {
2373 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002374 }
Dan Albert914449f2016-06-17 16:45:24 -07002375
2376 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002377
2378 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002379 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002380 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002381 {Mutator: "link", Variation: "shared"},
2382 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002383
2384 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002385 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002386 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002387 {Mutator: "link", Variation: "shared"},
2388 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002389
2390 if vndkdep := c.vndkdep; vndkdep != nil {
2391 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002392 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002393 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002394 {Mutator: "link", Variation: "shared"},
Justin Yun27b95722021-07-28 17:04:44 +09002395 }, vndkExtDepTag, RewriteSnapshotLib(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002396 }
2397 }
Colin Cross6362e272015-10-29 15:25:03 -07002398}
Colin Cross21b9a242015-03-24 14:15:58 -07002399
Colin Crosse40b4ea2018-10-02 22:25:58 -07002400func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002401 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2402 c.beginMutator(ctx)
2403 }
2404}
2405
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002406// Whether a module can link to another module, taking into
2407// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002408func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002409 tag blueprint.DependencyTag) {
2410
2411 switch t := tag.(type) {
2412 case dependencyTag:
2413 if t != vndkExtDepTag {
2414 return
2415 }
2416 case libraryDependencyTag:
2417 default:
2418 return
2419 }
2420
Ivan Lozanof9e21722020-12-02 09:00:51 -05002421 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002422 // Host code is not restricted
2423 return
2424 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002425
2426 // VNDK is cc.Module supported only for now.
2427 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002428 // Though allowed dependency is limited by the image mutator,
2429 // each vendor and product module needs to check link-type
2430 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002431 if ccTo, ok := to.(*Module); ok {
2432 if ccFrom.vndkdep != nil {
2433 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2434 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002435 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002436 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002437 }
2438 return
2439 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002440 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002441 // Platform code can link to anything
2442 return
2443 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002444 if from.InRamdisk() {
2445 // Ramdisk code is not NDK
2446 return
2447 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002448 if from.InVendorRamdisk() {
2449 // Vendor ramdisk code is not NDK
2450 return
2451 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002452 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002453 // Recovery code is not NDK
2454 return
2455 }
Colin Cross31076b32020-10-23 17:22:06 -07002456 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002457 if c.NdkPrebuiltStl() {
2458 // These are allowed, but they don't set sdk_version
2459 return
2460 }
2461 if c.StubDecorator() {
2462 // These aren't real libraries, but are the stub shared libraries that are included in
2463 // the NDK.
2464 return
2465 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002466 }
Logan Chien834b9a62019-01-14 15:39:03 +08002467
Ivan Lozano52767be2019-10-18 14:49:46 -07002468 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002469 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2470 // to link to libc++ (non-NDK and without sdk_version).
2471 return
2472 }
2473
Ivan Lozano52767be2019-10-18 14:49:46 -07002474 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002475 // NDK code linking to platform code is never okay.
2476 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002477 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002478 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002479 }
2480
2481 // At this point we know we have two NDK libraries, but we need to
2482 // check that we're not linking against anything built against a higher
2483 // API level, as it is only valid to link against older or equivalent
2484 // APIs.
2485
Inseob Kim01a28722018-04-11 09:48:45 +09002486 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002487 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002488 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002489 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002490 // Current can't be linked against by anything else.
2491 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002492 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002493 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002494 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002495 if err != nil {
2496 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002497 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002498 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002499 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002500 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002501 if err != nil {
2502 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002503 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002504 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002505 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002506
Inseob Kim01a28722018-04-11 09:48:45 +09002507 if toApi > fromApi {
2508 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002509 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002510 }
2511 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002512 }
Dan Albert202fe492017-12-15 13:56:59 -08002513
2514 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002515 fromStl := from.SelectedStl()
2516 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002517 if fromStl == "" || toStl == "" {
2518 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002519 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002520 // We can be permissive with the system "STL" since it is only the C++
2521 // ABI layer, but in the future we should make sure that everyone is
2522 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002523 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002524 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002525 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2526 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002527 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002528}
2529
Jooyung Han479ca172020-10-19 18:51:07 +09002530func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2531 if c, ok := ctx.Module().(*Module); ok {
2532 ctx.VisitDirectDeps(func(dep android.Module) {
2533 depTag := ctx.OtherModuleDependencyTag(dep)
2534 ccDep, ok := dep.(LinkableInterface)
2535 if ok {
2536 checkLinkType(ctx, c, ccDep, depTag)
2537 }
2538 })
2539 }
2540}
2541
Jiyong Park5fb8c102018-04-09 12:03:06 +09002542// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002543// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2544// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002545// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002546func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2547 check := func(child, parent android.Module) bool {
2548 to, ok := child.(*Module)
2549 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002550 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002551 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002552
Jooyung Hana70f0672019-01-18 15:20:43 +09002553 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2554 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002555 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002556
Jiyong Park0474e1f2021-01-14 14:26:06 +09002557 // These dependencies are not excercised at runtime. Tracking these will give us
2558 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002559 depTag := ctx.OtherModuleDependencyTag(child)
2560 if IsHeaderDepTag(depTag) {
2561 return false
2562 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002563 if depTag == staticVariantTag {
2564 return false
2565 }
2566 if depTag == stubImplDepTag {
2567 return false
2568 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002569
Justin Yun63e9ec72020-10-29 16:49:43 +09002570 // Even if target lib has no vendor variant, keep checking dependency
2571 // graph in case it depends on vendor_available or product_available
2572 // but not double_loadable transtively.
2573 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002574 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002575 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002576
Jiyong Park0474e1f2021-01-14 14:26:06 +09002577 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2578 // one.
2579 if Bool(to.VendorProperties.Double_loadable) {
2580 return true
2581 }
2582
Ivan Lozanod7586b62021-04-01 09:49:36 -04002583 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002584 return false
2585 }
2586
Jooyung Hana70f0672019-01-18 15:20:43 +09002587 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2588 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002589 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002590 return false
2591 }
2592 if module, ok := ctx.Module().(*Module); ok {
2593 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002594 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002595 ctx.WalkDeps(check)
2596 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002597 }
2598 }
2599}
2600
Colin Crossc99deeb2016-04-11 15:06:20 -07002601// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002602func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002603 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002604
Colin Cross0de8a1e2020-09-18 14:15:30 -07002605 var directStaticDeps []StaticLibraryInfo
2606 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002607
Colin Cross0de8a1e2020-09-18 14:15:30 -07002608 reexportExporter := func(exporter FlagExporterInfo) {
2609 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2610 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2611 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2612 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2613 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002614 }
2615
Jooyung Hande34d232020-07-23 13:04:15 +09002616 // For the dependency from platform to apex, use the latest stubs
2617 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002618 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2619 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002620 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002621 }
2622
2623 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2624 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2625 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2626 // (b/144430859)
2627 c.apexSdkVersion = android.FutureApiLevel
2628 }
2629
Colin Crossd11fcda2017-10-23 17:59:01 -07002630 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002631 depName := ctx.OtherModuleName(dep)
2632 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002633
Dan Willemsen47450072021-10-19 20:24:49 -07002634 if depTag == android.DarwinUniversalVariantTag {
2635 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2636 return
2637 }
2638
Ivan Lozano52767be2019-10-18 14:49:46 -07002639 ccDep, ok := dep.(LinkableInterface)
2640 if !ok {
2641
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002642 // handling for a few module types that aren't cc Module but that are also supported
2643 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002644 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002645 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002646 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2647 genRule.GeneratedSourceFiles()...)
2648 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002649 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002650 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002651 // Support exported headers from a generated_sources dependency
2652 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002653 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002654 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002655 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002656 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002657 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002658 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002659 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002660 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002661 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2662 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002663 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002664 // 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 +09002665 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002666
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002667 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002668 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002669 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002670 }
Colin Crosscef792e2021-06-11 18:01:26 -07002671 case CrtBeginDepTag:
2672 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2673 case CrtEndDepTag:
2674 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002675 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002676 return
2677 }
2678
Colin Crossfe17f6f2019-03-28 19:30:56 -07002679 if depTag == android.ProtoPluginDepTag {
2680 return
2681 }
2682
Colin Crossd11fcda2017-10-23 17:59:01 -07002683 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002684 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2685 return
2686 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002687 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002688 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2689 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002690 return
2691 }
2692
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002693 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002694 // Skip reused objects for stub libraries, they use their own stub object file instead.
2695 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2696 // version mutator, so the stubs variant is created from the shared variant that
2697 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002698 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002699 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2700 objs := staticAnalogue.ReuseObjects
2701 depPaths.Objs = depPaths.Objs.Append(objs)
2702 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2703 reexportExporter(depExporterInfo)
2704 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002705 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002706 }
2707
Colin Cross6e511a92020-07-27 21:26:48 -07002708 linkFile := ccDep.OutputFile()
2709
2710 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2711 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002712 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002713 return
2714 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002715
Jiyong Parke3867542020-12-03 17:28:25 +09002716 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2717 return
2718 }
2719
Colin Cross0de8a1e2020-09-18 14:15:30 -07002720 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002721
Colin Cross6e511a92020-07-27 21:26:48 -07002722 var ptr *android.Paths
2723 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002724
Colin Cross6e511a92020-07-27 21:26:48 -07002725 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002726
Colin Cross6e511a92020-07-27 21:26:48 -07002727 switch {
2728 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002729 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2730 if !ctx.Config().AllowMissingDependencies() {
2731 ctx.ModuleErrorf("module %q is not a header library", depName)
2732 } else {
2733 ctx.AddMissingDependencies([]string{depName})
2734 }
2735 return
2736 }
Colin Cross6e511a92020-07-27 21:26:48 -07002737 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002738 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2739 if !ctx.Config().AllowMissingDependencies() {
2740 ctx.ModuleErrorf("module %q is not a shared library", depName)
2741 } else {
2742 ctx.AddMissingDependencies([]string{depName})
2743 }
2744 return
2745 }
Jiyong Parke3867542020-12-03 17:28:25 +09002746
Jiyong Park7d55b612021-06-11 17:22:09 +09002747 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
2748 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002749
Jiyong Park1ad8e162020-12-01 23:40:09 +09002750 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2751 // linkFile, depFile, and ptr.
2752 if c.IsStubs() {
2753 break
2754 }
2755
Colin Cross0de8a1e2020-09-18 14:15:30 -07002756 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2757 depFile = sharedLibraryInfo.TableOfContents
2758
Colin Cross6e511a92020-07-27 21:26:48 -07002759 ptr = &depPaths.SharedLibs
2760 switch libDepTag.Order {
2761 case earlyLibraryDependency:
2762 ptr = &depPaths.EarlySharedLibs
2763 depPtr = &depPaths.EarlySharedLibsDeps
2764 case normalLibraryDependency:
2765 ptr = &depPaths.SharedLibs
2766 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002767 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002768 case lateLibraryDependency:
2769 ptr = &depPaths.LateSharedLibs
2770 depPtr = &depPaths.LateSharedLibsDeps
2771 default:
2772 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002773 }
Colin Cross6e511a92020-07-27 21:26:48 -07002774 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002775 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2776 if !ctx.Config().AllowMissingDependencies() {
2777 ctx.ModuleErrorf("module %q is not a static library", depName)
2778 } else {
2779 ctx.AddMissingDependencies([]string{depName})
2780 }
2781 return
2782 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002783
2784 // Stubs lib doesn't link to the static lib dependencies. Don't set
2785 // linkFile, depFile, and ptr.
2786 if c.IsStubs() {
2787 break
2788 }
2789
Colin Cross0de8a1e2020-09-18 14:15:30 -07002790 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2791 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002792 if libDepTag.wholeStatic {
2793 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002794 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2795 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002796 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002797 // This case normally catches prebuilt static
2798 // libraries, but it can also occur when
2799 // AllowMissingDependencies is on and the
2800 // dependencies has no sources of its own
2801 // but has a whole_static_libs dependency
2802 // on a missing library. We want to depend
2803 // on the .a file so that there is something
2804 // in the dependency tree that contains the
2805 // error rule for the missing transitive
2806 // dependency.
2807 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002808 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08002809 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
2810 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07002811 } else {
2812 switch libDepTag.Order {
2813 case earlyLibraryDependency:
2814 panic(fmt.Errorf("early static libs not suppported"))
2815 case normalLibraryDependency:
2816 // static dependencies will be handled separately so they can be ordered
2817 // using transitive dependencies.
2818 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002819 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002820 case lateLibraryDependency:
2821 ptr = &depPaths.LateStaticLibs
2822 default:
2823 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002824 }
2825 }
2826 }
2827
Colin Cross6e511a92020-07-27 21:26:48 -07002828 if libDepTag.static() && !libDepTag.wholeStatic {
2829 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2830 ctx.ModuleErrorf("module %q not a static library", depName)
2831 return
2832 }
Logan Chien43d34c32017-12-20 01:17:32 +08002833
Colin Cross6e511a92020-07-27 21:26:48 -07002834 // When combining coverage files for shared libraries and executables, coverage files
2835 // in static libraries act as if they were whole static libraries. The same goes for
2836 // source based Abi dump files.
2837 if c, ok := ccDep.(*Module); ok {
2838 staticLib := c.linker.(libraryInterface)
2839 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2840 staticLib.objs().coverageFiles...)
2841 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2842 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002843 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002844 // Handle non-CC modules here
2845 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002846 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002847 }
2848 }
2849
Colin Cross6e511a92020-07-27 21:26:48 -07002850 if ptr != nil {
2851 if !linkFile.Valid() {
2852 if !ctx.Config().AllowMissingDependencies() {
2853 ctx.ModuleErrorf("module %q missing output file", depName)
2854 } else {
2855 ctx.AddMissingDependencies([]string{depName})
2856 }
2857 return
2858 }
2859 *ptr = append(*ptr, linkFile.Path())
2860 }
2861
2862 if depPtr != nil {
2863 dep := depFile
2864 if !dep.Valid() {
2865 dep = linkFile
2866 }
2867 *depPtr = append(*depPtr, dep.Path())
2868 }
2869
Colin Cross0de8a1e2020-09-18 14:15:30 -07002870 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2871 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2872 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2873 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2874
2875 if libDepTag.reexportFlags {
2876 reexportExporter(depExporterInfo)
2877 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2878 // Re-exported shared library headers must be included as well since they can help us with type information
2879 // about template instantiations (instantiated from their headers).
2880 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2881 // scripts.
2882 c.sabi.Properties.ReexportedIncludes = append(
2883 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2884 }
2885
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002886 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002887 switch {
2888 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002889 c.Properties.AndroidMkHeaderLibs = append(
2890 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002891 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002892 if lib := moduleLibraryInterface(dep); lib != nil {
2893 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002894 // Add the dependency to the APEX(es) providing the library so that
2895 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002896 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09002897 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07002898 c.Properties.ApexesProvidingSharedLibs = append(
2899 c.Properties.ApexesProvidingSharedLibs, an)
2900 }
2901 }
2902 }
2903
2904 // Note: the order of libs in this list is not important because
2905 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002906 c.Properties.AndroidMkSharedLibs = append(
2907 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002908 // Record BaseLibName for snapshots.
2909 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002910 case libDepTag.static():
2911 if libDepTag.wholeStatic {
2912 c.Properties.AndroidMkWholeStaticLibs = append(
2913 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2914 } else {
2915 c.Properties.AndroidMkStaticLibs = append(
2916 c.Properties.AndroidMkStaticLibs, makeLibName)
2917 }
Justin Yun5e035862021-06-29 20:50:37 +09002918 // Record BaseLibName for snapshots.
2919 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002920 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002921 } else if !c.IsStubs() {
2922 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
2923
Colin Cross6e511a92020-07-27 21:26:48 -07002924 switch depTag {
2925 case runtimeDepTag:
2926 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002927 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002928 // Record BaseLibName for snapshots.
2929 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002930 case objDepTag:
2931 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2932 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002933 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002934 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002935 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002936 case dynamicLinkerDepTag:
2937 depPaths.DynamicLinker = linkFile
2938 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002939 }
Colin Crossca860ac2016-01-04 14:34:37 -08002940 })
2941
Jeff Gaston294356f2017-09-27 17:05:30 -07002942 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002943 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2944 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2945 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002946
Colin Crossdd84e052017-05-17 13:44:16 -07002947 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002948 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002949 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2950 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002951 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002952 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2953 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002954 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002955 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002956 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002957
2958 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002959 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002960 }
Colin Crossdd84e052017-05-17 13:44:16 -07002961
Colin Crossca860ac2016-01-04 14:34:37 -08002962 return depPaths
2963}
2964
Jiyong Park7d55b612021-06-11 17:22:09 +09002965// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
2966// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
2967// dependency. The stub variant is selected when the dependency crosses a boundary where each side
2968// has different level of updatability. For example, if a library foo in an APEX depends on a
2969// library bar which provides stable interface and exists in the platform, foo uses the stub variant
2970// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
2971// same APEX as foo, the non-stub variant of bar is used.
2972func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
2973 depName := ctx.OtherModuleName(dep)
2974 depTag := ctx.OtherModuleDependencyTag(dep)
2975 libDepTag, ok := depTag.(libraryDependencyTag)
2976 if !ok || !libDepTag.shared() {
2977 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2978 }
2979
2980 thisModule, ok := ctx.Module().(android.ApexModule)
2981 if !ok {
2982 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
2983 }
2984
2985 useVndk := false
2986 bootstrap := false
2987 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
2988 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
2989 } else {
2990 useVndk = linkable.UseVndk()
2991 bootstrap = linkable.Bootstrap()
2992 }
2993
2994 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
2995 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2996 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
2997 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2998
2999 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
3000 useStubs := false
3001
3002 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3003 if !apexInfo.IsForPlatform() {
3004 // For platform libraries, use current version of LLNDK
3005 // If this is for use_vendor apex we will apply the same rules
3006 // of apex sdk enforcement below to choose right version.
3007 useStubs = true
3008 }
Jiyong Park9477c262021-06-22 20:23:05 +09003009 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3010 // If not building for APEX or the containing APEX allows the use of
3011 // platform APIs, use stubs only when it is from an APEX (and not from
3012 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3013 // bootstrap modules, always link to non-stub variant
Jiyong Park7d55b612021-06-11 17:22:09 +09003014 useStubs = dep.(android.ApexModule).NotInPlatform() && !bootstrap
3015 if useStubs {
3016 // Another exception: if this module is a test for an APEX, then
3017 // it is linked with the non-stub variant of a module in the APEX
3018 // as if this is part of the APEX.
3019 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3020 for _, apexContents := range testFor.ApexContents {
3021 if apexContents.DirectlyInApex(depName) {
3022 useStubs = false
3023 break
3024 }
3025 }
3026 }
3027 if useStubs {
3028 // Yet another exception: If this module and the dependency are
3029 // available to the same APEXes then skip stubs between their
3030 // platform variants. This complements the test_for case above,
3031 // which avoids the stubs on a direct APEX library dependency, by
3032 // avoiding stubs for indirect test dependencies as well.
3033 //
3034 // TODO(b/183882457): This doesn't work if the two libraries have
3035 // only partially overlapping apex_available. For that test_for
3036 // modules would need to be split into APEX variants and resolved
3037 // separately for each APEX they have access to.
3038 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3039 useStubs = false
3040 }
3041 }
3042 } else {
3043 // If building for APEX, use stubs when the parent is in any APEX that
3044 // the child is not in.
3045 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3046 }
3047
3048 // when to use (unspecified) stubs, use the latest one.
3049 if useStubs {
3050 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3051 toUse := stubs[len(stubs)-1]
3052 sharedLibraryInfo = toUse.SharedLibraryInfo
3053 depExporterInfo = toUse.FlagExporterInfo
3054 }
3055 }
3056 return sharedLibraryInfo, depExporterInfo
3057}
3058
Colin Cross0de8a1e2020-09-18 14:15:30 -07003059// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3060// to match the topological order of the dependency tree, including any static analogues of
3061// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3062// of the transitive dependencies.
3063func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3064 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3065 var staticPaths android.Paths
3066 for _, staticDep := range staticDeps {
3067 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3068 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3069 }
3070 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003071 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3072 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003073 }
3074 }
3075 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3076
3077 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3078
3079 // reorder the dependencies based on transitive dependencies
3080 staticPaths = android.FirstUniquePaths(staticPaths)
3081 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3082
3083 if len(orderedStaticPaths) != len(staticPaths) {
3084 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3085 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3086 }
3087
3088 return orderedStaticPaths, transitiveStaticLibs
3089}
3090
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003091// BaseLibName trims known prefixes and suffixes
3092func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003093 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3094 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003095 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003096 return libName
3097}
3098
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003099func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003100 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003101 ccDepModule, _ := ccDep.(*Module)
3102 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003103 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003104
Justin Yuncbca3732021-02-03 19:24:13 +09003105 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003106 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07003107 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003108 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003109 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003110
Ivan Lozanod1dec542021-05-26 15:33:11 -04003111 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003112 }
3113 }
3114
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003115 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3116 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003117 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3118 // core module instead.
3119 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003120 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003121 // The vendor and product modules in Make will have been renamed to not conflict with the
3122 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003123 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003124 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003125 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003126 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003127 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003128 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003129 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003130 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003131 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003132 } else {
3133 return libName
3134 }
3135}
3136
Colin Crossca860ac2016-01-04 14:34:37 -08003137func (c *Module) InstallInData() bool {
3138 if c.installer == nil {
3139 return false
3140 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003141 return c.installer.inData()
3142}
3143
3144func (c *Module) InstallInSanitizerDir() bool {
3145 if c.installer == nil {
3146 return false
3147 }
3148 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003149 return true
3150 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003151 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003152}
3153
Yifan Hong1b3348d2020-01-21 15:53:22 -08003154func (c *Module) InstallInRamdisk() bool {
3155 return c.InRamdisk()
3156}
3157
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003158func (c *Module) InstallInVendorRamdisk() bool {
3159 return c.InVendorRamdisk()
3160}
3161
Jiyong Parkf9332f12018-02-01 00:54:12 +09003162func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003163 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003164}
3165
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003166func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003167 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003168 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003169 return
3170 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003171 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003172}
3173
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003174func (c *Module) HostToolPath() android.OptionalPath {
3175 if c.installer == nil {
3176 return android.OptionalPath{}
3177 }
3178 return c.installer.hostToolPath()
3179}
3180
Nan Zhangd4e641b2017-07-12 12:55:28 -07003181func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3182 return c.outputFile
3183}
3184
Colin Cross41955e82019-05-29 14:40:35 -07003185func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3186 switch tag {
3187 case "":
3188 if c.outputFile.Valid() {
3189 return android.Paths{c.outputFile.Path()}, nil
3190 }
3191 return android.Paths{}, nil
3192 default:
3193 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003194 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003195}
3196
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003197func (c *Module) static() bool {
3198 if static, ok := c.linker.(interface {
3199 static() bool
3200 }); ok {
3201 return static.static()
3202 }
3203 return false
3204}
3205
Jiyong Park379de2f2018-12-19 02:47:14 +09003206func (c *Module) staticBinary() bool {
3207 if static, ok := c.linker.(interface {
3208 staticBinary() bool
3209 }); ok {
3210 return static.staticBinary()
3211 }
3212 return false
3213}
3214
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003215func (c *Module) testBinary() bool {
3216 if test, ok := c.linker.(interface {
3217 testBinary() bool
3218 }); ok {
3219 return test.testBinary()
3220 }
3221 return false
3222}
3223
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003224func (c *Module) benchmarkBinary() bool {
3225 if b, ok := c.linker.(interface {
3226 benchmarkBinary() bool
3227 }); ok {
3228 return b.benchmarkBinary()
3229 }
3230 return false
3231}
3232
3233func (c *Module) fuzzBinary() bool {
3234 if f, ok := c.linker.(interface {
3235 fuzzBinary() bool
3236 }); ok {
3237 return f.fuzzBinary()
3238 }
3239 return false
3240}
3241
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003242// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3243func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003244 if h, ok := c.linker.(interface {
3245 header() bool
3246 }); ok {
3247 return h.header()
3248 }
3249 return false
3250}
3251
Ivan Lozanod7586b62021-04-01 09:49:36 -04003252func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003253 if b, ok := c.linker.(interface {
3254 binary() bool
3255 }); ok {
3256 return b.binary()
3257 }
3258 return false
3259}
3260
Justin Yun5e035862021-06-29 20:50:37 +09003261func (c *Module) StaticExecutable() bool {
3262 if b, ok := c.linker.(*binaryDecorator); ok {
3263 return b.static()
3264 }
3265 return false
3266}
3267
Ivan Lozanod7586b62021-04-01 09:49:36 -04003268func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003269 if o, ok := c.linker.(interface {
3270 object() bool
3271 }); ok {
3272 return o.object()
3273 }
3274 return false
3275}
3276
Ivan Lozanof9e21722020-12-02 09:00:51 -05003277func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003278 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003279 if c.IsLlndk() {
3280 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003281 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003282 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003283 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003284 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003285 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003286 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003287 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003288 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003289 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003290 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003291 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003292 return "native:product"
3293 }
Jooyung Han38002912019-05-16 04:01:54 +09003294 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003295 } else if c.InRamdisk() {
3296 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003297 } else if c.InVendorRamdisk() {
3298 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003299 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003300 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003301 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003302 return "native:ndk:none:none"
3303 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3304 //family, link := getNdkStlFamilyAndLinkType(c)
3305 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003306 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003307 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003308 } else {
3309 return "native:platform"
3310 }
3311}
3312
Jiyong Park9d452992018-10-03 00:38:19 +09003313// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003314// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003315func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003316 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003317 // Stub libs and prebuilt libs in a versioned SDK are not
3318 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003319 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003320 } else if _, ok := c.linker.(testPerSrc); ok {
3321 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003322 }
3323 return false
3324}
3325
Jiyong Parka90ca002019-10-07 15:47:24 +09003326func (c *Module) AvailableFor(what string) bool {
3327 if linker, ok := c.linker.(interface {
3328 availableFor(string) bool
3329 }); ok {
3330 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3331 } else {
3332 return c.ApexModuleBase.AvailableFor(what)
3333 }
3334}
3335
Jiyong Park62304bb2020-04-13 16:19:48 +09003336func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003337 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003338}
3339
Paul Duffin0cb37b92020-03-04 14:52:46 +00003340func (c *Module) EverInstallable() bool {
3341 return c.installer != nil &&
3342 // Check to see whether the module is actually ever installable.
3343 c.installer.everInstallable()
3344}
3345
Ivan Lozanod7586b62021-04-01 09:49:36 -04003346func (c *Module) PreventInstall() bool {
3347 return c.Properties.PreventInstall
3348}
3349
3350func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003351 if c.library != nil {
3352 if i := c.library.installable(); i != nil {
3353 return i
3354 }
3355 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003356 return c.Properties.Installable
3357}
3358
3359func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003360 ret := c.EverInstallable() &&
3361 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003362 proptools.BoolDefault(c.Installable(), true) &&
3363 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003364
3365 // The platform variant doesn't need further condition. Apex variants however might not
3366 // be installable because it will likely to be included in the APEX and won't appear
3367 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003368 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003369 return ret
3370 }
3371
3372 // Special case for modules that are configured to be installed to /data, which includes
3373 // test modules. For these modules, both APEX and non-APEX variants are considered as
3374 // installable. This is because even the APEX variants won't be included in the APEX, but
3375 // will anyway be installed to /data/*.
3376 // See b/146995717
3377 if c.InstallInData() {
3378 return ret
3379 }
3380
3381 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003382}
3383
Logan Chien41eabe62019-04-10 13:33:58 +08003384func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3385 if c.linker != nil {
3386 if library, ok := c.linker.(*libraryDecorator); ok {
3387 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3388 }
3389 }
3390}
3391
Jiyong Park45bf82e2020-12-15 22:29:02 +09003392var _ android.ApexModule = (*Module)(nil)
3393
3394// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003395func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003396 depTag := ctx.OtherModuleDependencyTag(dep)
3397 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3398
3399 if cc, ok := dep.(*Module); ok {
3400 if cc.HasStubsVariants() {
3401 if isLibDepTag && libDepTag.shared() {
3402 // dynamic dep to a stubs lib crosses APEX boundary
3403 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003404 }
Colin Cross6e511a92020-07-27 21:26:48 -07003405 if IsRuntimeDepTag(depTag) {
3406 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003407 return false
3408 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003409 }
Zhijun Heec285872021-04-24 10:47:08 -07003410 if cc.IsLlndk() {
3411 return false
3412 }
Colin Crossaac32222020-07-29 12:51:56 -07003413 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003414 // shared_lib dependency from a static lib is considered as crossing
3415 // the APEX boundary because the dependency doesn't actually is
3416 // linked; the dependency is used only during the compilation phase.
3417 return false
3418 }
Jiyong Parke3867542020-12-03 17:28:25 +09003419
3420 if isLibDepTag && libDepTag.excludeInApex {
3421 return false
3422 }
Colin Cross6e511a92020-07-27 21:26:48 -07003423 }
Colin Crossc1b36442021-05-06 13:42:48 -07003424 if depTag == stubImplDepTag {
3425 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003426 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003427 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003428 if depTag == staticVariantTag {
3429 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3430 // actually mean that the static lib (and its dependencies) are copied into the
3431 // APEX.
3432 return false
3433 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003434 return true
3435}
3436
Jiyong Park45bf82e2020-12-15 22:29:02 +09003437// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003438func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3439 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003440 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3441 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3442 return nil
3443 }
Jooyung Han749dc692020-04-15 11:03:39 +09003444 // We don't check for prebuilt modules
3445 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3446 return nil
3447 }
3448 minSdkVersion := c.MinSdkVersion()
3449 if minSdkVersion == "apex_inherit" {
3450 return nil
3451 }
3452 if minSdkVersion == "" {
3453 // JNI libs within APK-in-APEX fall into here
3454 // Those are okay to set sdk_version instead
3455 // We don't have to check if this is a SDK variant because
3456 // non-SDK variant resets sdk_version, which works too.
3457 minSdkVersion = c.SdkVersion()
3458 }
Dan Albertc8060532020-07-22 22:32:17 -07003459 if minSdkVersion == "" {
3460 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3461 }
3462 // Not using nativeApiLevelFromUser because the context here is not
3463 // necessarily a native context.
3464 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003465 if err != nil {
3466 return err
3467 }
Dan Albertc8060532020-07-22 22:32:17 -07003468
3469 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003470 return fmt.Errorf("newer SDK(%v)", ver)
3471 }
3472 return nil
3473}
3474
Paul Duffinb5769c12021-05-12 16:16:51 +01003475// Implements android.ApexModule
3476func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3477 // stub libraries and native bridge libraries are always available to platform
3478 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3479}
3480
Jooyung Han91f92032022-02-04 12:36:33 +09003481// Overrides android.ApexModuleBase.UniqueApexVariations
3482func (c *Module) UniqueApexVariations() bool {
3483 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3484 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3485 // variation of the VNDK lib because APEX variations are merged/grouped.
3486 return c.UseVndk() && c.IsVndk()
3487}
3488
Rob Seymour925aa092021-08-10 20:42:03 +00003489var _ snapshot.RelativeInstallPath = (*Module)(nil)
3490
Liz Kammer35ca77e2021-12-22 15:31:40 -05003491type moduleType int
3492
3493const (
3494 unknownType moduleType = iota
3495 binary
3496 object
3497 fullLibrary
3498 staticLibrary
3499 sharedLibrary
3500 headerLibrary
3501)
3502
3503func (c *Module) typ() moduleType {
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003504 if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003505 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003506 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003507 return object
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003508 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003509 static := false
3510 shared := false
3511 if library, ok := c.linker.(*libraryDecorator); ok {
3512 static = library.MutatedProperties.BuildStatic
3513 shared = library.MutatedProperties.BuildShared
3514 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3515 static = library.MutatedProperties.BuildStatic
3516 shared = library.MutatedProperties.BuildShared
3517 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003518 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003519 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003520 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003521 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003522 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003523 return staticLibrary
3524 }
3525 return sharedLibrary
3526 }
3527 return unknownType
3528}
3529
3530// ConvertWithBp2build converts Module to Bazel for bp2build.
3531func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
3532 prebuilt := c.IsPrebuilt()
3533 switch c.typ() {
3534 case binary:
3535 if !prebuilt {
3536 binaryBp2build(ctx, c, ctx.ModuleType())
3537 }
3538 case object:
3539 if !prebuilt {
3540 objectBp2Build(ctx, c)
3541 }
3542 case fullLibrary:
3543 if !prebuilt {
3544 libraryBp2Build(ctx, c)
3545 }
3546 case headerLibrary:
3547 libraryHeadersBp2Build(ctx, c)
3548 case staticLibrary:
3549
3550 if prebuilt {
3551 prebuiltLibraryStaticBp2Build(ctx, c)
3552 } else {
3553 sharedOrStaticLibraryBp2Build(ctx, c, true)
3554 }
3555 case sharedLibrary:
3556 if prebuilt {
3557 prebuiltLibrarySharedBp2Build(ctx, c)
3558 } else {
3559 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003560 }
3561 }
3562}
3563
Colin Cross2ba19d92015-05-07 15:44:20 -07003564//
Colin Crosscfad1192015-11-02 16:43:11 -08003565// Defaults
3566//
Colin Crossca860ac2016-01-04 14:34:37 -08003567type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003568 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003569 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003570 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003571}
3572
Patrice Arrudac249c712019-03-19 17:00:29 -07003573// cc_defaults provides a set of properties that can be inherited by other cc
3574// modules. A module can use the properties from a cc_defaults using
3575// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3576// merged (when possible) by prepending the default module's values to the
3577// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003578func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003579 return DefaultsFactory()
3580}
3581
Colin Cross36242852017-06-23 15:06:31 -07003582func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003583 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003584
Colin Cross36242852017-06-23 15:06:31 -07003585 module.AddProperties(props...)
3586 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003587 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003588 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003589 &BaseCompilerProperties{},
3590 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003591 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003592 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003593 &StaticProperties{},
3594 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003595 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003596 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003597 &TestLinkerProperties{},
3598 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003599 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003600 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003601 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003602 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003603 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003604 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003605 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003606 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003607 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003608 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003609 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003610 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003611 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003612 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003613 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003614 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3615 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003616 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003617 )
Colin Crosscfad1192015-11-02 16:43:11 -08003618
Jooyung Hancc372c52019-09-25 15:18:44 +09003619 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003620
3621 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003622}
3623
Jiyong Park2286afd2020-06-16 21:58:53 +09003624func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003625 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003626}
3627
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003628func kytheExtractAllFactory() android.Singleton {
3629 return &kytheExtractAllSingleton{}
3630}
3631
3632type kytheExtractAllSingleton struct {
3633}
3634
3635func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3636 var xrefTargets android.Paths
3637 ctx.VisitAllModules(func(module android.Module) {
3638 if ccModule, ok := module.(xref); ok {
3639 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3640 }
3641 })
3642 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3643 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003644 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003645 }
3646}
3647
Colin Cross06a931b2015-10-28 17:23:31 -07003648var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003649var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003650var BoolPtr = proptools.BoolPtr
3651var String = proptools.String
3652var StringPtr = proptools.StringPtr