blob: 39fdcb7a04466e99f05ebd8d685435e8af6874e2 [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Colin Cross97ba0732015-03-23 17:50:24 -070027 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070028 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070029
Colin Cross635c3b02016-05-18 15:37:25 -070030 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070031 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070032 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070033 "android/soong/genrule"
Rob Seymour925aa092021-08-10 20:42:03 +000034 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080035)
36
Colin Cross463a90e2015-06-17 14:20:06 -070037func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000038 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070039
Paul Duffin036e7002019-12-19 19:16:28 +000040 pctx.Import("android/soong/cc/config")
41}
42
43func RegisterCCBuildComponents(ctx android.RegistrationContext) {
44 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
45
46 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000047 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090048 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070049 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010050 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070051 ctx.BottomUp("version_selector", versionSelectorMutator).Parallel()
52 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070053 ctx.BottomUp("begin", BeginMutator).Parallel()
Inseob Kimac1e9862019-12-09 18:15:47 +090054 ctx.BottomUp("sysprop_cc", SyspropMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070055 })
Colin Cross16b23492016-01-06 14:41:07 -080056
Paul Duffin036e7002019-12-19 19:16:28 +000057 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040058 for _, san := range Sanitizers {
59 san.registerMutators(ctx)
60 }
Dan Willemsen581341d2017-02-09 16:16:31 -080061
Colin Cross0b908332019-06-19 23:00:20 -070062 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090063 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080064
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080065 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070066
67 ctx.TopDown("lto_deps", ltoDepsMutator)
68 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090069
Jooyung Han479ca172020-10-19 18:51:07 +090070 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090071 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070072 })
Colin Crossb98c8b02016-07-29 13:44:28 -070073
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080074 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
75 // sabi mutator needs to be run after apex mutator finishes.
76 ctx.TopDown("sabi_deps", sabiDepsMutator)
77 })
78
Colin Cross57898582020-10-29 18:25:19 -070079 ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070080}
81
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050082// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
83// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
84// edges to these modules.
85// This object is constructed in DepsMutator, by calling to various module delegates to set
86// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
87// dependencies.
88// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
89// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080090type Deps struct {
91 SharedLibs, LateSharedLibs []string
92 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080093 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +080094 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -070095
Chris Parsons79d66a52020-06-05 17:26:16 -040096 // Used for data dependencies adjacent to tests
97 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -070098 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -040099
Yo Chiang219968c2020-09-22 18:45:04 +0800100 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
101 SystemSharedLibs []string
102
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500103 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800104 StaticUnwinderIfLegacy bool
105
Colin Cross5950f382016-12-13 12:50:57 -0800106 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700107
Colin Cross81413472016-04-11 14:37:39 -0700108 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700109
Dan Willemsenb40aab62016-04-20 14:21:14 -0700110 GeneratedSources []string
111 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900112 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700113
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700114 ReexportGeneratedHeaders []string
115
Colin Crossc465efd2021-06-11 18:00:04 -0700116 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700117
118 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700119 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900120
121 // List of libs that need to be excluded for APEX variant
122 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700123}
124
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500125// PathDeps is a struct containing file paths to dependencies of a module.
126// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
127// It's used to construct flags for various build statements (such as for compiling and linking).
128// It is then passed to module decorator functions responsible for registering build statements
129// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800130type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700131 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900132 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700133 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900134 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700135 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700136 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700137
Colin Cross0de8a1e2020-09-18 14:15:30 -0700138 // Transitive static library dependencies of static libraries for use in ordering.
139 TranstiveStaticLibrariesForOrdering *android.DepSet
140
Colin Cross26c34ed2016-09-30 17:10:16 -0700141 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100142 Objs Objects
143 // Paths to .o files in dependencies that provide them. Note that these lists
144 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800145 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700146 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700147
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100148 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
149 // the libs from all whole_static_lib dependencies.
150 WholeStaticLibsFromPrebuilts android.Paths
151
Colin Cross26c34ed2016-09-30 17:10:16 -0700152 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700153 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900154 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700155
Inseob Kimd110f872019-12-06 13:15:38 +0900156 Flags []string
157 IncludeDirs android.Paths
158 SystemIncludeDirs android.Paths
159 ReexportedDirs android.Paths
160 ReexportedSystemDirs android.Paths
161 ReexportedFlags []string
162 ReexportedGeneratedHeaders android.Paths
163 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700164
Colin Cross26c34ed2016-09-30 17:10:16 -0700165 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700166 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700167
Dan Willemsena0790e32018-10-12 00:24:23 -0700168 // Path to the dynamic linker binary
169 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700170
171 // For Darwin builds, the path to the second architecture's output that should
172 // be combined with this architectures's output into a FAT MachO file.
173 DarwinSecondArchOutput android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700174}
175
Colin Cross4af21ed2019-11-04 09:37:55 -0800176// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
177// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
178// command line so they can be overridden by the local module flags).
179type LocalOrGlobalFlags struct {
180 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700181 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800182 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700183 CFlags []string // Flags that apply to C and C++ source files
184 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
185 ConlyFlags []string // Flags that apply to C source files
186 CppFlags []string // Flags that apply to C++ source files
187 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700188 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800189}
190
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500191// Flags contains various types of command line flags (and settings) for use in building build
192// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800193type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500194 // Local flags (which individual modules are responsible for). These may override global flags.
195 Local LocalOrGlobalFlags
196 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800197 Global LocalOrGlobalFlags
198
199 aidlFlags []string // Flags that apply to aidl source files
200 rsFlags []string // Flags that apply to renderscript source files
201 libFlags []string // Flags to add libraries early to the link order
202 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
203 TidyFlags []string // Flags that apply to clang-tidy
204 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700205
Colin Crossc3199482017-03-30 15:03:04 -0700206 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800207 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700208 SystemIncludeFlags []string
209
Oliver Nguyen04526782020-04-21 12:40:27 -0700210 Toolchain config.Toolchain
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500211 Tidy bool // True if clang-tidy is enabled.
212 GcovCoverage bool // True if coverage files should be generated.
213 SAbiDump bool // True if header abi dumps should be generated.
Oliver Nguyen04526782020-04-21 12:40:27 -0700214 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800215
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500216 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800217 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500218 // The target-device system path to the dynamic linker.
219 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800220
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700221 CFlagsDeps android.Paths // Files depended on by compiler flags
222 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800223
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500224 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700225 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800226
Colin Cross19878da2019-03-28 14:45:07 -0700227 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700228 protoC bool // Whether to use C instead of C++
229 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700230
231 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200232 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700233}
234
Colin Crossca860ac2016-01-04 14:34:37 -0800235// Properties used to compile all C or C++ modules
236type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700237 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800238 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700239
Jiyong Parkb35a8192020-08-10 15:59:36 +0900240 // The API level that this module is built against. The APIs of this API level will be
241 // visible at build time, but use of any APIs newer than min_sdk_version will render the
242 // module unloadable on older devices. In the future it will be possible to weakly-link new
243 // APIs, making the behavior match Java: such modules will load on older devices, but
244 // calling new APIs on devices that do not support them will result in a crash.
245 //
246 // This property has the same behavior as sdk_version does for Java modules. For those
247 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
248 // does for Java code.
249 //
250 // In addition, setting this property causes two variants to be built, one for the platform
251 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800252 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700253
Jiyong Parkb35a8192020-08-10 15:59:36 +0900254 // Minimum OS API level supported by this C or C++ module. This property becomes the value
255 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
256 // this property is also used to ensure that the min_sdk_version of the containing module is
257 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
258 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
259 // min_sdk_version of the containing APEX. When the module
260 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900261 Min_sdk_version *string
262
Colin Crossc511bc52020-04-07 16:50:32 +0000263 // If true, always create an sdk variant and don't create a platform variant.
264 Sdk_variant_only *bool
265
Jiyong Parkde866cb2018-12-07 23:08:36 +0900266 AndroidMkSharedLibs []string `blueprint:"mutated"`
267 AndroidMkStaticLibs []string `blueprint:"mutated"`
268 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
269 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700270 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900271 HideFromMake bool `blueprint:"mutated"`
272 PreventInstall bool `blueprint:"mutated"`
273 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700274
Yo Chiang219968c2020-09-22 18:45:04 +0800275 // Set by DepsMutator.
276 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
277
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200278 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900279 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200280
281 // The VNDK version this module is built against. If empty, the module is not
282 // build against the VNDK.
283 VndkVersion string `blueprint:"mutated"`
284
285 // Suffix for the name of Android.mk entries generated by this module
286 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800287
288 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
289 // file
290 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900291
Yifan Hong39143a92020-10-26 12:43:12 -0700292 // Make this module available when building for ramdisk.
293 // On device without a dedicated recovery partition, the module is only
294 // available after switching root into
295 // /first_stage_ramdisk. To expose the module before switching root, install
296 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800297 Ramdisk_available *bool
298
Yifan Hong39143a92020-10-26 12:43:12 -0700299 // Make this module available when building for vendor ramdisk.
300 // On device without a dedicated recovery partition, the module is only
301 // available after switching root into
302 // /first_stage_ramdisk. To expose the module before switching root, install
303 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700304 Vendor_ramdisk_available *bool
305
Jiyong Parkf9332f12018-02-01 00:54:12 +0900306 // Make this module available when building for recovery
307 Recovery_available *bool
308
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200309 // Used by imageMutator, set by ImageMutatorBegin()
310 CoreVariantNeeded bool `blueprint:"mutated"`
311 RamdiskVariantNeeded bool `blueprint:"mutated"`
312 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
313 RecoveryVariantNeeded bool `blueprint:"mutated"`
314
315 // A list of variations for the "image" mutator of the form
316 //<image name> '.' <version char>, for example, 'vendor.S'
317 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900318
319 // Allows this module to use non-APEX version of libraries. Useful
320 // for building binaries that are started before APEXes are activated.
321 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900322
323 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
324 // see soong/cc/config/vndk.go
325 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900326
327 // Used by vendor snapshot to record dependencies from snapshot modules.
328 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900329 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900330 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000331
Colin Cross1bc94122021-10-28 13:25:54 -0700332 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000333
334 // Set by factories of module types that can only be referenced from variants compiled against
335 // the SDK.
336 AlwaysSdk bool `blueprint:"mutated"`
337
338 // Variant is an SDK variant created by sdkMutator
339 IsSdkVariant bool `blueprint:"mutated"`
340 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
341 // variant to have a ".sdk" suffix.
342 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700343
344 // Normally Soong uses the directory structure to decide which modules
345 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800346 // different snapshots (vendor, recovery, etc.), but this property
347 // allows a partner to exclude a module normally thought of as a
348 // framework module from the vendor snapshot.
349 Exclude_from_vendor_snapshot *bool
350
351 // Normally Soong uses the directory structure to decide which modules
352 // should be included (framework) or excluded (non-framework) from the
353 // different snapshots (vendor, recovery, etc.), but this property
354 // allows a partner to exclude a module normally thought of as a
355 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800356 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900357
358 // List of APEXes that this module has private access to for testing purpose. The module
359 // can depend on libraries that are not exported by the APEXes and use private symbols
360 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000361 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800362
363 Target struct {
364 Platform struct {
365 // List of modules required by the core variant.
366 Required []string `android:"arch_variant"`
367
368 // List of modules not required by the core variant.
369 Exclude_required []string `android:"arch_variant"`
370 } `android:"arch_variant"`
371
372 Recovery struct {
373 // List of modules required by the recovery variant.
374 Required []string `android:"arch_variant"`
375
376 // List of modules not required by the recovery variant.
377 Exclude_required []string `android:"arch_variant"`
378 } `android:"arch_variant"`
379 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700380}
381
382type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900383 // whether this module should be allowed to be directly depended by other
384 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900385 // If set to true, two variants will be built separately, one like
386 // normal, and the other limited to the set of libraries and headers
387 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700388 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900389 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700390 // so it shouldn't have any unversioned runtime dependencies, or
391 // make assumptions about the system that may not be true in the
392 // future.
393 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900394 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900395 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900396 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900397 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900398 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700399 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
400 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900401
Justin Yunebcf0c52021-01-08 18:00:19 +0900402 // This is the same as the "vendor_available" except that the install path
403 // of the vendor variant is /odm or /vendor/odm.
404 // By replacing "vendor_available: true" with "odm_available: true", the
405 // module will install its vendor variant to the /odm partition or /vendor/odm.
406 // As the modules with "odm_available: true" still create the vendor variants,
407 // they can link to the other vendor modules as the vendor_available modules do.
408 // Also, the vendor modules can link to odm_available modules.
409 //
410 // It may not be used for VNDK modules.
411 Odm_available *bool
412
Justin Yun63e9ec72020-10-29 16:49:43 +0900413 // whether this module should be allowed to be directly depended by other
414 // modules with `product_specific: true` or `product_available: true`.
415 // If set to true, an additional product variant will be built separately
416 // that is limited to the set of libraries and headers that are exposed to
417 // /product modules.
418 //
419 // The product variant may be used with a different (newer) /system,
420 // so it shouldn't have any unversioned runtime dependencies, or
421 // make assumptions about the system that may not be true in the
422 // future.
423 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900424 // If set to false, this module becomes inaccessible from /product modules.
425 //
426 // Different from the 'vendor_available' property, the modules with
427 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
428 // library without 'product_available' may not be depended on by any other
429 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900430 //
431 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
432 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
433 Product_available *bool
434
Jiyong Park5fb8c102018-04-09 12:03:06 +0900435 // whether this module is capable of being loaded with other instance
436 // (possibly an older version) of the same module in the same process.
437 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
438 // can be double loaded in a vendor process if the library is also a
439 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
440 // explicitly marked as `double_loadable: true` by the owner, or the dependency
441 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
442 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800443
444 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
445 IsLLNDK bool `blueprint:"mutated"`
446
Colin Cross78212242021-01-06 14:51:30 -0800447 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
448 // set and the module is not listed in VndkMustUseVendorVariantList.
449 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
450
451 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
452 IsVNDKCore bool `blueprint:"mutated"`
453
454 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
455 IsVNDKSP bool `blueprint:"mutated"`
456
457 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
458 // module sets the llndk.private property.
459 IsVNDKPrivate bool `blueprint:"mutated"`
460
461 // IsVNDKProduct is set if a VNDK module sets the product_available property.
462 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700463
464 // IsVendorPublicLibrary is set for the core and product variants of a library that has
465 // vendor_public_library stubs.
466 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800467}
468
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500469// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
470// to understanding details about the type of the current module.
471// For example, one might call these functions to determine whether the current module is a static
472// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800473type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800474 static() bool
475 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700476 testBinary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900477 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900478 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900479 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700480 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900481 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700482 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800483 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900484 minSdkVersion() string
485 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700486 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700487 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800488 IsLlndk() bool
489 IsLlndkPublic() bool
490 isImplementationForLLNDKPublic() bool
491 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900492 isVndk() bool
493 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500494 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700495 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900496 inProduct() bool
497 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800498 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700499 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900500 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700501 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700502 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800503 getVndkExtendsModuleName() string
Yi Kong7e53c572018-02-14 18:16:12 +0800504 isPgoCompile() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800505 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800506 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800507 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700508 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700509 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900510 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800511 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700512 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700513 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800514 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800515 isCfiAssemblySupportEnabled() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800516}
517
518type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700519 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800520 ModuleContextIntf
521}
522
523type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700524 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800525 ModuleContextIntf
526}
527
Colin Cross37047f12016-12-13 17:06:13 -0800528type DepsContext interface {
529 android.BottomUpMutatorContext
530 ModuleContextIntf
531}
532
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500533// feature represents additional (optional) steps to building cc-related modules, such as invocation
534// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800535type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800536 flags(ctx ModuleContext, flags Flags) Flags
537 props() []interface{}
538}
539
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500540// compiler is the interface for a compiler helper object. Different module decorators may implement
541// this helper differently. For example, compiling a `cc_library` may use a different build
542// statement than building a `toolchain_library`.
Colin Crossca860ac2016-01-04 14:34:37 -0800543type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700544 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800545 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800546 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700547 compilerProps() []interface{}
548
Colin Cross76fada02016-07-27 10:31:13 -0700549 appendCflags([]string)
550 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700551 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800552}
553
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500554// linker is the interface for a linker decorator object. Individual module types can provide
555// their own implementation for this decorator, and thus specify custom logic regarding build
556// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800557type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700558 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800559 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700560 linkerFlags(ctx ModuleContext, flags Flags) Flags
561 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800562 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700563
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700564 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700565 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900566 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700567
568 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900569 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000570
571 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000572 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
573}
574
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500575// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000576type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500577 sharedLibs []string
578 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
579 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700580 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800581}
582
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500583// installer is the interface for an installer helper object. This helper is responsible for
584// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800585type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700586 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700587 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000588 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800589 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700590 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700591 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900592 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100593 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900594 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800595}
596
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800597type xref interface {
598 XrefCcFiles() android.Paths
599}
600
Colin Cross6e511a92020-07-27 21:26:48 -0700601type libraryDependencyKind int
602
603const (
604 headerLibraryDependency = iota
605 sharedLibraryDependency
606 staticLibraryDependency
607)
608
609func (k libraryDependencyKind) String() string {
610 switch k {
611 case headerLibraryDependency:
612 return "headerLibraryDependency"
613 case sharedLibraryDependency:
614 return "sharedLibraryDependency"
615 case staticLibraryDependency:
616 return "staticLibraryDependency"
617 default:
618 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
619 }
620}
621
622type libraryDependencyOrder int
623
624const (
625 earlyLibraryDependency = -1
626 normalLibraryDependency = 0
627 lateLibraryDependency = 1
628)
629
630func (o libraryDependencyOrder) String() string {
631 switch o {
632 case earlyLibraryDependency:
633 return "earlyLibraryDependency"
634 case normalLibraryDependency:
635 return "normalLibraryDependency"
636 case lateLibraryDependency:
637 return "lateLibraryDependency"
638 default:
639 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
640 }
641}
642
643// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
644// tags that have a set of predefined tag objects that are reused for each dependency, a
645// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
646// That means that comparing a libraryDependencyTag for equality will only be equal if all
647// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
648// then check individual metadata fields instead.
649type libraryDependencyTag struct {
650 blueprint.BaseDependencyTag
651
652 // These are exported so that fmt.Printf("%#v") can call their String methods.
653 Kind libraryDependencyKind
654 Order libraryDependencyOrder
655
656 wholeStatic bool
657
658 reexportFlags bool
659 explicitlyVersioned bool
660 dataLib bool
661 ndk bool
662
663 staticUnwinder bool
664
665 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900666
Cindy Zhou18417cb2020-12-10 07:12:38 -0800667 // Whether or not this dependency should skip the apex dependency check
668 skipApexAllowedDependenciesCheck bool
669
Jiyong Parke3867542020-12-03 17:28:25 +0900670 // Whether or not this dependency has to be followed for the apex variants
671 excludeInApex bool
Colin Cross6e511a92020-07-27 21:26:48 -0700672}
673
674// header returns true if the libraryDependencyTag is tagging a header lib dependency.
675func (d libraryDependencyTag) header() bool {
676 return d.Kind == headerLibraryDependency
677}
678
679// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
680func (d libraryDependencyTag) shared() bool {
681 return d.Kind == sharedLibraryDependency
682}
683
684// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
685func (d libraryDependencyTag) static() bool {
686 return d.Kind == staticLibraryDependency
687}
688
Colin Cross65cb3142021-12-10 23:05:02 +0000689func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
690 if d.shared() {
691 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
692 }
693 return nil
694}
695
696var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
697
Colin Crosse9fe2942020-11-10 18:12:15 -0800698// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
699// binaries or other shared libraries are installed as dependencies.
700func (d libraryDependencyTag) InstallDepNeeded() bool {
701 return d.shared()
702}
703
704var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
705
706// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700707// libraryDependencyTag. Each tag object is created globally and reused for multiple
708// dependencies (although since the object contains no references, assigning a tag to a
709// variable and modifying it will not modify the original). Users can compare the tag
710// returned by ctx.OtherModuleDependencyTag against the global original
711type dependencyTag struct {
712 blueprint.BaseDependencyTag
713 name string
714}
715
Colin Crosse9fe2942020-11-10 18:12:15 -0800716// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
717// libraryDependencyTag, but where the dependency needs to be installed when the parent is
718// installed.
719type installDependencyTag struct {
720 blueprint.BaseDependencyTag
721 android.InstallAlwaysNeededDependencyTag
722 name string
723}
724
Colin Crossc99deeb2016-04-11 15:06:20 -0700725var (
Colin Cross6e511a92020-07-27 21:26:48 -0700726 genSourceDepTag = dependencyTag{name: "gen source"}
727 genHeaderDepTag = dependencyTag{name: "gen header"}
728 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
729 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900730 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700731 reuseObjTag = dependencyTag{name: "reuse objects"}
732 staticVariantTag = dependencyTag{name: "static variant"}
733 vndkExtDepTag = dependencyTag{name: "vndk extends"}
734 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700735 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800736 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700737 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700738 stubImplDepTag = dependencyTag{name: "stub_impl"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700739)
740
Roland Levillainf89cd092019-07-29 16:22:59 +0100741func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700742 ccLibDepTag, ok := depTag.(libraryDependencyTag)
743 return ok && ccLibDepTag.shared()
744}
745
746func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
747 ccLibDepTag, ok := depTag.(libraryDependencyTag)
748 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100749}
750
Zach Johnson3df4e632020-11-06 11:56:27 -0800751func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
752 ccLibDepTag, ok := depTag.(libraryDependencyTag)
753 return ok && ccLibDepTag.header()
754}
755
Roland Levillainf89cd092019-07-29 16:22:59 +0100756func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800757 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100758}
759
760func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700761 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100762 return ok && ccDepTag == testPerSrcDepTag
763}
764
Colin Crossca860ac2016-01-04 14:34:37 -0800765// Module contains the properties and members used by all C/C++ module types, and implements
766// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500767// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
768// interface.
769//
770// To define a C/C++ related module, construct a new Module object and point its delegates to
771// type-specific structs. These delegates will be invoked to register module-specific build
772// statements which may be unique to the module type. For example, module.compiler.compile() should
773// be defined so as to register build statements which are responsible for compiling the module.
774//
775// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
776// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
777// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
778// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800779type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700780 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700781
Jiyong Parkd1063c12019-07-17 20:08:41 +0900782 android.SdkBase
Liz Kammerea6666f2021-02-17 10:17:28 -0500783 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700784
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700785 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700786 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700787
Colin Crossca860ac2016-01-04 14:34:37 -0800788 // initialize before calling Init
Colin Cross635c3b02016-05-18 15:37:25 -0700789 hod android.HostOrDeviceSupported
790 multilib android.Multilib
Colin Crossc472d572015-03-17 15:06:21 -0700791
Paul Duffina0843f62019-12-13 19:50:38 +0000792 // Allowable SdkMemberTypes of this module type.
793 sdkMemberTypes []android.SdkMemberType
794
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500795 // decorator delegates, initialize before calling Init
796 // these may contain module-specific implementations, and effectively allow for custom
797 // type-specific logic. These members may reference different objects or the same object.
798 // Functions of these decorators will be invoked to initialize and register type-specific
799 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500800 compiler compiler
801 linker linker
802 installer installer
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux0d990452021-08-11 16:46:13 +0000803 bazelHandler android.BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500804
805 features []feature
806 stl *stl
807 sanitize *sanitize
808 coverage *coverage
809 sabi *sabi
810 vndkdep *vndkdep
811 lto *lto
812 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800813
Colin Cross31076b32020-10-23 17:22:06 -0700814 library libraryInterface
815
Colin Cross635c3b02016-05-18 15:37:25 -0700816 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800817
Colin Crossb98c8b02016-07-29 13:44:28 -0700818 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700819
820 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800821
822 // Flags used to compile this module
823 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700824
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800825 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700826 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900827
828 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800829 // Kythe (source file indexer) paths for this compilation module
830 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700831 // Object .o file output paths for this compilation module
832 objFiles android.Paths
833 // Tidy .tidy file output paths for this compilation module
834 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900835
836 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700837 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700838
839 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700840}
841
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200842func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400843 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
844 if b, ok := c.compiler.(*baseCompiler); ok {
845 hasAidl = b.hasSrcExt(".aidl")
846 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
847 hasProto = b.hasSrcExt(".proto")
848 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
849 hasSysprop = b.hasSrcExt(".sysprop")
850 hasWinMsg = b.hasSrcExt(".mc")
851 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
852 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200853 c.AndroidModuleBase().AddJSONData(d)
854 (*d)["Cc"] = map[string]interface{}{
855 "SdkVersion": c.SdkVersion(),
856 "MinSdkVersion": c.MinSdkVersion(),
857 "VndkVersion": c.VndkVersion(),
858 "ProductSpecific": c.ProductSpecific(),
859 "SocSpecific": c.SocSpecific(),
860 "DeviceSpecific": c.DeviceSpecific(),
861 "InProduct": c.InProduct(),
862 "InVendor": c.InVendor(),
863 "InRamdisk": c.InRamdisk(),
864 "InVendorRamdisk": c.InVendorRamdisk(),
865 "InRecovery": c.InRecovery(),
866 "VendorAvailable": c.VendorAvailable(),
867 "ProductAvailable": c.ProductAvailable(),
868 "RamdiskAvailable": c.RamdiskAvailable(),
869 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
870 "RecoveryAvailable": c.RecoveryAvailable(),
871 "OdmAvailable": c.OdmAvailable(),
872 "InstallInData": c.InstallInData(),
873 "InstallInRamdisk": c.InstallInRamdisk(),
874 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
875 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
876 "InstallInRecovery": c.InstallInRecovery(),
877 "InstallInRoot": c.InstallInRoot(),
878 "IsVndk": c.IsVndk(),
879 "IsVndkExt": c.IsVndkExt(),
880 "IsVndkPrivate": c.IsVndkPrivate(),
881 "IsVndkSp": c.IsVndkSp(),
882 "IsLlndk": c.IsLlndk(),
883 "IsLlndkPublic": c.IsLlndkPublic(),
884 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
885 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
886 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
887 "ApexSdkVersion": c.apexSdkVersion,
888 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400889 "AidlSrcs": hasAidl,
890 "LexSrcs": hasLex,
891 "ProtoSrcs": hasProto,
892 "RenderscriptSrcs": hasRenderscript,
893 "SyspropSrcs": hasSysprop,
894 "WinMsgSrcs": hasWinMsg,
895 "YaccSrsc": hasYacc,
896 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200897 }
898}
899
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500900func (c *Module) SetPreventInstall() {
901 c.Properties.PreventInstall = true
902}
903
904func (c *Module) SetHideFromMake() {
905 c.Properties.HideFromMake = true
906}
907
Ivan Lozanod7586b62021-04-01 09:49:36 -0400908func (c *Module) HiddenFromMake() bool {
909 return c.Properties.HideFromMake
910}
911
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800912func (c *Module) RequiredModuleNames() []string {
913 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
914 if c.ImageVariation().Variation == android.CoreVariation {
915 required = append(required, c.Properties.Target.Platform.Required...)
916 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
917 } else if c.InRecovery() {
918 required = append(required, c.Properties.Target.Recovery.Required...)
919 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
920 }
921 return android.FirstUniqueStrings(required)
922}
923
Ivan Lozano52767be2019-10-18 14:49:46 -0700924func (c *Module) Toc() android.OptionalPath {
925 if c.linker != nil {
926 if library, ok := c.linker.(libraryInterface); ok {
927 return library.toc()
928 }
929 }
930 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
931}
932
933func (c *Module) ApiLevel() string {
934 if c.linker != nil {
935 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700936 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700937 }
938 }
939 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
940}
941
942func (c *Module) Static() bool {
943 if c.linker != nil {
944 if library, ok := c.linker.(libraryInterface); ok {
945 return library.static()
946 }
947 }
948 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
949}
950
951func (c *Module) Shared() bool {
952 if c.linker != nil {
953 if library, ok := c.linker.(libraryInterface); ok {
954 return library.shared()
955 }
956 }
957 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
958}
959
960func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +0000961 if c.stl != nil {
962 return c.stl.Properties.SelectedStl
963 }
964 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -0700965}
966
967func (c *Module) ToolchainLibrary() bool {
968 if _, ok := c.linker.(*toolchainLibraryDecorator); ok {
969 return true
970 }
971 return false
972}
973
974func (c *Module) NdkPrebuiltStl() bool {
975 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
976 return true
977 }
978 return false
979}
980
981func (c *Module) StubDecorator() bool {
982 if _, ok := c.linker.(*stubDecorator); ok {
983 return true
984 }
985 return false
986}
987
988func (c *Module) SdkVersion() string {
989 return String(c.Properties.Sdk_version)
990}
991
Artur Satayev480e25b2020-04-27 18:53:18 +0100992func (c *Module) MinSdkVersion() string {
993 return String(c.Properties.Min_sdk_version)
994}
995
Jiyong Park5df7bd32021-08-25 16:18:46 +0900996func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -0700997 if linker, ok := c.linker.(*objectLinker); ok {
998 return linker.isCrt()
999 }
1000 return false
1001}
1002
Jiyong Park5df7bd32021-08-25 16:18:46 +09001003func (c *Module) SplitPerApiLevel() bool {
1004 return c.canUseSdk() && c.isCrt()
1005}
1006
Colin Crossc511bc52020-04-07 16:50:32 +00001007func (c *Module) AlwaysSdk() bool {
1008 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1009}
1010
Ivan Lozano183a3212019-10-18 14:18:45 -07001011func (c *Module) CcLibrary() bool {
1012 if c.linker != nil {
1013 if _, ok := c.linker.(*libraryDecorator); ok {
1014 return true
1015 }
Colin Crossd48fe732020-09-23 20:37:24 -07001016 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1017 return true
1018 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001019 }
1020 return false
1021}
1022
1023func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001024 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001025 return true
1026 }
1027 return false
1028}
1029
Ivan Lozano2b262972019-11-21 12:30:50 -08001030func (c *Module) NonCcVariants() bool {
1031 return false
1032}
1033
Ivan Lozano183a3212019-10-18 14:18:45 -07001034func (c *Module) SetStatic() {
1035 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001036 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001037 library.setStatic()
1038 return
1039 }
1040 }
1041 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1042}
1043
1044func (c *Module) SetShared() {
1045 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001046 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001047 library.setShared()
1048 return
1049 }
1050 }
1051 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1052}
1053
1054func (c *Module) BuildStaticVariant() bool {
1055 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001056 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001057 return library.buildStatic()
1058 }
1059 }
1060 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1061}
1062
1063func (c *Module) BuildSharedVariant() bool {
1064 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001065 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001066 return library.buildShared()
1067 }
1068 }
1069 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1070}
1071
1072func (c *Module) Module() android.Module {
1073 return c
1074}
1075
Jiyong Parkc20eee32018-09-05 22:36:17 +09001076func (c *Module) OutputFile() android.OptionalPath {
1077 return c.outputFile
1078}
1079
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001080func (c *Module) CoverageFiles() android.Paths {
1081 if c.linker != nil {
1082 if library, ok := c.linker.(libraryInterface); ok {
1083 return library.objs().coverageFiles
1084 }
1085 }
1086 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1087}
1088
Ivan Lozano183a3212019-10-18 14:18:45 -07001089var _ LinkableInterface = (*Module)(nil)
1090
Jiyong Park719b4462019-01-13 00:39:51 +09001091func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001092 if c.linker != nil {
1093 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001094 }
1095 return nil
1096}
1097
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001098func (c *Module) CoverageOutputFile() android.OptionalPath {
1099 if c.linker != nil {
1100 return c.linker.coverageOutputFilePath()
1101 }
1102 return android.OptionalPath{}
1103}
1104
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001105func (c *Module) RelativeInstallPath() string {
1106 if c.installer != nil {
1107 return c.installer.relativeInstallPath()
1108 }
1109 return ""
1110}
1111
Jooyung Han344d5432019-08-23 11:17:39 +09001112func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001113 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001114}
1115
Colin Cross36242852017-06-23 15:06:31 -07001116func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001117 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001118 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001119 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001120 }
1121 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001122 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001123 }
1124 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001125 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001126 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001127 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001128 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001129 }
Colin Cross16b23492016-01-06 14:41:07 -08001130 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001131 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001132 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001133 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001134 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001135 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001136 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001137 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001138 }
Justin Yun8effde42017-06-23 19:24:43 +09001139 if c.vndkdep != nil {
1140 c.AddProperties(c.vndkdep.props()...)
1141 }
Stephen Craneba090d12017-05-09 15:44:35 -07001142 if c.lto != nil {
1143 c.AddProperties(c.lto.props()...)
1144 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001145 if c.pgo != nil {
1146 c.AddProperties(c.pgo.props()...)
1147 }
Colin Crossca860ac2016-01-04 14:34:37 -08001148 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001149 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001150 }
Colin Crossc472d572015-03-17 15:06:21 -07001151
Colin Cross36242852017-06-23 15:06:31 -07001152 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerea6666f2021-02-17 10:17:28 -05001153 android.InitBazelModule(c)
Jiyong Park7916bfc2019-09-30 19:13:12 +09001154 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001155 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001156 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001157
Colin Cross36242852017-06-23 15:06:31 -07001158 return c
Colin Crossc472d572015-03-17 15:06:21 -07001159}
1160
Ivan Lozano52767be2019-10-18 14:49:46 -07001161func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001162 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001163}
1164
Colin Crossc511bc52020-04-07 16:50:32 +00001165func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001166 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1167 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001168}
1169
1170func (c *Module) UseSdk() bool {
1171 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001172 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001173 }
1174 return false
1175}
1176
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001177func (c *Module) isCoverageVariant() bool {
1178 return c.coverage.Properties.IsCoverageVariant
1179}
1180
Colin Cross95f1ca02020-10-29 20:47:22 -07001181func (c *Module) IsNdk(config android.Config) bool {
1182 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001183}
1184
Colin Cross127bb8b2020-12-16 16:46:01 -08001185func (c *Module) IsLlndk() bool {
1186 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001187}
1188
Colin Cross127bb8b2020-12-16 16:46:01 -08001189func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001190 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001191}
1192
Colin Cross1f3f1302021-04-26 18:37:44 -07001193func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001194 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001195 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001196}
1197
Colin Cross5271fea2021-04-27 13:06:04 -07001198func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1199 lib := moduleLibraryInterface(m)
1200 return lib != nil && (lib.hasVendorPublicLibrary())
1201}
1202
1203// IsVendorPublicLibrary returns true for vendor public libraries.
1204func (c *Module) IsVendorPublicLibrary() bool {
1205 return c.VendorProperties.IsVendorPublicLibrary
1206}
1207
Ivan Lozanod7586b62021-04-01 09:49:36 -04001208func (c *Module) HasLlndkStubs() bool {
1209 lib := moduleLibraryInterface(c)
1210 return lib != nil && lib.hasLLNDKStubs()
1211}
1212
1213func (c *Module) StubsVersion() string {
1214 if lib, ok := c.linker.(versionedInterface); ok {
1215 return lib.stubsVersion()
1216 }
1217 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1218}
1219
Colin Cross127bb8b2020-12-16 16:46:01 -08001220// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1221// and does not set llndk.vendor_available: false.
1222func (c *Module) isImplementationForLLNDKPublic() bool {
1223 library, _ := c.library.(*libraryDecorator)
1224 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001225 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001226}
1227
Justin Yunfd9e8042020-12-23 18:23:14 +09001228// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001229func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001230 // Check if VNDK-core-private or VNDK-SP-private
1231 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001232 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001233 }
1234
1235 // Check if LLNDK-private
1236 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001237 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001238 }
1239
1240 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001241}
1242
Ivan Lozano52767be2019-10-18 14:49:46 -07001243func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001244 if vndkdep := c.vndkdep; vndkdep != nil {
1245 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001246 }
1247 return false
1248}
1249
Yi Kong7e53c572018-02-14 18:16:12 +08001250func (c *Module) isPgoCompile() bool {
1251 if pgo := c.pgo; pgo != nil {
1252 return pgo.Properties.PgoCompile
1253 }
1254 return false
1255}
1256
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001257func (c *Module) isNDKStubLibrary() bool {
1258 if _, ok := c.compiler.(*stubDecorator); ok {
1259 return true
1260 }
1261 return false
1262}
1263
Ivan Lozanod7586b62021-04-01 09:49:36 -04001264func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001265 if vndkdep := c.vndkdep; vndkdep != nil {
1266 return vndkdep.isVndkSp()
1267 }
1268 return false
1269}
1270
Ivan Lozanof9e21722020-12-02 09:00:51 -05001271func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001272 if vndkdep := c.vndkdep; vndkdep != nil {
1273 return vndkdep.isVndkExt()
1274 }
1275 return false
1276}
1277
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001278func (c *Module) SubName() string {
1279 return c.Properties.SubName
1280}
1281
Ivan Lozano52767be2019-10-18 14:49:46 -07001282func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001283 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001284}
1285
Logan Chienf3511742017-10-31 18:04:35 +08001286func (c *Module) getVndkExtendsModuleName() string {
1287 if vndkdep := c.vndkdep; vndkdep != nil {
1288 return vndkdep.getVndkExtendsModuleName()
1289 }
1290 return ""
1291}
1292
Jiyong Park25fc6a92018-11-18 18:02:45 +09001293func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001294 if lib := c.library; lib != nil {
1295 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001296 }
1297 return false
1298}
1299
1300func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001301 if lib := c.library; lib != nil {
1302 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001303 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001304 return false
1305}
1306
Colin Cross0477b422020-10-13 18:43:54 -07001307// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1308// the implementation. If it is an implementation library it returns its own name.
1309func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1310 name := ctx.OtherModuleName(c)
1311 if versioned, ok := c.linker.(versionedInterface); ok {
1312 name = versioned.implementationModuleName(name)
1313 }
1314 return name
1315}
1316
Martin Stjernholm2856c662020-12-02 15:03:42 +00001317// Similar to ImplementationModuleName, but uses the Make variant of the module
1318// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1319// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1320// under the premise that the prebuilt module overrides its source counterpart
1321// if it is exposed to Make).
1322func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1323 name := c.BaseModuleName()
1324 if versioned, ok := c.linker.(versionedInterface); ok {
1325 name = versioned.implementationModuleName(name)
1326 }
1327 return name
1328}
1329
Jiyong Park7d55b612021-06-11 17:22:09 +09001330func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001331 return Bool(c.Properties.Bootstrap)
1332}
1333
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001334func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001335 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1336 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1337 return false
1338 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001339 return c.linker != nil && c.linker.nativeCoverage()
1340}
1341
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001342func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001343 if p, ok := c.linker.(SnapshotInterface); ok {
1344 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001345 }
1346 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001347}
1348
Bill Peckham945441c2020-08-31 16:07:58 -07001349func (c *Module) ExcludeFromVendorSnapshot() bool {
1350 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1351}
1352
Jose Galmesf7294582020-11-13 12:07:36 -08001353func (c *Module) ExcludeFromRecoverySnapshot() bool {
1354 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1355}
1356
Jiyong Parkf1194352019-02-25 11:05:47 +09001357func isBionic(name string) bool {
1358 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001359 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001360 return true
1361 }
1362 return false
1363}
1364
Martin Stjernholm279de572019-09-10 23:18:20 +01001365func InstallToBootstrap(name string, config android.Config) bool {
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001366 if name == "libclang_rt.hwasan-aarch64-android" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001367 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001368 }
1369 return isBionic(name)
1370}
1371
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001372func (c *Module) XrefCcFiles() android.Paths {
1373 return c.kytheFiles
1374}
1375
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001376func (c *Module) isCfiAssemblySupportEnabled() bool {
1377 return c.sanitize != nil &&
1378 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1379}
1380
Inseob Kim800d1142021-06-14 12:03:51 +09001381func (c *Module) InstallInRoot() bool {
1382 return c.installer != nil && c.installer.installInRoot()
1383}
1384
Colin Crossacfcc1f2021-10-25 15:40:32 -07001385func (c *Module) InstallBypassMake() bool { return true }
1386
Colin Crossca860ac2016-01-04 14:34:37 -08001387type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001388 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001389 moduleContextImpl
1390}
1391
Colin Cross37047f12016-12-13 17:06:13 -08001392type depsContext struct {
1393 android.BottomUpMutatorContext
1394 moduleContextImpl
1395}
1396
Colin Crossca860ac2016-01-04 14:34:37 -08001397type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001398 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001399 moduleContextImpl
1400}
1401
1402type moduleContextImpl struct {
1403 mod *Module
1404 ctx BaseModuleContext
1405}
1406
Colin Crossb98c8b02016-07-29 13:44:28 -07001407func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001408 return ctx.mod.toolchain(ctx.ctx)
1409}
1410
1411func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001412 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001413}
1414
1415func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001416 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001417}
1418
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001419func (ctx *moduleContextImpl) testBinary() bool {
1420 return ctx.mod.testBinary()
1421}
1422
Jiyong Park1d1119f2019-07-29 21:27:18 +09001423func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001424 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001425}
1426
Inseob Kim7f283f42020-06-01 21:53:49 +09001427func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001428 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001429}
1430
Inseob Kim1042d292020-06-01 23:23:05 +09001431func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001432 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001433}
1434
Jooyung Hanccce2f22020-03-07 03:45:53 +09001435func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001436 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001437}
1438
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001439func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001440 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001441}
1442
1443func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001444 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001445 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001446 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001447 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001448 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001449 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001450 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001451 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001452 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001453 }
1454 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001455}
1456
Jiyong Parkb35a8192020-08-10 15:59:36 +09001457func (ctx *moduleContextImpl) minSdkVersion() string {
1458 ver := ctx.mod.MinSdkVersion()
1459 if ver == "apex_inherit" && !ctx.isForPlatform() {
1460 ver = ctx.apexSdkVersion().String()
1461 }
1462 if ver == "apex_inherit" || ver == "" {
1463 ver = ctx.sdkVersion()
1464 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001465 // For crt objects, the meaning of min_sdk_version is very different from other types of
1466 // module. For them, min_sdk_version defines the oldest version that the build system will
1467 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1468 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1469 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001470 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1471 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1472 // support such an old version. The version is set to the later version in case when the
1473 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1474 // it's for an APEX.
1475 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1476 if ctx.isForPlatform() {
1477 ver = strconv.Itoa(android.FutureApiLevelInt)
1478 } else { // for apex
1479 ver = ctx.apexSdkVersion().String()
1480 if ver == "" { // in case when min_sdk_version was not set by the APEX
1481 ver = ctx.sdkVersion()
1482 }
1483 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001484 }
1485
Jiyong Parkb35a8192020-08-10 15:59:36 +09001486 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1487 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1488 minSdkVersionInt, err2 := strconv.Atoi(ver)
1489 if err == nil && err2 == nil {
1490 if sdkVersionInt < minSdkVersionInt {
1491 return strconv.Itoa(sdkVersionInt)
1492 }
1493 }
1494 return ver
1495}
1496
1497func (ctx *moduleContextImpl) isSdkVariant() bool {
1498 return ctx.mod.IsSdkVariant()
1499}
1500
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001501func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001502 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001503}
Justin Yun8effde42017-06-23 19:24:43 +09001504
Colin Cross95f1ca02020-10-29 20:47:22 -07001505func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1506 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001507}
1508
Colin Cross127bb8b2020-12-16 16:46:01 -08001509func (ctx *moduleContextImpl) IsLlndk() bool {
1510 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001511}
1512
Colin Cross127bb8b2020-12-16 16:46:01 -08001513func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1514 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001515}
1516
Colin Cross127bb8b2020-12-16 16:46:01 -08001517func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1518 return ctx.mod.isImplementationForLLNDKPublic()
1519}
1520
1521func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1522 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001523}
1524
Logan Chienf3511742017-10-31 18:04:35 +08001525func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001526 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001527}
1528
Yi Kong7e53c572018-02-14 18:16:12 +08001529func (ctx *moduleContextImpl) isPgoCompile() bool {
1530 return ctx.mod.isPgoCompile()
1531}
1532
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001533func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1534 return ctx.mod.isNDKStubLibrary()
1535}
1536
Justin Yun8effde42017-06-23 19:24:43 +09001537func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001538 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001539}
1540
Ivan Lozanof9e21722020-12-02 09:00:51 -05001541func (ctx *moduleContextImpl) IsVndkExt() bool {
1542 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001543}
1544
Colin Cross5271fea2021-04-27 13:06:04 -07001545func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1546 return ctx.mod.IsVendorPublicLibrary()
1547}
1548
Vic Yangefd249e2018-11-12 20:19:56 -08001549func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001550 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001551}
1552
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001553func (ctx *moduleContextImpl) selectedStl() string {
1554 if stl := ctx.mod.stl; stl != nil {
1555 return stl.Properties.SelectedStl
1556 }
1557 return ""
1558}
1559
Ivan Lozanobd721262018-11-27 14:33:03 -08001560func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1561 return ctx.mod.linker.useClangLld(actx)
1562}
1563
Colin Crossce75d2c2016-10-06 16:12:58 -07001564func (ctx *moduleContextImpl) baseModuleName() string {
1565 return ctx.mod.ModuleBase.BaseModuleName()
1566}
1567
Logan Chienf3511742017-10-31 18:04:35 +08001568func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1569 return ctx.mod.getVndkExtendsModuleName()
1570}
1571
Logan Chiene274fc92019-12-03 11:18:32 -08001572func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001573 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001574}
1575
Colin Crosse07f2312020-08-13 11:24:56 -07001576func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001577 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001578}
1579
Dan Albertc8060532020-07-22 22:32:17 -07001580func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001581 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001582}
1583
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001584func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001585 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001586}
1587
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001588func (ctx *moduleContextImpl) nativeCoverage() bool {
1589 return ctx.mod.nativeCoverage()
1590}
1591
Colin Cross56a83212020-09-15 18:30:11 -07001592func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1593 return ctx.mod.DirectlyInAnyApex()
1594}
1595
Colin Cross95b07f22020-12-16 11:06:50 -08001596func (ctx *moduleContextImpl) isPreventInstall() bool {
1597 return ctx.mod.Properties.PreventInstall
1598}
1599
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001600func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1601 return ctx.mod.isCfiAssemblySupportEnabled()
1602}
1603
Colin Cross635c3b02016-05-18 15:37:25 -07001604func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001605 return &Module{
1606 hod: hod,
1607 multilib: multilib,
1608 }
1609}
1610
Colin Cross635c3b02016-05-18 15:37:25 -07001611func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001612 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001613 module.features = []feature{
1614 &tidyFeature{},
1615 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001616 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001617 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001618 module.coverage = &coverage{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001619 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001620 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001621 module.lto = &lto{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001622 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001623 return module
1624}
1625
Colin Crossce75d2c2016-10-06 16:12:58 -07001626func (c *Module) Prebuilt() *android.Prebuilt {
1627 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1628 return p.prebuilt()
1629 }
1630 return nil
1631}
1632
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001633func (c *Module) IsPrebuilt() bool {
1634 return c.Prebuilt() != nil
1635}
1636
Colin Crossce75d2c2016-10-06 16:12:58 -07001637func (c *Module) Name() string {
1638 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001639 if p, ok := c.linker.(interface {
1640 Name(string) string
1641 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001642 name = p.Name(name)
1643 }
1644 return name
1645}
1646
Alex Light3d673592019-01-18 14:37:31 -08001647func (c *Module) Symlinks() []string {
1648 if p, ok := c.installer.(interface {
1649 symlinkList() []string
1650 }); ok {
1651 return p.symlinkList()
1652 }
1653 return nil
1654}
1655
Roland Levillainf89cd092019-07-29 16:22:59 +01001656func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1657 test, ok := c.linker.(testPerSrc)
1658 return ok && test.isAllTestsVariation()
1659}
1660
Chris Parsons216e10a2020-07-09 17:12:52 -04001661func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001662 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001663 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001664 }); ok {
1665 return p.dataPaths()
1666 }
1667 return nil
1668}
1669
Justin Yun5f7f7e82019-11-18 19:52:14 +09001670func (c *Module) getNameSuffixWithVndkVersion(ctx android.ModuleContext) string {
1671 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1672 // "current", it will append the VNDK version to the name suffix.
1673 var vndkVersion string
1674 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001675 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001676 if c.ProductSpecific() {
1677 // If the module is product specific with 'product_specific: true',
1678 // do not add a name suffix because it is a base module.
1679 return ""
1680 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001681 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001682 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001683 } else {
1684 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001685 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001686 }
1687 if vndkVersion == "current" {
1688 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1689 }
Colin Cross127bb8b2020-12-16 16:46:01 -08001690 if c.Properties.VndkVersion != vndkVersion && c.Properties.VndkVersion != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001691 // add version suffix only if the module is using different vndk version than the
1692 // version in product or vendor partition.
1693 nameSuffix += "." + c.Properties.VndkVersion
1694 }
1695 return nameSuffix
1696}
1697
Chris Parsons8d6e4332021-02-22 16:13:50 -05001698func (c *Module) setSubnameProperty(actx android.ModuleContext) {
Inseob Kim64c43952019-08-26 16:52:35 +09001699 c.Properties.SubName = ""
1700
1701 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07001702 c.Properties.SubName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001703 }
1704
Colin Cross127bb8b2020-12-16 16:46:01 -08001705 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001706 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001707 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1708 // added for product variant only when we have vendor and product variants with core
1709 // variant. The suffix is not added for vendor-only or product-only module.
1710 c.Properties.SubName += c.getNameSuffixWithVndkVersion(actx)
Colin Cross5271fea2021-04-27 13:06:04 -07001711 } else if c.IsVendorPublicLibrary() {
1712 c.Properties.SubName += vendorPublicLibrarySuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001713 } else if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
Inseob Kim64c43952019-08-26 16:52:35 +09001714 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1715 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001716 c.Properties.SubName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001717 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07001718 c.Properties.SubName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001719 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001720 c.Properties.SubName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001721 } else if c.InRecovery() && !c.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08001722 c.Properties.SubName += RecoverySuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001723 } else if c.IsSdkVariant() && (c.Properties.SdkAndPlatformVariantVisibleToMake || c.SplitPerApiLevel()) {
Colin Crossc511bc52020-04-07 16:50:32 +00001724 c.Properties.SubName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001725 if c.SplitPerApiLevel() {
1726 c.Properties.SubName += "." + c.SdkVersion()
1727 }
Inseob Kim64c43952019-08-26 16:52:35 +09001728 }
Chris Parsons8d6e4332021-02-22 16:13:50 -05001729}
1730
1731// Returns true if Bazel was successfully used for the analysis of this module.
1732func (c *Module) maybeGenerateBazelActions(actx android.ModuleContext) bool {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001733 var bazelModuleLabel string
1734 if actx.ModuleType() == "cc_library" && c.static() {
1735 // cc_library is a special case in bp2build; two targets are generated -- one for each
1736 // of the shared and static variants. The shared variant keeps the module name, but the
1737 // static variant uses a different suffixed name.
1738 bazelModuleLabel = bazelLabelForStaticModule(actx, c)
1739 } else {
1740 bazelModuleLabel = c.GetBazelLabel(actx, c)
1741 }
Chris Parsons8d6e4332021-02-22 16:13:50 -05001742 bazelActionsUsed := false
Chris Parsons18266212021-09-23 13:42:38 -04001743 // Mixed builds mode is disabled for modules outside of device OS.
1744 // TODO(b/200841190): Support non-device OS in mixed builds.
Chris Parsons494eef32021-11-09 10:29:52 -05001745 if c.MixedBuildsEnabled(actx) && c.bazelHandler != nil {
Alex Márquez Pérez Muñíz Díaz Púras Thaureaux0d990452021-08-11 16:46:13 +00001746 bazelActionsUsed = c.bazelHandler.GenerateBazelBuildActions(actx, bazelModuleLabel)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001747 }
1748 return bazelActionsUsed
1749}
1750
1751func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
1752 // TODO(cparsons): Any logic in this method occurring prior to querying Bazel should be
1753 // requested from Bazel instead.
1754
1755 // Handle the case of a test module split by `test_per_src` mutator.
1756 //
1757 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1758 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1759 // module and return early, as this module does not produce an output file per se.
1760 if c.IsTestPerSrcAllTestsVariation() {
1761 c.outputFile = android.OptionalPath{}
1762 return
1763 }
1764
1765 c.setSubnameProperty(actx)
1766 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1767 if !apexInfo.IsForPlatform() {
1768 c.hideApexVariantFromMake = true
1769 }
1770
Chris Parsonseefc9e62021-04-02 17:36:47 -04001771 c.makeLinkType = GetMakeLinkType(actx, c)
1772
Colin Crossca860ac2016-01-04 14:34:37 -08001773 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001774 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001775 moduleContextImpl: moduleContextImpl{
1776 mod: c,
1777 },
1778 }
1779 ctx.ctx = ctx
1780
Chris Parsons94a0bba2021-06-04 15:03:47 -04001781 if c.maybeGenerateBazelActions(actx) {
1782 c.maybeInstall(ctx, apexInfo)
1783 return
1784 }
1785
Colin Crossf18e1102017-11-16 14:33:08 -08001786 deps := c.depsToPaths(ctx)
1787 if ctx.Failed() {
1788 return
1789 }
1790
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001791 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1792 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1793 }
1794
Colin Crossca860ac2016-01-04 14:34:37 -08001795 flags := Flags{
1796 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001797 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001798 }
Colin Crossca860ac2016-01-04 14:34:37 -08001799 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001800 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001801 }
1802 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001803 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001804 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001805 if c.stl != nil {
1806 flags = c.stl.flags(ctx, flags)
1807 }
Colin Cross16b23492016-01-06 14:41:07 -08001808 if c.sanitize != nil {
1809 flags = c.sanitize.flags(ctx, flags)
1810 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001811 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001812 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001813 }
Stephen Craneba090d12017-05-09 15:44:35 -07001814 if c.lto != nil {
1815 flags = c.lto.flags(ctx, flags)
1816 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001817 if c.pgo != nil {
1818 flags = c.pgo.flags(ctx, flags)
1819 }
Colin Crossca860ac2016-01-04 14:34:37 -08001820 for _, feature := range c.features {
1821 flags = feature.flags(ctx, flags)
1822 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001823 if ctx.Failed() {
1824 return
1825 }
1826
Colin Cross4af21ed2019-11-04 09:37:55 -08001827 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1828 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1829 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001830
Colin Cross4af21ed2019-11-04 09:37:55 -08001831 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001832
1833 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001834 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001835 }
1836 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001837 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001838 }
1839
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001840 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001841 // We need access to all the flags seen by a source file.
1842 if c.sabi != nil {
1843 flags = c.sabi.flags(ctx, flags)
1844 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001845
Colin Cross4af21ed2019-11-04 09:37:55 -08001846 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001847
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001848 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001849 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001850 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001851 if ctx.Failed() {
1852 return
1853 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001854 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07001855 c.objFiles = objs.objFiles
1856 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001857 }
1858
Colin Crossca860ac2016-01-04 14:34:37 -08001859 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001860 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001861 if ctx.Failed() {
1862 return
1863 }
Colin Cross635c3b02016-05-18 15:37:25 -07001864 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001865
Chris Parsons94a0bba2021-06-04 15:03:47 -04001866 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001867
Jose Galmes6f843bc2020-12-11 13:36:29 -08001868 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1869 // RECOVERY_SNAPSHOT_VERSION is current.
1870 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001871 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001872 i.collectHeadersForSnapshot(ctx)
1873 }
1874 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001875 }
Colin Cross5049f022015-03-18 13:28:46 -07001876
Chris Parsons94a0bba2021-06-04 15:03:47 -04001877 c.maybeInstall(ctx, apexInfo)
1878}
1879
1880func (c *Module) maybeUnhideFromMake() {
1881 // If a lib is directly included in any of the APEXes or is not available to the
1882 // platform (which is often the case when the stub is provided as a prebuilt),
1883 // unhide the stubs variant having the latest version gets visible to make. In
1884 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
1885 // force anything in the make world to link against the stubs library. (unless it
1886 // is explicitly referenced via .bootstrap suffix or the module is marked with
1887 // 'bootstrap: true').
1888 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
1889 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
1890 c.IsStubs() && !c.InVendorRamdisk() {
1891 c.Properties.HideFromMake = false // unhide
1892 // Note: this is still non-installable
1893 }
1894}
1895
1896func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07001897 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001898 // If the module has been specifically configure to not be installed then
1899 // hide from make as otherwise it will break when running inside make
1900 // as the output path to install will not be specified. Not all uninstallable
1901 // modules can be hidden from make as some are needed for resolving make side
1902 // dependencies.
1903 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04001904 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001905 c.SkipInstall()
1906 }
1907
1908 // Still call c.installer.install though, the installs will be stored as PackageSpecs
1909 // to allow using the outputs in a genrule.
1910 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07001911 c.installer.install(ctx, c.outputFile.Path())
1912 if ctx.Failed() {
1913 return
Colin Crossca860ac2016-01-04 14:34:37 -08001914 }
Dan Albertc403f7c2015-03-18 14:01:18 -07001915 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001916}
1917
Colin Cross0ea8ba82019-06-06 14:33:29 -07001918func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001919 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05001920 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08001921 }
Colin Crossca860ac2016-01-04 14:34:37 -08001922 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08001923}
1924
Colin Crossca860ac2016-01-04 14:34:37 -08001925func (c *Module) begin(ctx BaseModuleContext) {
1926 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001927 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07001928 }
Colin Crossca860ac2016-01-04 14:34:37 -08001929 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001930 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08001931 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001932 if c.stl != nil {
1933 c.stl.begin(ctx)
1934 }
Colin Cross16b23492016-01-06 14:41:07 -08001935 if c.sanitize != nil {
1936 c.sanitize.begin(ctx)
1937 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001938 if c.coverage != nil {
1939 c.coverage.begin(ctx)
1940 }
Stephen Craneba090d12017-05-09 15:44:35 -07001941 if c.lto != nil {
1942 c.lto.begin(ctx)
1943 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001944 if c.pgo != nil {
1945 c.pgo.begin(ctx)
1946 }
Dan Albert92fe7402020-07-15 13:33:30 -07001947 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07001948 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001949 if err != nil {
1950 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07001951 c.Properties.Sdk_version = nil
1952 } else {
1953 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001954 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07001955 }
Colin Crossca860ac2016-01-04 14:34:37 -08001956}
1957
Colin Cross37047f12016-12-13 17:06:13 -08001958func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07001959 deps := Deps{}
1960
1961 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001962 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001963 }
1964 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001965 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07001966 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001967 if c.stl != nil {
1968 deps = c.stl.deps(ctx, deps)
1969 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00001970 if c.coverage != nil {
1971 deps = c.coverage.deps(ctx, deps)
1972 }
Colin Crossc99deeb2016-04-11 15:06:20 -07001973
Colin Crossb6715442017-10-24 11:13:31 -07001974 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
1975 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
1976 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
1977 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
1978 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
1979 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08001980 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07001981
Liz Kammer356f7d42021-01-26 09:18:53 -05001982 // In Bazel conversion mode, we dependency and build validations will occur in Bazel, so there is
1983 // no need to do so in Soong.
1984 if ctx.BazelConversionMode() {
1985 return deps
1986 }
1987
Dan Willemsen490a8dc2016-06-06 18:22:19 -07001988 for _, lib := range deps.ReexportSharedLibHeaders {
1989 if !inList(lib, deps.SharedLibs) {
1990 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
1991 }
1992 }
1993
1994 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00001995 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
1996 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 -07001997 }
1998 }
1999
Colin Cross5950f382016-12-13 12:50:57 -08002000 for _, lib := range deps.ReexportHeaderLibHeaders {
2001 if !inList(lib, deps.HeaderLibs) {
2002 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2003 }
2004 }
2005
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002006 for _, gen := range deps.ReexportGeneratedHeaders {
2007 if !inList(gen, deps.GeneratedHeaders) {
2008 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2009 }
2010 }
2011
Colin Crossc99deeb2016-04-11 15:06:20 -07002012 return deps
2013}
2014
Dan Albert7e9d2952016-08-04 13:02:36 -07002015func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002016 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002017 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002018 moduleContextImpl: moduleContextImpl{
2019 mod: c,
2020 },
2021 }
2022 ctx.ctx = ctx
2023
Colin Crossca860ac2016-01-04 14:34:37 -08002024 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002025}
2026
Jiyong Park7ed9de32018-10-15 22:25:07 +09002027// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002028func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002029 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2030 version := name[sharp+1:]
2031 libname := name[:sharp]
2032 return libname, version
2033 }
2034 return name, ""
2035}
2036
Dan Albert92fe7402020-07-15 13:33:30 -07002037func GetCrtVariations(ctx android.BottomUpMutatorContext,
2038 m LinkableInterface) []blueprint.Variation {
2039 if ctx.Os() != android.Android {
2040 return nil
2041 }
2042 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002043 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2044 minSdkVersion := m.MinSdkVersion()
2045 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2046 minSdkVersion = m.SdkVersion()
2047 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002048 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2049 if err != nil {
2050 ctx.PropertyErrorf("min_sdk_version", err.Error())
2051 }
Dan Albert92fe7402020-07-15 13:33:30 -07002052 return []blueprint.Variation{
2053 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002054 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002055 }
2056 }
2057 return []blueprint.Variation{
2058 {Mutator: "sdk", Variation: ""},
2059 }
2060}
2061
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002062func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2063 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002064
2065 variations = append([]blueprint.Variation(nil), variations...)
2066
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002067 if version != "" && CanBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002068 // Version is explicitly specified. i.e. libFoo#30
2069 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002070 if tag, ok := depTag.(libraryDependencyTag); ok {
2071 tag.explicitlyVersioned = true
2072 } else {
2073 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2074 }
Colin Crosse7257d22020-09-24 09:56:18 -07002075 }
Colin Crosse7257d22020-09-24 09:56:18 -07002076
Colin Cross0de8a1e2020-09-18 14:15:30 -07002077 if far {
2078 ctx.AddFarVariationDependencies(variations, depTag, name)
2079 } else {
2080 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002081 }
2082}
2083
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002084func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002085 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002086 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002087 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002088 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2089 // between the modules in the snapshot and the snapshot itself.
2090 var snapshotModule []blueprint.Module
2091 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2092 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2093 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2094 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2095 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002096 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002097 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2098 *snapshotInfo = &snapshot
2099 // republish the snapshot for use in later mutators on this module
2100 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002101 }
2102 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002103 if *snapshotInfo == nil {
2104 *snapshotInfo = &SnapshotInfo{}
2105 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002106 return **snapshotInfo
2107}
2108
2109func RewriteSnapshotLib(lib string, snapshotMap map[string]string) string {
2110 if snapshot, ok := snapshotMap[lib]; ok {
2111 return snapshot
2112 }
2113
2114 return lib
2115}
2116
2117// RewriteLibs takes a list of names of shared libraries and scans it for three types
2118// of names:
2119//
2120// 1. Name of an NDK library that refers to a prebuilt module.
2121// For each of these, it adds the name of the prebuilt module (which will be in
2122// prebuilts/ndk) to the list of nonvariant libs.
2123// 2. Name of an NDK library that refers to an ndk_library module.
2124// For each of these, it adds the name of the ndk_library module to the list of
2125// variant libs.
2126// 3. Anything else (so anything that isn't an NDK library).
2127// It adds these to the nonvariantLibs list.
2128//
2129// The caller can then know to add the variantLibs dependencies differently from the
2130// nonvariantLibs
2131func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2132 variantLibs = []string{}
2133
2134 nonvariantLibs = []string{}
2135 for _, entry := range list {
2136 // strip #version suffix out
2137 name, _ := StubsLibNameAndVersion(entry)
2138 if c.InRecovery() {
2139 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2140 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2141 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2142 } else if c.UseVndk() {
2143 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2144 } else {
2145 // put name#version back
2146 nonvariantLibs = append(nonvariantLibs, entry)
2147 }
2148 }
2149 return nonvariantLibs, variantLibs
2150}
2151
Colin Cross1e676be2016-10-12 14:38:15 -07002152func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002153 if !c.Enabled() {
2154 return
2155 }
2156
Colin Cross37047f12016-12-13 17:06:13 -08002157 ctx := &depsContext{
2158 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002159 moduleContextImpl: moduleContextImpl{
2160 mod: c,
2161 },
2162 }
2163 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002164
Colin Crossc99deeb2016-04-11 15:06:20 -07002165 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002166
Yo Chiang219968c2020-09-22 18:45:04 +08002167 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2168
Colin Crosse0edaf92021-01-11 17:31:17 -08002169 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002170
Dan Albert914449f2016-06-17 16:45:24 -07002171 variantNdkLibs := []string{}
2172 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002173 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002174 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2175 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2176 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002177
2178 for idx, lib := range deps.RuntimeLibs {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002179 deps.RuntimeLibs[idx] = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002180 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002181 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002182
Colin Cross32ec36c2016-12-15 07:39:51 -08002183 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002184 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002185 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002186 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002187 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002188
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002189 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002190
Jiyong Park1ad8e162020-12-01 23:40:09 +09002191 if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002192 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002193 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002194 } else {
2195 actx.AddVariationDependencies(nil, depTag, lib)
2196 }
2197 }
2198
Dan Albertf1d14c72020-07-30 14:32:55 -07002199 if c.isNDKStubLibrary() {
2200 // NDK stubs depend on their implementation because the ABI dumps are
2201 // generated from the implementation library.
2202 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2203 c.ImageVariation(),
2204 blueprint.Variation{Mutator: "link", Variation: "shared"},
2205 ), stubImplementation, c.BaseModuleName())
2206 }
2207
Inseob Kim07def122020-11-23 14:43:02 +09002208 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
2209 // C++ implementation library and one Java implementation library. When a module links against
2210 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
2211 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
2212 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09002213 syspropImplLibraries := syspropImplLibraries(actx.Config())
2214
Jiyong Park5d1598f2019-02-25 22:14:17 +09002215 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002216 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09002217 if impl, ok := syspropImplLibraries[lib]; ok {
2218 lib = impl
2219 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002220
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002221 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002222
Jiyong Park5d1598f2019-02-25 22:14:17 +09002223 actx.AddVariationDependencies([]blueprint.Variation{
2224 {Mutator: "link", Variation: "static"},
2225 }, depTag, lib)
2226 }
2227
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002228 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002229 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002230 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002231 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002232 }
Jiyong Parke3867542020-12-03 17:28:25 +09002233 if inList(lib, deps.ExcludeLibsForApex) {
2234 depTag.excludeInApex = true
2235 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002236
2237 if impl, ok := syspropImplLibraries[lib]; ok {
2238 lib = impl
2239 }
2240
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002241 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002242
Dan Willemsen59339a22018-07-22 21:18:45 -07002243 actx.AddVariationDependencies([]blueprint.Variation{
2244 {Mutator: "link", Variation: "static"},
2245 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002246 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002247
Jooyung Han75568392020-03-20 04:29:24 +09002248 // staticUnwinderDep is treated as staticDep for Q apexes
2249 // so that native libraries/binaries are linked with static unwinder
2250 // because Q libc doesn't have unwinder APIs
2251 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002252 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002253 actx.AddVariationDependencies([]blueprint.Variation{
2254 {Mutator: "link", Variation: "static"},
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002255 }, depTag, RewriteSnapshotLib(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002256 }
2257
Jiyong Park7ed9de32018-10-15 22:25:07 +09002258 // shared lib names without the #version suffix
2259 var sharedLibNames []string
2260
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002261 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002262 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002263 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002264 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002265 }
Jiyong Parke3867542020-12-03 17:28:25 +09002266 if inList(lib, deps.ExcludeLibsForApex) {
2267 depTag.excludeInApex = true
2268 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002269
2270 if impl, ok := syspropImplLibraries[lib]; ok {
2271 lib = impl
2272 }
2273
Jiyong Park73c54ee2019-10-22 20:31:18 +09002274 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002275 sharedLibNames = append(sharedLibNames, name)
2276
Colin Crosse7257d22020-09-24 09:56:18 -07002277 variations := []blueprint.Variation{
2278 {Mutator: "link", Variation: "shared"},
2279 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002280 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002281 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002282
Colin Crossfe9acfe2021-06-14 16:13:03 -07002283 for _, lib := range deps.LateStaticLibs {
2284 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2285 actx.AddVariationDependencies([]blueprint.Variation{
2286 {Mutator: "link", Variation: "static"},
2287 }, depTag, RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
2288 }
2289
Jiyong Park7ed9de32018-10-15 22:25:07 +09002290 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002291 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002292 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2293 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2294 // linking against both the stubs lib and the non-stubs lib at the same time.
2295 continue
2296 }
Colin Cross6e511a92020-07-27 21:26:48 -07002297 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002298 variations := []blueprint.Variation{
2299 {Mutator: "link", Variation: "shared"},
2300 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002301 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002302 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002303
Dan Willemsen59339a22018-07-22 21:18:45 -07002304 actx.AddVariationDependencies([]blueprint.Variation{
2305 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002306 }, dataLibDepTag, deps.DataLibs...)
2307
Colin Crossc8caa062021-09-24 16:50:14 -07002308 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2309
Chris Parsons79d66a52020-06-05 17:26:16 -04002310 actx.AddVariationDependencies([]blueprint.Variation{
2311 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002312 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002313
Colin Cross68861832016-07-08 10:41:41 -07002314 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002315
2316 for _, gen := range deps.GeneratedHeaders {
2317 depTag := genHeaderDepTag
2318 if inList(gen, deps.ReexportGeneratedHeaders) {
2319 depTag = genHeaderExportDepTag
2320 }
2321 actx.AddDependency(c, depTag, gen)
2322 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002323
Dan Albert92fe7402020-07-15 13:33:30 -07002324 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002325 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002326 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002327 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002328 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002329 }
Colin Crossc465efd2021-06-11 18:00:04 -07002330 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002331 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002332 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002333 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002334 if deps.DynamicLinker != "" {
2335 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002336 }
Dan Albert914449f2016-06-17 16:45:24 -07002337
2338 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002339
2340 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002341 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002342 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002343 {Mutator: "link", Variation: "shared"},
2344 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002345
2346 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002347 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002348 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002349 {Mutator: "link", Variation: "shared"},
2350 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002351
2352 if vndkdep := c.vndkdep; vndkdep != nil {
2353 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002354 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002355 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002356 {Mutator: "link", Variation: "shared"},
Justin Yun27b95722021-07-28 17:04:44 +09002357 }, vndkExtDepTag, RewriteSnapshotLib(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002358 }
2359 }
Colin Cross6362e272015-10-29 15:25:03 -07002360}
Colin Cross21b9a242015-03-24 14:15:58 -07002361
Colin Crosse40b4ea2018-10-02 22:25:58 -07002362func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002363 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2364 c.beginMutator(ctx)
2365 }
2366}
2367
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002368// Whether a module can link to another module, taking into
2369// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002370func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002371 tag blueprint.DependencyTag) {
2372
2373 switch t := tag.(type) {
2374 case dependencyTag:
2375 if t != vndkExtDepTag {
2376 return
2377 }
2378 case libraryDependencyTag:
2379 default:
2380 return
2381 }
2382
Ivan Lozanof9e21722020-12-02 09:00:51 -05002383 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002384 // Host code is not restricted
2385 return
2386 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002387
2388 // VNDK is cc.Module supported only for now.
2389 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002390 // Though allowed dependency is limited by the image mutator,
2391 // each vendor and product module needs to check link-type
2392 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002393 if ccTo, ok := to.(*Module); ok {
2394 if ccFrom.vndkdep != nil {
2395 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2396 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002397 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002398 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002399 }
2400 return
2401 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002402 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002403 // Platform code can link to anything
2404 return
2405 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002406 if from.InRamdisk() {
2407 // Ramdisk code is not NDK
2408 return
2409 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002410 if from.InVendorRamdisk() {
2411 // Vendor ramdisk code is not NDK
2412 return
2413 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002414 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002415 // Recovery code is not NDK
2416 return
2417 }
Colin Cross31076b32020-10-23 17:22:06 -07002418 if c, ok := to.(*Module); ok {
2419 if c.ToolchainLibrary() {
2420 // These are always allowed
2421 return
2422 }
2423 if c.NdkPrebuiltStl() {
2424 // These are allowed, but they don't set sdk_version
2425 return
2426 }
2427 if c.StubDecorator() {
2428 // These aren't real libraries, but are the stub shared libraries that are included in
2429 // the NDK.
2430 return
2431 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002432 }
Logan Chien834b9a62019-01-14 15:39:03 +08002433
Ivan Lozano52767be2019-10-18 14:49:46 -07002434 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002435 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2436 // to link to libc++ (non-NDK and without sdk_version).
2437 return
2438 }
2439
Ivan Lozano52767be2019-10-18 14:49:46 -07002440 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002441 // NDK code linking to platform code is never okay.
2442 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002443 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002444 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002445 }
2446
2447 // At this point we know we have two NDK libraries, but we need to
2448 // check that we're not linking against anything built against a higher
2449 // API level, as it is only valid to link against older or equivalent
2450 // APIs.
2451
Inseob Kim01a28722018-04-11 09:48:45 +09002452 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002453 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002454 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002455 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002456 // Current can't be linked against by anything else.
2457 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002458 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002459 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002460 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002461 if err != nil {
2462 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002463 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002464 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002465 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002466 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002467 if err != nil {
2468 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002469 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002470 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002471 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002472
Inseob Kim01a28722018-04-11 09:48:45 +09002473 if toApi > fromApi {
2474 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002475 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002476 }
2477 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002478 }
Dan Albert202fe492017-12-15 13:56:59 -08002479
2480 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002481 fromStl := from.SelectedStl()
2482 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002483 if fromStl == "" || toStl == "" {
2484 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002485 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002486 // We can be permissive with the system "STL" since it is only the C++
2487 // ABI layer, but in the future we should make sure that everyone is
2488 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002489 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002490 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002491 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2492 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002493 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002494}
2495
Jooyung Han479ca172020-10-19 18:51:07 +09002496func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2497 if c, ok := ctx.Module().(*Module); ok {
2498 ctx.VisitDirectDeps(func(dep android.Module) {
2499 depTag := ctx.OtherModuleDependencyTag(dep)
2500 ccDep, ok := dep.(LinkableInterface)
2501 if ok {
2502 checkLinkType(ctx, c, ccDep, depTag)
2503 }
2504 })
2505 }
2506}
2507
Jiyong Park5fb8c102018-04-09 12:03:06 +09002508// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002509// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2510// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002511// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002512func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2513 check := func(child, parent android.Module) bool {
2514 to, ok := child.(*Module)
2515 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002516 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002517 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002518
Jooyung Hana70f0672019-01-18 15:20:43 +09002519 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2520 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002521 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002522
Jiyong Park0474e1f2021-01-14 14:26:06 +09002523 // These dependencies are not excercised at runtime. Tracking these will give us
2524 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002525 depTag := ctx.OtherModuleDependencyTag(child)
2526 if IsHeaderDepTag(depTag) {
2527 return false
2528 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002529 if depTag == staticVariantTag {
2530 return false
2531 }
2532 if depTag == stubImplDepTag {
2533 return false
2534 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002535
Justin Yun63e9ec72020-10-29 16:49:43 +09002536 // Even if target lib has no vendor variant, keep checking dependency
2537 // graph in case it depends on vendor_available or product_available
2538 // but not double_loadable transtively.
2539 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002540 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002541 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002542
Jiyong Park0474e1f2021-01-14 14:26:06 +09002543 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2544 // one.
2545 if Bool(to.VendorProperties.Double_loadable) {
2546 return true
2547 }
2548
Ivan Lozanod7586b62021-04-01 09:49:36 -04002549 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002550 return false
2551 }
2552
Jooyung Hana70f0672019-01-18 15:20:43 +09002553 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2554 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002555 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002556 return false
2557 }
2558 if module, ok := ctx.Module().(*Module); ok {
2559 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002560 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002561 ctx.WalkDeps(check)
2562 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002563 }
2564 }
2565}
2566
Colin Crossc99deeb2016-04-11 15:06:20 -07002567// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002568func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002569 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002570
Colin Cross0de8a1e2020-09-18 14:15:30 -07002571 var directStaticDeps []StaticLibraryInfo
2572 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002573
Colin Cross0de8a1e2020-09-18 14:15:30 -07002574 reexportExporter := func(exporter FlagExporterInfo) {
2575 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2576 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2577 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2578 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2579 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002580 }
2581
Jooyung Hande34d232020-07-23 13:04:15 +09002582 // For the dependency from platform to apex, use the latest stubs
2583 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002584 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2585 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002586 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002587 }
2588
2589 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2590 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2591 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2592 // (b/144430859)
2593 c.apexSdkVersion = android.FutureApiLevel
2594 }
2595
Colin Crossd11fcda2017-10-23 17:59:01 -07002596 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002597 depName := ctx.OtherModuleName(dep)
2598 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002599
Dan Willemsen47450072021-10-19 20:24:49 -07002600 if depTag == android.DarwinUniversalVariantTag {
2601 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2602 return
2603 }
2604
Ivan Lozano52767be2019-10-18 14:49:46 -07002605 ccDep, ok := dep.(LinkableInterface)
2606 if !ok {
2607
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002608 // handling for a few module types that aren't cc Module but that are also supported
2609 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002610 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002611 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002612 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2613 genRule.GeneratedSourceFiles()...)
2614 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002615 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002616 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002617 // Support exported headers from a generated_sources dependency
2618 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002619 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002620 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002621 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002622 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002623 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002624 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002625 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002626 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002627 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2628 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002629 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002630 // 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 +09002631 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002632
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002633 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002634 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002635 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002636 }
Colin Crosscef792e2021-06-11 18:01:26 -07002637 case CrtBeginDepTag:
2638 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2639 case CrtEndDepTag:
2640 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002641 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002642 return
2643 }
2644
Colin Crossfe17f6f2019-03-28 19:30:56 -07002645 if depTag == android.ProtoPluginDepTag {
2646 return
2647 }
2648
Colin Crossd11fcda2017-10-23 17:59:01 -07002649 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002650 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2651 return
2652 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002653 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002654 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2655 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002656 return
2657 }
2658
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002659 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002660 // Skip reused objects for stub libraries, they use their own stub object file instead.
2661 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2662 // version mutator, so the stubs variant is created from the shared variant that
2663 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002664 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002665 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2666 objs := staticAnalogue.ReuseObjects
2667 depPaths.Objs = depPaths.Objs.Append(objs)
2668 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2669 reexportExporter(depExporterInfo)
2670 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002671 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002672 }
2673
Colin Cross6e511a92020-07-27 21:26:48 -07002674 linkFile := ccDep.OutputFile()
2675
2676 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2677 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002678 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002679 return
2680 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002681
Jiyong Parke3867542020-12-03 17:28:25 +09002682 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2683 return
2684 }
2685
Colin Cross0de8a1e2020-09-18 14:15:30 -07002686 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002687
Colin Cross6e511a92020-07-27 21:26:48 -07002688 var ptr *android.Paths
2689 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002690
Colin Cross6e511a92020-07-27 21:26:48 -07002691 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002692
Colin Cross6e511a92020-07-27 21:26:48 -07002693 switch {
2694 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002695 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2696 if !ctx.Config().AllowMissingDependencies() {
2697 ctx.ModuleErrorf("module %q is not a header library", depName)
2698 } else {
2699 ctx.AddMissingDependencies([]string{depName})
2700 }
2701 return
2702 }
Colin Cross6e511a92020-07-27 21:26:48 -07002703 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002704 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2705 if !ctx.Config().AllowMissingDependencies() {
2706 ctx.ModuleErrorf("module %q is not a shared library", depName)
2707 } else {
2708 ctx.AddMissingDependencies([]string{depName})
2709 }
2710 return
2711 }
Jiyong Parke3867542020-12-03 17:28:25 +09002712
Jiyong Park7d55b612021-06-11 17:22:09 +09002713 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
2714 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002715
Jiyong Park1ad8e162020-12-01 23:40:09 +09002716 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2717 // linkFile, depFile, and ptr.
2718 if c.IsStubs() {
2719 break
2720 }
2721
Colin Cross0de8a1e2020-09-18 14:15:30 -07002722 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2723 depFile = sharedLibraryInfo.TableOfContents
2724
Colin Cross6e511a92020-07-27 21:26:48 -07002725 ptr = &depPaths.SharedLibs
2726 switch libDepTag.Order {
2727 case earlyLibraryDependency:
2728 ptr = &depPaths.EarlySharedLibs
2729 depPtr = &depPaths.EarlySharedLibsDeps
2730 case normalLibraryDependency:
2731 ptr = &depPaths.SharedLibs
2732 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002733 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002734 case lateLibraryDependency:
2735 ptr = &depPaths.LateSharedLibs
2736 depPtr = &depPaths.LateSharedLibsDeps
2737 default:
2738 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002739 }
Colin Cross6e511a92020-07-27 21:26:48 -07002740 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002741 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2742 if !ctx.Config().AllowMissingDependencies() {
2743 ctx.ModuleErrorf("module %q is not a static library", depName)
2744 } else {
2745 ctx.AddMissingDependencies([]string{depName})
2746 }
2747 return
2748 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002749
2750 // Stubs lib doesn't link to the static lib dependencies. Don't set
2751 // linkFile, depFile, and ptr.
2752 if c.IsStubs() {
2753 break
2754 }
2755
Colin Cross0de8a1e2020-09-18 14:15:30 -07002756 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2757 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002758 if libDepTag.wholeStatic {
2759 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002760 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2761 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002762 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002763 // This case normally catches prebuilt static
2764 // libraries, but it can also occur when
2765 // AllowMissingDependencies is on and the
2766 // dependencies has no sources of its own
2767 // but has a whole_static_libs dependency
2768 // on a missing library. We want to depend
2769 // on the .a file so that there is something
2770 // in the dependency tree that contains the
2771 // error rule for the missing transitive
2772 // dependency.
2773 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002774 }
Colin Cross6e511a92020-07-27 21:26:48 -07002775 } else {
2776 switch libDepTag.Order {
2777 case earlyLibraryDependency:
2778 panic(fmt.Errorf("early static libs not suppported"))
2779 case normalLibraryDependency:
2780 // static dependencies will be handled separately so they can be ordered
2781 // using transitive dependencies.
2782 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002783 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002784 case lateLibraryDependency:
2785 ptr = &depPaths.LateStaticLibs
2786 default:
2787 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002788 }
2789 }
2790 }
2791
Colin Cross6e511a92020-07-27 21:26:48 -07002792 if libDepTag.static() && !libDepTag.wholeStatic {
2793 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2794 ctx.ModuleErrorf("module %q not a static library", depName)
2795 return
2796 }
Logan Chien43d34c32017-12-20 01:17:32 +08002797
Colin Cross6e511a92020-07-27 21:26:48 -07002798 // When combining coverage files for shared libraries and executables, coverage files
2799 // in static libraries act as if they were whole static libraries. The same goes for
2800 // source based Abi dump files.
2801 if c, ok := ccDep.(*Module); ok {
2802 staticLib := c.linker.(libraryInterface)
2803 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2804 staticLib.objs().coverageFiles...)
2805 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2806 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002807 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002808 // Handle non-CC modules here
2809 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002810 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002811 }
2812 }
2813
Colin Cross6e511a92020-07-27 21:26:48 -07002814 if ptr != nil {
2815 if !linkFile.Valid() {
2816 if !ctx.Config().AllowMissingDependencies() {
2817 ctx.ModuleErrorf("module %q missing output file", depName)
2818 } else {
2819 ctx.AddMissingDependencies([]string{depName})
2820 }
2821 return
2822 }
2823 *ptr = append(*ptr, linkFile.Path())
2824 }
2825
2826 if depPtr != nil {
2827 dep := depFile
2828 if !dep.Valid() {
2829 dep = linkFile
2830 }
2831 *depPtr = append(*depPtr, dep.Path())
2832 }
2833
Colin Cross0de8a1e2020-09-18 14:15:30 -07002834 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2835 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2836 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2837 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2838
2839 if libDepTag.reexportFlags {
2840 reexportExporter(depExporterInfo)
2841 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2842 // Re-exported shared library headers must be included as well since they can help us with type information
2843 // about template instantiations (instantiated from their headers).
2844 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2845 // scripts.
2846 c.sabi.Properties.ReexportedIncludes = append(
2847 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2848 }
2849
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002850 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002851 switch {
2852 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002853 c.Properties.AndroidMkHeaderLibs = append(
2854 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002855 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002856 if lib := moduleLibraryInterface(dep); lib != nil {
2857 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002858 // Add the dependency to the APEX(es) providing the library so that
2859 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002860 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09002861 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07002862 c.Properties.ApexesProvidingSharedLibs = append(
2863 c.Properties.ApexesProvidingSharedLibs, an)
2864 }
2865 }
2866 }
2867
2868 // Note: the order of libs in this list is not important because
2869 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002870 c.Properties.AndroidMkSharedLibs = append(
2871 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002872 // Record BaseLibName for snapshots.
2873 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002874 case libDepTag.static():
2875 if libDepTag.wholeStatic {
2876 c.Properties.AndroidMkWholeStaticLibs = append(
2877 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2878 } else {
2879 c.Properties.AndroidMkStaticLibs = append(
2880 c.Properties.AndroidMkStaticLibs, makeLibName)
2881 }
Justin Yun5e035862021-06-29 20:50:37 +09002882 // Record BaseLibName for snapshots.
2883 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002884 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002885 } else if !c.IsStubs() {
2886 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
2887
Colin Cross6e511a92020-07-27 21:26:48 -07002888 switch depTag {
2889 case runtimeDepTag:
2890 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002891 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002892 // Record BaseLibName for snapshots.
2893 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002894 case objDepTag:
2895 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
2896 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002897 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002898 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07002899 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002900 case dynamicLinkerDepTag:
2901 depPaths.DynamicLinker = linkFile
2902 }
Jiyong Park27b188b2017-07-18 13:23:39 +09002903 }
Colin Crossca860ac2016-01-04 14:34:37 -08002904 })
2905
Jeff Gaston294356f2017-09-27 17:05:30 -07002906 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07002907 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
2908 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
2909 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07002910
Colin Crossdd84e052017-05-17 13:44:16 -07002911 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07002912 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09002913 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
2914 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09002915 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09002916 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
2917 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07002918 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09002919 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09002920 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002921
2922 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09002923 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07002924 }
Colin Crossdd84e052017-05-17 13:44:16 -07002925
Colin Crossca860ac2016-01-04 14:34:37 -08002926 return depPaths
2927}
2928
Jiyong Park7d55b612021-06-11 17:22:09 +09002929// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
2930// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
2931// dependency. The stub variant is selected when the dependency crosses a boundary where each side
2932// has different level of updatability. For example, if a library foo in an APEX depends on a
2933// library bar which provides stable interface and exists in the platform, foo uses the stub variant
2934// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
2935// same APEX as foo, the non-stub variant of bar is used.
2936func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
2937 depName := ctx.OtherModuleName(dep)
2938 depTag := ctx.OtherModuleDependencyTag(dep)
2939 libDepTag, ok := depTag.(libraryDependencyTag)
2940 if !ok || !libDepTag.shared() {
2941 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2942 }
2943
2944 thisModule, ok := ctx.Module().(android.ApexModule)
2945 if !ok {
2946 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
2947 }
2948
2949 useVndk := false
2950 bootstrap := false
2951 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
2952 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
2953 } else {
2954 useVndk = linkable.UseVndk()
2955 bootstrap = linkable.Bootstrap()
2956 }
2957
2958 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
2959 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2960 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
2961 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2962
2963 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
2964 useStubs := false
2965
2966 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
2967 if !apexInfo.IsForPlatform() {
2968 // For platform libraries, use current version of LLNDK
2969 // If this is for use_vendor apex we will apply the same rules
2970 // of apex sdk enforcement below to choose right version.
2971 useStubs = true
2972 }
Jiyong Park9477c262021-06-22 20:23:05 +09002973 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
2974 // If not building for APEX or the containing APEX allows the use of
2975 // platform APIs, use stubs only when it is from an APEX (and not from
2976 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
2977 // bootstrap modules, always link to non-stub variant
Jiyong Park7d55b612021-06-11 17:22:09 +09002978 useStubs = dep.(android.ApexModule).NotInPlatform() && !bootstrap
2979 if useStubs {
2980 // Another exception: if this module is a test for an APEX, then
2981 // it is linked with the non-stub variant of a module in the APEX
2982 // as if this is part of the APEX.
2983 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
2984 for _, apexContents := range testFor.ApexContents {
2985 if apexContents.DirectlyInApex(depName) {
2986 useStubs = false
2987 break
2988 }
2989 }
2990 }
2991 if useStubs {
2992 // Yet another exception: If this module and the dependency are
2993 // available to the same APEXes then skip stubs between their
2994 // platform variants. This complements the test_for case above,
2995 // which avoids the stubs on a direct APEX library dependency, by
2996 // avoiding stubs for indirect test dependencies as well.
2997 //
2998 // TODO(b/183882457): This doesn't work if the two libraries have
2999 // only partially overlapping apex_available. For that test_for
3000 // modules would need to be split into APEX variants and resolved
3001 // separately for each APEX they have access to.
3002 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3003 useStubs = false
3004 }
3005 }
3006 } else {
3007 // If building for APEX, use stubs when the parent is in any APEX that
3008 // the child is not in.
3009 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3010 }
3011
3012 // when to use (unspecified) stubs, use the latest one.
3013 if useStubs {
3014 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3015 toUse := stubs[len(stubs)-1]
3016 sharedLibraryInfo = toUse.SharedLibraryInfo
3017 depExporterInfo = toUse.FlagExporterInfo
3018 }
3019 }
3020 return sharedLibraryInfo, depExporterInfo
3021}
3022
Colin Cross0de8a1e2020-09-18 14:15:30 -07003023// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3024// to match the topological order of the dependency tree, including any static analogues of
3025// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3026// of the transitive dependencies.
3027func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3028 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3029 var staticPaths android.Paths
3030 for _, staticDep := range staticDeps {
3031 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3032 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3033 }
3034 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003035 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3036 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003037 }
3038 }
3039 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3040
3041 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3042
3043 // reorder the dependencies based on transitive dependencies
3044 staticPaths = android.FirstUniquePaths(staticPaths)
3045 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3046
3047 if len(orderedStaticPaths) != len(staticPaths) {
3048 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3049 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3050 }
3051
3052 return orderedStaticPaths, transitiveStaticLibs
3053}
3054
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003055// BaseLibName trims known prefixes and suffixes
3056func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003057 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3058 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003059 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003060 return libName
3061}
3062
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003063func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003064 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003065 ccDepModule, _ := ccDep.(*Module)
3066 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003067 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003068
Justin Yuncbca3732021-02-03 19:24:13 +09003069 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003070 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07003071 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003072 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003073 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003074
Ivan Lozanod1dec542021-05-26 15:33:11 -04003075 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003076 }
3077 }
3078
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003079 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3080 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003081 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3082 // core module instead.
3083 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003084 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003085 // The vendor and product modules in Make will have been renamed to not conflict with the
3086 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003087 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003088 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003089 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003090 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003091 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003092 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003093 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003094 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003095 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003096 } else {
3097 return libName
3098 }
3099}
3100
Colin Crossca860ac2016-01-04 14:34:37 -08003101func (c *Module) InstallInData() bool {
3102 if c.installer == nil {
3103 return false
3104 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003105 return c.installer.inData()
3106}
3107
3108func (c *Module) InstallInSanitizerDir() bool {
3109 if c.installer == nil {
3110 return false
3111 }
3112 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003113 return true
3114 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003115 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003116}
3117
Yifan Hong1b3348d2020-01-21 15:53:22 -08003118func (c *Module) InstallInRamdisk() bool {
3119 return c.InRamdisk()
3120}
3121
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003122func (c *Module) InstallInVendorRamdisk() bool {
3123 return c.InVendorRamdisk()
3124}
3125
Jiyong Parkf9332f12018-02-01 00:54:12 +09003126func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003127 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003128}
3129
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003130func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003131 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003132 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003133 return
3134 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003135 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003136}
3137
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003138func (c *Module) HostToolPath() android.OptionalPath {
3139 if c.installer == nil {
3140 return android.OptionalPath{}
3141 }
3142 return c.installer.hostToolPath()
3143}
3144
Nan Zhangd4e641b2017-07-12 12:55:28 -07003145func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3146 return c.outputFile
3147}
3148
Colin Cross41955e82019-05-29 14:40:35 -07003149func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3150 switch tag {
3151 case "":
3152 if c.outputFile.Valid() {
3153 return android.Paths{c.outputFile.Path()}, nil
3154 }
3155 return android.Paths{}, nil
3156 default:
3157 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003158 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003159}
3160
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003161func (c *Module) static() bool {
3162 if static, ok := c.linker.(interface {
3163 static() bool
3164 }); ok {
3165 return static.static()
3166 }
3167 return false
3168}
3169
Jiyong Park379de2f2018-12-19 02:47:14 +09003170func (c *Module) staticBinary() bool {
3171 if static, ok := c.linker.(interface {
3172 staticBinary() bool
3173 }); ok {
3174 return static.staticBinary()
3175 }
3176 return false
3177}
3178
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003179func (c *Module) testBinary() bool {
3180 if test, ok := c.linker.(interface {
3181 testBinary() bool
3182 }); ok {
3183 return test.testBinary()
3184 }
3185 return false
3186}
3187
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003188// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3189func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003190 if h, ok := c.linker.(interface {
3191 header() bool
3192 }); ok {
3193 return h.header()
3194 }
3195 return false
3196}
3197
Ivan Lozanod7586b62021-04-01 09:49:36 -04003198func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003199 if b, ok := c.linker.(interface {
3200 binary() bool
3201 }); ok {
3202 return b.binary()
3203 }
3204 return false
3205}
3206
Justin Yun5e035862021-06-29 20:50:37 +09003207func (c *Module) StaticExecutable() bool {
3208 if b, ok := c.linker.(*binaryDecorator); ok {
3209 return b.static()
3210 }
3211 return false
3212}
3213
Ivan Lozanod7586b62021-04-01 09:49:36 -04003214func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003215 if o, ok := c.linker.(interface {
3216 object() bool
3217 }); ok {
3218 return o.object()
3219 }
3220 return false
3221}
3222
Ivan Lozanof9e21722020-12-02 09:00:51 -05003223func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003224 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003225 if c.IsLlndk() {
3226 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003227 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003228 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003229 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003230 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003231 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003232 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003233 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003234 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003235 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003236 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003237 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003238 return "native:product"
3239 }
Jooyung Han38002912019-05-16 04:01:54 +09003240 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003241 } else if c.InRamdisk() {
3242 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003243 } else if c.InVendorRamdisk() {
3244 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003245 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003246 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003247 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003248 return "native:ndk:none:none"
3249 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3250 //family, link := getNdkStlFamilyAndLinkType(c)
3251 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003252 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003253 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003254 } else {
3255 return "native:platform"
3256 }
3257}
3258
Jiyong Park9d452992018-10-03 00:38:19 +09003259// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003260// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003261func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003262 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003263 // Stub libs and prebuilt libs in a versioned SDK are not
3264 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003265 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003266 } else if _, ok := c.linker.(testPerSrc); ok {
3267 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003268 }
3269 return false
3270}
3271
Jiyong Parka90ca002019-10-07 15:47:24 +09003272func (c *Module) AvailableFor(what string) bool {
3273 if linker, ok := c.linker.(interface {
3274 availableFor(string) bool
3275 }); ok {
3276 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3277 } else {
3278 return c.ApexModuleBase.AvailableFor(what)
3279 }
3280}
3281
Jiyong Park62304bb2020-04-13 16:19:48 +09003282func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003283 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003284}
3285
Paul Duffin0cb37b92020-03-04 14:52:46 +00003286func (c *Module) EverInstallable() bool {
3287 return c.installer != nil &&
3288 // Check to see whether the module is actually ever installable.
3289 c.installer.everInstallable()
3290}
3291
Ivan Lozanod7586b62021-04-01 09:49:36 -04003292func (c *Module) PreventInstall() bool {
3293 return c.Properties.PreventInstall
3294}
3295
3296func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003297 if c.library != nil {
3298 if i := c.library.installable(); i != nil {
3299 return i
3300 }
3301 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003302 return c.Properties.Installable
3303}
3304
3305func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003306 ret := c.EverInstallable() &&
3307 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003308 proptools.BoolDefault(c.Installable(), true) &&
3309 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003310
3311 // The platform variant doesn't need further condition. Apex variants however might not
3312 // be installable because it will likely to be included in the APEX and won't appear
3313 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003314 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003315 return ret
3316 }
3317
3318 // Special case for modules that are configured to be installed to /data, which includes
3319 // test modules. For these modules, both APEX and non-APEX variants are considered as
3320 // installable. This is because even the APEX variants won't be included in the APEX, but
3321 // will anyway be installed to /data/*.
3322 // See b/146995717
3323 if c.InstallInData() {
3324 return ret
3325 }
3326
3327 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003328}
3329
Logan Chien41eabe62019-04-10 13:33:58 +08003330func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3331 if c.linker != nil {
3332 if library, ok := c.linker.(*libraryDecorator); ok {
3333 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3334 }
3335 }
3336}
3337
Jiyong Park45bf82e2020-12-15 22:29:02 +09003338var _ android.ApexModule = (*Module)(nil)
3339
3340// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003341func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003342 depTag := ctx.OtherModuleDependencyTag(dep)
3343 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3344
3345 if cc, ok := dep.(*Module); ok {
3346 if cc.HasStubsVariants() {
3347 if isLibDepTag && libDepTag.shared() {
3348 // dynamic dep to a stubs lib crosses APEX boundary
3349 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003350 }
Colin Cross6e511a92020-07-27 21:26:48 -07003351 if IsRuntimeDepTag(depTag) {
3352 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003353 return false
3354 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003355 }
Zhijun Heec285872021-04-24 10:47:08 -07003356 if cc.IsLlndk() {
3357 return false
3358 }
Colin Crossaac32222020-07-29 12:51:56 -07003359 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003360 // shared_lib dependency from a static lib is considered as crossing
3361 // the APEX boundary because the dependency doesn't actually is
3362 // linked; the dependency is used only during the compilation phase.
3363 return false
3364 }
Jiyong Parke3867542020-12-03 17:28:25 +09003365
3366 if isLibDepTag && libDepTag.excludeInApex {
3367 return false
3368 }
Colin Cross6e511a92020-07-27 21:26:48 -07003369 }
Colin Crossc1b36442021-05-06 13:42:48 -07003370 if depTag == stubImplDepTag {
3371 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003372 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003373 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003374 if depTag == staticVariantTag {
3375 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3376 // actually mean that the static lib (and its dependencies) are copied into the
3377 // APEX.
3378 return false
3379 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003380 return true
3381}
3382
Jiyong Park45bf82e2020-12-15 22:29:02 +09003383// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003384func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3385 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003386 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3387 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3388 return nil
3389 }
3390 // b/154569636: set min_sdk_version correctly for toolchain_libraries
3391 if c.ToolchainLibrary() {
3392 return nil
3393 }
3394 // We don't check for prebuilt modules
3395 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3396 return nil
3397 }
3398 minSdkVersion := c.MinSdkVersion()
3399 if minSdkVersion == "apex_inherit" {
3400 return nil
3401 }
3402 if minSdkVersion == "" {
3403 // JNI libs within APK-in-APEX fall into here
3404 // Those are okay to set sdk_version instead
3405 // We don't have to check if this is a SDK variant because
3406 // non-SDK variant resets sdk_version, which works too.
3407 minSdkVersion = c.SdkVersion()
3408 }
Dan Albertc8060532020-07-22 22:32:17 -07003409 if minSdkVersion == "" {
3410 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3411 }
3412 // Not using nativeApiLevelFromUser because the context here is not
3413 // necessarily a native context.
3414 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003415 if err != nil {
3416 return err
3417 }
Dan Albertc8060532020-07-22 22:32:17 -07003418
3419 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003420 return fmt.Errorf("newer SDK(%v)", ver)
3421 }
3422 return nil
3423}
3424
Paul Duffinb5769c12021-05-12 16:16:51 +01003425// Implements android.ApexModule
3426func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3427 // stub libraries and native bridge libraries are always available to platform
3428 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3429}
3430
Rob Seymour925aa092021-08-10 20:42:03 +00003431var _ snapshot.RelativeInstallPath = (*Module)(nil)
3432
Colin Cross2ba19d92015-05-07 15:44:20 -07003433//
Colin Crosscfad1192015-11-02 16:43:11 -08003434// Defaults
3435//
Colin Crossca860ac2016-01-04 14:34:37 -08003436type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003437 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003438 android.DefaultsModuleBase
Liz Kammer3cf52112021-03-31 15:42:03 -04003439 // Included to support setting bazel_module.label for multiple Soong modules to the same Bazel
3440 // target. This is primarily useful for modules that were architecture specific and instead are
3441 // handled in Bazel as a select().
3442 android.BazelModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003443 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003444}
3445
Patrice Arrudac249c712019-03-19 17:00:29 -07003446// cc_defaults provides a set of properties that can be inherited by other cc
3447// modules. A module can use the properties from a cc_defaults using
3448// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3449// merged (when possible) by prepending the default module's values to the
3450// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003451func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003452 return DefaultsFactory()
3453}
3454
Colin Cross36242852017-06-23 15:06:31 -07003455func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003456 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003457
Colin Cross36242852017-06-23 15:06:31 -07003458 module.AddProperties(props...)
3459 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003460 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003461 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003462 &BaseCompilerProperties{},
3463 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003464 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003465 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003466 &StaticProperties{},
3467 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003468 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003469 &BinaryLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003470 &TestProperties{},
3471 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003472 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003473 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003474 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003475 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003476 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003477 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003478 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003479 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003480 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003481 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003482 &LTOProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003483 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003484 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003485 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3486 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003487 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003488 )
Colin Crosscfad1192015-11-02 16:43:11 -08003489
Liz Kammer3cf52112021-03-31 15:42:03 -04003490 // Bazel module must be initialized _before_ Defaults to be included in cc_defaults module.
3491 android.InitBazelModule(module)
Jooyung Hancc372c52019-09-25 15:18:44 +09003492 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003493
3494 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003495}
3496
Jiyong Park2286afd2020-06-16 21:58:53 +09003497func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003498 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003499}
3500
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003501func kytheExtractAllFactory() android.Singleton {
3502 return &kytheExtractAllSingleton{}
3503}
3504
3505type kytheExtractAllSingleton struct {
3506}
3507
3508func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3509 var xrefTargets android.Paths
3510 ctx.VisitAllModules(func(module android.Module) {
3511 if ccModule, ok := module.(xref); ok {
3512 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3513 }
3514 })
3515 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3516 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003517 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003518 }
3519}
3520
Colin Cross06a931b2015-10-28 17:23:31 -07003521var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003522var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003523var BoolPtr = proptools.BoolPtr
3524var String = proptools.String
3525var StringPtr = proptools.StringPtr