blob: 9035e357da754e5f93345fd6aec772cc80edeb05 [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"
Kiyoung Kim487689e2022-07-26 09:48:22 +090034 "android/soong/multitree"
Rob Seymour925aa092021-08-10 20:42:03 +000035 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080036)
37
Colin Cross463a90e2015-06-17 14:20:06 -070038func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000039 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070040
Paul Duffin036e7002019-12-19 19:16:28 +000041 pctx.Import("android/soong/cc/config")
42}
43
44func RegisterCCBuildComponents(ctx android.RegistrationContext) {
45 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
46
47 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000048 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090049 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070050 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010051 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070052 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070053 ctx.BottomUp("begin", BeginMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070054 })
Colin Cross16b23492016-01-06 14:41:07 -080055
Paul Duffin036e7002019-12-19 19:16:28 +000056 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040057 for _, san := range Sanitizers {
58 san.registerMutators(ctx)
59 }
Dan Willemsen581341d2017-02-09 16:16:31 -080060
Colin Cross0b908332019-06-19 23:00:20 -070061 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090062 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080063
Cory Barkera1da26f2022-06-07 20:12:06 +000064 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000065
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080066 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070067
Yi Kongeb8efc92021-12-09 18:06:29 +080068 ctx.TopDown("afdo_deps", afdoDepsMutator)
69 ctx.BottomUp("afdo", afdoMutator).Parallel()
70
Stephen Craneba090d12017-05-09 15:44:35 -070071 ctx.TopDown("lto_deps", ltoDepsMutator)
72 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090073
Jooyung Han479ca172020-10-19 18:51:07 +090074 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090075 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070076 })
Colin Crossb98c8b02016-07-29 13:44:28 -070077
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080078 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
79 // sabi mutator needs to be run after apex mutator finishes.
80 ctx.TopDown("sabi_deps", sabiDepsMutator)
81 })
82
Colin Cross57898582020-10-29 18:25:19 -070083 ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070084}
85
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050086// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
87// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
88// edges to these modules.
89// This object is constructed in DepsMutator, by calling to various module delegates to set
90// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
91// dependencies.
92// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
93// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080094type Deps struct {
95 SharedLibs, LateSharedLibs []string
96 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080097 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +080098 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -070099
Colin Cross3e5e7782022-06-17 22:17:05 +0000100 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
101 // prevent automatically exporting symbols.
102 UnexportedStaticLibs []string
103
Chris Parsons79d66a52020-06-05 17:26:16 -0400104 // Used for data dependencies adjacent to tests
105 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700106 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400107
Yo Chiang219968c2020-09-22 18:45:04 +0800108 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
109 SystemSharedLibs []string
110
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500111 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800112 StaticUnwinderIfLegacy bool
113
Colin Cross5950f382016-12-13 12:50:57 -0800114 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700115
Colin Cross81413472016-04-11 14:37:39 -0700116 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700117
Dan Willemsenb40aab62016-04-20 14:21:14 -0700118 GeneratedSources []string
119 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900120 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700121
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700122 ReexportGeneratedHeaders []string
123
Colin Crossc465efd2021-06-11 18:00:04 -0700124 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700125
126 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700127 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900128
129 // List of libs that need to be excluded for APEX variant
130 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700131}
132
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500133// PathDeps is a struct containing file paths to dependencies of a module.
134// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
135// It's used to construct flags for various build statements (such as for compiling and linking).
136// It is then passed to module decorator functions responsible for registering build statements
137// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800138type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700139 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900140 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700141 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900142 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700143 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700144 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700145
Colin Cross0de8a1e2020-09-18 14:15:30 -0700146 // Transitive static library dependencies of static libraries for use in ordering.
147 TranstiveStaticLibrariesForOrdering *android.DepSet
148
Colin Cross26c34ed2016-09-30 17:10:16 -0700149 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100150 Objs Objects
151 // Paths to .o files in dependencies that provide them. Note that these lists
152 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800153 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700154 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700155
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100156 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
157 // the libs from all whole_static_lib dependencies.
158 WholeStaticLibsFromPrebuilts android.Paths
159
Colin Cross26c34ed2016-09-30 17:10:16 -0700160 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700161 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900162 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700163
Inseob Kimd110f872019-12-06 13:15:38 +0900164 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000165 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900166 IncludeDirs android.Paths
167 SystemIncludeDirs android.Paths
168 ReexportedDirs android.Paths
169 ReexportedSystemDirs android.Paths
170 ReexportedFlags []string
171 ReexportedGeneratedHeaders android.Paths
172 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700173
Colin Cross26c34ed2016-09-30 17:10:16 -0700174 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700175 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700176
Dan Willemsena0790e32018-10-12 00:24:23 -0700177 // Path to the dynamic linker binary
178 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700179
180 // For Darwin builds, the path to the second architecture's output that should
181 // be combined with this architectures's output into a FAT MachO file.
182 DarwinSecondArchOutput android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700183}
184
Colin Cross4af21ed2019-11-04 09:37:55 -0800185// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
186// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
187// command line so they can be overridden by the local module flags).
188type LocalOrGlobalFlags struct {
189 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700190 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800191 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700192 CFlags []string // Flags that apply to C and C++ source files
193 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
194 ConlyFlags []string // Flags that apply to C source files
195 CppFlags []string // Flags that apply to C++ source files
196 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700197 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800198}
199
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500200// Flags contains various types of command line flags (and settings) for use in building build
201// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800202type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500203 // Local flags (which individual modules are responsible for). These may override global flags.
204 Local LocalOrGlobalFlags
205 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800206 Global LocalOrGlobalFlags
207
208 aidlFlags []string // Flags that apply to aidl source files
209 rsFlags []string // Flags that apply to renderscript source files
210 libFlags []string // Flags to add libraries early to the link order
211 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
212 TidyFlags []string // Flags that apply to clang-tidy
213 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700214
Colin Crossc3199482017-03-30 15:03:04 -0700215 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800216 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700217 SystemIncludeFlags []string
218
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800219 Toolchain config.Toolchain
220 Tidy bool // True if ninja .tidy rules should be generated.
221 NeedTidyFiles bool // True if module link should depend on .tidy files
222 GcovCoverage bool // True if coverage files should be generated.
223 SAbiDump bool // True if header abi dumps should be generated.
224 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800225
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500226 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800227 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500228 // The target-device system path to the dynamic linker.
229 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800230
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700231 CFlagsDeps android.Paths // Files depended on by compiler flags
232 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800233
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500234 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700235 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800236
Colin Cross19878da2019-03-28 14:45:07 -0700237 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700238 protoC bool // Whether to use C instead of C++
239 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700240
241 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200242 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700243}
244
Colin Crossca860ac2016-01-04 14:34:37 -0800245// Properties used to compile all C or C++ modules
246type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700247 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800248 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700249
Jiyong Parkb35a8192020-08-10 15:59:36 +0900250 // The API level that this module is built against. The APIs of this API level will be
251 // visible at build time, but use of any APIs newer than min_sdk_version will render the
252 // module unloadable on older devices. In the future it will be possible to weakly-link new
253 // APIs, making the behavior match Java: such modules will load on older devices, but
254 // calling new APIs on devices that do not support them will result in a crash.
255 //
256 // This property has the same behavior as sdk_version does for Java modules. For those
257 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
258 // does for Java code.
259 //
260 // In addition, setting this property causes two variants to be built, one for the platform
261 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800262 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700263
Jiyong Parkb35a8192020-08-10 15:59:36 +0900264 // Minimum OS API level supported by this C or C++ module. This property becomes the value
265 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
266 // this property is also used to ensure that the min_sdk_version of the containing module is
267 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
268 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
269 // min_sdk_version of the containing APEX. When the module
270 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900271 Min_sdk_version *string
272
Colin Crossc511bc52020-04-07 16:50:32 +0000273 // If true, always create an sdk variant and don't create a platform variant.
274 Sdk_variant_only *bool
275
Jiyong Parkde866cb2018-12-07 23:08:36 +0900276 AndroidMkSharedLibs []string `blueprint:"mutated"`
277 AndroidMkStaticLibs []string `blueprint:"mutated"`
278 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
279 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700280 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900281 HideFromMake bool `blueprint:"mutated"`
282 PreventInstall bool `blueprint:"mutated"`
283 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700284
Yo Chiang219968c2020-09-22 18:45:04 +0800285 // Set by DepsMutator.
286 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
287
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200288 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900289 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200290
291 // The VNDK version this module is built against. If empty, the module is not
292 // build against the VNDK.
293 VndkVersion string `blueprint:"mutated"`
294
295 // Suffix for the name of Android.mk entries generated by this module
296 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800297
298 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
299 // file
300 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900301
Yifan Hong39143a92020-10-26 12:43:12 -0700302 // Make this module available when building for ramdisk.
303 // On device without a dedicated recovery partition, the module is only
304 // available after switching root into
305 // /first_stage_ramdisk. To expose the module before switching root, install
306 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800307 Ramdisk_available *bool
308
Yifan Hong39143a92020-10-26 12:43:12 -0700309 // Make this module available when building for vendor ramdisk.
310 // On device without a dedicated recovery partition, the module is only
311 // available after switching root into
312 // /first_stage_ramdisk. To expose the module before switching root, install
313 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700314 Vendor_ramdisk_available *bool
315
Jiyong Parkf9332f12018-02-01 00:54:12 +0900316 // Make this module available when building for recovery
317 Recovery_available *bool
318
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200319 // Used by imageMutator, set by ImageMutatorBegin()
320 CoreVariantNeeded bool `blueprint:"mutated"`
321 RamdiskVariantNeeded bool `blueprint:"mutated"`
322 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
323 RecoveryVariantNeeded bool `blueprint:"mutated"`
324
325 // A list of variations for the "image" mutator of the form
326 //<image name> '.' <version char>, for example, 'vendor.S'
327 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900328
329 // Allows this module to use non-APEX version of libraries. Useful
330 // for building binaries that are started before APEXes are activated.
331 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900332
333 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
334 // see soong/cc/config/vndk.go
335 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900336
337 // Used by vendor snapshot to record dependencies from snapshot modules.
338 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900339 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900340 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000341
Colin Cross1bc94122021-10-28 13:25:54 -0700342 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000343
344 // Set by factories of module types that can only be referenced from variants compiled against
345 // the SDK.
346 AlwaysSdk bool `blueprint:"mutated"`
347
348 // Variant is an SDK variant created by sdkMutator
349 IsSdkVariant bool `blueprint:"mutated"`
350 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
351 // variant to have a ".sdk" suffix.
352 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700353
354 // Normally Soong uses the directory structure to decide which modules
355 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800356 // different snapshots (vendor, recovery, etc.), but this property
357 // allows a partner to exclude a module normally thought of as a
358 // framework module from the vendor snapshot.
359 Exclude_from_vendor_snapshot *bool
360
361 // Normally Soong uses the directory structure to decide which modules
362 // should be included (framework) or excluded (non-framework) from the
363 // different snapshots (vendor, recovery, etc.), but this property
364 // allows a partner to exclude a module normally thought of as a
365 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800366 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900367
368 // List of APEXes that this module has private access to for testing purpose. The module
369 // can depend on libraries that are not exported by the APEXes and use private symbols
370 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000371 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800372
373 Target struct {
374 Platform struct {
375 // List of modules required by the core variant.
376 Required []string `android:"arch_variant"`
377
378 // List of modules not required by the core variant.
379 Exclude_required []string `android:"arch_variant"`
380 } `android:"arch_variant"`
381
382 Recovery struct {
383 // List of modules required by the recovery variant.
384 Required []string `android:"arch_variant"`
385
386 // List of modules not required by the recovery variant.
387 Exclude_required []string `android:"arch_variant"`
388 } `android:"arch_variant"`
389 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700390}
391
392type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900393 // whether this module should be allowed to be directly depended by other
394 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900395 // If set to true, two variants will be built separately, one like
396 // normal, and the other limited to the set of libraries and headers
397 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700398 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900399 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700400 // so it shouldn't have any unversioned runtime dependencies, or
401 // make assumptions about the system that may not be true in the
402 // future.
403 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900404 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900405 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900406 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900407 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900408 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700409 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
410 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900411
Justin Yunebcf0c52021-01-08 18:00:19 +0900412 // This is the same as the "vendor_available" except that the install path
413 // of the vendor variant is /odm or /vendor/odm.
414 // By replacing "vendor_available: true" with "odm_available: true", the
415 // module will install its vendor variant to the /odm partition or /vendor/odm.
416 // As the modules with "odm_available: true" still create the vendor variants,
417 // they can link to the other vendor modules as the vendor_available modules do.
418 // Also, the vendor modules can link to odm_available modules.
419 //
420 // It may not be used for VNDK modules.
421 Odm_available *bool
422
Justin Yun63e9ec72020-10-29 16:49:43 +0900423 // whether this module should be allowed to be directly depended by other
424 // modules with `product_specific: true` or `product_available: true`.
425 // If set to true, an additional product variant will be built separately
426 // that is limited to the set of libraries and headers that are exposed to
427 // /product modules.
428 //
429 // The product variant may be used with a different (newer) /system,
430 // so it shouldn't have any unversioned runtime dependencies, or
431 // make assumptions about the system that may not be true in the
432 // future.
433 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900434 // If set to false, this module becomes inaccessible from /product modules.
435 //
436 // Different from the 'vendor_available' property, the modules with
437 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
438 // library without 'product_available' may not be depended on by any other
439 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900440 //
441 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
442 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
443 Product_available *bool
444
Jiyong Park5fb8c102018-04-09 12:03:06 +0900445 // whether this module is capable of being loaded with other instance
446 // (possibly an older version) of the same module in the same process.
447 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
448 // can be double loaded in a vendor process if the library is also a
449 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
450 // explicitly marked as `double_loadable: true` by the owner, or the dependency
451 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
452 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800453
454 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
455 IsLLNDK bool `blueprint:"mutated"`
456
Colin Cross78212242021-01-06 14:51:30 -0800457 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
458 // set and the module is not listed in VndkMustUseVendorVariantList.
459 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
460
461 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
462 IsVNDKCore bool `blueprint:"mutated"`
463
464 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
465 IsVNDKSP bool `blueprint:"mutated"`
466
467 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
468 // module sets the llndk.private property.
469 IsVNDKPrivate bool `blueprint:"mutated"`
470
471 // IsVNDKProduct is set if a VNDK module sets the product_available property.
472 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700473
474 // IsVendorPublicLibrary is set for the core and product variants of a library that has
475 // vendor_public_library stubs.
476 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800477}
478
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500479// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
480// to understanding details about the type of the current module.
481// For example, one might call these functions to determine whether the current module is a static
482// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800483type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800484 static() bool
485 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700486 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800487 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900488 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900489 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900490 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700491 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900492 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700493 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800494 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900495 minSdkVersion() string
496 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700497 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700498 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800499 IsLlndk() bool
500 IsLlndkPublic() bool
501 isImplementationForLLNDKPublic() bool
502 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900503 isVndk() bool
504 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500505 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700506 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900507 inProduct() bool
508 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800509 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700510 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900511 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700512 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700513 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800514 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800515 isAfdoCompile() bool
Yi Kong7e53c572018-02-14 18:16:12 +0800516 isPgoCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800517 isCfi() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800518 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800519 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800520 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700521 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700522 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900523 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800524 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700525 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700526 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800527 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800528 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800529 getSharedFlags() *SharedFlags
530}
531
532type SharedFlags struct {
533 numSharedFlags int
534 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800535}
536
537type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700538 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800539 ModuleContextIntf
540}
541
542type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700543 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800544 ModuleContextIntf
545}
546
Colin Cross37047f12016-12-13 17:06:13 -0800547type DepsContext interface {
548 android.BottomUpMutatorContext
549 ModuleContextIntf
550}
551
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500552// feature represents additional (optional) steps to building cc-related modules, such as invocation
553// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800554type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800555 flags(ctx ModuleContext, flags Flags) Flags
556 props() []interface{}
557}
558
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500559// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500560// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800561type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700562 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800563 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800564 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700565 compilerProps() []interface{}
566
Colin Cross76fada02016-07-27 10:31:13 -0700567 appendCflags([]string)
568 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700569 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800570}
571
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500572// linker is the interface for a linker decorator object. Individual module types can provide
573// their own implementation for this decorator, and thus specify custom logic regarding build
574// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800575type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700576 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800577 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700578 linkerFlags(ctx ModuleContext, flags Flags) Flags
579 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800580 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700581
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700582 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700583 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900584 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700585
586 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900587 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000588
589 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000590 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
591}
592
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500593// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000594type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500595 sharedLibs []string
596 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
597 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700598 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800599}
600
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500601// installer is the interface for an installer helper object. This helper is responsible for
602// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800603type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700604 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700605 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000606 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800607 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700608 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700609 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900610 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100611 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900612 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800613}
614
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800615type xref interface {
616 XrefCcFiles() android.Paths
617}
618
Inseob Kima1888ce2022-10-04 14:42:02 +0900619type overridable interface {
620 overriddenModules() []string
621}
622
Colin Cross6e511a92020-07-27 21:26:48 -0700623type libraryDependencyKind int
624
625const (
626 headerLibraryDependency = iota
627 sharedLibraryDependency
628 staticLibraryDependency
629)
630
631func (k libraryDependencyKind) String() string {
632 switch k {
633 case headerLibraryDependency:
634 return "headerLibraryDependency"
635 case sharedLibraryDependency:
636 return "sharedLibraryDependency"
637 case staticLibraryDependency:
638 return "staticLibraryDependency"
639 default:
640 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
641 }
642}
643
644type libraryDependencyOrder int
645
646const (
647 earlyLibraryDependency = -1
648 normalLibraryDependency = 0
649 lateLibraryDependency = 1
650)
651
652func (o libraryDependencyOrder) String() string {
653 switch o {
654 case earlyLibraryDependency:
655 return "earlyLibraryDependency"
656 case normalLibraryDependency:
657 return "normalLibraryDependency"
658 case lateLibraryDependency:
659 return "lateLibraryDependency"
660 default:
661 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
662 }
663}
664
665// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
666// tags that have a set of predefined tag objects that are reused for each dependency, a
667// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
668// That means that comparing a libraryDependencyTag for equality will only be equal if all
669// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
670// then check individual metadata fields instead.
671type libraryDependencyTag struct {
672 blueprint.BaseDependencyTag
673
674 // These are exported so that fmt.Printf("%#v") can call their String methods.
675 Kind libraryDependencyKind
676 Order libraryDependencyOrder
677
678 wholeStatic bool
679
680 reexportFlags bool
681 explicitlyVersioned bool
682 dataLib bool
683 ndk bool
684
685 staticUnwinder bool
686
687 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900688
Cindy Zhou18417cb2020-12-10 07:12:38 -0800689 // Whether or not this dependency should skip the apex dependency check
690 skipApexAllowedDependenciesCheck bool
691
Jiyong Parke3867542020-12-03 17:28:25 +0900692 // Whether or not this dependency has to be followed for the apex variants
693 excludeInApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000694
695 // If true, don't automatically export symbols from the static library into a shared library.
696 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700697}
698
699// header returns true if the libraryDependencyTag is tagging a header lib dependency.
700func (d libraryDependencyTag) header() bool {
701 return d.Kind == headerLibraryDependency
702}
703
704// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
705func (d libraryDependencyTag) shared() bool {
706 return d.Kind == sharedLibraryDependency
707}
708
709// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
710func (d libraryDependencyTag) static() bool {
711 return d.Kind == staticLibraryDependency
712}
713
Colin Cross65cb3142021-12-10 23:05:02 +0000714func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
715 if d.shared() {
716 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
717 }
718 return nil
719}
720
721var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
722
Colin Crosse9fe2942020-11-10 18:12:15 -0800723// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
724// binaries or other shared libraries are installed as dependencies.
725func (d libraryDependencyTag) InstallDepNeeded() bool {
726 return d.shared()
727}
728
729var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
730
731// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700732// libraryDependencyTag. Each tag object is created globally and reused for multiple
733// dependencies (although since the object contains no references, assigning a tag to a
734// variable and modifying it will not modify the original). Users can compare the tag
735// returned by ctx.OtherModuleDependencyTag against the global original
736type dependencyTag struct {
737 blueprint.BaseDependencyTag
738 name string
739}
740
Colin Crosse9fe2942020-11-10 18:12:15 -0800741// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
742// libraryDependencyTag, but where the dependency needs to be installed when the parent is
743// installed.
744type installDependencyTag struct {
745 blueprint.BaseDependencyTag
746 android.InstallAlwaysNeededDependencyTag
747 name string
748}
749
Colin Crossc99deeb2016-04-11 15:06:20 -0700750var (
Colin Cross6e511a92020-07-27 21:26:48 -0700751 genSourceDepTag = dependencyTag{name: "gen source"}
752 genHeaderDepTag = dependencyTag{name: "gen header"}
753 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
754 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900755 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700756 reuseObjTag = dependencyTag{name: "reuse objects"}
757 staticVariantTag = dependencyTag{name: "static variant"}
758 vndkExtDepTag = dependencyTag{name: "vndk extends"}
759 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700760 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800761 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700762 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700763 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000764 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700765)
766
Roland Levillainf89cd092019-07-29 16:22:59 +0100767func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700768 ccLibDepTag, ok := depTag.(libraryDependencyTag)
769 return ok && ccLibDepTag.shared()
770}
771
772func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
773 ccLibDepTag, ok := depTag.(libraryDependencyTag)
774 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100775}
776
Zach Johnson3df4e632020-11-06 11:56:27 -0800777func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
778 ccLibDepTag, ok := depTag.(libraryDependencyTag)
779 return ok && ccLibDepTag.header()
780}
781
Roland Levillainf89cd092019-07-29 16:22:59 +0100782func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800783 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100784}
785
786func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700787 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100788 return ok && ccDepTag == testPerSrcDepTag
789}
790
Chris Parsonsf874e462022-05-10 13:50:12 -0400791// bazelHandler is the interface for a helper object related to deferring to Bazel for
792// processing a cc module (during Bazel mixed builds). Individual module types should define
793// their own bazel handler if they support being handled by Bazel.
794type BazelHandler interface {
795 // QueueBazelCall invokes request-queueing functions on the BazelContext
796 //so that these requests are handled when Bazel's cquery is invoked.
797 QueueBazelCall(ctx android.BaseModuleContext, label string)
798
799 // ProcessBazelQueryResponse uses information retrieved from Bazel to set properties
800 // on the current module with given label.
801 ProcessBazelQueryResponse(ctx android.ModuleContext, label string)
802}
803
Colin Crossca860ac2016-01-04 14:34:37 -0800804// Module contains the properties and members used by all C/C++ module types, and implements
805// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500806// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
807// interface.
808//
809// To define a C/C++ related module, construct a new Module object and point its delegates to
810// type-specific structs. These delegates will be invoked to register module-specific build
811// statements which may be unique to the module type. For example, module.compiler.compile() should
812// be defined so as to register build statements which are responsible for compiling the module.
813//
814// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
815// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
816// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
817// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800818type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700819 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700820
Jiyong Parkd1063c12019-07-17 20:08:41 +0900821 android.SdkBase
Liz Kammerea6666f2021-02-17 10:17:28 -0500822 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700823
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700824 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700825 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700826
Colin Crossca860ac2016-01-04 14:34:37 -0800827 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400828 hod android.HostOrDeviceSupported
829 multilib android.Multilib
830 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700831
Paul Duffina0843f62019-12-13 19:50:38 +0000832 // Allowable SdkMemberTypes of this module type.
833 sdkMemberTypes []android.SdkMemberType
834
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500835 // decorator delegates, initialize before calling Init
836 // these may contain module-specific implementations, and effectively allow for custom
837 // type-specific logic. These members may reference different objects or the same object.
838 // Functions of these decorators will be invoked to initialize and register type-specific
839 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500840 compiler compiler
841 linker linker
842 installer installer
Chris Parsonsf874e462022-05-10 13:50:12 -0400843 bazelHandler BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500844
845 features []feature
846 stl *stl
847 sanitize *sanitize
848 coverage *coverage
Cory Barkera1da26f2022-06-07 20:12:06 +0000849 fuzzer *fuzzer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500850 sabi *sabi
851 vndkdep *vndkdep
852 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800853 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500854 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800855
Colin Cross31076b32020-10-23 17:22:06 -0700856 library libraryInterface
857
Colin Cross635c3b02016-05-18 15:37:25 -0700858 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800859
Colin Crossb98c8b02016-07-29 13:44:28 -0700860 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700861
862 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800863
864 // Flags used to compile this module
865 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700866
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800867 // Shared flags among build rules of this module
868 sharedFlags SharedFlags
869
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800870 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700871 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900872
873 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800874 // Kythe (source file indexer) paths for this compilation module
875 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700876 // Object .o file output paths for this compilation module
877 objFiles android.Paths
878 // Tidy .tidy file output paths for this compilation module
879 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900880
881 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700882 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700883
884 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700885}
886
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200887func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400888 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
889 if b, ok := c.compiler.(*baseCompiler); ok {
890 hasAidl = b.hasSrcExt(".aidl")
891 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
892 hasProto = b.hasSrcExt(".proto")
893 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
894 hasSysprop = b.hasSrcExt(".sysprop")
895 hasWinMsg = b.hasSrcExt(".mc")
896 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
897 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200898 c.AndroidModuleBase().AddJSONData(d)
899 (*d)["Cc"] = map[string]interface{}{
900 "SdkVersion": c.SdkVersion(),
901 "MinSdkVersion": c.MinSdkVersion(),
902 "VndkVersion": c.VndkVersion(),
903 "ProductSpecific": c.ProductSpecific(),
904 "SocSpecific": c.SocSpecific(),
905 "DeviceSpecific": c.DeviceSpecific(),
906 "InProduct": c.InProduct(),
907 "InVendor": c.InVendor(),
908 "InRamdisk": c.InRamdisk(),
909 "InVendorRamdisk": c.InVendorRamdisk(),
910 "InRecovery": c.InRecovery(),
911 "VendorAvailable": c.VendorAvailable(),
912 "ProductAvailable": c.ProductAvailable(),
913 "RamdiskAvailable": c.RamdiskAvailable(),
914 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
915 "RecoveryAvailable": c.RecoveryAvailable(),
916 "OdmAvailable": c.OdmAvailable(),
917 "InstallInData": c.InstallInData(),
918 "InstallInRamdisk": c.InstallInRamdisk(),
919 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
920 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
921 "InstallInRecovery": c.InstallInRecovery(),
922 "InstallInRoot": c.InstallInRoot(),
923 "IsVndk": c.IsVndk(),
924 "IsVndkExt": c.IsVndkExt(),
925 "IsVndkPrivate": c.IsVndkPrivate(),
926 "IsVndkSp": c.IsVndkSp(),
927 "IsLlndk": c.IsLlndk(),
928 "IsLlndkPublic": c.IsLlndkPublic(),
929 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
930 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
931 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
932 "ApexSdkVersion": c.apexSdkVersion,
933 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400934 "AidlSrcs": hasAidl,
935 "LexSrcs": hasLex,
936 "ProtoSrcs": hasProto,
937 "RenderscriptSrcs": hasRenderscript,
938 "SyspropSrcs": hasSysprop,
939 "WinMsgSrcs": hasWinMsg,
940 "YaccSrsc": hasYacc,
941 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200942 }
943}
944
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500945func (c *Module) SetPreventInstall() {
946 c.Properties.PreventInstall = true
947}
948
949func (c *Module) SetHideFromMake() {
950 c.Properties.HideFromMake = true
951}
952
Ivan Lozanod7586b62021-04-01 09:49:36 -0400953func (c *Module) HiddenFromMake() bool {
954 return c.Properties.HideFromMake
955}
956
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800957func (c *Module) RequiredModuleNames() []string {
958 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
959 if c.ImageVariation().Variation == android.CoreVariation {
960 required = append(required, c.Properties.Target.Platform.Required...)
961 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
962 } else if c.InRecovery() {
963 required = append(required, c.Properties.Target.Recovery.Required...)
964 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
965 }
966 return android.FirstUniqueStrings(required)
967}
968
Ivan Lozano52767be2019-10-18 14:49:46 -0700969func (c *Module) Toc() android.OptionalPath {
970 if c.linker != nil {
971 if library, ok := c.linker.(libraryInterface); ok {
972 return library.toc()
973 }
974 }
975 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
976}
977
978func (c *Module) ApiLevel() string {
979 if c.linker != nil {
980 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700981 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700982 }
983 }
984 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
985}
986
987func (c *Module) Static() bool {
988 if c.linker != nil {
989 if library, ok := c.linker.(libraryInterface); ok {
990 return library.static()
991 }
992 }
993 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
994}
995
996func (c *Module) Shared() bool {
997 if c.linker != nil {
998 if library, ok := c.linker.(libraryInterface); ok {
999 return library.shared()
1000 }
1001 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001002
Ivan Lozano52767be2019-10-18 14:49:46 -07001003 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1004}
1005
1006func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001007 if c.stl != nil {
1008 return c.stl.Properties.SelectedStl
1009 }
1010 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001011}
1012
Ivan Lozano52767be2019-10-18 14:49:46 -07001013func (c *Module) NdkPrebuiltStl() bool {
1014 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1015 return true
1016 }
1017 return false
1018}
1019
1020func (c *Module) StubDecorator() bool {
1021 if _, ok := c.linker.(*stubDecorator); ok {
1022 return true
1023 }
1024 return false
1025}
1026
1027func (c *Module) SdkVersion() string {
1028 return String(c.Properties.Sdk_version)
1029}
1030
Artur Satayev480e25b2020-04-27 18:53:18 +01001031func (c *Module) MinSdkVersion() string {
1032 return String(c.Properties.Min_sdk_version)
1033}
1034
Jiyong Park5df7bd32021-08-25 16:18:46 +09001035func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001036 if linker, ok := c.linker.(*objectLinker); ok {
1037 return linker.isCrt()
1038 }
1039 return false
1040}
1041
Jiyong Park5df7bd32021-08-25 16:18:46 +09001042func (c *Module) SplitPerApiLevel() bool {
1043 return c.canUseSdk() && c.isCrt()
1044}
1045
Colin Crossc511bc52020-04-07 16:50:32 +00001046func (c *Module) AlwaysSdk() bool {
1047 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1048}
1049
Ivan Lozano183a3212019-10-18 14:18:45 -07001050func (c *Module) CcLibrary() bool {
1051 if c.linker != nil {
1052 if _, ok := c.linker.(*libraryDecorator); ok {
1053 return true
1054 }
Colin Crossd48fe732020-09-23 20:37:24 -07001055 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1056 return true
1057 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001058 }
1059 return false
1060}
1061
1062func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001063 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001064 return true
1065 }
1066 return false
1067}
1068
Ivan Lozano2b262972019-11-21 12:30:50 -08001069func (c *Module) NonCcVariants() bool {
1070 return false
1071}
1072
Ivan Lozano183a3212019-10-18 14:18:45 -07001073func (c *Module) SetStatic() {
1074 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001075 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001076 library.setStatic()
1077 return
1078 }
1079 }
1080 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1081}
1082
1083func (c *Module) SetShared() {
1084 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001085 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001086 library.setShared()
1087 return
1088 }
1089 }
1090 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1091}
1092
1093func (c *Module) BuildStaticVariant() bool {
1094 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001095 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001096 return library.buildStatic()
1097 }
1098 }
1099 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1100}
1101
1102func (c *Module) BuildSharedVariant() bool {
1103 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001104 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001105 return library.buildShared()
1106 }
1107 }
1108 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1109}
1110
1111func (c *Module) Module() android.Module {
1112 return c
1113}
1114
Jiyong Parkc20eee32018-09-05 22:36:17 +09001115func (c *Module) OutputFile() android.OptionalPath {
1116 return c.outputFile
1117}
1118
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001119func (c *Module) CoverageFiles() android.Paths {
1120 if c.linker != nil {
1121 if library, ok := c.linker.(libraryInterface); ok {
1122 return library.objs().coverageFiles
1123 }
1124 }
1125 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1126}
1127
Ivan Lozano183a3212019-10-18 14:18:45 -07001128var _ LinkableInterface = (*Module)(nil)
1129
Jiyong Park719b4462019-01-13 00:39:51 +09001130func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001131 if c.linker != nil {
1132 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001133 }
1134 return nil
1135}
1136
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001137func (c *Module) CoverageOutputFile() android.OptionalPath {
1138 if c.linker != nil {
1139 return c.linker.coverageOutputFilePath()
1140 }
1141 return android.OptionalPath{}
1142}
1143
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001144func (c *Module) RelativeInstallPath() string {
1145 if c.installer != nil {
1146 return c.installer.relativeInstallPath()
1147 }
1148 return ""
1149}
1150
Jooyung Han344d5432019-08-23 11:17:39 +09001151func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001152 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001153}
1154
Colin Cross36242852017-06-23 15:06:31 -07001155func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001156 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001157 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001158 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001159 }
1160 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001161 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001162 }
1163 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001164 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001165 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001166 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001167 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001168 }
Colin Cross16b23492016-01-06 14:41:07 -08001169 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001170 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001171 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001172 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001173 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001174 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001175 if c.fuzzer != nil {
1176 c.AddProperties(c.fuzzer.props()...)
1177 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001178 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001179 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001180 }
Justin Yun8effde42017-06-23 19:24:43 +09001181 if c.vndkdep != nil {
1182 c.AddProperties(c.vndkdep.props()...)
1183 }
Stephen Craneba090d12017-05-09 15:44:35 -07001184 if c.lto != nil {
1185 c.AddProperties(c.lto.props()...)
1186 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001187 if c.afdo != nil {
1188 c.AddProperties(c.afdo.props()...)
1189 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001190 if c.pgo != nil {
1191 c.AddProperties(c.pgo.props()...)
1192 }
Colin Crossca860ac2016-01-04 14:34:37 -08001193 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001194 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001195 }
Colin Crossc472d572015-03-17 15:06:21 -07001196
Colin Cross36242852017-06-23 15:06:31 -07001197 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001198 if c.bazelable {
1199 android.InitBazelModule(c)
1200 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001201 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001202 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001203 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001204
Colin Cross36242852017-06-23 15:06:31 -07001205 return c
Colin Crossc472d572015-03-17 15:06:21 -07001206}
1207
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001208// UseVndk() returns true if this module is built against VNDK.
1209// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001210func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001211 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001212}
1213
Colin Crossc511bc52020-04-07 16:50:32 +00001214func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001215 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1216 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001217}
1218
1219func (c *Module) UseSdk() bool {
1220 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001221 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001222 }
1223 return false
1224}
1225
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001226func (c *Module) isCoverageVariant() bool {
1227 return c.coverage.Properties.IsCoverageVariant
1228}
1229
Colin Cross95f1ca02020-10-29 20:47:22 -07001230func (c *Module) IsNdk(config android.Config) bool {
1231 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001232}
1233
Colin Cross127bb8b2020-12-16 16:46:01 -08001234func (c *Module) IsLlndk() bool {
1235 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001236}
1237
Colin Cross127bb8b2020-12-16 16:46:01 -08001238func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001239 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001240}
1241
Colin Cross1f3f1302021-04-26 18:37:44 -07001242func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001243 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001244 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001245}
1246
Colin Cross5271fea2021-04-27 13:06:04 -07001247func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1248 lib := moduleLibraryInterface(m)
1249 return lib != nil && (lib.hasVendorPublicLibrary())
1250}
1251
1252// IsVendorPublicLibrary returns true for vendor public libraries.
1253func (c *Module) IsVendorPublicLibrary() bool {
1254 return c.VendorProperties.IsVendorPublicLibrary
1255}
1256
Ivan Lozanof1868af2022-04-12 13:08:36 -04001257func (c *Module) IsVndkPrebuiltLibrary() bool {
1258 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1259 return true
1260 }
1261 return false
1262}
1263
1264func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1265 return c.Properties.SdkAndPlatformVariantVisibleToMake
1266}
1267
Ivan Lozanod7586b62021-04-01 09:49:36 -04001268func (c *Module) HasLlndkStubs() bool {
1269 lib := moduleLibraryInterface(c)
1270 return lib != nil && lib.hasLLNDKStubs()
1271}
1272
1273func (c *Module) StubsVersion() string {
1274 if lib, ok := c.linker.(versionedInterface); ok {
1275 return lib.stubsVersion()
1276 }
1277 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1278}
1279
Colin Cross127bb8b2020-12-16 16:46:01 -08001280// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1281// and does not set llndk.vendor_available: false.
1282func (c *Module) isImplementationForLLNDKPublic() bool {
1283 library, _ := c.library.(*libraryDecorator)
1284 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001285 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001286}
1287
Justin Yunfd9e8042020-12-23 18:23:14 +09001288// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001289func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001290 // Check if VNDK-core-private or VNDK-SP-private
1291 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001292 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001293 }
1294
1295 // Check if LLNDK-private
1296 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001297 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001298 }
1299
1300 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001301}
1302
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001303// IsVndk() returns true if this module has a vndk variant.
1304// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1305// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001306func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001307 if vndkdep := c.vndkdep; vndkdep != nil {
1308 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001309 }
1310 return false
1311}
1312
Yi Kong4ef54592022-02-14 20:00:10 +08001313func (c *Module) isAfdoCompile() bool {
1314 if afdo := c.afdo; afdo != nil {
1315 return afdo.Properties.AfdoTarget != nil
1316 }
1317 return false
1318}
1319
Yi Kong7e53c572018-02-14 18:16:12 +08001320func (c *Module) isPgoCompile() bool {
1321 if pgo := c.pgo; pgo != nil {
1322 return pgo.Properties.PgoCompile
1323 }
1324 return false
1325}
1326
Yi Kongc702ebd2022-08-19 16:02:45 +08001327func (c *Module) isCfi() bool {
1328 if sanitize := c.sanitize; sanitize != nil {
1329 return Bool(sanitize.Properties.Sanitize.Cfi)
1330 }
1331 return false
1332}
1333
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001334func (c *Module) isNDKStubLibrary() bool {
1335 if _, ok := c.compiler.(*stubDecorator); ok {
1336 return true
1337 }
1338 return false
1339}
1340
Ivan Lozanod7586b62021-04-01 09:49:36 -04001341func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001342 if vndkdep := c.vndkdep; vndkdep != nil {
1343 return vndkdep.isVndkSp()
1344 }
1345 return false
1346}
1347
Ivan Lozanof9e21722020-12-02 09:00:51 -05001348func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001349 if vndkdep := c.vndkdep; vndkdep != nil {
1350 return vndkdep.isVndkExt()
1351 }
1352 return false
1353}
1354
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001355func (c *Module) SubName() string {
1356 return c.Properties.SubName
1357}
1358
Ivan Lozano52767be2019-10-18 14:49:46 -07001359func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001360 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001361}
1362
Logan Chienf3511742017-10-31 18:04:35 +08001363func (c *Module) getVndkExtendsModuleName() string {
1364 if vndkdep := c.vndkdep; vndkdep != nil {
1365 return vndkdep.getVndkExtendsModuleName()
1366 }
1367 return ""
1368}
1369
Jiyong Park25fc6a92018-11-18 18:02:45 +09001370func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001371 if lib := c.library; lib != nil {
1372 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001373 }
1374 return false
1375}
1376
1377func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001378 if lib := c.library; lib != nil {
1379 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001380 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001381 return false
1382}
1383
Colin Cross0477b422020-10-13 18:43:54 -07001384// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1385// the implementation. If it is an implementation library it returns its own name.
1386func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1387 name := ctx.OtherModuleName(c)
1388 if versioned, ok := c.linker.(versionedInterface); ok {
1389 name = versioned.implementationModuleName(name)
1390 }
1391 return name
1392}
1393
Martin Stjernholm2856c662020-12-02 15:03:42 +00001394// Similar to ImplementationModuleName, but uses the Make variant of the module
1395// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1396// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1397// under the premise that the prebuilt module overrides its source counterpart
1398// if it is exposed to Make).
1399func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1400 name := c.BaseModuleName()
1401 if versioned, ok := c.linker.(versionedInterface); ok {
1402 name = versioned.implementationModuleName(name)
1403 }
1404 return name
1405}
1406
Jiyong Park7d55b612021-06-11 17:22:09 +09001407func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001408 return Bool(c.Properties.Bootstrap)
1409}
1410
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001411func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001412 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1413 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1414 return false
1415 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001416 return c.linker != nil && c.linker.nativeCoverage()
1417}
1418
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001419func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001420 if p, ok := c.linker.(SnapshotInterface); ok {
1421 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001422 }
1423 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001424}
1425
Bill Peckham945441c2020-08-31 16:07:58 -07001426func (c *Module) ExcludeFromVendorSnapshot() bool {
1427 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1428}
1429
Jose Galmesf7294582020-11-13 12:07:36 -08001430func (c *Module) ExcludeFromRecoverySnapshot() bool {
1431 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1432}
1433
Jiyong Parkf1194352019-02-25 11:05:47 +09001434func isBionic(name string) bool {
1435 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001436 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001437 return true
1438 }
1439 return false
1440}
1441
Martin Stjernholm279de572019-09-10 23:18:20 +01001442func InstallToBootstrap(name string, config android.Config) bool {
Colin Cross4c4c1be2022-02-10 11:41:18 -08001443 if name == "libclang_rt.hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001444 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001445 }
1446 return isBionic(name)
1447}
1448
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001449func (c *Module) XrefCcFiles() android.Paths {
1450 return c.kytheFiles
1451}
1452
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001453func (c *Module) isCfiAssemblySupportEnabled() bool {
1454 return c.sanitize != nil &&
1455 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1456}
1457
Inseob Kim800d1142021-06-14 12:03:51 +09001458func (c *Module) InstallInRoot() bool {
1459 return c.installer != nil && c.installer.installInRoot()
1460}
1461
Colin Crossca860ac2016-01-04 14:34:37 -08001462type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001463 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001464 moduleContextImpl
1465}
1466
Colin Cross37047f12016-12-13 17:06:13 -08001467type depsContext struct {
1468 android.BottomUpMutatorContext
1469 moduleContextImpl
1470}
1471
Colin Crossca860ac2016-01-04 14:34:37 -08001472type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001473 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001474 moduleContextImpl
1475}
1476
1477type moduleContextImpl struct {
1478 mod *Module
1479 ctx BaseModuleContext
1480}
1481
Colin Crossb98c8b02016-07-29 13:44:28 -07001482func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001483 return ctx.mod.toolchain(ctx.ctx)
1484}
1485
1486func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001487 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001488}
1489
1490func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001491 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001492}
1493
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001494func (ctx *moduleContextImpl) testBinary() bool {
1495 return ctx.mod.testBinary()
1496}
1497
Yi Kong56fc1b62022-09-06 16:24:00 +08001498func (ctx *moduleContextImpl) testLibrary() bool {
1499 return ctx.mod.testLibrary()
1500}
1501
Jiyong Park1d1119f2019-07-29 21:27:18 +09001502func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001503 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001504}
1505
Inseob Kim7f283f42020-06-01 21:53:49 +09001506func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001507 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001508}
1509
Inseob Kim1042d292020-06-01 23:23:05 +09001510func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001511 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001512}
1513
Jooyung Hanccce2f22020-03-07 03:45:53 +09001514func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001515 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001516}
1517
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001518func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001519 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001520}
1521
1522func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001523 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001524 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001525 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001526 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001527 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001528 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001529 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001530 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001531 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001532 }
1533 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001534}
1535
Jiyong Parkb35a8192020-08-10 15:59:36 +09001536func (ctx *moduleContextImpl) minSdkVersion() string {
1537 ver := ctx.mod.MinSdkVersion()
1538 if ver == "apex_inherit" && !ctx.isForPlatform() {
1539 ver = ctx.apexSdkVersion().String()
1540 }
1541 if ver == "apex_inherit" || ver == "" {
1542 ver = ctx.sdkVersion()
1543 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001544 // For crt objects, the meaning of min_sdk_version is very different from other types of
1545 // module. For them, min_sdk_version defines the oldest version that the build system will
1546 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1547 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1548 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001549 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1550 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1551 // support such an old version. The version is set to the later version in case when the
1552 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1553 // it's for an APEX.
1554 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1555 if ctx.isForPlatform() {
1556 ver = strconv.Itoa(android.FutureApiLevelInt)
1557 } else { // for apex
1558 ver = ctx.apexSdkVersion().String()
1559 if ver == "" { // in case when min_sdk_version was not set by the APEX
1560 ver = ctx.sdkVersion()
1561 }
1562 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001563 }
1564
Jiyong Parkb35a8192020-08-10 15:59:36 +09001565 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1566 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1567 minSdkVersionInt, err2 := strconv.Atoi(ver)
1568 if err == nil && err2 == nil {
1569 if sdkVersionInt < minSdkVersionInt {
1570 return strconv.Itoa(sdkVersionInt)
1571 }
1572 }
1573 return ver
1574}
1575
1576func (ctx *moduleContextImpl) isSdkVariant() bool {
1577 return ctx.mod.IsSdkVariant()
1578}
1579
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001580func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001581 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001582}
Justin Yun8effde42017-06-23 19:24:43 +09001583
Colin Cross95f1ca02020-10-29 20:47:22 -07001584func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1585 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001586}
1587
Colin Cross127bb8b2020-12-16 16:46:01 -08001588func (ctx *moduleContextImpl) IsLlndk() bool {
1589 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001590}
1591
Colin Cross127bb8b2020-12-16 16:46:01 -08001592func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1593 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001594}
1595
Colin Cross127bb8b2020-12-16 16:46:01 -08001596func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1597 return ctx.mod.isImplementationForLLNDKPublic()
1598}
1599
1600func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1601 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001602}
1603
Logan Chienf3511742017-10-31 18:04:35 +08001604func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001605 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001606}
1607
Yi Kong4ef54592022-02-14 20:00:10 +08001608func (ctx *moduleContextImpl) isAfdoCompile() bool {
1609 return ctx.mod.isAfdoCompile()
1610}
1611
Yi Kong7e53c572018-02-14 18:16:12 +08001612func (ctx *moduleContextImpl) isPgoCompile() bool {
1613 return ctx.mod.isPgoCompile()
1614}
1615
Yi Kongc702ebd2022-08-19 16:02:45 +08001616func (ctx *moduleContextImpl) isCfi() bool {
1617 return ctx.mod.isCfi()
1618}
1619
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001620func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1621 return ctx.mod.isNDKStubLibrary()
1622}
1623
Justin Yun8effde42017-06-23 19:24:43 +09001624func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001625 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001626}
1627
Ivan Lozanof9e21722020-12-02 09:00:51 -05001628func (ctx *moduleContextImpl) IsVndkExt() bool {
1629 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001630}
1631
Colin Cross5271fea2021-04-27 13:06:04 -07001632func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1633 return ctx.mod.IsVendorPublicLibrary()
1634}
1635
Vic Yangefd249e2018-11-12 20:19:56 -08001636func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001637 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001638}
1639
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001640func (ctx *moduleContextImpl) selectedStl() string {
1641 if stl := ctx.mod.stl; stl != nil {
1642 return stl.Properties.SelectedStl
1643 }
1644 return ""
1645}
1646
Ivan Lozanobd721262018-11-27 14:33:03 -08001647func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1648 return ctx.mod.linker.useClangLld(actx)
1649}
1650
Colin Crossce75d2c2016-10-06 16:12:58 -07001651func (ctx *moduleContextImpl) baseModuleName() string {
1652 return ctx.mod.ModuleBase.BaseModuleName()
1653}
1654
Logan Chienf3511742017-10-31 18:04:35 +08001655func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1656 return ctx.mod.getVndkExtendsModuleName()
1657}
1658
Logan Chiene274fc92019-12-03 11:18:32 -08001659func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001660 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001661}
1662
Colin Crosse07f2312020-08-13 11:24:56 -07001663func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001664 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001665}
1666
Dan Albertc8060532020-07-22 22:32:17 -07001667func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001668 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001669}
1670
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001671func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001672 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001673}
1674
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001675func (ctx *moduleContextImpl) nativeCoverage() bool {
1676 return ctx.mod.nativeCoverage()
1677}
1678
Colin Cross56a83212020-09-15 18:30:11 -07001679func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1680 return ctx.mod.DirectlyInAnyApex()
1681}
1682
Colin Cross95b07f22020-12-16 11:06:50 -08001683func (ctx *moduleContextImpl) isPreventInstall() bool {
1684 return ctx.mod.Properties.PreventInstall
1685}
1686
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001687func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1688 shared := &ctx.mod.sharedFlags
1689 if shared.flagsMap == nil {
1690 shared.numSharedFlags = 0
1691 shared.flagsMap = make(map[string]string)
1692 }
1693 return shared
1694}
1695
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001696func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1697 return ctx.mod.isCfiAssemblySupportEnabled()
1698}
1699
Colin Cross635c3b02016-05-18 15:37:25 -07001700func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001701 return &Module{
1702 hod: hod,
1703 multilib: multilib,
1704 }
1705}
1706
Colin Cross635c3b02016-05-18 15:37:25 -07001707func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001708 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001709 module.features = []feature{
1710 &tidyFeature{},
1711 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001712 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001713 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001714 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001715 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001716 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001717 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001718 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001719 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001720 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001721 return module
1722}
1723
Colin Crossce75d2c2016-10-06 16:12:58 -07001724func (c *Module) Prebuilt() *android.Prebuilt {
1725 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1726 return p.prebuilt()
1727 }
1728 return nil
1729}
1730
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001731func (c *Module) IsPrebuilt() bool {
1732 return c.Prebuilt() != nil
1733}
1734
Colin Crossce75d2c2016-10-06 16:12:58 -07001735func (c *Module) Name() string {
1736 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001737 if p, ok := c.linker.(interface {
1738 Name(string) string
1739 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001740 name = p.Name(name)
1741 }
1742 return name
1743}
1744
Alex Light3d673592019-01-18 14:37:31 -08001745func (c *Module) Symlinks() []string {
1746 if p, ok := c.installer.(interface {
1747 symlinkList() []string
1748 }); ok {
1749 return p.symlinkList()
1750 }
1751 return nil
1752}
1753
Roland Levillainf89cd092019-07-29 16:22:59 +01001754func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1755 test, ok := c.linker.(testPerSrc)
1756 return ok && test.isAllTestsVariation()
1757}
1758
Chris Parsons216e10a2020-07-09 17:12:52 -04001759func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001760 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001761 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001762 }); ok {
1763 return p.dataPaths()
1764 }
1765 return nil
1766}
1767
Ivan Lozanof1868af2022-04-12 13:08:36 -04001768func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001769 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1770 // "current", it will append the VNDK version to the name suffix.
1771 var vndkVersion string
1772 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001773 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001774 if c.ProductSpecific() {
1775 // If the module is product specific with 'product_specific: true',
1776 // do not add a name suffix because it is a base module.
1777 return ""
1778 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001779 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001780 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001781 } else {
1782 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001783 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001784 }
1785 if vndkVersion == "current" {
1786 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1787 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001788 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001789 // add version suffix only if the module is using different vndk version than the
1790 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001791 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001792 }
1793 return nameSuffix
1794}
1795
Ivan Lozanof1868af2022-04-12 13:08:36 -04001796func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1797 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001798
1799 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001800 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001801 }
1802
Colin Cross127bb8b2020-12-16 16:46:01 -08001803 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001804 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001805 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1806 // added for product variant only when we have vendor and product variants with core
1807 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001808 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001809 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001810 subName += vendorPublicLibrarySuffix
1811 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001812 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1813 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001814 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001815 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001816 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001817 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001818 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001819 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001820 subName += RecoverySuffix
1821 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1822 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001823 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001824 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001825 }
Inseob Kim64c43952019-08-26 16:52:35 +09001826 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001827
1828 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001829}
1830
Chris Parsonsf874e462022-05-10 13:50:12 -04001831var _ android.MixedBuildBuildable = (*Module)(nil)
1832
1833func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001834 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001835 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001836 // cc_library is a special case in bp2build; two targets are generated -- one for each
1837 // of the shared and static variants. The shared variant keeps the module name, but the
1838 // static variant uses a different suffixed name.
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001839 bazelModuleLabel = bazelLabelForStaticModule(ctx, c)
1840 } else {
1841 bazelModuleLabel = c.GetBazelLabel(ctx, c)
Chris Parsonsf874e462022-05-10 13:50:12 -04001842 }
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001843 labelNoPrebuilt := bazelModuleLabel
1844 if c.IsPrebuilt() {
1845 labelNoPrebuilt = android.RemoveOptionalPrebuiltPrefixFromBazelLabel(bazelModuleLabel)
1846 }
1847 return labelNoPrebuilt
Chris Parsonsf874e462022-05-10 13:50:12 -04001848}
1849
1850func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1851 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1852}
1853
1854func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
1855 return c.bazelHandler != nil
1856}
1857
1858func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
1859 bazelModuleLabel := c.getBazelModuleLabel(ctx)
1860
Sam Delmerico9a9f6522022-11-07 16:41:43 -05001861 bazelCtx := ctx.Config().BazelContext
1862 if ccInfo, err := bazelCtx.GetCcInfo(bazelModuleLabel, android.GetConfigKey(ctx)); err == nil {
1863 c.tidyFiles = android.PathsForBazelOut(ctx, ccInfo.TidyFiles)
1864 }
1865
Chris Parsonsf874e462022-05-10 13:50:12 -04001866 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
1867
1868 c.Properties.SubName = GetSubnameProperty(ctx, c)
1869 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1870 if !apexInfo.IsForPlatform() {
1871 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05001872 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05001873
Chris Parsonsf874e462022-05-10 13:50:12 -04001874 c.makeLinkType = GetMakeLinkType(ctx, c)
1875
1876 mctx := &moduleContext{
1877 ModuleContext: ctx,
1878 moduleContextImpl: moduleContextImpl{
1879 mod: c,
1880 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05001881 }
Chris Parsonsf874e462022-05-10 13:50:12 -04001882 mctx.ctx = mctx
1883
1884 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001885}
1886
1887func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001888 // Handle the case of a test module split by `test_per_src` mutator.
1889 //
1890 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1891 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1892 // module and return early, as this module does not produce an output file per se.
1893 if c.IsTestPerSrcAllTestsVariation() {
1894 c.outputFile = android.OptionalPath{}
1895 return
1896 }
1897
Ivan Lozanof1868af2022-04-12 13:08:36 -04001898 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001899 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1900 if !apexInfo.IsForPlatform() {
1901 c.hideApexVariantFromMake = true
1902 }
1903
Chris Parsonseefc9e62021-04-02 17:36:47 -04001904 c.makeLinkType = GetMakeLinkType(actx, c)
1905
Colin Crossca860ac2016-01-04 14:34:37 -08001906 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001907 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001908 moduleContextImpl: moduleContextImpl{
1909 mod: c,
1910 },
1911 }
1912 ctx.ctx = ctx
1913
Colin Crossf18e1102017-11-16 14:33:08 -08001914 deps := c.depsToPaths(ctx)
1915 if ctx.Failed() {
1916 return
1917 }
1918
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001919 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1920 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001921 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1922 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001923 }
1924
Colin Crossca860ac2016-01-04 14:34:37 -08001925 flags := Flags{
1926 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001927 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001928 }
Colin Crossca860ac2016-01-04 14:34:37 -08001929 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001930 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001931 }
1932 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001933 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001934 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001935 if c.stl != nil {
1936 flags = c.stl.flags(ctx, flags)
1937 }
Colin Cross16b23492016-01-06 14:41:07 -08001938 if c.sanitize != nil {
1939 flags = c.sanitize.flags(ctx, flags)
1940 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001941 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001942 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001943 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001944 if c.fuzzer != nil {
1945 flags = c.fuzzer.flags(ctx, flags)
1946 }
Stephen Craneba090d12017-05-09 15:44:35 -07001947 if c.lto != nil {
1948 flags = c.lto.flags(ctx, flags)
1949 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001950 if c.afdo != nil {
1951 flags = c.afdo.flags(ctx, flags)
1952 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001953 if c.pgo != nil {
1954 flags = c.pgo.flags(ctx, flags)
1955 }
Colin Crossca860ac2016-01-04 14:34:37 -08001956 for _, feature := range c.features {
1957 flags = feature.flags(ctx, flags)
1958 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001959 if ctx.Failed() {
1960 return
1961 }
1962
Colin Cross4af21ed2019-11-04 09:37:55 -08001963 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1964 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1965 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001966
Colin Cross4af21ed2019-11-04 09:37:55 -08001967 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001968
1969 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001970 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001971 }
1972 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001973 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001974 }
1975
Colin Cross3e5e7782022-06-17 22:17:05 +00001976 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
1977
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001978 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001979 // We need access to all the flags seen by a source file.
1980 if c.sabi != nil {
1981 flags = c.sabi.flags(ctx, flags)
1982 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001983
Colin Cross4af21ed2019-11-04 09:37:55 -08001984 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001985
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001986 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001987 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001988 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001989 if ctx.Failed() {
1990 return
1991 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001992 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07001993 c.objFiles = objs.objFiles
1994 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001995 }
1996
Colin Crossca860ac2016-01-04 14:34:37 -08001997 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001998 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001999 if ctx.Failed() {
2000 return
2001 }
Colin Cross635c3b02016-05-18 15:37:25 -07002002 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002003
Chris Parsons94a0bba2021-06-04 15:03:47 -04002004 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002005
Jose Galmes6f843bc2020-12-11 13:36:29 -08002006 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2007 // RECOVERY_SNAPSHOT_VERSION is current.
2008 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002009 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002010 i.collectHeadersForSnapshot(ctx)
2011 }
2012 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002013 }
Colin Cross5049f022015-03-18 13:28:46 -07002014
Chris Parsons94a0bba2021-06-04 15:03:47 -04002015 c.maybeInstall(ctx, apexInfo)
2016}
2017
2018func (c *Module) maybeUnhideFromMake() {
2019 // If a lib is directly included in any of the APEXes or is not available to the
2020 // platform (which is often the case when the stub is provided as a prebuilt),
2021 // unhide the stubs variant having the latest version gets visible to make. In
2022 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2023 // force anything in the make world to link against the stubs library. (unless it
2024 // is explicitly referenced via .bootstrap suffix or the module is marked with
2025 // 'bootstrap: true').
2026 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
2027 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
2028 c.IsStubs() && !c.InVendorRamdisk() {
2029 c.Properties.HideFromMake = false // unhide
2030 // Note: this is still non-installable
2031 }
2032}
2033
2034func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002035 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002036 // If the module has been specifically configure to not be installed then
2037 // hide from make as otherwise it will break when running inside make
2038 // as the output path to install will not be specified. Not all uninstallable
2039 // modules can be hidden from make as some are needed for resolving make side
2040 // dependencies.
2041 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002042 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002043 c.SkipInstall()
2044 }
2045
2046 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2047 // to allow using the outputs in a genrule.
2048 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002049 c.installer.install(ctx, c.outputFile.Path())
2050 if ctx.Failed() {
2051 return
Colin Crossca860ac2016-01-04 14:34:37 -08002052 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002053 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002054}
2055
Colin Cross0ea8ba82019-06-06 14:33:29 -07002056func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002057 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002058 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002059 }
Colin Crossca860ac2016-01-04 14:34:37 -08002060 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002061}
2062
Colin Crossca860ac2016-01-04 14:34:37 -08002063func (c *Module) begin(ctx BaseModuleContext) {
2064 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002065 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002066 }
Colin Crossca860ac2016-01-04 14:34:37 -08002067 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002068 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002069 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002070 if c.stl != nil {
2071 c.stl.begin(ctx)
2072 }
Colin Cross16b23492016-01-06 14:41:07 -08002073 if c.sanitize != nil {
2074 c.sanitize.begin(ctx)
2075 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002076 if c.coverage != nil {
2077 c.coverage.begin(ctx)
2078 }
Stephen Craneba090d12017-05-09 15:44:35 -07002079 if c.lto != nil {
2080 c.lto.begin(ctx)
2081 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002082 if c.afdo != nil {
2083 c.afdo.begin(ctx)
2084 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002085 if c.pgo != nil {
2086 c.pgo.begin(ctx)
2087 }
Dan Albert92fe7402020-07-15 13:33:30 -07002088 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002089 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002090 if err != nil {
2091 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002092 c.Properties.Sdk_version = nil
2093 } else {
2094 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002095 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002096 }
Colin Crossca860ac2016-01-04 14:34:37 -08002097}
2098
Colin Cross37047f12016-12-13 17:06:13 -08002099func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002100 deps := Deps{}
2101
2102 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002103 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002104 }
2105 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002106 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002107 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002108 if c.stl != nil {
2109 deps = c.stl.deps(ctx, deps)
2110 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002111 if c.coverage != nil {
2112 deps = c.coverage.deps(ctx, deps)
2113 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002114
Colin Crossb6715442017-10-24 11:13:31 -07002115 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2116 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2117 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2118 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2119 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2120 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002121 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002122
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002123 for _, lib := range deps.ReexportSharedLibHeaders {
2124 if !inList(lib, deps.SharedLibs) {
2125 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2126 }
2127 }
2128
2129 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002130 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2131 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 -07002132 }
2133 }
2134
Colin Cross5950f382016-12-13 12:50:57 -08002135 for _, lib := range deps.ReexportHeaderLibHeaders {
2136 if !inList(lib, deps.HeaderLibs) {
2137 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2138 }
2139 }
2140
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002141 for _, gen := range deps.ReexportGeneratedHeaders {
2142 if !inList(gen, deps.GeneratedHeaders) {
2143 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2144 }
2145 }
2146
Colin Crossc99deeb2016-04-11 15:06:20 -07002147 return deps
2148}
2149
Dan Albert7e9d2952016-08-04 13:02:36 -07002150func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002151 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002152 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002153 moduleContextImpl: moduleContextImpl{
2154 mod: c,
2155 },
2156 }
2157 ctx.ctx = ctx
2158
Colin Crossca860ac2016-01-04 14:34:37 -08002159 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002160}
2161
Jiyong Park7ed9de32018-10-15 22:25:07 +09002162// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002163func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002164 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2165 version := name[sharp+1:]
2166 libname := name[:sharp]
2167 return libname, version
2168 }
2169 return name, ""
2170}
2171
Dan Albert92fe7402020-07-15 13:33:30 -07002172func GetCrtVariations(ctx android.BottomUpMutatorContext,
2173 m LinkableInterface) []blueprint.Variation {
2174 if ctx.Os() != android.Android {
2175 return nil
2176 }
2177 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002178 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2179 minSdkVersion := m.MinSdkVersion()
2180 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2181 minSdkVersion = m.SdkVersion()
2182 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002183 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2184 if err != nil {
2185 ctx.PropertyErrorf("min_sdk_version", err.Error())
2186 }
Dan Albert92fe7402020-07-15 13:33:30 -07002187 return []blueprint.Variation{
2188 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002189 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002190 }
2191 }
2192 return []blueprint.Variation{
2193 {Mutator: "sdk", Variation: ""},
2194 }
2195}
2196
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002197func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2198 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002199
2200 variations = append([]blueprint.Variation(nil), variations...)
2201
Liz Kammer23942242022-04-08 15:41:00 -04002202 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002203 // Version is explicitly specified. i.e. libFoo#30
2204 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002205 if tag, ok := depTag.(libraryDependencyTag); ok {
2206 tag.explicitlyVersioned = true
2207 } else {
2208 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2209 }
Colin Crosse7257d22020-09-24 09:56:18 -07002210 }
Colin Crosse7257d22020-09-24 09:56:18 -07002211
Colin Cross0de8a1e2020-09-18 14:15:30 -07002212 if far {
2213 ctx.AddFarVariationDependencies(variations, depTag, name)
2214 } else {
2215 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002216 }
2217}
2218
Kiyoung Kim487689e2022-07-26 09:48:22 +09002219func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2220 apiImportInfo := multitree.ApiImportInfo{}
2221
2222 if c.Device() {
2223 var apiImportModule []blueprint.Module
2224 if actx.OtherModuleExists("api_imports") {
2225 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2226 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
2227 apiInfo := actx.OtherModuleProvider(apiImportModule[0], multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2228 apiImportInfo = apiInfo
2229 actx.SetProvider(multitree.ApiImportsProvider, apiInfo)
2230 }
2231 }
2232 }
2233
2234 return apiImportInfo
2235}
2236
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002237func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002238 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002239 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002240 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002241 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2242 // between the modules in the snapshot and the snapshot itself.
2243 var snapshotModule []blueprint.Module
2244 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2245 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2246 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2247 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2248 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002249 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002250 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2251 *snapshotInfo = &snapshot
2252 // republish the snapshot for use in later mutators on this module
2253 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002254 }
2255 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002256 if *snapshotInfo == nil {
2257 *snapshotInfo = &SnapshotInfo{}
2258 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002259 return **snapshotInfo
2260}
2261
Kiyoung Kim487689e2022-07-26 09:48:22 +09002262func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2263 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002264 return snapshot
2265 }
2266
2267 return lib
2268}
2269
2270// RewriteLibs takes a list of names of shared libraries and scans it for three types
2271// of names:
2272//
2273// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002274//
2275// For each of these, it adds the name of the prebuilt module (which will be in
2276// prebuilts/ndk) to the list of nonvariant libs.
2277//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002278// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002279//
2280// For each of these, it adds the name of the ndk_library module to the list of
2281// variant libs.
2282//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002283// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002284//
2285// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002286//
2287// The caller can then know to add the variantLibs dependencies differently from the
2288// nonvariantLibs
2289func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2290 variantLibs = []string{}
2291
2292 nonvariantLibs = []string{}
2293 for _, entry := range list {
2294 // strip #version suffix out
2295 name, _ := StubsLibNameAndVersion(entry)
2296 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002297 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002298 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2299 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2300 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002301 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002302 } else {
2303 // put name#version back
2304 nonvariantLibs = append(nonvariantLibs, entry)
2305 }
2306 }
2307 return nonvariantLibs, variantLibs
2308}
2309
Kiyoung Kim487689e2022-07-26 09:48:22 +09002310func updateDepsWithApiImports(deps Deps, apiImports multitree.ApiImportInfo) Deps {
2311 for idx, lib := range deps.SharedLibs {
2312 deps.SharedLibs[idx] = GetReplaceModuleName(lib, apiImports.SharedLibs)
2313 }
2314
2315 for idx, lib := range deps.LateSharedLibs {
2316 deps.LateSharedLibs[idx] = GetReplaceModuleName(lib, apiImports.SharedLibs)
2317 }
2318
2319 for idx, lib := range deps.RuntimeLibs {
2320 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, apiImports.SharedLibs)
2321 }
2322
Kiyoung Kim51279d32022-08-24 14:10:46 +09002323 for idx, lib := range deps.SystemSharedLibs {
2324 deps.SystemSharedLibs[idx] = GetReplaceModuleName(lib, apiImports.SharedLibs)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002325 }
Kiyoung Kim51279d32022-08-24 14:10:46 +09002326
2327 for idx, lib := range deps.ReexportSharedLibHeaders {
2328 deps.ReexportSharedLibHeaders[idx] = GetReplaceModuleName(lib, apiImports.SharedLibs)
2329 }
2330
Kiyoung Kim487689e2022-07-26 09:48:22 +09002331 return deps
2332}
2333
Colin Cross1e676be2016-10-12 14:38:15 -07002334func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002335 if !c.Enabled() {
2336 return
2337 }
2338
Colin Cross37047f12016-12-13 17:06:13 -08002339 ctx := &depsContext{
2340 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002341 moduleContextImpl: moduleContextImpl{
2342 mod: c,
2343 },
2344 }
2345 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002346
Colin Crossc99deeb2016-04-11 15:06:20 -07002347 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002348 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002349
2350 if ctx.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2351 deps = updateDepsWithApiImports(deps, apiImportInfo)
2352 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002353
Yo Chiang219968c2020-09-22 18:45:04 +08002354 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2355
Colin Crosse0edaf92021-01-11 17:31:17 -08002356 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002357
Dan Albert914449f2016-06-17 16:45:24 -07002358 variantNdkLibs := []string{}
2359 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002360 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002361 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2362 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2363 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002364
2365 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002366 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002367 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002368 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002369
Colin Cross32ec36c2016-12-15 07:39:51 -08002370 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002371 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002372 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002373 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002374 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002375
Kiyoung Kim51279d32022-08-24 14:10:46 +09002376 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim11d91082022-10-19 19:20:57 +09002377 if ctx.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2378 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2379 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002380 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002381
Spandan Das73bcafc2022-08-18 23:26:00 +00002382 if c.isNDKStubLibrary() {
2383 // ndk_headers do not have any variations
2384 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002385 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002386 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002387 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002388 } else {
2389 actx.AddVariationDependencies(nil, depTag, lib)
2390 }
2391 }
2392
Dan Albertf1d14c72020-07-30 14:32:55 -07002393 if c.isNDKStubLibrary() {
2394 // NDK stubs depend on their implementation because the ABI dumps are
2395 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002396 apiImportName := c.BaseModuleName() + multitree.GetApiImportSuffix()
2397
2398 // If original library exists as imported API, set dependency on the imported library
2399 if actx.OtherModuleExists(apiImportName) {
2400 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2401 c.ImageVariation(),
2402 blueprint.Variation{Mutator: "link", Variation: "shared"},
2403 ), stubImplementation, apiImportName)
2404 } else {
2405 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2406 c.ImageVariation(),
2407 blueprint.Variation{Mutator: "link", Variation: "shared"},
2408 ), stubImplementation, c.BaseModuleName())
2409 }
Dan Albertf1d14c72020-07-30 14:32:55 -07002410 }
2411
Jiyong Park5d1598f2019-02-25 22:14:17 +09002412 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002413 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002414
Kiyoung Kim487689e2022-07-26 09:48:22 +09002415 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002416
Jiyong Park5d1598f2019-02-25 22:14:17 +09002417 actx.AddVariationDependencies([]blueprint.Variation{
2418 {Mutator: "link", Variation: "static"},
2419 }, depTag, lib)
2420 }
2421
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002422 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002423 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002424 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002425 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002426 }
Jiyong Parke3867542020-12-03 17:28:25 +09002427 if inList(lib, deps.ExcludeLibsForApex) {
2428 depTag.excludeInApex = true
2429 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002430
Kiyoung Kim487689e2022-07-26 09:48:22 +09002431 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002432
Dan Willemsen59339a22018-07-22 21:18:45 -07002433 actx.AddVariationDependencies([]blueprint.Variation{
2434 {Mutator: "link", Variation: "static"},
2435 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002436 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002437
Jooyung Han75568392020-03-20 04:29:24 +09002438 // staticUnwinderDep is treated as staticDep for Q apexes
2439 // so that native libraries/binaries are linked with static unwinder
2440 // because Q libc doesn't have unwinder APIs
2441 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002442 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002443 actx.AddVariationDependencies([]blueprint.Variation{
2444 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002445 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002446 }
2447
Jiyong Park7ed9de32018-10-15 22:25:07 +09002448 // shared lib names without the #version suffix
2449 var sharedLibNames []string
2450
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002451 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002452 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002453 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002454 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002455 }
Jiyong Parke3867542020-12-03 17:28:25 +09002456 if inList(lib, deps.ExcludeLibsForApex) {
2457 depTag.excludeInApex = true
2458 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002459
Jiyong Park73c54ee2019-10-22 20:31:18 +09002460 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002461 sharedLibNames = append(sharedLibNames, name)
2462
Colin Crosse7257d22020-09-24 09:56:18 -07002463 variations := []blueprint.Variation{
2464 {Mutator: "link", Variation: "shared"},
2465 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002466 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002467 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002468
Colin Crossfe9acfe2021-06-14 16:13:03 -07002469 for _, lib := range deps.LateStaticLibs {
2470 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2471 actx.AddVariationDependencies([]blueprint.Variation{
2472 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002473 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002474 }
2475
Colin Cross3e5e7782022-06-17 22:17:05 +00002476 for _, lib := range deps.UnexportedStaticLibs {
2477 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2478 actx.AddVariationDependencies([]blueprint.Variation{
2479 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002480 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002481 }
2482
Jiyong Park7ed9de32018-10-15 22:25:07 +09002483 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002484 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002485 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2486 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2487 // linking against both the stubs lib and the non-stubs lib at the same time.
2488 continue
2489 }
Colin Cross6e511a92020-07-27 21:26:48 -07002490 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002491 variations := []blueprint.Variation{
2492 {Mutator: "link", Variation: "shared"},
2493 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002494 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002495 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002496
Dan Willemsen59339a22018-07-22 21:18:45 -07002497 actx.AddVariationDependencies([]blueprint.Variation{
2498 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002499 }, dataLibDepTag, deps.DataLibs...)
2500
Colin Crossc8caa062021-09-24 16:50:14 -07002501 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2502
Chris Parsons79d66a52020-06-05 17:26:16 -04002503 actx.AddVariationDependencies([]blueprint.Variation{
2504 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002505 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002506
Colin Cross68861832016-07-08 10:41:41 -07002507 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002508
2509 for _, gen := range deps.GeneratedHeaders {
2510 depTag := genHeaderDepTag
2511 if inList(gen, deps.ReexportGeneratedHeaders) {
2512 depTag = genHeaderExportDepTag
2513 }
2514 actx.AddDependency(c, depTag, gen)
2515 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002516
Dan Albert92fe7402020-07-15 13:33:30 -07002517 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002518 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002519 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002520 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002521 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002522 }
Colin Crossc465efd2021-06-11 18:00:04 -07002523 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002524 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002525 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002526 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002527 if deps.DynamicLinker != "" {
2528 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002529 }
Dan Albert914449f2016-06-17 16:45:24 -07002530
2531 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002532
2533 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002534 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002535 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002536 {Mutator: "link", Variation: "shared"},
2537 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002538
2539 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002540 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002541 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002542 {Mutator: "link", Variation: "shared"},
2543 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002544
2545 if vndkdep := c.vndkdep; vndkdep != nil {
2546 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002547 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002548 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002549 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002550 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002551 }
2552 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002553
2554 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002555}
Colin Cross21b9a242015-03-24 14:15:58 -07002556
Colin Crosse40b4ea2018-10-02 22:25:58 -07002557func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002558 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2559 c.beginMutator(ctx)
2560 }
2561}
2562
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002563// Whether a module can link to another module, taking into
2564// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002565func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002566 tag blueprint.DependencyTag) {
2567
2568 switch t := tag.(type) {
2569 case dependencyTag:
2570 if t != vndkExtDepTag {
2571 return
2572 }
2573 case libraryDependencyTag:
2574 default:
2575 return
2576 }
2577
Ivan Lozanof9e21722020-12-02 09:00:51 -05002578 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002579 // Host code is not restricted
2580 return
2581 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002582
2583 // VNDK is cc.Module supported only for now.
2584 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002585 // Though allowed dependency is limited by the image mutator,
2586 // each vendor and product module needs to check link-type
2587 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002588 if ccTo, ok := to.(*Module); ok {
2589 if ccFrom.vndkdep != nil {
2590 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2591 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002592 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002593 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002594 }
2595 return
2596 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002597 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002598 // Platform code can link to anything
2599 return
2600 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002601 if from.InRamdisk() {
2602 // Ramdisk code is not NDK
2603 return
2604 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002605 if from.InVendorRamdisk() {
2606 // Vendor ramdisk code is not NDK
2607 return
2608 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002609 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002610 // Recovery code is not NDK
2611 return
2612 }
Colin Cross31076b32020-10-23 17:22:06 -07002613 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002614 if c.NdkPrebuiltStl() {
2615 // These are allowed, but they don't set sdk_version
2616 return
2617 }
2618 if c.StubDecorator() {
2619 // These aren't real libraries, but are the stub shared libraries that are included in
2620 // the NDK.
2621 return
2622 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002623 }
Logan Chien834b9a62019-01-14 15:39:03 +08002624
Ivan Lozano52767be2019-10-18 14:49:46 -07002625 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002626 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2627 // to link to libc++ (non-NDK and without sdk_version).
2628 return
2629 }
2630
Ivan Lozano52767be2019-10-18 14:49:46 -07002631 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002632 // NDK code linking to platform code is never okay.
2633 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002634 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002635 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002636 }
2637
2638 // At this point we know we have two NDK libraries, but we need to
2639 // check that we're not linking against anything built against a higher
2640 // API level, as it is only valid to link against older or equivalent
2641 // APIs.
2642
Inseob Kim01a28722018-04-11 09:48:45 +09002643 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002644 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002645 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002646 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002647 // Current can't be linked against by anything else.
2648 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002649 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002650 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002651 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002652 if err != nil {
2653 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002654 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002655 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002656 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002657 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002658 if err != nil {
2659 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002660 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002661 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002662 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002663
Inseob Kim01a28722018-04-11 09:48:45 +09002664 if toApi > fromApi {
2665 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002666 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002667 }
2668 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002669 }
Dan Albert202fe492017-12-15 13:56:59 -08002670
2671 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002672 fromStl := from.SelectedStl()
2673 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002674 if fromStl == "" || toStl == "" {
2675 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002676 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002677 // We can be permissive with the system "STL" since it is only the C++
2678 // ABI layer, but in the future we should make sure that everyone is
2679 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002680 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002681 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002682 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2683 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002684 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002685}
2686
Jooyung Han479ca172020-10-19 18:51:07 +09002687func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2688 if c, ok := ctx.Module().(*Module); ok {
2689 ctx.VisitDirectDeps(func(dep android.Module) {
2690 depTag := ctx.OtherModuleDependencyTag(dep)
2691 ccDep, ok := dep.(LinkableInterface)
2692 if ok {
2693 checkLinkType(ctx, c, ccDep, depTag)
2694 }
2695 })
2696 }
2697}
2698
Jiyong Park5fb8c102018-04-09 12:03:06 +09002699// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002700// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2701// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002702// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002703func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2704 check := func(child, parent android.Module) bool {
2705 to, ok := child.(*Module)
2706 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002707 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002708 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002709
Jooyung Hana70f0672019-01-18 15:20:43 +09002710 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2711 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002712 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002713
Jiyong Park0474e1f2021-01-14 14:26:06 +09002714 // These dependencies are not excercised at runtime. Tracking these will give us
2715 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002716 depTag := ctx.OtherModuleDependencyTag(child)
2717 if IsHeaderDepTag(depTag) {
2718 return false
2719 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002720 if depTag == staticVariantTag {
2721 return false
2722 }
2723 if depTag == stubImplDepTag {
2724 return false
2725 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002726
Justin Yun63e9ec72020-10-29 16:49:43 +09002727 // Even if target lib has no vendor variant, keep checking dependency
2728 // graph in case it depends on vendor_available or product_available
2729 // but not double_loadable transtively.
2730 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002731 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002732 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002733
Jiyong Park0474e1f2021-01-14 14:26:06 +09002734 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2735 // one.
2736 if Bool(to.VendorProperties.Double_loadable) {
2737 return true
2738 }
2739
Ivan Lozanod7586b62021-04-01 09:49:36 -04002740 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002741 return false
2742 }
2743
Jooyung Hana70f0672019-01-18 15:20:43 +09002744 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2745 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002746 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002747 return false
2748 }
2749 if module, ok := ctx.Module().(*Module); ok {
2750 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002751 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002752 ctx.WalkDeps(check)
2753 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002754 }
2755 }
2756}
2757
Colin Crossc99deeb2016-04-11 15:06:20 -07002758// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002759func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002760 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002761
Colin Cross0de8a1e2020-09-18 14:15:30 -07002762 var directStaticDeps []StaticLibraryInfo
2763 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002764
Colin Cross0de8a1e2020-09-18 14:15:30 -07002765 reexportExporter := func(exporter FlagExporterInfo) {
2766 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2767 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2768 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2769 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2770 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002771 }
2772
Jooyung Hande34d232020-07-23 13:04:15 +09002773 // For the dependency from platform to apex, use the latest stubs
2774 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002775 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2776 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002777 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002778 }
2779
2780 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2781 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2782 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2783 // (b/144430859)
2784 c.apexSdkVersion = android.FutureApiLevel
2785 }
2786
Colin Crossd11fcda2017-10-23 17:59:01 -07002787 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002788 depName := ctx.OtherModuleName(dep)
2789 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002790
Dan Willemsen47450072021-10-19 20:24:49 -07002791 if depTag == android.DarwinUniversalVariantTag {
2792 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2793 return
2794 }
2795
Ivan Lozano52767be2019-10-18 14:49:46 -07002796 ccDep, ok := dep.(LinkableInterface)
2797 if !ok {
2798
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002799 // handling for a few module types that aren't cc Module but that are also supported
2800 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002801 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002802 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002803 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2804 genRule.GeneratedSourceFiles()...)
2805 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002806 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002807 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002808 // Support exported headers from a generated_sources dependency
2809 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002810 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002811 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002812 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002813 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002814 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002815 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002816 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002817 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002818 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2819 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002820 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002821 // 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 +09002822 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002823
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002824 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002825 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002826 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002827 }
Colin Crosscef792e2021-06-11 18:01:26 -07002828 case CrtBeginDepTag:
2829 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2830 case CrtEndDepTag:
2831 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002832 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002833 return
2834 }
2835
Colin Crossfe17f6f2019-03-28 19:30:56 -07002836 if depTag == android.ProtoPluginDepTag {
2837 return
2838 }
2839
Colin Crossd11fcda2017-10-23 17:59:01 -07002840 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002841 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2842 return
2843 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002844 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002845 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2846 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002847 return
2848 }
2849
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002850 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002851 // Skip reused objects for stub libraries, they use their own stub object file instead.
2852 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2853 // version mutator, so the stubs variant is created from the shared variant that
2854 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002855 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002856 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2857 objs := staticAnalogue.ReuseObjects
2858 depPaths.Objs = depPaths.Objs.Append(objs)
2859 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2860 reexportExporter(depExporterInfo)
2861 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002862 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002863 }
2864
Colin Cross6e511a92020-07-27 21:26:48 -07002865 linkFile := ccDep.OutputFile()
2866
2867 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2868 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002869 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002870 return
2871 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002872
Jiyong Parke3867542020-12-03 17:28:25 +09002873 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2874 return
2875 }
2876
Colin Cross0de8a1e2020-09-18 14:15:30 -07002877 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002878
Colin Cross6e511a92020-07-27 21:26:48 -07002879 var ptr *android.Paths
2880 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002881
Colin Cross6e511a92020-07-27 21:26:48 -07002882 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002883
Colin Cross6e511a92020-07-27 21:26:48 -07002884 switch {
2885 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002886 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2887 if !ctx.Config().AllowMissingDependencies() {
2888 ctx.ModuleErrorf("module %q is not a header library", depName)
2889 } else {
2890 ctx.AddMissingDependencies([]string{depName})
2891 }
2892 return
2893 }
Colin Cross6e511a92020-07-27 21:26:48 -07002894 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002895 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2896 if !ctx.Config().AllowMissingDependencies() {
2897 ctx.ModuleErrorf("module %q is not a shared library", depName)
2898 } else {
2899 ctx.AddMissingDependencies([]string{depName})
2900 }
2901 return
2902 }
Jiyong Parke3867542020-12-03 17:28:25 +09002903
Jiyong Park7d55b612021-06-11 17:22:09 +09002904 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
2905 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002906
Jiyong Park1ad8e162020-12-01 23:40:09 +09002907 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2908 // linkFile, depFile, and ptr.
2909 if c.IsStubs() {
2910 break
2911 }
2912
Colin Cross0de8a1e2020-09-18 14:15:30 -07002913 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2914 depFile = sharedLibraryInfo.TableOfContents
2915
Colin Cross6e511a92020-07-27 21:26:48 -07002916 ptr = &depPaths.SharedLibs
2917 switch libDepTag.Order {
2918 case earlyLibraryDependency:
2919 ptr = &depPaths.EarlySharedLibs
2920 depPtr = &depPaths.EarlySharedLibsDeps
2921 case normalLibraryDependency:
2922 ptr = &depPaths.SharedLibs
2923 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002924 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002925 case lateLibraryDependency:
2926 ptr = &depPaths.LateSharedLibs
2927 depPtr = &depPaths.LateSharedLibsDeps
2928 default:
2929 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002930 }
Colin Cross6e511a92020-07-27 21:26:48 -07002931 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002932 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2933 if !ctx.Config().AllowMissingDependencies() {
2934 ctx.ModuleErrorf("module %q is not a static library", depName)
2935 } else {
2936 ctx.AddMissingDependencies([]string{depName})
2937 }
2938 return
2939 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002940
2941 // Stubs lib doesn't link to the static lib dependencies. Don't set
2942 // linkFile, depFile, and ptr.
2943 if c.IsStubs() {
2944 break
2945 }
2946
Colin Cross0de8a1e2020-09-18 14:15:30 -07002947 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2948 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002949 if libDepTag.wholeStatic {
2950 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002951 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2952 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002953 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002954 // This case normally catches prebuilt static
2955 // libraries, but it can also occur when
2956 // AllowMissingDependencies is on and the
2957 // dependencies has no sources of its own
2958 // but has a whole_static_libs dependency
2959 // on a missing library. We want to depend
2960 // on the .a file so that there is something
2961 // in the dependency tree that contains the
2962 // error rule for the missing transitive
2963 // dependency.
2964 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002965 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08002966 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
2967 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07002968 } else {
2969 switch libDepTag.Order {
2970 case earlyLibraryDependency:
2971 panic(fmt.Errorf("early static libs not suppported"))
2972 case normalLibraryDependency:
2973 // static dependencies will be handled separately so they can be ordered
2974 // using transitive dependencies.
2975 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002976 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002977 case lateLibraryDependency:
2978 ptr = &depPaths.LateStaticLibs
2979 default:
2980 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002981 }
2982 }
Colin Cross3e5e7782022-06-17 22:17:05 +00002983 if libDepTag.unexportedSymbols {
2984 depPaths.LdFlags = append(depPaths.LdFlags,
2985 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
2986 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002987 }
2988
Colin Cross6e511a92020-07-27 21:26:48 -07002989 if libDepTag.static() && !libDepTag.wholeStatic {
2990 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2991 ctx.ModuleErrorf("module %q not a static library", depName)
2992 return
2993 }
Logan Chien43d34c32017-12-20 01:17:32 +08002994
Colin Cross6e511a92020-07-27 21:26:48 -07002995 // When combining coverage files for shared libraries and executables, coverage files
2996 // in static libraries act as if they were whole static libraries. The same goes for
2997 // source based Abi dump files.
2998 if c, ok := ccDep.(*Module); ok {
2999 staticLib := c.linker.(libraryInterface)
3000 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3001 staticLib.objs().coverageFiles...)
3002 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3003 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003004 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003005 // Handle non-CC modules here
3006 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003007 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003008 }
3009 }
3010
Colin Cross6e511a92020-07-27 21:26:48 -07003011 if ptr != nil {
3012 if !linkFile.Valid() {
3013 if !ctx.Config().AllowMissingDependencies() {
3014 ctx.ModuleErrorf("module %q missing output file", depName)
3015 } else {
3016 ctx.AddMissingDependencies([]string{depName})
3017 }
3018 return
3019 }
3020 *ptr = append(*ptr, linkFile.Path())
3021 }
3022
3023 if depPtr != nil {
3024 dep := depFile
3025 if !dep.Valid() {
3026 dep = linkFile
3027 }
3028 *depPtr = append(*depPtr, dep.Path())
3029 }
3030
Colin Cross0de8a1e2020-09-18 14:15:30 -07003031 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3032 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3033 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3034 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3035
3036 if libDepTag.reexportFlags {
3037 reexportExporter(depExporterInfo)
3038 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3039 // Re-exported shared library headers must be included as well since they can help us with type information
3040 // about template instantiations (instantiated from their headers).
3041 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3042 // scripts.
3043 c.sabi.Properties.ReexportedIncludes = append(
3044 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3045 }
3046
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003047 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003048 switch {
3049 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003050 c.Properties.AndroidMkHeaderLibs = append(
3051 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003052 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003053 if lib := moduleLibraryInterface(dep); lib != nil {
3054 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003055 // Add the dependency to the APEX(es) providing the library so that
3056 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07003057 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09003058 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003059 c.Properties.ApexesProvidingSharedLibs = append(
3060 c.Properties.ApexesProvidingSharedLibs, an)
3061 }
3062 }
3063 }
3064
3065 // Note: the order of libs in this list is not important because
3066 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003067 c.Properties.AndroidMkSharedLibs = append(
3068 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003069 // Record BaseLibName for snapshots.
3070 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003071 case libDepTag.static():
3072 if libDepTag.wholeStatic {
3073 c.Properties.AndroidMkWholeStaticLibs = append(
3074 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3075 } else {
3076 c.Properties.AndroidMkStaticLibs = append(
3077 c.Properties.AndroidMkStaticLibs, makeLibName)
3078 }
Justin Yun5e035862021-06-29 20:50:37 +09003079 // Record BaseLibName for snapshots.
3080 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003081 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003082 } else if !c.IsStubs() {
3083 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3084
Colin Cross6e511a92020-07-27 21:26:48 -07003085 switch depTag {
3086 case runtimeDepTag:
3087 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003088 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003089 // Record BaseLibName for snapshots.
3090 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003091 case objDepTag:
3092 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3093 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003094 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003095 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003096 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003097 case dynamicLinkerDepTag:
3098 depPaths.DynamicLinker = linkFile
3099 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003100 }
Colin Crossca860ac2016-01-04 14:34:37 -08003101 })
3102
Jeff Gaston294356f2017-09-27 17:05:30 -07003103 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003104 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3105 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3106 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003107
Colin Crossdd84e052017-05-17 13:44:16 -07003108 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003109 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003110 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3111 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003112 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003113 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3114 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003115 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003116 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003117 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003118
3119 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003120 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003121 }
Colin Crossdd84e052017-05-17 13:44:16 -07003122
Colin Crossca860ac2016-01-04 14:34:37 -08003123 return depPaths
3124}
3125
Jiyong Park7d55b612021-06-11 17:22:09 +09003126// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3127// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3128// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3129// has different level of updatability. For example, if a library foo in an APEX depends on a
3130// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3131// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3132// same APEX as foo, the non-stub variant of bar is used.
3133func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3134 depName := ctx.OtherModuleName(dep)
3135 depTag := ctx.OtherModuleDependencyTag(dep)
3136 libDepTag, ok := depTag.(libraryDependencyTag)
3137 if !ok || !libDepTag.shared() {
3138 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3139 }
3140
3141 thisModule, ok := ctx.Module().(android.ApexModule)
3142 if !ok {
3143 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3144 }
3145
3146 useVndk := false
3147 bootstrap := false
3148 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3149 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3150 } else {
3151 useVndk = linkable.UseVndk()
3152 bootstrap = linkable.Bootstrap()
3153 }
3154
3155 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3156 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3157 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
3158 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3159
3160 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
3161 useStubs := false
3162
3163 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3164 if !apexInfo.IsForPlatform() {
3165 // For platform libraries, use current version of LLNDK
3166 // If this is for use_vendor apex we will apply the same rules
3167 // of apex sdk enforcement below to choose right version.
3168 useStubs = true
3169 }
Jiyong Park9477c262021-06-22 20:23:05 +09003170 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3171 // If not building for APEX or the containing APEX allows the use of
3172 // platform APIs, use stubs only when it is from an APEX (and not from
3173 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3174 // bootstrap modules, always link to non-stub variant
Jiyong Park7d55b612021-06-11 17:22:09 +09003175 useStubs = dep.(android.ApexModule).NotInPlatform() && !bootstrap
3176 if useStubs {
3177 // Another exception: if this module is a test for an APEX, then
3178 // it is linked with the non-stub variant of a module in the APEX
3179 // as if this is part of the APEX.
3180 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3181 for _, apexContents := range testFor.ApexContents {
3182 if apexContents.DirectlyInApex(depName) {
3183 useStubs = false
3184 break
3185 }
3186 }
3187 }
3188 if useStubs {
3189 // Yet another exception: If this module and the dependency are
3190 // available to the same APEXes then skip stubs between their
3191 // platform variants. This complements the test_for case above,
3192 // which avoids the stubs on a direct APEX library dependency, by
3193 // avoiding stubs for indirect test dependencies as well.
3194 //
3195 // TODO(b/183882457): This doesn't work if the two libraries have
3196 // only partially overlapping apex_available. For that test_for
3197 // modules would need to be split into APEX variants and resolved
3198 // separately for each APEX they have access to.
3199 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3200 useStubs = false
3201 }
3202 }
3203 } else {
3204 // If building for APEX, use stubs when the parent is in any APEX that
3205 // the child is not in.
3206 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3207 }
3208
3209 // when to use (unspecified) stubs, use the latest one.
3210 if useStubs {
3211 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3212 toUse := stubs[len(stubs)-1]
3213 sharedLibraryInfo = toUse.SharedLibraryInfo
3214 depExporterInfo = toUse.FlagExporterInfo
3215 }
3216 }
3217 return sharedLibraryInfo, depExporterInfo
3218}
3219
Colin Cross0de8a1e2020-09-18 14:15:30 -07003220// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3221// to match the topological order of the dependency tree, including any static analogues of
3222// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3223// of the transitive dependencies.
3224func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3225 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3226 var staticPaths android.Paths
3227 for _, staticDep := range staticDeps {
3228 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3229 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3230 }
3231 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003232 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3233 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003234 }
3235 }
3236 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3237
3238 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3239
3240 // reorder the dependencies based on transitive dependencies
3241 staticPaths = android.FirstUniquePaths(staticPaths)
3242 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3243
3244 if len(orderedStaticPaths) != len(staticPaths) {
3245 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3246 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3247 }
3248
3249 return orderedStaticPaths, transitiveStaticLibs
3250}
3251
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003252// BaseLibName trims known prefixes and suffixes
3253func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003254 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3255 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003256 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003257 return libName
3258}
3259
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003260func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003261 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003262 ccDepModule, _ := ccDep.(*Module)
3263 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003264 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003265
Justin Yuncbca3732021-02-03 19:24:13 +09003266 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003267 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07003268 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003269 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003270 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003271
Ivan Lozanod1dec542021-05-26 15:33:11 -04003272 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003273 }
3274 }
3275
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003276 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3277 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003278 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3279 // core module instead.
3280 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003281 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003282 // The vendor and product modules in Make will have been renamed to not conflict with the
3283 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003284 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003285 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003286 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003287 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003288 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003289 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003290 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003291 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003292 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003293 } else {
3294 return libName
3295 }
3296}
3297
Colin Crossca860ac2016-01-04 14:34:37 -08003298func (c *Module) InstallInData() bool {
3299 if c.installer == nil {
3300 return false
3301 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003302 return c.installer.inData()
3303}
3304
3305func (c *Module) InstallInSanitizerDir() bool {
3306 if c.installer == nil {
3307 return false
3308 }
3309 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003310 return true
3311 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003312 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003313}
3314
Yifan Hong1b3348d2020-01-21 15:53:22 -08003315func (c *Module) InstallInRamdisk() bool {
3316 return c.InRamdisk()
3317}
3318
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003319func (c *Module) InstallInVendorRamdisk() bool {
3320 return c.InVendorRamdisk()
3321}
3322
Jiyong Parkf9332f12018-02-01 00:54:12 +09003323func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003324 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003325}
3326
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003327func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003328 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003329 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003330 return
3331 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003332 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003333}
3334
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003335func (c *Module) HostToolPath() android.OptionalPath {
3336 if c.installer == nil {
3337 return android.OptionalPath{}
3338 }
3339 return c.installer.hostToolPath()
3340}
3341
Nan Zhangd4e641b2017-07-12 12:55:28 -07003342func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3343 return c.outputFile
3344}
3345
Colin Cross41955e82019-05-29 14:40:35 -07003346func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3347 switch tag {
3348 case "":
3349 if c.outputFile.Valid() {
3350 return android.Paths{c.outputFile.Path()}, nil
3351 }
3352 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003353 case "unstripped":
3354 if c.linker != nil {
3355 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3356 }
3357 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003358 default:
3359 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003360 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003361}
3362
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003363func (c *Module) static() bool {
3364 if static, ok := c.linker.(interface {
3365 static() bool
3366 }); ok {
3367 return static.static()
3368 }
3369 return false
3370}
3371
Jiyong Park379de2f2018-12-19 02:47:14 +09003372func (c *Module) staticBinary() bool {
3373 if static, ok := c.linker.(interface {
3374 staticBinary() bool
3375 }); ok {
3376 return static.staticBinary()
3377 }
3378 return false
3379}
3380
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003381func (c *Module) testBinary() bool {
3382 if test, ok := c.linker.(interface {
3383 testBinary() bool
3384 }); ok {
3385 return test.testBinary()
3386 }
3387 return false
3388}
3389
Jingwen Chen537242c2022-08-24 11:53:27 +00003390func (c *Module) testLibrary() bool {
3391 if test, ok := c.linker.(interface {
3392 testLibrary() bool
3393 }); ok {
3394 return test.testLibrary()
3395 }
3396 return false
3397}
3398
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003399func (c *Module) benchmarkBinary() bool {
3400 if b, ok := c.linker.(interface {
3401 benchmarkBinary() bool
3402 }); ok {
3403 return b.benchmarkBinary()
3404 }
3405 return false
3406}
3407
3408func (c *Module) fuzzBinary() bool {
3409 if f, ok := c.linker.(interface {
3410 fuzzBinary() bool
3411 }); ok {
3412 return f.fuzzBinary()
3413 }
3414 return false
3415}
3416
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003417// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3418func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003419 if h, ok := c.linker.(interface {
3420 header() bool
3421 }); ok {
3422 return h.header()
3423 }
3424 return false
3425}
3426
Ivan Lozanod7586b62021-04-01 09:49:36 -04003427func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003428 if b, ok := c.linker.(interface {
3429 binary() bool
3430 }); ok {
3431 return b.binary()
3432 }
3433 return false
3434}
3435
Justin Yun5e035862021-06-29 20:50:37 +09003436func (c *Module) StaticExecutable() bool {
3437 if b, ok := c.linker.(*binaryDecorator); ok {
3438 return b.static()
3439 }
3440 return false
3441}
3442
Ivan Lozanod7586b62021-04-01 09:49:36 -04003443func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003444 if o, ok := c.linker.(interface {
3445 object() bool
3446 }); ok {
3447 return o.object()
3448 }
3449 return false
3450}
3451
Ivan Lozanof9e21722020-12-02 09:00:51 -05003452func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003453 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003454 if c.IsLlndk() {
3455 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003456 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003457 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003458 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003459 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003460 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003461 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003462 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003463 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003464 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003465 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003466 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003467 return "native:product"
3468 }
Jooyung Han38002912019-05-16 04:01:54 +09003469 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003470 } else if c.InRamdisk() {
3471 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003472 } else if c.InVendorRamdisk() {
3473 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003474 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003475 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003476 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003477 return "native:ndk:none:none"
3478 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3479 //family, link := getNdkStlFamilyAndLinkType(c)
3480 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003481 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003482 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003483 } else {
3484 return "native:platform"
3485 }
3486}
3487
Jiyong Park9d452992018-10-03 00:38:19 +09003488// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003489// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003490func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003491 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003492 // Stub libs and prebuilt libs in a versioned SDK are not
3493 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003494 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003495 } else if _, ok := c.linker.(testPerSrc); ok {
3496 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003497 }
3498 return false
3499}
3500
Jiyong Parka90ca002019-10-07 15:47:24 +09003501func (c *Module) AvailableFor(what string) bool {
3502 if linker, ok := c.linker.(interface {
3503 availableFor(string) bool
3504 }); ok {
3505 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3506 } else {
3507 return c.ApexModuleBase.AvailableFor(what)
3508 }
3509}
3510
Jiyong Park62304bb2020-04-13 16:19:48 +09003511func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003512 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003513}
3514
Paul Duffin0cb37b92020-03-04 14:52:46 +00003515func (c *Module) EverInstallable() bool {
3516 return c.installer != nil &&
3517 // Check to see whether the module is actually ever installable.
3518 c.installer.everInstallable()
3519}
3520
Ivan Lozanod7586b62021-04-01 09:49:36 -04003521func (c *Module) PreventInstall() bool {
3522 return c.Properties.PreventInstall
3523}
3524
3525func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003526 if c.library != nil {
3527 if i := c.library.installable(); i != nil {
3528 return i
3529 }
3530 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003531 return c.Properties.Installable
3532}
3533
3534func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003535 ret := c.EverInstallable() &&
3536 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003537 proptools.BoolDefault(c.Installable(), true) &&
3538 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003539
3540 // The platform variant doesn't need further condition. Apex variants however might not
3541 // be installable because it will likely to be included in the APEX and won't appear
3542 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003543 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003544 return ret
3545 }
3546
3547 // Special case for modules that are configured to be installed to /data, which includes
3548 // test modules. For these modules, both APEX and non-APEX variants are considered as
3549 // installable. This is because even the APEX variants won't be included in the APEX, but
3550 // will anyway be installed to /data/*.
3551 // See b/146995717
3552 if c.InstallInData() {
3553 return ret
3554 }
3555
3556 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003557}
3558
Logan Chien41eabe62019-04-10 13:33:58 +08003559func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3560 if c.linker != nil {
3561 if library, ok := c.linker.(*libraryDecorator); ok {
3562 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3563 }
3564 }
3565}
3566
Jiyong Park45bf82e2020-12-15 22:29:02 +09003567var _ android.ApexModule = (*Module)(nil)
3568
3569// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003570func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003571 depTag := ctx.OtherModuleDependencyTag(dep)
3572 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3573
3574 if cc, ok := dep.(*Module); ok {
3575 if cc.HasStubsVariants() {
3576 if isLibDepTag && libDepTag.shared() {
3577 // dynamic dep to a stubs lib crosses APEX boundary
3578 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003579 }
Colin Cross6e511a92020-07-27 21:26:48 -07003580 if IsRuntimeDepTag(depTag) {
3581 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003582 return false
3583 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003584 }
Zhijun Heec285872021-04-24 10:47:08 -07003585 if cc.IsLlndk() {
3586 return false
3587 }
Colin Crossaac32222020-07-29 12:51:56 -07003588 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003589 // shared_lib dependency from a static lib is considered as crossing
3590 // the APEX boundary because the dependency doesn't actually is
3591 // linked; the dependency is used only during the compilation phase.
3592 return false
3593 }
Jiyong Parke3867542020-12-03 17:28:25 +09003594
3595 if isLibDepTag && libDepTag.excludeInApex {
3596 return false
3597 }
Colin Cross6e511a92020-07-27 21:26:48 -07003598 }
Colin Crossc1b36442021-05-06 13:42:48 -07003599 if depTag == stubImplDepTag {
3600 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003601 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003602 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003603 if depTag == staticVariantTag {
3604 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3605 // actually mean that the static lib (and its dependencies) are copied into the
3606 // APEX.
3607 return false
3608 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003609 return true
3610}
3611
Jiyong Park45bf82e2020-12-15 22:29:02 +09003612// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003613func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3614 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003615 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3616 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3617 return nil
3618 }
Jooyung Han749dc692020-04-15 11:03:39 +09003619 // We don't check for prebuilt modules
3620 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3621 return nil
3622 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003623
Jooyung Han749dc692020-04-15 11:03:39 +09003624 minSdkVersion := c.MinSdkVersion()
3625 if minSdkVersion == "apex_inherit" {
3626 return nil
3627 }
3628 if minSdkVersion == "" {
3629 // JNI libs within APK-in-APEX fall into here
3630 // Those are okay to set sdk_version instead
3631 // We don't have to check if this is a SDK variant because
3632 // non-SDK variant resets sdk_version, which works too.
3633 minSdkVersion = c.SdkVersion()
3634 }
Dan Albertc8060532020-07-22 22:32:17 -07003635 if minSdkVersion == "" {
3636 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3637 }
3638 // Not using nativeApiLevelFromUser because the context here is not
3639 // necessarily a native context.
3640 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003641 if err != nil {
3642 return err
3643 }
Dan Albertc8060532020-07-22 22:32:17 -07003644
Colin Cross8ca61c12022-10-06 21:00:14 -07003645 // A dependency only needs to support a min_sdk_version at least
3646 // as high as the api level that the architecture was introduced in.
3647 // This allows introducing new architectures in the platform that
3648 // need to be included in apexes that normally require an older
3649 // min_sdk_version.
3650 minApiForArch := minApiForArch(ctx, c.Target().Arch.ArchType)
3651 if sdkVersion.LessThan(minApiForArch) {
3652 sdkVersion = minApiForArch
3653 }
3654
Dan Albertc8060532020-07-22 22:32:17 -07003655 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003656 return fmt.Errorf("newer SDK(%v)", ver)
3657 }
3658 return nil
3659}
3660
Paul Duffinb5769c12021-05-12 16:16:51 +01003661// Implements android.ApexModule
3662func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3663 // stub libraries and native bridge libraries are always available to platform
3664 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3665}
3666
Jooyung Han91f92032022-02-04 12:36:33 +09003667// Overrides android.ApexModuleBase.UniqueApexVariations
3668func (c *Module) UniqueApexVariations() bool {
3669 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3670 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3671 // variation of the VNDK lib because APEX variations are merged/grouped.
3672 return c.UseVndk() && c.IsVndk()
3673}
3674
Inseob Kima1888ce2022-10-04 14:42:02 +09003675func (c *Module) overriddenModules() []string {
3676 if o, ok := c.linker.(overridable); ok {
3677 return o.overriddenModules()
3678 }
3679 return nil
3680}
3681
Rob Seymour925aa092021-08-10 20:42:03 +00003682var _ snapshot.RelativeInstallPath = (*Module)(nil)
3683
Liz Kammer35ca77e2021-12-22 15:31:40 -05003684type moduleType int
3685
3686const (
3687 unknownType moduleType = iota
3688 binary
3689 object
3690 fullLibrary
3691 staticLibrary
3692 sharedLibrary
3693 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003694 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003695 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003696)
3697
3698func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003699 if c.testBinary() {
3700 // testBinary is also a binary, so this comes before the c.Binary()
3701 // conditional. A testBinary has additional implicit dependencies and
3702 // other test-only semantics.
3703 return testBin
3704 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003705 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003706 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003707 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003708 } else if c.testLibrary() {
3709 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3710 // will let them add implicit compile deps on gtest, for example.
3711 //
3712 // For now, treat them as regular shared libraries.
3713 return sharedLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003714 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003715 static := false
3716 shared := false
3717 if library, ok := c.linker.(*libraryDecorator); ok {
3718 static = library.MutatedProperties.BuildStatic
3719 shared = library.MutatedProperties.BuildShared
3720 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3721 static = library.MutatedProperties.BuildStatic
3722 shared = library.MutatedProperties.BuildShared
3723 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003724 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003725 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003726 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003727 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003728 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003729 return staticLibrary
3730 }
3731 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003732 } else if c.isNDKStubLibrary() {
3733 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003734 }
3735 return unknownType
3736}
3737
3738// ConvertWithBp2build converts Module to Bazel for bp2build.
3739func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
3740 prebuilt := c.IsPrebuilt()
3741 switch c.typ() {
3742 case binary:
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxb12ff592022-09-01 15:04:04 +00003743 if prebuilt {
3744 prebuiltBinaryBp2Build(ctx, c)
3745 } else {
Jingwen Chen537242c2022-08-24 11:53:27 +00003746 binaryBp2build(ctx, c)
3747 }
3748 case testBin:
3749 if !prebuilt {
3750 testBinaryBp2build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003751 }
3752 case object:
3753 if !prebuilt {
3754 objectBp2Build(ctx, c)
3755 }
3756 case fullLibrary:
3757 if !prebuilt {
3758 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003759 } else {
3760 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003761 }
3762 case headerLibrary:
3763 libraryHeadersBp2Build(ctx, c)
3764 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05003765 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003766 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003767 } else {
3768 sharedOrStaticLibraryBp2Build(ctx, c, true)
3769 }
3770 case sharedLibrary:
3771 if prebuilt {
3772 prebuiltLibrarySharedBp2Build(ctx, c)
3773 } else {
3774 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003775 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00003776 }
3777}
3778
3779var _ android.ApiProvider = (*Module)(nil)
3780
3781func (c *Module) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) {
Spandan Das4238c652022-09-09 01:38:47 +00003782 if c.IsPrebuilt() {
3783 return
3784 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00003785 switch c.typ() {
Spandan Das4238c652022-09-09 01:38:47 +00003786 case fullLibrary:
3787 apiContributionBp2Build(ctx, c)
3788 case sharedLibrary:
3789 apiContributionBp2Build(ctx, c)
3790 case headerLibrary:
3791 // Aggressively generate api targets for all header modules
3792 // This is necessary since the header module does not know if it is a dep of API surface stub library
3793 apiLibraryHeadersBp2Build(ctx, c)
Spandan Das1278c2c2022-08-19 18:17:28 +00003794 case ndkLibrary:
3795 ndkLibraryBp2build(ctx, c)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003796 }
3797}
3798
Colin Crosscfad1192015-11-02 16:43:11 -08003799// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003800type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003801 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003802 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003803 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003804}
3805
Patrice Arrudac249c712019-03-19 17:00:29 -07003806// cc_defaults provides a set of properties that can be inherited by other cc
3807// modules. A module can use the properties from a cc_defaults using
3808// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3809// merged (when possible) by prepending the default module's values to the
3810// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003811func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003812 return DefaultsFactory()
3813}
3814
Colin Cross36242852017-06-23 15:06:31 -07003815func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003816 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003817
Colin Cross36242852017-06-23 15:06:31 -07003818 module.AddProperties(props...)
3819 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003820 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003821 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003822 &BaseCompilerProperties{},
3823 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003824 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003825 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003826 &StaticProperties{},
3827 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003828 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003829 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003830 &TestLinkerProperties{},
3831 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003832 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003833 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003834 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003835 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003836 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003837 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003838 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003839 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003840 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003841 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003842 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003843 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003844 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003845 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003846 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003847 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3848 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003849 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003850 )
Colin Crosscfad1192015-11-02 16:43:11 -08003851
Jooyung Hancc372c52019-09-25 15:18:44 +09003852 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003853
3854 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003855}
3856
Jiyong Park2286afd2020-06-16 21:58:53 +09003857func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003858 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003859}
3860
Kiyoung Kim51279d32022-08-24 14:10:46 +09003861func (c *Module) isImportedApiLibrary() bool {
3862 _, ok := c.linker.(*apiLibraryDecorator)
3863 return ok
3864}
3865
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003866func kytheExtractAllFactory() android.Singleton {
3867 return &kytheExtractAllSingleton{}
3868}
3869
3870type kytheExtractAllSingleton struct {
3871}
3872
3873func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3874 var xrefTargets android.Paths
3875 ctx.VisitAllModules(func(module android.Module) {
3876 if ccModule, ok := module.(xref); ok {
3877 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3878 }
3879 })
3880 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3881 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003882 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003883 }
3884}
3885
Jihoon Kangf78a8902022-09-01 22:47:07 +00003886func (c *Module) Partition() string {
3887 if p, ok := c.installer.(interface {
3888 getPartition() string
3889 }); ok {
3890 return p.getPartition()
3891 }
3892 return ""
3893}
3894
Colin Cross06a931b2015-10-28 17:23:31 -07003895var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003896var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003897var BoolPtr = proptools.BoolPtr
3898var String = proptools.String
3899var StringPtr = proptools.StringPtr