blob: da8a8078da297cedd6a7924819615c507421b06b [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"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000748 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700749)
750
Roland Levillainf89cd092019-07-29 16:22:59 +0100751func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700752 ccLibDepTag, ok := depTag.(libraryDependencyTag)
753 return ok && ccLibDepTag.shared()
754}
755
756func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
757 ccLibDepTag, ok := depTag.(libraryDependencyTag)
758 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100759}
760
Zach Johnson3df4e632020-11-06 11:56:27 -0800761func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
762 ccLibDepTag, ok := depTag.(libraryDependencyTag)
763 return ok && ccLibDepTag.header()
764}
765
Roland Levillainf89cd092019-07-29 16:22:59 +0100766func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800767 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100768}
769
770func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700771 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100772 return ok && ccDepTag == testPerSrcDepTag
773}
774
Chris Parsonsf874e462022-05-10 13:50:12 -0400775// bazelHandler is the interface for a helper object related to deferring to Bazel for
776// processing a cc module (during Bazel mixed builds). Individual module types should define
777// their own bazel handler if they support being handled by Bazel.
778type BazelHandler interface {
779 // QueueBazelCall invokes request-queueing functions on the BazelContext
780 //so that these requests are handled when Bazel's cquery is invoked.
781 QueueBazelCall(ctx android.BaseModuleContext, label string)
782
783 // ProcessBazelQueryResponse uses information retrieved from Bazel to set properties
784 // on the current module with given label.
785 ProcessBazelQueryResponse(ctx android.ModuleContext, label string)
786}
787
Colin Crossca860ac2016-01-04 14:34:37 -0800788// Module contains the properties and members used by all C/C++ module types, and implements
789// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500790// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
791// interface.
792//
793// To define a C/C++ related module, construct a new Module object and point its delegates to
794// type-specific structs. These delegates will be invoked to register module-specific build
795// statements which may be unique to the module type. For example, module.compiler.compile() should
796// be defined so as to register build statements which are responsible for compiling the module.
797//
798// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
799// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
800// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
801// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800802type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700803 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700804
Jiyong Parkd1063c12019-07-17 20:08:41 +0900805 android.SdkBase
Liz Kammerea6666f2021-02-17 10:17:28 -0500806 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700807
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700808 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700809 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700810
Colin Crossca860ac2016-01-04 14:34:37 -0800811 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400812 hod android.HostOrDeviceSupported
813 multilib android.Multilib
814 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700815
Paul Duffina0843f62019-12-13 19:50:38 +0000816 // Allowable SdkMemberTypes of this module type.
817 sdkMemberTypes []android.SdkMemberType
818
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500819 // decorator delegates, initialize before calling Init
820 // these may contain module-specific implementations, and effectively allow for custom
821 // type-specific logic. These members may reference different objects or the same object.
822 // Functions of these decorators will be invoked to initialize and register type-specific
823 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500824 compiler compiler
825 linker linker
826 installer installer
Chris Parsonsf874e462022-05-10 13:50:12 -0400827 bazelHandler BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500828
829 features []feature
830 stl *stl
831 sanitize *sanitize
832 coverage *coverage
833 sabi *sabi
834 vndkdep *vndkdep
835 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800836 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500837 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800838
Colin Cross31076b32020-10-23 17:22:06 -0700839 library libraryInterface
840
Colin Cross635c3b02016-05-18 15:37:25 -0700841 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800842
Colin Crossb98c8b02016-07-29 13:44:28 -0700843 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700844
845 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800846
847 // Flags used to compile this module
848 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700849
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800850 // Shared flags among build rules of this module
851 sharedFlags SharedFlags
852
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800853 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700854 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900855
856 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800857 // Kythe (source file indexer) paths for this compilation module
858 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700859 // Object .o file output paths for this compilation module
860 objFiles android.Paths
861 // Tidy .tidy file output paths for this compilation module
862 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900863
864 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700865 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700866
867 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700868}
869
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200870func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400871 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
872 if b, ok := c.compiler.(*baseCompiler); ok {
873 hasAidl = b.hasSrcExt(".aidl")
874 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
875 hasProto = b.hasSrcExt(".proto")
876 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
877 hasSysprop = b.hasSrcExt(".sysprop")
878 hasWinMsg = b.hasSrcExt(".mc")
879 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
880 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200881 c.AndroidModuleBase().AddJSONData(d)
882 (*d)["Cc"] = map[string]interface{}{
883 "SdkVersion": c.SdkVersion(),
884 "MinSdkVersion": c.MinSdkVersion(),
885 "VndkVersion": c.VndkVersion(),
886 "ProductSpecific": c.ProductSpecific(),
887 "SocSpecific": c.SocSpecific(),
888 "DeviceSpecific": c.DeviceSpecific(),
889 "InProduct": c.InProduct(),
890 "InVendor": c.InVendor(),
891 "InRamdisk": c.InRamdisk(),
892 "InVendorRamdisk": c.InVendorRamdisk(),
893 "InRecovery": c.InRecovery(),
894 "VendorAvailable": c.VendorAvailable(),
895 "ProductAvailable": c.ProductAvailable(),
896 "RamdiskAvailable": c.RamdiskAvailable(),
897 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
898 "RecoveryAvailable": c.RecoveryAvailable(),
899 "OdmAvailable": c.OdmAvailable(),
900 "InstallInData": c.InstallInData(),
901 "InstallInRamdisk": c.InstallInRamdisk(),
902 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
903 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
904 "InstallInRecovery": c.InstallInRecovery(),
905 "InstallInRoot": c.InstallInRoot(),
906 "IsVndk": c.IsVndk(),
907 "IsVndkExt": c.IsVndkExt(),
908 "IsVndkPrivate": c.IsVndkPrivate(),
909 "IsVndkSp": c.IsVndkSp(),
910 "IsLlndk": c.IsLlndk(),
911 "IsLlndkPublic": c.IsLlndkPublic(),
912 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
913 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
914 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
915 "ApexSdkVersion": c.apexSdkVersion,
916 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400917 "AidlSrcs": hasAidl,
918 "LexSrcs": hasLex,
919 "ProtoSrcs": hasProto,
920 "RenderscriptSrcs": hasRenderscript,
921 "SyspropSrcs": hasSysprop,
922 "WinMsgSrcs": hasWinMsg,
923 "YaccSrsc": hasYacc,
924 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200925 }
926}
927
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500928func (c *Module) SetPreventInstall() {
929 c.Properties.PreventInstall = true
930}
931
932func (c *Module) SetHideFromMake() {
933 c.Properties.HideFromMake = true
934}
935
Ivan Lozanod7586b62021-04-01 09:49:36 -0400936func (c *Module) HiddenFromMake() bool {
937 return c.Properties.HideFromMake
938}
939
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800940func (c *Module) RequiredModuleNames() []string {
941 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
942 if c.ImageVariation().Variation == android.CoreVariation {
943 required = append(required, c.Properties.Target.Platform.Required...)
944 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
945 } else if c.InRecovery() {
946 required = append(required, c.Properties.Target.Recovery.Required...)
947 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
948 }
949 return android.FirstUniqueStrings(required)
950}
951
Ivan Lozano52767be2019-10-18 14:49:46 -0700952func (c *Module) Toc() android.OptionalPath {
953 if c.linker != nil {
954 if library, ok := c.linker.(libraryInterface); ok {
955 return library.toc()
956 }
957 }
958 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
959}
960
961func (c *Module) ApiLevel() string {
962 if c.linker != nil {
963 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700964 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700965 }
966 }
967 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
968}
969
970func (c *Module) Static() bool {
971 if c.linker != nil {
972 if library, ok := c.linker.(libraryInterface); ok {
973 return library.static()
974 }
975 }
976 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
977}
978
979func (c *Module) Shared() bool {
980 if c.linker != nil {
981 if library, ok := c.linker.(libraryInterface); ok {
982 return library.shared()
983 }
984 }
985 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
986}
987
988func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000989 if c.stl != nil {
990 return c.stl.Properties.SelectedStl
991 }
992 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700993}
994
Ivan Lozano52767be2019-10-18 14:49:46 -0700995func (c *Module) NdkPrebuiltStl() bool {
996 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
997 return true
998 }
999 return false
1000}
1001
1002func (c *Module) StubDecorator() bool {
1003 if _, ok := c.linker.(*stubDecorator); ok {
1004 return true
1005 }
1006 return false
1007}
1008
1009func (c *Module) SdkVersion() string {
1010 return String(c.Properties.Sdk_version)
1011}
1012
Artur Satayev480e25b2020-04-27 18:53:18 +01001013func (c *Module) MinSdkVersion() string {
1014 return String(c.Properties.Min_sdk_version)
1015}
1016
Jiyong Park5df7bd32021-08-25 16:18:46 +09001017func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001018 if linker, ok := c.linker.(*objectLinker); ok {
1019 return linker.isCrt()
1020 }
1021 return false
1022}
1023
Jiyong Park5df7bd32021-08-25 16:18:46 +09001024func (c *Module) SplitPerApiLevel() bool {
1025 return c.canUseSdk() && c.isCrt()
1026}
1027
Colin Crossc511bc52020-04-07 16:50:32 +00001028func (c *Module) AlwaysSdk() bool {
1029 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1030}
1031
Ivan Lozano183a3212019-10-18 14:18:45 -07001032func (c *Module) CcLibrary() bool {
1033 if c.linker != nil {
1034 if _, ok := c.linker.(*libraryDecorator); ok {
1035 return true
1036 }
Colin Crossd48fe732020-09-23 20:37:24 -07001037 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1038 return true
1039 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001040 }
1041 return false
1042}
1043
1044func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001045 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001046 return true
1047 }
1048 return false
1049}
1050
Ivan Lozano2b262972019-11-21 12:30:50 -08001051func (c *Module) NonCcVariants() bool {
1052 return false
1053}
1054
Ivan Lozano183a3212019-10-18 14:18:45 -07001055func (c *Module) SetStatic() {
1056 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001057 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001058 library.setStatic()
1059 return
1060 }
1061 }
1062 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1063}
1064
1065func (c *Module) SetShared() {
1066 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001067 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001068 library.setShared()
1069 return
1070 }
1071 }
1072 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1073}
1074
1075func (c *Module) BuildStaticVariant() bool {
1076 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001077 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001078 return library.buildStatic()
1079 }
1080 }
1081 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1082}
1083
1084func (c *Module) BuildSharedVariant() bool {
1085 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001086 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001087 return library.buildShared()
1088 }
1089 }
1090 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1091}
1092
1093func (c *Module) Module() android.Module {
1094 return c
1095}
1096
Jiyong Parkc20eee32018-09-05 22:36:17 +09001097func (c *Module) OutputFile() android.OptionalPath {
1098 return c.outputFile
1099}
1100
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001101func (c *Module) CoverageFiles() android.Paths {
1102 if c.linker != nil {
1103 if library, ok := c.linker.(libraryInterface); ok {
1104 return library.objs().coverageFiles
1105 }
1106 }
1107 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1108}
1109
Ivan Lozano183a3212019-10-18 14:18:45 -07001110var _ LinkableInterface = (*Module)(nil)
1111
Jiyong Park719b4462019-01-13 00:39:51 +09001112func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001113 if c.linker != nil {
1114 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001115 }
1116 return nil
1117}
1118
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001119func (c *Module) CoverageOutputFile() android.OptionalPath {
1120 if c.linker != nil {
1121 return c.linker.coverageOutputFilePath()
1122 }
1123 return android.OptionalPath{}
1124}
1125
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001126func (c *Module) RelativeInstallPath() string {
1127 if c.installer != nil {
1128 return c.installer.relativeInstallPath()
1129 }
1130 return ""
1131}
1132
Jooyung Han344d5432019-08-23 11:17:39 +09001133func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001134 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001135}
1136
Colin Cross36242852017-06-23 15:06:31 -07001137func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001138 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001139 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001140 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001141 }
1142 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001143 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001144 }
1145 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001146 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001147 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001148 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001149 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001150 }
Colin Cross16b23492016-01-06 14:41:07 -08001151 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001152 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001153 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001154 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001155 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001156 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001157 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001158 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001159 }
Justin Yun8effde42017-06-23 19:24:43 +09001160 if c.vndkdep != nil {
1161 c.AddProperties(c.vndkdep.props()...)
1162 }
Stephen Craneba090d12017-05-09 15:44:35 -07001163 if c.lto != nil {
1164 c.AddProperties(c.lto.props()...)
1165 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001166 if c.afdo != nil {
1167 c.AddProperties(c.afdo.props()...)
1168 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001169 if c.pgo != nil {
1170 c.AddProperties(c.pgo.props()...)
1171 }
Colin Crossca860ac2016-01-04 14:34:37 -08001172 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001173 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001174 }
Colin Crossc472d572015-03-17 15:06:21 -07001175
Colin Cross36242852017-06-23 15:06:31 -07001176 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001177 if c.bazelable {
1178 android.InitBazelModule(c)
1179 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001180 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001181 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001182 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001183
Colin Cross36242852017-06-23 15:06:31 -07001184 return c
Colin Crossc472d572015-03-17 15:06:21 -07001185}
1186
Ivan Lozano52767be2019-10-18 14:49:46 -07001187func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001188 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001189}
1190
Colin Crossc511bc52020-04-07 16:50:32 +00001191func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001192 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1193 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001194}
1195
1196func (c *Module) UseSdk() bool {
1197 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001198 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001199 }
1200 return false
1201}
1202
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001203func (c *Module) isCoverageVariant() bool {
1204 return c.coverage.Properties.IsCoverageVariant
1205}
1206
Colin Cross95f1ca02020-10-29 20:47:22 -07001207func (c *Module) IsNdk(config android.Config) bool {
1208 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001209}
1210
Colin Cross127bb8b2020-12-16 16:46:01 -08001211func (c *Module) IsLlndk() bool {
1212 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001213}
1214
Colin Cross127bb8b2020-12-16 16:46:01 -08001215func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001216 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001217}
1218
Colin Cross1f3f1302021-04-26 18:37:44 -07001219func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001220 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001221 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001222}
1223
Colin Cross5271fea2021-04-27 13:06:04 -07001224func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1225 lib := moduleLibraryInterface(m)
1226 return lib != nil && (lib.hasVendorPublicLibrary())
1227}
1228
1229// IsVendorPublicLibrary returns true for vendor public libraries.
1230func (c *Module) IsVendorPublicLibrary() bool {
1231 return c.VendorProperties.IsVendorPublicLibrary
1232}
1233
Ivan Lozanof1868af2022-04-12 13:08:36 -04001234func (c *Module) IsVndkPrebuiltLibrary() bool {
1235 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1236 return true
1237 }
1238 return false
1239}
1240
1241func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1242 return c.Properties.SdkAndPlatformVariantVisibleToMake
1243}
1244
Ivan Lozanod7586b62021-04-01 09:49:36 -04001245func (c *Module) HasLlndkStubs() bool {
1246 lib := moduleLibraryInterface(c)
1247 return lib != nil && lib.hasLLNDKStubs()
1248}
1249
1250func (c *Module) StubsVersion() string {
1251 if lib, ok := c.linker.(versionedInterface); ok {
1252 return lib.stubsVersion()
1253 }
1254 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1255}
1256
Colin Cross127bb8b2020-12-16 16:46:01 -08001257// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1258// and does not set llndk.vendor_available: false.
1259func (c *Module) isImplementationForLLNDKPublic() bool {
1260 library, _ := c.library.(*libraryDecorator)
1261 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001262 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001263}
1264
Justin Yunfd9e8042020-12-23 18:23:14 +09001265// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001266func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001267 // Check if VNDK-core-private or VNDK-SP-private
1268 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001269 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001270 }
1271
1272 // Check if LLNDK-private
1273 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001274 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001275 }
1276
1277 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001278}
1279
Ivan Lozano52767be2019-10-18 14:49:46 -07001280func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001281 if vndkdep := c.vndkdep; vndkdep != nil {
1282 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001283 }
1284 return false
1285}
1286
Yi Kong4ef54592022-02-14 20:00:10 +08001287func (c *Module) isAfdoCompile() bool {
1288 if afdo := c.afdo; afdo != nil {
1289 return afdo.Properties.AfdoTarget != nil
1290 }
1291 return false
1292}
1293
Yi Kong7e53c572018-02-14 18:16:12 +08001294func (c *Module) isPgoCompile() bool {
1295 if pgo := c.pgo; pgo != nil {
1296 return pgo.Properties.PgoCompile
1297 }
1298 return false
1299}
1300
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001301func (c *Module) isNDKStubLibrary() bool {
1302 if _, ok := c.compiler.(*stubDecorator); ok {
1303 return true
1304 }
1305 return false
1306}
1307
Ivan Lozanod7586b62021-04-01 09:49:36 -04001308func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001309 if vndkdep := c.vndkdep; vndkdep != nil {
1310 return vndkdep.isVndkSp()
1311 }
1312 return false
1313}
1314
Ivan Lozanof9e21722020-12-02 09:00:51 -05001315func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001316 if vndkdep := c.vndkdep; vndkdep != nil {
1317 return vndkdep.isVndkExt()
1318 }
1319 return false
1320}
1321
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001322func (c *Module) SubName() string {
1323 return c.Properties.SubName
1324}
1325
Ivan Lozano52767be2019-10-18 14:49:46 -07001326func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001327 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001328}
1329
Logan Chienf3511742017-10-31 18:04:35 +08001330func (c *Module) getVndkExtendsModuleName() string {
1331 if vndkdep := c.vndkdep; vndkdep != nil {
1332 return vndkdep.getVndkExtendsModuleName()
1333 }
1334 return ""
1335}
1336
Jiyong Park25fc6a92018-11-18 18:02:45 +09001337func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001338 if lib := c.library; lib != nil {
1339 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001340 }
1341 return false
1342}
1343
1344func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001345 if lib := c.library; lib != nil {
1346 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001347 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001348 return false
1349}
1350
Colin Cross0477b422020-10-13 18:43:54 -07001351// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1352// the implementation. If it is an implementation library it returns its own name.
1353func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1354 name := ctx.OtherModuleName(c)
1355 if versioned, ok := c.linker.(versionedInterface); ok {
1356 name = versioned.implementationModuleName(name)
1357 }
1358 return name
1359}
1360
Martin Stjernholm2856c662020-12-02 15:03:42 +00001361// Similar to ImplementationModuleName, but uses the Make variant of the module
1362// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1363// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1364// under the premise that the prebuilt module overrides its source counterpart
1365// if it is exposed to Make).
1366func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1367 name := c.BaseModuleName()
1368 if versioned, ok := c.linker.(versionedInterface); ok {
1369 name = versioned.implementationModuleName(name)
1370 }
1371 return name
1372}
1373
Jiyong Park7d55b612021-06-11 17:22:09 +09001374func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001375 return Bool(c.Properties.Bootstrap)
1376}
1377
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001378func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001379 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1380 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1381 return false
1382 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001383 return c.linker != nil && c.linker.nativeCoverage()
1384}
1385
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001386func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001387 if p, ok := c.linker.(SnapshotInterface); ok {
1388 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001389 }
1390 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001391}
1392
Bill Peckham945441c2020-08-31 16:07:58 -07001393func (c *Module) ExcludeFromVendorSnapshot() bool {
1394 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1395}
1396
Jose Galmesf7294582020-11-13 12:07:36 -08001397func (c *Module) ExcludeFromRecoverySnapshot() bool {
1398 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1399}
1400
Jiyong Parkf1194352019-02-25 11:05:47 +09001401func isBionic(name string) bool {
1402 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001403 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001404 return true
1405 }
1406 return false
1407}
1408
Martin Stjernholm279de572019-09-10 23:18:20 +01001409func InstallToBootstrap(name string, config android.Config) bool {
Colin Cross4c4c1be2022-02-10 11:41:18 -08001410 if name == "libclang_rt.hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001411 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001412 }
1413 return isBionic(name)
1414}
1415
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001416func (c *Module) XrefCcFiles() android.Paths {
1417 return c.kytheFiles
1418}
1419
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001420func (c *Module) isCfiAssemblySupportEnabled() bool {
1421 return c.sanitize != nil &&
1422 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1423}
1424
Inseob Kim800d1142021-06-14 12:03:51 +09001425func (c *Module) InstallInRoot() bool {
1426 return c.installer != nil && c.installer.installInRoot()
1427}
1428
Colin Crossca860ac2016-01-04 14:34:37 -08001429type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001430 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001431 moduleContextImpl
1432}
1433
Colin Cross37047f12016-12-13 17:06:13 -08001434type depsContext struct {
1435 android.BottomUpMutatorContext
1436 moduleContextImpl
1437}
1438
Colin Crossca860ac2016-01-04 14:34:37 -08001439type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001440 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001441 moduleContextImpl
1442}
1443
1444type moduleContextImpl struct {
1445 mod *Module
1446 ctx BaseModuleContext
1447}
1448
Colin Crossb98c8b02016-07-29 13:44:28 -07001449func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001450 return ctx.mod.toolchain(ctx.ctx)
1451}
1452
1453func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001454 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001455}
1456
1457func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001458 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001459}
1460
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001461func (ctx *moduleContextImpl) testBinary() bool {
1462 return ctx.mod.testBinary()
1463}
1464
Jiyong Park1d1119f2019-07-29 21:27:18 +09001465func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001466 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001467}
1468
Inseob Kim7f283f42020-06-01 21:53:49 +09001469func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001470 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001471}
1472
Inseob Kim1042d292020-06-01 23:23:05 +09001473func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001474 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001475}
1476
Jooyung Hanccce2f22020-03-07 03:45:53 +09001477func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001478 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001479}
1480
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001481func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001482 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001483}
1484
1485func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001486 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001487 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001488 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001489 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001490 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001491 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001492 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001493 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001494 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001495 }
1496 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001497}
1498
Jiyong Parkb35a8192020-08-10 15:59:36 +09001499func (ctx *moduleContextImpl) minSdkVersion() string {
1500 ver := ctx.mod.MinSdkVersion()
1501 if ver == "apex_inherit" && !ctx.isForPlatform() {
1502 ver = ctx.apexSdkVersion().String()
1503 }
1504 if ver == "apex_inherit" || ver == "" {
1505 ver = ctx.sdkVersion()
1506 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001507 // For crt objects, the meaning of min_sdk_version is very different from other types of
1508 // module. For them, min_sdk_version defines the oldest version that the build system will
1509 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1510 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1511 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001512 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1513 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1514 // support such an old version. The version is set to the later version in case when the
1515 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1516 // it's for an APEX.
1517 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1518 if ctx.isForPlatform() {
1519 ver = strconv.Itoa(android.FutureApiLevelInt)
1520 } else { // for apex
1521 ver = ctx.apexSdkVersion().String()
1522 if ver == "" { // in case when min_sdk_version was not set by the APEX
1523 ver = ctx.sdkVersion()
1524 }
1525 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001526 }
1527
Jiyong Parkb35a8192020-08-10 15:59:36 +09001528 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1529 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1530 minSdkVersionInt, err2 := strconv.Atoi(ver)
1531 if err == nil && err2 == nil {
1532 if sdkVersionInt < minSdkVersionInt {
1533 return strconv.Itoa(sdkVersionInt)
1534 }
1535 }
1536 return ver
1537}
1538
1539func (ctx *moduleContextImpl) isSdkVariant() bool {
1540 return ctx.mod.IsSdkVariant()
1541}
1542
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001543func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001544 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001545}
Justin Yun8effde42017-06-23 19:24:43 +09001546
Colin Cross95f1ca02020-10-29 20:47:22 -07001547func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1548 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001549}
1550
Colin Cross127bb8b2020-12-16 16:46:01 -08001551func (ctx *moduleContextImpl) IsLlndk() bool {
1552 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001553}
1554
Colin Cross127bb8b2020-12-16 16:46:01 -08001555func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1556 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001557}
1558
Colin Cross127bb8b2020-12-16 16:46:01 -08001559func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1560 return ctx.mod.isImplementationForLLNDKPublic()
1561}
1562
1563func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1564 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001565}
1566
Logan Chienf3511742017-10-31 18:04:35 +08001567func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001568 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001569}
1570
Yi Kong4ef54592022-02-14 20:00:10 +08001571func (ctx *moduleContextImpl) isAfdoCompile() bool {
1572 return ctx.mod.isAfdoCompile()
1573}
1574
Yi Kong7e53c572018-02-14 18:16:12 +08001575func (ctx *moduleContextImpl) isPgoCompile() bool {
1576 return ctx.mod.isPgoCompile()
1577}
1578
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001579func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1580 return ctx.mod.isNDKStubLibrary()
1581}
1582
Justin Yun8effde42017-06-23 19:24:43 +09001583func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001584 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001585}
1586
Ivan Lozanof9e21722020-12-02 09:00:51 -05001587func (ctx *moduleContextImpl) IsVndkExt() bool {
1588 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001589}
1590
Colin Cross5271fea2021-04-27 13:06:04 -07001591func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1592 return ctx.mod.IsVendorPublicLibrary()
1593}
1594
Vic Yangefd249e2018-11-12 20:19:56 -08001595func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001596 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001597}
1598
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001599func (ctx *moduleContextImpl) selectedStl() string {
1600 if stl := ctx.mod.stl; stl != nil {
1601 return stl.Properties.SelectedStl
1602 }
1603 return ""
1604}
1605
Ivan Lozanobd721262018-11-27 14:33:03 -08001606func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1607 return ctx.mod.linker.useClangLld(actx)
1608}
1609
Colin Crossce75d2c2016-10-06 16:12:58 -07001610func (ctx *moduleContextImpl) baseModuleName() string {
1611 return ctx.mod.ModuleBase.BaseModuleName()
1612}
1613
Logan Chienf3511742017-10-31 18:04:35 +08001614func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1615 return ctx.mod.getVndkExtendsModuleName()
1616}
1617
Logan Chiene274fc92019-12-03 11:18:32 -08001618func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001619 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001620}
1621
Colin Crosse07f2312020-08-13 11:24:56 -07001622func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001623 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001624}
1625
Dan Albertc8060532020-07-22 22:32:17 -07001626func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001627 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001628}
1629
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001630func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001631 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001632}
1633
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001634func (ctx *moduleContextImpl) nativeCoverage() bool {
1635 return ctx.mod.nativeCoverage()
1636}
1637
Colin Cross56a83212020-09-15 18:30:11 -07001638func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1639 return ctx.mod.DirectlyInAnyApex()
1640}
1641
Colin Cross95b07f22020-12-16 11:06:50 -08001642func (ctx *moduleContextImpl) isPreventInstall() bool {
1643 return ctx.mod.Properties.PreventInstall
1644}
1645
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001646func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1647 shared := &ctx.mod.sharedFlags
1648 if shared.flagsMap == nil {
1649 shared.numSharedFlags = 0
1650 shared.flagsMap = make(map[string]string)
1651 }
1652 return shared
1653}
1654
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001655func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1656 return ctx.mod.isCfiAssemblySupportEnabled()
1657}
1658
Colin Cross635c3b02016-05-18 15:37:25 -07001659func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001660 return &Module{
1661 hod: hod,
1662 multilib: multilib,
1663 }
1664}
1665
Colin Cross635c3b02016-05-18 15:37:25 -07001666func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001667 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001668 module.features = []feature{
1669 &tidyFeature{},
1670 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001671 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001672 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001673 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001674 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001675 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001676 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001677 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001678 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001679 return module
1680}
1681
Colin Crossce75d2c2016-10-06 16:12:58 -07001682func (c *Module) Prebuilt() *android.Prebuilt {
1683 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1684 return p.prebuilt()
1685 }
1686 return nil
1687}
1688
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001689func (c *Module) IsPrebuilt() bool {
1690 return c.Prebuilt() != nil
1691}
1692
Colin Crossce75d2c2016-10-06 16:12:58 -07001693func (c *Module) Name() string {
1694 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001695 if p, ok := c.linker.(interface {
1696 Name(string) string
1697 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001698 name = p.Name(name)
1699 }
1700 return name
1701}
1702
Alex Light3d673592019-01-18 14:37:31 -08001703func (c *Module) Symlinks() []string {
1704 if p, ok := c.installer.(interface {
1705 symlinkList() []string
1706 }); ok {
1707 return p.symlinkList()
1708 }
1709 return nil
1710}
1711
Roland Levillainf89cd092019-07-29 16:22:59 +01001712func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1713 test, ok := c.linker.(testPerSrc)
1714 return ok && test.isAllTestsVariation()
1715}
1716
Chris Parsons216e10a2020-07-09 17:12:52 -04001717func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001718 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001719 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001720 }); ok {
1721 return p.dataPaths()
1722 }
1723 return nil
1724}
1725
Ivan Lozanof1868af2022-04-12 13:08:36 -04001726func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001727 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1728 // "current", it will append the VNDK version to the name suffix.
1729 var vndkVersion string
1730 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001731 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001732 if c.ProductSpecific() {
1733 // If the module is product specific with 'product_specific: true',
1734 // do not add a name suffix because it is a base module.
1735 return ""
1736 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001737 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001738 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001739 } else {
1740 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001741 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001742 }
1743 if vndkVersion == "current" {
1744 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1745 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001746 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001747 // add version suffix only if the module is using different vndk version than the
1748 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001749 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001750 }
1751 return nameSuffix
1752}
1753
Ivan Lozanof1868af2022-04-12 13:08:36 -04001754func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1755 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001756
1757 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001758 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001759 }
1760
Colin Cross127bb8b2020-12-16 16:46:01 -08001761 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001762 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001763 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1764 // added for product variant only when we have vendor and product variants with core
1765 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001766 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001767 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001768 subName += vendorPublicLibrarySuffix
1769 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001770 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1771 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001772 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001773 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001774 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001775 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001776 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001777 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001778 subName += RecoverySuffix
1779 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1780 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001781 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001782 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001783 }
Inseob Kim64c43952019-08-26 16:52:35 +09001784 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001785
1786 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001787}
1788
Chris Parsonsf874e462022-05-10 13:50:12 -04001789var _ android.MixedBuildBuildable = (*Module)(nil)
1790
1791func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Liz Kammer35ca77e2021-12-22 15:31:40 -05001792 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001793 // cc_library is a special case in bp2build; two targets are generated -- one for each
1794 // of the shared and static variants. The shared variant keeps the module name, but the
1795 // static variant uses a different suffixed name.
Chris Parsonsf874e462022-05-10 13:50:12 -04001796 return bazelLabelForStaticModule(ctx, c)
1797 }
1798 return c.GetBazelLabel(ctx, c)
1799}
1800
1801func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1802 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1803}
1804
1805func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
1806 return c.bazelHandler != nil
1807}
1808
1809func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
1810 bazelModuleLabel := c.getBazelModuleLabel(ctx)
1811
1812 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
1813
1814 c.Properties.SubName = GetSubnameProperty(ctx, c)
1815 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1816 if !apexInfo.IsForPlatform() {
1817 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05001818 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05001819
Chris Parsonsf874e462022-05-10 13:50:12 -04001820 c.makeLinkType = GetMakeLinkType(ctx, c)
1821
1822 mctx := &moduleContext{
1823 ModuleContext: ctx,
1824 moduleContextImpl: moduleContextImpl{
1825 mod: c,
1826 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05001827 }
Chris Parsonsf874e462022-05-10 13:50:12 -04001828 mctx.ctx = mctx
1829
1830 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001831}
1832
1833func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001834 // Handle the case of a test module split by `test_per_src` mutator.
1835 //
1836 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1837 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1838 // module and return early, as this module does not produce an output file per se.
1839 if c.IsTestPerSrcAllTestsVariation() {
1840 c.outputFile = android.OptionalPath{}
1841 return
1842 }
1843
Ivan Lozanof1868af2022-04-12 13:08:36 -04001844 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001845 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1846 if !apexInfo.IsForPlatform() {
1847 c.hideApexVariantFromMake = true
1848 }
1849
Chris Parsonseefc9e62021-04-02 17:36:47 -04001850 c.makeLinkType = GetMakeLinkType(actx, c)
1851
Colin Crossca860ac2016-01-04 14:34:37 -08001852 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001853 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001854 moduleContextImpl: moduleContextImpl{
1855 mod: c,
1856 },
1857 }
1858 ctx.ctx = ctx
1859
Colin Crossf18e1102017-11-16 14:33:08 -08001860 deps := c.depsToPaths(ctx)
1861 if ctx.Failed() {
1862 return
1863 }
1864
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001865 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1866 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1867 }
1868
Colin Crossca860ac2016-01-04 14:34:37 -08001869 flags := Flags{
1870 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001871 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001872 }
Colin Crossca860ac2016-01-04 14:34:37 -08001873 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001874 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001875 }
1876 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001877 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001878 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001879 if c.stl != nil {
1880 flags = c.stl.flags(ctx, flags)
1881 }
Colin Cross16b23492016-01-06 14:41:07 -08001882 if c.sanitize != nil {
1883 flags = c.sanitize.flags(ctx, flags)
1884 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001885 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001886 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001887 }
Stephen Craneba090d12017-05-09 15:44:35 -07001888 if c.lto != nil {
1889 flags = c.lto.flags(ctx, flags)
1890 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001891 if c.afdo != nil {
1892 flags = c.afdo.flags(ctx, flags)
1893 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001894 if c.pgo != nil {
1895 flags = c.pgo.flags(ctx, flags)
1896 }
Colin Crossca860ac2016-01-04 14:34:37 -08001897 for _, feature := range c.features {
1898 flags = feature.flags(ctx, flags)
1899 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001900 if ctx.Failed() {
1901 return
1902 }
1903
Colin Cross4af21ed2019-11-04 09:37:55 -08001904 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1905 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1906 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001907
Colin Cross4af21ed2019-11-04 09:37:55 -08001908 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001909
1910 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001911 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001912 }
1913 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001914 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001915 }
1916
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001917 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001918 // We need access to all the flags seen by a source file.
1919 if c.sabi != nil {
1920 flags = c.sabi.flags(ctx, flags)
1921 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001922
Colin Cross4af21ed2019-11-04 09:37:55 -08001923 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001924
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001925 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001926 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001927 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001928 if ctx.Failed() {
1929 return
1930 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001931 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07001932 c.objFiles = objs.objFiles
1933 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001934 }
1935
Colin Crossca860ac2016-01-04 14:34:37 -08001936 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001937 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001938 if ctx.Failed() {
1939 return
1940 }
Colin Cross635c3b02016-05-18 15:37:25 -07001941 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001942
Chris Parsons94a0bba2021-06-04 15:03:47 -04001943 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001944
Jose Galmes6f843bc2020-12-11 13:36:29 -08001945 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1946 // RECOVERY_SNAPSHOT_VERSION is current.
1947 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001948 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001949 i.collectHeadersForSnapshot(ctx)
1950 }
1951 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001952 }
Colin Cross5049f022015-03-18 13:28:46 -07001953
Chris Parsons94a0bba2021-06-04 15:03:47 -04001954 c.maybeInstall(ctx, apexInfo)
1955}
1956
1957func (c *Module) maybeUnhideFromMake() {
1958 // If a lib is directly included in any of the APEXes or is not available to the
1959 // platform (which is often the case when the stub is provided as a prebuilt),
1960 // unhide the stubs variant having the latest version gets visible to make. In
1961 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
1962 // force anything in the make world to link against the stubs library. (unless it
1963 // is explicitly referenced via .bootstrap suffix or the module is marked with
1964 // 'bootstrap: true').
1965 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
1966 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
1967 c.IsStubs() && !c.InVendorRamdisk() {
1968 c.Properties.HideFromMake = false // unhide
1969 // Note: this is still non-installable
1970 }
1971}
1972
1973func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07001974 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001975 // If the module has been specifically configure to not be installed then
1976 // hide from make as otherwise it will break when running inside make
1977 // as the output path to install will not be specified. Not all uninstallable
1978 // modules can be hidden from make as some are needed for resolving make side
1979 // dependencies.
1980 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04001981 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001982 c.SkipInstall()
1983 }
1984
1985 // Still call c.installer.install though, the installs will be stored as PackageSpecs
1986 // to allow using the outputs in a genrule.
1987 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001988 c.installer.install(ctx, c.outputFile.Path())
1989 if ctx.Failed() {
1990 return
Colin Crossca860ac2016-01-04 14:34:37 -08001991 }
Dan Albertc403f7c2015-03-18 14:01:18 -07001992 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001993}
1994
Colin Cross0ea8ba82019-06-06 14:33:29 -07001995func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001996 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05001997 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08001998 }
Colin Crossca860ac2016-01-04 14:34:37 -08001999 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002000}
2001
Colin Crossca860ac2016-01-04 14:34:37 -08002002func (c *Module) begin(ctx BaseModuleContext) {
2003 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002004 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002005 }
Colin Crossca860ac2016-01-04 14:34:37 -08002006 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002007 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002008 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002009 if c.stl != nil {
2010 c.stl.begin(ctx)
2011 }
Colin Cross16b23492016-01-06 14:41:07 -08002012 if c.sanitize != nil {
2013 c.sanitize.begin(ctx)
2014 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002015 if c.coverage != nil {
2016 c.coverage.begin(ctx)
2017 }
Stephen Craneba090d12017-05-09 15:44:35 -07002018 if c.lto != nil {
2019 c.lto.begin(ctx)
2020 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002021 if c.afdo != nil {
2022 c.afdo.begin(ctx)
2023 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002024 if c.pgo != nil {
2025 c.pgo.begin(ctx)
2026 }
Dan Albert92fe7402020-07-15 13:33:30 -07002027 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002028 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002029 if err != nil {
2030 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002031 c.Properties.Sdk_version = nil
2032 } else {
2033 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002034 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002035 }
Colin Crossca860ac2016-01-04 14:34:37 -08002036}
2037
Colin Cross37047f12016-12-13 17:06:13 -08002038func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002039 deps := Deps{}
2040
2041 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002042 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002043 }
2044 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002045 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002046 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002047 if c.stl != nil {
2048 deps = c.stl.deps(ctx, deps)
2049 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002050 if c.coverage != nil {
2051 deps = c.coverage.deps(ctx, deps)
2052 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002053
Colin Crossb6715442017-10-24 11:13:31 -07002054 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2055 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2056 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2057 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2058 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2059 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002060 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002061
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002062 for _, lib := range deps.ReexportSharedLibHeaders {
2063 if !inList(lib, deps.SharedLibs) {
2064 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2065 }
2066 }
2067
2068 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002069 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2070 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 -07002071 }
2072 }
2073
Colin Cross5950f382016-12-13 12:50:57 -08002074 for _, lib := range deps.ReexportHeaderLibHeaders {
2075 if !inList(lib, deps.HeaderLibs) {
2076 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2077 }
2078 }
2079
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002080 for _, gen := range deps.ReexportGeneratedHeaders {
2081 if !inList(gen, deps.GeneratedHeaders) {
2082 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2083 }
2084 }
2085
Colin Crossc99deeb2016-04-11 15:06:20 -07002086 return deps
2087}
2088
Dan Albert7e9d2952016-08-04 13:02:36 -07002089func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002090 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002091 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002092 moduleContextImpl: moduleContextImpl{
2093 mod: c,
2094 },
2095 }
2096 ctx.ctx = ctx
2097
Colin Crossca860ac2016-01-04 14:34:37 -08002098 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002099}
2100
Jiyong Park7ed9de32018-10-15 22:25:07 +09002101// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002102func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002103 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2104 version := name[sharp+1:]
2105 libname := name[:sharp]
2106 return libname, version
2107 }
2108 return name, ""
2109}
2110
Dan Albert92fe7402020-07-15 13:33:30 -07002111func GetCrtVariations(ctx android.BottomUpMutatorContext,
2112 m LinkableInterface) []blueprint.Variation {
2113 if ctx.Os() != android.Android {
2114 return nil
2115 }
2116 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002117 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2118 minSdkVersion := m.MinSdkVersion()
2119 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2120 minSdkVersion = m.SdkVersion()
2121 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002122 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2123 if err != nil {
2124 ctx.PropertyErrorf("min_sdk_version", err.Error())
2125 }
Dan Albert92fe7402020-07-15 13:33:30 -07002126 return []blueprint.Variation{
2127 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002128 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002129 }
2130 }
2131 return []blueprint.Variation{
2132 {Mutator: "sdk", Variation: ""},
2133 }
2134}
2135
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002136func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2137 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002138
2139 variations = append([]blueprint.Variation(nil), variations...)
2140
Liz Kammer23942242022-04-08 15:41:00 -04002141 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002142 // Version is explicitly specified. i.e. libFoo#30
2143 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002144 if tag, ok := depTag.(libraryDependencyTag); ok {
2145 tag.explicitlyVersioned = true
2146 } else {
2147 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2148 }
Colin Crosse7257d22020-09-24 09:56:18 -07002149 }
Colin Crosse7257d22020-09-24 09:56:18 -07002150
Colin Cross0de8a1e2020-09-18 14:15:30 -07002151 if far {
2152 ctx.AddFarVariationDependencies(variations, depTag, name)
2153 } else {
2154 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002155 }
2156}
2157
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002158func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002159 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002160 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002161 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002162 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2163 // between the modules in the snapshot and the snapshot itself.
2164 var snapshotModule []blueprint.Module
2165 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2166 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2167 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2168 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2169 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002170 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002171 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2172 *snapshotInfo = &snapshot
2173 // republish the snapshot for use in later mutators on this module
2174 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002175 }
2176 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002177 if *snapshotInfo == nil {
2178 *snapshotInfo = &SnapshotInfo{}
2179 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002180 return **snapshotInfo
2181}
2182
2183func RewriteSnapshotLib(lib string, snapshotMap map[string]string) string {
2184 if snapshot, ok := snapshotMap[lib]; ok {
2185 return snapshot
2186 }
2187
2188 return lib
2189}
2190
2191// RewriteLibs takes a list of names of shared libraries and scans it for three types
2192// of names:
2193//
2194// 1. Name of an NDK library that refers to a prebuilt module.
2195// For each of these, it adds the name of the prebuilt module (which will be in
2196// prebuilts/ndk) to the list of nonvariant libs.
2197// 2. Name of an NDK library that refers to an ndk_library module.
2198// For each of these, it adds the name of the ndk_library module to the list of
2199// variant libs.
2200// 3. Anything else (so anything that isn't an NDK library).
2201// It adds these to the nonvariantLibs list.
2202//
2203// The caller can then know to add the variantLibs dependencies differently from the
2204// nonvariantLibs
2205func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2206 variantLibs = []string{}
2207
2208 nonvariantLibs = []string{}
2209 for _, entry := range list {
2210 // strip #version suffix out
2211 name, _ := StubsLibNameAndVersion(entry)
2212 if c.InRecovery() {
2213 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2214 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2215 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2216 } else if c.UseVndk() {
2217 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2218 } else {
2219 // put name#version back
2220 nonvariantLibs = append(nonvariantLibs, entry)
2221 }
2222 }
2223 return nonvariantLibs, variantLibs
2224}
2225
Colin Cross1e676be2016-10-12 14:38:15 -07002226func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002227 if !c.Enabled() {
2228 return
2229 }
2230
Colin Cross37047f12016-12-13 17:06:13 -08002231 ctx := &depsContext{
2232 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002233 moduleContextImpl: moduleContextImpl{
2234 mod: c,
2235 },
2236 }
2237 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002238
Colin Crossc99deeb2016-04-11 15:06:20 -07002239 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002240
Yo Chiang219968c2020-09-22 18:45:04 +08002241 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2242
Colin Crosse0edaf92021-01-11 17:31:17 -08002243 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002244
Dan Albert914449f2016-06-17 16:45:24 -07002245 variantNdkLibs := []string{}
2246 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002247 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002248 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2249 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2250 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002251
2252 for idx, lib := range deps.RuntimeLibs {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002253 deps.RuntimeLibs[idx] = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002254 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002255 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002256
Colin Cross32ec36c2016-12-15 07:39:51 -08002257 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002258 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002259 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002260 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002261 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002262
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002263 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002264
Jiyong Park1ad8e162020-12-01 23:40:09 +09002265 if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002266 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002267 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002268 } else {
2269 actx.AddVariationDependencies(nil, depTag, lib)
2270 }
2271 }
2272
Dan Albertf1d14c72020-07-30 14:32:55 -07002273 if c.isNDKStubLibrary() {
2274 // NDK stubs depend on their implementation because the ABI dumps are
2275 // generated from the implementation library.
2276 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2277 c.ImageVariation(),
2278 blueprint.Variation{Mutator: "link", Variation: "shared"},
2279 ), stubImplementation, c.BaseModuleName())
2280 }
2281
Inseob Kim07def122020-11-23 14:43:02 +09002282 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
2283 // C++ implementation library and one Java implementation library. When a module links against
2284 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
2285 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
2286 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09002287 syspropImplLibraries := syspropImplLibraries(actx.Config())
2288
Jiyong Park5d1598f2019-02-25 22:14:17 +09002289 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002290 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09002291 if impl, ok := syspropImplLibraries[lib]; ok {
2292 lib = impl
2293 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002294
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002295 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002296
Jiyong Park5d1598f2019-02-25 22:14:17 +09002297 actx.AddVariationDependencies([]blueprint.Variation{
2298 {Mutator: "link", Variation: "static"},
2299 }, depTag, lib)
2300 }
2301
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002302 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002303 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002304 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002305 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002306 }
Jiyong Parke3867542020-12-03 17:28:25 +09002307 if inList(lib, deps.ExcludeLibsForApex) {
2308 depTag.excludeInApex = true
2309 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002310
2311 if impl, ok := syspropImplLibraries[lib]; ok {
2312 lib = impl
2313 }
2314
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002315 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002316
Dan Willemsen59339a22018-07-22 21:18:45 -07002317 actx.AddVariationDependencies([]blueprint.Variation{
2318 {Mutator: "link", Variation: "static"},
2319 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002320 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002321
Jooyung Han75568392020-03-20 04:29:24 +09002322 // staticUnwinderDep is treated as staticDep for Q apexes
2323 // so that native libraries/binaries are linked with static unwinder
2324 // because Q libc doesn't have unwinder APIs
2325 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002326 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002327 actx.AddVariationDependencies([]blueprint.Variation{
2328 {Mutator: "link", Variation: "static"},
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002329 }, depTag, RewriteSnapshotLib(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002330 }
2331
Jiyong Park7ed9de32018-10-15 22:25:07 +09002332 // shared lib names without the #version suffix
2333 var sharedLibNames []string
2334
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002335 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002336 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002337 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002338 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002339 }
Jiyong Parke3867542020-12-03 17:28:25 +09002340 if inList(lib, deps.ExcludeLibsForApex) {
2341 depTag.excludeInApex = true
2342 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002343
2344 if impl, ok := syspropImplLibraries[lib]; ok {
2345 lib = impl
2346 }
2347
Jiyong Park73c54ee2019-10-22 20:31:18 +09002348 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002349 sharedLibNames = append(sharedLibNames, name)
2350
Colin Crosse7257d22020-09-24 09:56:18 -07002351 variations := []blueprint.Variation{
2352 {Mutator: "link", Variation: "shared"},
2353 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002354 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002355 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002356
Colin Crossfe9acfe2021-06-14 16:13:03 -07002357 for _, lib := range deps.LateStaticLibs {
2358 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2359 actx.AddVariationDependencies([]blueprint.Variation{
2360 {Mutator: "link", Variation: "static"},
2361 }, depTag, RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
2362 }
2363
Jiyong Park7ed9de32018-10-15 22:25:07 +09002364 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002365 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002366 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2367 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2368 // linking against both the stubs lib and the non-stubs lib at the same time.
2369 continue
2370 }
Colin Cross6e511a92020-07-27 21:26:48 -07002371 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002372 variations := []blueprint.Variation{
2373 {Mutator: "link", Variation: "shared"},
2374 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002375 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002376 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002377
Dan Willemsen59339a22018-07-22 21:18:45 -07002378 actx.AddVariationDependencies([]blueprint.Variation{
2379 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002380 }, dataLibDepTag, deps.DataLibs...)
2381
Colin Crossc8caa062021-09-24 16:50:14 -07002382 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2383
Chris Parsons79d66a52020-06-05 17:26:16 -04002384 actx.AddVariationDependencies([]blueprint.Variation{
2385 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002386 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002387
Colin Cross68861832016-07-08 10:41:41 -07002388 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002389
2390 for _, gen := range deps.GeneratedHeaders {
2391 depTag := genHeaderDepTag
2392 if inList(gen, deps.ReexportGeneratedHeaders) {
2393 depTag = genHeaderExportDepTag
2394 }
2395 actx.AddDependency(c, depTag, gen)
2396 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002397
Dan Albert92fe7402020-07-15 13:33:30 -07002398 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002399 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002400 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002401 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002402 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002403 }
Colin Crossc465efd2021-06-11 18:00:04 -07002404 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002405 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002406 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002407 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002408 if deps.DynamicLinker != "" {
2409 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002410 }
Dan Albert914449f2016-06-17 16:45:24 -07002411
2412 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002413
2414 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002415 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002416 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002417 {Mutator: "link", Variation: "shared"},
2418 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002419
2420 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002421 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002422 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002423 {Mutator: "link", Variation: "shared"},
2424 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002425
2426 if vndkdep := c.vndkdep; vndkdep != nil {
2427 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002428 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002429 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002430 {Mutator: "link", Variation: "shared"},
Justin Yun27b95722021-07-28 17:04:44 +09002431 }, vndkExtDepTag, RewriteSnapshotLib(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002432 }
2433 }
Colin Cross6362e272015-10-29 15:25:03 -07002434}
Colin Cross21b9a242015-03-24 14:15:58 -07002435
Colin Crosse40b4ea2018-10-02 22:25:58 -07002436func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002437 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2438 c.beginMutator(ctx)
2439 }
2440}
2441
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002442// Whether a module can link to another module, taking into
2443// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002444func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002445 tag blueprint.DependencyTag) {
2446
2447 switch t := tag.(type) {
2448 case dependencyTag:
2449 if t != vndkExtDepTag {
2450 return
2451 }
2452 case libraryDependencyTag:
2453 default:
2454 return
2455 }
2456
Ivan Lozanof9e21722020-12-02 09:00:51 -05002457 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002458 // Host code is not restricted
2459 return
2460 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002461
2462 // VNDK is cc.Module supported only for now.
2463 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002464 // Though allowed dependency is limited by the image mutator,
2465 // each vendor and product module needs to check link-type
2466 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002467 if ccTo, ok := to.(*Module); ok {
2468 if ccFrom.vndkdep != nil {
2469 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2470 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002471 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002472 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002473 }
2474 return
2475 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002476 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002477 // Platform code can link to anything
2478 return
2479 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002480 if from.InRamdisk() {
2481 // Ramdisk code is not NDK
2482 return
2483 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002484 if from.InVendorRamdisk() {
2485 // Vendor ramdisk code is not NDK
2486 return
2487 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002488 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002489 // Recovery code is not NDK
2490 return
2491 }
Colin Cross31076b32020-10-23 17:22:06 -07002492 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002493 if c.NdkPrebuiltStl() {
2494 // These are allowed, but they don't set sdk_version
2495 return
2496 }
2497 if c.StubDecorator() {
2498 // These aren't real libraries, but are the stub shared libraries that are included in
2499 // the NDK.
2500 return
2501 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002502 }
Logan Chien834b9a62019-01-14 15:39:03 +08002503
Ivan Lozano52767be2019-10-18 14:49:46 -07002504 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002505 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2506 // to link to libc++ (non-NDK and without sdk_version).
2507 return
2508 }
2509
Ivan Lozano52767be2019-10-18 14:49:46 -07002510 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002511 // NDK code linking to platform code is never okay.
2512 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002513 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002514 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002515 }
2516
2517 // At this point we know we have two NDK libraries, but we need to
2518 // check that we're not linking against anything built against a higher
2519 // API level, as it is only valid to link against older or equivalent
2520 // APIs.
2521
Inseob Kim01a28722018-04-11 09:48:45 +09002522 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002523 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002524 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002525 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002526 // Current can't be linked against by anything else.
2527 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002528 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002529 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002530 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002531 if err != nil {
2532 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002533 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002534 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002535 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002536 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002537 if err != nil {
2538 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002539 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002540 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002541 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002542
Inseob Kim01a28722018-04-11 09:48:45 +09002543 if toApi > fromApi {
2544 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002545 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002546 }
2547 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002548 }
Dan Albert202fe492017-12-15 13:56:59 -08002549
2550 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002551 fromStl := from.SelectedStl()
2552 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002553 if fromStl == "" || toStl == "" {
2554 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002555 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002556 // We can be permissive with the system "STL" since it is only the C++
2557 // ABI layer, but in the future we should make sure that everyone is
2558 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002559 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002560 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002561 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2562 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002563 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002564}
2565
Jooyung Han479ca172020-10-19 18:51:07 +09002566func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2567 if c, ok := ctx.Module().(*Module); ok {
2568 ctx.VisitDirectDeps(func(dep android.Module) {
2569 depTag := ctx.OtherModuleDependencyTag(dep)
2570 ccDep, ok := dep.(LinkableInterface)
2571 if ok {
2572 checkLinkType(ctx, c, ccDep, depTag)
2573 }
2574 })
2575 }
2576}
2577
Jiyong Park5fb8c102018-04-09 12:03:06 +09002578// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002579// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2580// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002581// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002582func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2583 check := func(child, parent android.Module) bool {
2584 to, ok := child.(*Module)
2585 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002586 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002587 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002588
Jooyung Hana70f0672019-01-18 15:20:43 +09002589 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2590 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002591 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002592
Jiyong Park0474e1f2021-01-14 14:26:06 +09002593 // These dependencies are not excercised at runtime. Tracking these will give us
2594 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002595 depTag := ctx.OtherModuleDependencyTag(child)
2596 if IsHeaderDepTag(depTag) {
2597 return false
2598 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002599 if depTag == staticVariantTag {
2600 return false
2601 }
2602 if depTag == stubImplDepTag {
2603 return false
2604 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002605
Justin Yun63e9ec72020-10-29 16:49:43 +09002606 // Even if target lib has no vendor variant, keep checking dependency
2607 // graph in case it depends on vendor_available or product_available
2608 // but not double_loadable transtively.
2609 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002610 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002611 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002612
Jiyong Park0474e1f2021-01-14 14:26:06 +09002613 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2614 // one.
2615 if Bool(to.VendorProperties.Double_loadable) {
2616 return true
2617 }
2618
Ivan Lozanod7586b62021-04-01 09:49:36 -04002619 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002620 return false
2621 }
2622
Jooyung Hana70f0672019-01-18 15:20:43 +09002623 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2624 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002625 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002626 return false
2627 }
2628 if module, ok := ctx.Module().(*Module); ok {
2629 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002630 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002631 ctx.WalkDeps(check)
2632 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002633 }
2634 }
2635}
2636
Colin Crossc99deeb2016-04-11 15:06:20 -07002637// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002638func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002639 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002640
Colin Cross0de8a1e2020-09-18 14:15:30 -07002641 var directStaticDeps []StaticLibraryInfo
2642 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002643
Colin Cross0de8a1e2020-09-18 14:15:30 -07002644 reexportExporter := func(exporter FlagExporterInfo) {
2645 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2646 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2647 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2648 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2649 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002650 }
2651
Jooyung Hande34d232020-07-23 13:04:15 +09002652 // For the dependency from platform to apex, use the latest stubs
2653 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002654 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2655 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002656 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002657 }
2658
2659 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2660 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2661 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2662 // (b/144430859)
2663 c.apexSdkVersion = android.FutureApiLevel
2664 }
2665
Colin Crossd11fcda2017-10-23 17:59:01 -07002666 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002667 depName := ctx.OtherModuleName(dep)
2668 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002669
Dan Willemsen47450072021-10-19 20:24:49 -07002670 if depTag == android.DarwinUniversalVariantTag {
2671 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2672 return
2673 }
2674
Ivan Lozano52767be2019-10-18 14:49:46 -07002675 ccDep, ok := dep.(LinkableInterface)
2676 if !ok {
2677
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002678 // handling for a few module types that aren't cc Module but that are also supported
2679 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002680 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002681 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002682 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2683 genRule.GeneratedSourceFiles()...)
2684 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002685 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002686 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002687 // Support exported headers from a generated_sources dependency
2688 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002689 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002690 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002691 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002692 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002693 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002694 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002695 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002696 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002697 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2698 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002699 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002700 // 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 +09002701 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002702
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002703 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002704 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002705 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002706 }
Colin Crosscef792e2021-06-11 18:01:26 -07002707 case CrtBeginDepTag:
2708 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2709 case CrtEndDepTag:
2710 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002711 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002712 return
2713 }
2714
Colin Crossfe17f6f2019-03-28 19:30:56 -07002715 if depTag == android.ProtoPluginDepTag {
2716 return
2717 }
2718
Colin Crossd11fcda2017-10-23 17:59:01 -07002719 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002720 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2721 return
2722 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002723 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002724 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2725 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002726 return
2727 }
2728
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002729 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002730 // Skip reused objects for stub libraries, they use their own stub object file instead.
2731 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2732 // version mutator, so the stubs variant is created from the shared variant that
2733 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002734 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002735 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2736 objs := staticAnalogue.ReuseObjects
2737 depPaths.Objs = depPaths.Objs.Append(objs)
2738 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2739 reexportExporter(depExporterInfo)
2740 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002741 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002742 }
2743
Colin Cross6e511a92020-07-27 21:26:48 -07002744 linkFile := ccDep.OutputFile()
2745
2746 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2747 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002748 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002749 return
2750 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002751
Jiyong Parke3867542020-12-03 17:28:25 +09002752 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2753 return
2754 }
2755
Colin Cross0de8a1e2020-09-18 14:15:30 -07002756 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002757
Colin Cross6e511a92020-07-27 21:26:48 -07002758 var ptr *android.Paths
2759 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002760
Colin Cross6e511a92020-07-27 21:26:48 -07002761 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002762
Colin Cross6e511a92020-07-27 21:26:48 -07002763 switch {
2764 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002765 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2766 if !ctx.Config().AllowMissingDependencies() {
2767 ctx.ModuleErrorf("module %q is not a header library", depName)
2768 } else {
2769 ctx.AddMissingDependencies([]string{depName})
2770 }
2771 return
2772 }
Colin Cross6e511a92020-07-27 21:26:48 -07002773 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002774 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2775 if !ctx.Config().AllowMissingDependencies() {
2776 ctx.ModuleErrorf("module %q is not a shared library", depName)
2777 } else {
2778 ctx.AddMissingDependencies([]string{depName})
2779 }
2780 return
2781 }
Jiyong Parke3867542020-12-03 17:28:25 +09002782
Jiyong Park7d55b612021-06-11 17:22:09 +09002783 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
2784 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002785
Jiyong Park1ad8e162020-12-01 23:40:09 +09002786 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2787 // linkFile, depFile, and ptr.
2788 if c.IsStubs() {
2789 break
2790 }
2791
Colin Cross0de8a1e2020-09-18 14:15:30 -07002792 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2793 depFile = sharedLibraryInfo.TableOfContents
2794
Colin Cross6e511a92020-07-27 21:26:48 -07002795 ptr = &depPaths.SharedLibs
2796 switch libDepTag.Order {
2797 case earlyLibraryDependency:
2798 ptr = &depPaths.EarlySharedLibs
2799 depPtr = &depPaths.EarlySharedLibsDeps
2800 case normalLibraryDependency:
2801 ptr = &depPaths.SharedLibs
2802 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002803 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002804 case lateLibraryDependency:
2805 ptr = &depPaths.LateSharedLibs
2806 depPtr = &depPaths.LateSharedLibsDeps
2807 default:
2808 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002809 }
Colin Cross6e511a92020-07-27 21:26:48 -07002810 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002811 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2812 if !ctx.Config().AllowMissingDependencies() {
2813 ctx.ModuleErrorf("module %q is not a static library", depName)
2814 } else {
2815 ctx.AddMissingDependencies([]string{depName})
2816 }
2817 return
2818 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002819
2820 // Stubs lib doesn't link to the static lib dependencies. Don't set
2821 // linkFile, depFile, and ptr.
2822 if c.IsStubs() {
2823 break
2824 }
2825
Colin Cross0de8a1e2020-09-18 14:15:30 -07002826 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2827 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002828 if libDepTag.wholeStatic {
2829 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002830 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2831 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002832 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002833 // This case normally catches prebuilt static
2834 // libraries, but it can also occur when
2835 // AllowMissingDependencies is on and the
2836 // dependencies has no sources of its own
2837 // but has a whole_static_libs dependency
2838 // on a missing library. We want to depend
2839 // on the .a file so that there is something
2840 // in the dependency tree that contains the
2841 // error rule for the missing transitive
2842 // dependency.
2843 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002844 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08002845 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
2846 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07002847 } else {
2848 switch libDepTag.Order {
2849 case earlyLibraryDependency:
2850 panic(fmt.Errorf("early static libs not suppported"))
2851 case normalLibraryDependency:
2852 // static dependencies will be handled separately so they can be ordered
2853 // using transitive dependencies.
2854 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002855 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002856 case lateLibraryDependency:
2857 ptr = &depPaths.LateStaticLibs
2858 default:
2859 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002860 }
2861 }
2862 }
2863
Colin Cross6e511a92020-07-27 21:26:48 -07002864 if libDepTag.static() && !libDepTag.wholeStatic {
2865 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2866 ctx.ModuleErrorf("module %q not a static library", depName)
2867 return
2868 }
Logan Chien43d34c32017-12-20 01:17:32 +08002869
Colin Cross6e511a92020-07-27 21:26:48 -07002870 // When combining coverage files for shared libraries and executables, coverage files
2871 // in static libraries act as if they were whole static libraries. The same goes for
2872 // source based Abi dump files.
2873 if c, ok := ccDep.(*Module); ok {
2874 staticLib := c.linker.(libraryInterface)
2875 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2876 staticLib.objs().coverageFiles...)
2877 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2878 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002879 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002880 // Handle non-CC modules here
2881 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002882 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002883 }
2884 }
2885
Colin Cross6e511a92020-07-27 21:26:48 -07002886 if ptr != nil {
2887 if !linkFile.Valid() {
2888 if !ctx.Config().AllowMissingDependencies() {
2889 ctx.ModuleErrorf("module %q missing output file", depName)
2890 } else {
2891 ctx.AddMissingDependencies([]string{depName})
2892 }
2893 return
2894 }
2895 *ptr = append(*ptr, linkFile.Path())
2896 }
2897
2898 if depPtr != nil {
2899 dep := depFile
2900 if !dep.Valid() {
2901 dep = linkFile
2902 }
2903 *depPtr = append(*depPtr, dep.Path())
2904 }
2905
Colin Cross0de8a1e2020-09-18 14:15:30 -07002906 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2907 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2908 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2909 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2910
2911 if libDepTag.reexportFlags {
2912 reexportExporter(depExporterInfo)
2913 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2914 // Re-exported shared library headers must be included as well since they can help us with type information
2915 // about template instantiations (instantiated from their headers).
2916 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2917 // scripts.
2918 c.sabi.Properties.ReexportedIncludes = append(
2919 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2920 }
2921
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002922 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002923 switch {
2924 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002925 c.Properties.AndroidMkHeaderLibs = append(
2926 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002927 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002928 if lib := moduleLibraryInterface(dep); lib != nil {
2929 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002930 // Add the dependency to the APEX(es) providing the library so that
2931 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002932 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09002933 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07002934 c.Properties.ApexesProvidingSharedLibs = append(
2935 c.Properties.ApexesProvidingSharedLibs, an)
2936 }
2937 }
2938 }
2939
2940 // Note: the order of libs in this list is not important because
2941 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002942 c.Properties.AndroidMkSharedLibs = append(
2943 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002944 // Record BaseLibName for snapshots.
2945 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002946 case libDepTag.static():
2947 if libDepTag.wholeStatic {
2948 c.Properties.AndroidMkWholeStaticLibs = append(
2949 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2950 } else {
2951 c.Properties.AndroidMkStaticLibs = append(
2952 c.Properties.AndroidMkStaticLibs, makeLibName)
2953 }
Justin Yun5e035862021-06-29 20:50:37 +09002954 // Record BaseLibName for snapshots.
2955 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002956 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002957 } else if !c.IsStubs() {
2958 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
2959
Colin Cross6e511a92020-07-27 21:26:48 -07002960 switch depTag {
2961 case runtimeDepTag:
2962 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002963 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002964 // Record BaseLibName for snapshots.
2965 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002966 case objDepTag:
2967 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2968 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002969 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002970 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002971 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002972 case dynamicLinkerDepTag:
2973 depPaths.DynamicLinker = linkFile
2974 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002975 }
Colin Crossca860ac2016-01-04 14:34:37 -08002976 })
2977
Jeff Gaston294356f2017-09-27 17:05:30 -07002978 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002979 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2980 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2981 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002982
Colin Crossdd84e052017-05-17 13:44:16 -07002983 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002984 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002985 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2986 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002987 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002988 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2989 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002990 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002991 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002992 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002993
2994 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002995 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002996 }
Colin Crossdd84e052017-05-17 13:44:16 -07002997
Colin Crossca860ac2016-01-04 14:34:37 -08002998 return depPaths
2999}
3000
Jiyong Park7d55b612021-06-11 17:22:09 +09003001// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3002// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3003// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3004// has different level of updatability. For example, if a library foo in an APEX depends on a
3005// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3006// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3007// same APEX as foo, the non-stub variant of bar is used.
3008func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3009 depName := ctx.OtherModuleName(dep)
3010 depTag := ctx.OtherModuleDependencyTag(dep)
3011 libDepTag, ok := depTag.(libraryDependencyTag)
3012 if !ok || !libDepTag.shared() {
3013 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3014 }
3015
3016 thisModule, ok := ctx.Module().(android.ApexModule)
3017 if !ok {
3018 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3019 }
3020
3021 useVndk := false
3022 bootstrap := false
3023 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3024 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3025 } else {
3026 useVndk = linkable.UseVndk()
3027 bootstrap = linkable.Bootstrap()
3028 }
3029
3030 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3031 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3032 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
3033 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3034
3035 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
3036 useStubs := false
3037
3038 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3039 if !apexInfo.IsForPlatform() {
3040 // For platform libraries, use current version of LLNDK
3041 // If this is for use_vendor apex we will apply the same rules
3042 // of apex sdk enforcement below to choose right version.
3043 useStubs = true
3044 }
Jiyong Park9477c262021-06-22 20:23:05 +09003045 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3046 // If not building for APEX or the containing APEX allows the use of
3047 // platform APIs, use stubs only when it is from an APEX (and not from
3048 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3049 // bootstrap modules, always link to non-stub variant
Jiyong Park7d55b612021-06-11 17:22:09 +09003050 useStubs = dep.(android.ApexModule).NotInPlatform() && !bootstrap
3051 if useStubs {
3052 // Another exception: if this module is a test for an APEX, then
3053 // it is linked with the non-stub variant of a module in the APEX
3054 // as if this is part of the APEX.
3055 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3056 for _, apexContents := range testFor.ApexContents {
3057 if apexContents.DirectlyInApex(depName) {
3058 useStubs = false
3059 break
3060 }
3061 }
3062 }
3063 if useStubs {
3064 // Yet another exception: If this module and the dependency are
3065 // available to the same APEXes then skip stubs between their
3066 // platform variants. This complements the test_for case above,
3067 // which avoids the stubs on a direct APEX library dependency, by
3068 // avoiding stubs for indirect test dependencies as well.
3069 //
3070 // TODO(b/183882457): This doesn't work if the two libraries have
3071 // only partially overlapping apex_available. For that test_for
3072 // modules would need to be split into APEX variants and resolved
3073 // separately for each APEX they have access to.
3074 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3075 useStubs = false
3076 }
3077 }
3078 } else {
3079 // If building for APEX, use stubs when the parent is in any APEX that
3080 // the child is not in.
3081 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3082 }
3083
3084 // when to use (unspecified) stubs, use the latest one.
3085 if useStubs {
3086 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3087 toUse := stubs[len(stubs)-1]
3088 sharedLibraryInfo = toUse.SharedLibraryInfo
3089 depExporterInfo = toUse.FlagExporterInfo
3090 }
3091 }
3092 return sharedLibraryInfo, depExporterInfo
3093}
3094
Colin Cross0de8a1e2020-09-18 14:15:30 -07003095// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3096// to match the topological order of the dependency tree, including any static analogues of
3097// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3098// of the transitive dependencies.
3099func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3100 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3101 var staticPaths android.Paths
3102 for _, staticDep := range staticDeps {
3103 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3104 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3105 }
3106 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003107 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3108 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003109 }
3110 }
3111 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3112
3113 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3114
3115 // reorder the dependencies based on transitive dependencies
3116 staticPaths = android.FirstUniquePaths(staticPaths)
3117 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3118
3119 if len(orderedStaticPaths) != len(staticPaths) {
3120 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3121 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3122 }
3123
3124 return orderedStaticPaths, transitiveStaticLibs
3125}
3126
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003127// BaseLibName trims known prefixes and suffixes
3128func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003129 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3130 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003131 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003132 return libName
3133}
3134
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003135func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003136 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003137 ccDepModule, _ := ccDep.(*Module)
3138 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003139 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003140
Justin Yuncbca3732021-02-03 19:24:13 +09003141 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003142 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07003143 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003144 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003145 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003146
Ivan Lozanod1dec542021-05-26 15:33:11 -04003147 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003148 }
3149 }
3150
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003151 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3152 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003153 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3154 // core module instead.
3155 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003156 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003157 // The vendor and product modules in Make will have been renamed to not conflict with the
3158 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003159 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003160 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003161 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003162 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003163 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003164 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003165 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003166 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003167 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003168 } else {
3169 return libName
3170 }
3171}
3172
Colin Crossca860ac2016-01-04 14:34:37 -08003173func (c *Module) InstallInData() bool {
3174 if c.installer == nil {
3175 return false
3176 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003177 return c.installer.inData()
3178}
3179
3180func (c *Module) InstallInSanitizerDir() bool {
3181 if c.installer == nil {
3182 return false
3183 }
3184 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003185 return true
3186 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003187 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003188}
3189
Yifan Hong1b3348d2020-01-21 15:53:22 -08003190func (c *Module) InstallInRamdisk() bool {
3191 return c.InRamdisk()
3192}
3193
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003194func (c *Module) InstallInVendorRamdisk() bool {
3195 return c.InVendorRamdisk()
3196}
3197
Jiyong Parkf9332f12018-02-01 00:54:12 +09003198func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003199 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003200}
3201
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003202func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003203 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003204 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003205 return
3206 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003207 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003208}
3209
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003210func (c *Module) HostToolPath() android.OptionalPath {
3211 if c.installer == nil {
3212 return android.OptionalPath{}
3213 }
3214 return c.installer.hostToolPath()
3215}
3216
Nan Zhangd4e641b2017-07-12 12:55:28 -07003217func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3218 return c.outputFile
3219}
3220
Colin Cross41955e82019-05-29 14:40:35 -07003221func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3222 switch tag {
3223 case "":
3224 if c.outputFile.Valid() {
3225 return android.Paths{c.outputFile.Path()}, nil
3226 }
3227 return android.Paths{}, nil
3228 default:
3229 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003230 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003231}
3232
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003233func (c *Module) static() bool {
3234 if static, ok := c.linker.(interface {
3235 static() bool
3236 }); ok {
3237 return static.static()
3238 }
3239 return false
3240}
3241
Jiyong Park379de2f2018-12-19 02:47:14 +09003242func (c *Module) staticBinary() bool {
3243 if static, ok := c.linker.(interface {
3244 staticBinary() bool
3245 }); ok {
3246 return static.staticBinary()
3247 }
3248 return false
3249}
3250
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003251func (c *Module) testBinary() bool {
3252 if test, ok := c.linker.(interface {
3253 testBinary() bool
3254 }); ok {
3255 return test.testBinary()
3256 }
3257 return false
3258}
3259
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003260func (c *Module) benchmarkBinary() bool {
3261 if b, ok := c.linker.(interface {
3262 benchmarkBinary() bool
3263 }); ok {
3264 return b.benchmarkBinary()
3265 }
3266 return false
3267}
3268
3269func (c *Module) fuzzBinary() bool {
3270 if f, ok := c.linker.(interface {
3271 fuzzBinary() bool
3272 }); ok {
3273 return f.fuzzBinary()
3274 }
3275 return false
3276}
3277
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003278// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3279func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003280 if h, ok := c.linker.(interface {
3281 header() bool
3282 }); ok {
3283 return h.header()
3284 }
3285 return false
3286}
3287
Ivan Lozanod7586b62021-04-01 09:49:36 -04003288func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003289 if b, ok := c.linker.(interface {
3290 binary() bool
3291 }); ok {
3292 return b.binary()
3293 }
3294 return false
3295}
3296
Justin Yun5e035862021-06-29 20:50:37 +09003297func (c *Module) StaticExecutable() bool {
3298 if b, ok := c.linker.(*binaryDecorator); ok {
3299 return b.static()
3300 }
3301 return false
3302}
3303
Ivan Lozanod7586b62021-04-01 09:49:36 -04003304func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003305 if o, ok := c.linker.(interface {
3306 object() bool
3307 }); ok {
3308 return o.object()
3309 }
3310 return false
3311}
3312
Ivan Lozanof9e21722020-12-02 09:00:51 -05003313func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003314 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003315 if c.IsLlndk() {
3316 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003317 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003318 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003319 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003320 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003321 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003322 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003323 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003324 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003325 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003326 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003327 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003328 return "native:product"
3329 }
Jooyung Han38002912019-05-16 04:01:54 +09003330 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003331 } else if c.InRamdisk() {
3332 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003333 } else if c.InVendorRamdisk() {
3334 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003335 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003336 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003337 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003338 return "native:ndk:none:none"
3339 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3340 //family, link := getNdkStlFamilyAndLinkType(c)
3341 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003342 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003343 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003344 } else {
3345 return "native:platform"
3346 }
3347}
3348
Jiyong Park9d452992018-10-03 00:38:19 +09003349// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003350// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003351func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003352 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003353 // Stub libs and prebuilt libs in a versioned SDK are not
3354 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003355 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003356 } else if _, ok := c.linker.(testPerSrc); ok {
3357 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003358 }
3359 return false
3360}
3361
Jiyong Parka90ca002019-10-07 15:47:24 +09003362func (c *Module) AvailableFor(what string) bool {
3363 if linker, ok := c.linker.(interface {
3364 availableFor(string) bool
3365 }); ok {
3366 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3367 } else {
3368 return c.ApexModuleBase.AvailableFor(what)
3369 }
3370}
3371
Jiyong Park62304bb2020-04-13 16:19:48 +09003372func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003373 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003374}
3375
Paul Duffin0cb37b92020-03-04 14:52:46 +00003376func (c *Module) EverInstallable() bool {
3377 return c.installer != nil &&
3378 // Check to see whether the module is actually ever installable.
3379 c.installer.everInstallable()
3380}
3381
Ivan Lozanod7586b62021-04-01 09:49:36 -04003382func (c *Module) PreventInstall() bool {
3383 return c.Properties.PreventInstall
3384}
3385
3386func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003387 if c.library != nil {
3388 if i := c.library.installable(); i != nil {
3389 return i
3390 }
3391 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003392 return c.Properties.Installable
3393}
3394
3395func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003396 ret := c.EverInstallable() &&
3397 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003398 proptools.BoolDefault(c.Installable(), true) &&
3399 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003400
3401 // The platform variant doesn't need further condition. Apex variants however might not
3402 // be installable because it will likely to be included in the APEX and won't appear
3403 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003404 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003405 return ret
3406 }
3407
3408 // Special case for modules that are configured to be installed to /data, which includes
3409 // test modules. For these modules, both APEX and non-APEX variants are considered as
3410 // installable. This is because even the APEX variants won't be included in the APEX, but
3411 // will anyway be installed to /data/*.
3412 // See b/146995717
3413 if c.InstallInData() {
3414 return ret
3415 }
3416
3417 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003418}
3419
Logan Chien41eabe62019-04-10 13:33:58 +08003420func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3421 if c.linker != nil {
3422 if library, ok := c.linker.(*libraryDecorator); ok {
3423 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3424 }
3425 }
3426}
3427
Jiyong Park45bf82e2020-12-15 22:29:02 +09003428var _ android.ApexModule = (*Module)(nil)
3429
3430// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003431func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003432 depTag := ctx.OtherModuleDependencyTag(dep)
3433 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3434
3435 if cc, ok := dep.(*Module); ok {
3436 if cc.HasStubsVariants() {
3437 if isLibDepTag && libDepTag.shared() {
3438 // dynamic dep to a stubs lib crosses APEX boundary
3439 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003440 }
Colin Cross6e511a92020-07-27 21:26:48 -07003441 if IsRuntimeDepTag(depTag) {
3442 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003443 return false
3444 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003445 }
Zhijun Heec285872021-04-24 10:47:08 -07003446 if cc.IsLlndk() {
3447 return false
3448 }
Colin Crossaac32222020-07-29 12:51:56 -07003449 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003450 // shared_lib dependency from a static lib is considered as crossing
3451 // the APEX boundary because the dependency doesn't actually is
3452 // linked; the dependency is used only during the compilation phase.
3453 return false
3454 }
Jiyong Parke3867542020-12-03 17:28:25 +09003455
3456 if isLibDepTag && libDepTag.excludeInApex {
3457 return false
3458 }
Colin Cross6e511a92020-07-27 21:26:48 -07003459 }
Colin Crossc1b36442021-05-06 13:42:48 -07003460 if depTag == stubImplDepTag {
3461 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003462 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003463 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003464 if depTag == staticVariantTag {
3465 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3466 // actually mean that the static lib (and its dependencies) are copied into the
3467 // APEX.
3468 return false
3469 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003470 return true
3471}
3472
Jiyong Park45bf82e2020-12-15 22:29:02 +09003473// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003474func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3475 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003476 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3477 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3478 return nil
3479 }
Jooyung Han749dc692020-04-15 11:03:39 +09003480 // We don't check for prebuilt modules
3481 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3482 return nil
3483 }
3484 minSdkVersion := c.MinSdkVersion()
3485 if minSdkVersion == "apex_inherit" {
3486 return nil
3487 }
3488 if minSdkVersion == "" {
3489 // JNI libs within APK-in-APEX fall into here
3490 // Those are okay to set sdk_version instead
3491 // We don't have to check if this is a SDK variant because
3492 // non-SDK variant resets sdk_version, which works too.
3493 minSdkVersion = c.SdkVersion()
3494 }
Dan Albertc8060532020-07-22 22:32:17 -07003495 if minSdkVersion == "" {
3496 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3497 }
3498 // Not using nativeApiLevelFromUser because the context here is not
3499 // necessarily a native context.
3500 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003501 if err != nil {
3502 return err
3503 }
Dan Albertc8060532020-07-22 22:32:17 -07003504
3505 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003506 return fmt.Errorf("newer SDK(%v)", ver)
3507 }
3508 return nil
3509}
3510
Paul Duffinb5769c12021-05-12 16:16:51 +01003511// Implements android.ApexModule
3512func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3513 // stub libraries and native bridge libraries are always available to platform
3514 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3515}
3516
Jooyung Han91f92032022-02-04 12:36:33 +09003517// Overrides android.ApexModuleBase.UniqueApexVariations
3518func (c *Module) UniqueApexVariations() bool {
3519 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3520 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3521 // variation of the VNDK lib because APEX variations are merged/grouped.
3522 return c.UseVndk() && c.IsVndk()
3523}
3524
Rob Seymour925aa092021-08-10 20:42:03 +00003525var _ snapshot.RelativeInstallPath = (*Module)(nil)
3526
Liz Kammer35ca77e2021-12-22 15:31:40 -05003527type moduleType int
3528
3529const (
3530 unknownType moduleType = iota
3531 binary
3532 object
3533 fullLibrary
3534 staticLibrary
3535 sharedLibrary
3536 headerLibrary
3537)
3538
3539func (c *Module) typ() moduleType {
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003540 if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003541 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003542 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003543 return object
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003544 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003545 static := false
3546 shared := false
3547 if library, ok := c.linker.(*libraryDecorator); ok {
3548 static = library.MutatedProperties.BuildStatic
3549 shared = library.MutatedProperties.BuildShared
3550 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3551 static = library.MutatedProperties.BuildStatic
3552 shared = library.MutatedProperties.BuildShared
3553 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003554 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003555 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003556 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003557 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003558 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003559 return staticLibrary
3560 }
3561 return sharedLibrary
3562 }
3563 return unknownType
3564}
3565
3566// ConvertWithBp2build converts Module to Bazel for bp2build.
3567func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
3568 prebuilt := c.IsPrebuilt()
3569 switch c.typ() {
3570 case binary:
3571 if !prebuilt {
3572 binaryBp2build(ctx, c, ctx.ModuleType())
3573 }
3574 case object:
3575 if !prebuilt {
3576 objectBp2Build(ctx, c)
3577 }
3578 case fullLibrary:
3579 if !prebuilt {
3580 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003581 } else {
3582 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003583 }
3584 case headerLibrary:
3585 libraryHeadersBp2Build(ctx, c)
3586 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05003587 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003588 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003589 } else {
3590 sharedOrStaticLibraryBp2Build(ctx, c, true)
3591 }
3592 case sharedLibrary:
3593 if prebuilt {
3594 prebuiltLibrarySharedBp2Build(ctx, c)
3595 } else {
3596 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003597 }
3598 }
3599}
3600
Colin Cross2ba19d92015-05-07 15:44:20 -07003601//
Colin Crosscfad1192015-11-02 16:43:11 -08003602// Defaults
3603//
Colin Crossca860ac2016-01-04 14:34:37 -08003604type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003605 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003606 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003607 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003608}
3609
Patrice Arrudac249c712019-03-19 17:00:29 -07003610// cc_defaults provides a set of properties that can be inherited by other cc
3611// modules. A module can use the properties from a cc_defaults using
3612// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3613// merged (when possible) by prepending the default module's values to the
3614// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003615func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003616 return DefaultsFactory()
3617}
3618
Colin Cross36242852017-06-23 15:06:31 -07003619func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003620 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003621
Colin Cross36242852017-06-23 15:06:31 -07003622 module.AddProperties(props...)
3623 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003624 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003625 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003626 &BaseCompilerProperties{},
3627 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003628 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003629 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003630 &StaticProperties{},
3631 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003632 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003633 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003634 &TestLinkerProperties{},
3635 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003636 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003637 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003638 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003639 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003640 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003641 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003642 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003643 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003644 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003645 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003646 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003647 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003648 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003649 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003650 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003651 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3652 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003653 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003654 )
Colin Crosscfad1192015-11-02 16:43:11 -08003655
Jooyung Hancc372c52019-09-25 15:18:44 +09003656 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003657
3658 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003659}
3660
Jiyong Park2286afd2020-06-16 21:58:53 +09003661func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003662 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003663}
3664
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003665func kytheExtractAllFactory() android.Singleton {
3666 return &kytheExtractAllSingleton{}
3667}
3668
3669type kytheExtractAllSingleton struct {
3670}
3671
3672func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3673 var xrefTargets android.Paths
3674 ctx.VisitAllModules(func(module android.Module) {
3675 if ccModule, ok := module.(xref); ok {
3676 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3677 }
3678 })
3679 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3680 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003681 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003682 }
3683}
3684
Colin Cross06a931b2015-10-28 17:23:31 -07003685var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003686var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003687var BoolPtr = proptools.BoolPtr
3688var String = proptools.String
3689var StringPtr = proptools.StringPtr