blob: 2ff5bbacc17564eca9c5d13eb85e8697d86cf5ce [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
Alan Stokes73feba32022-11-14 12:21:24 +00001384func (c *Module) IsStubsImplementationRequired() bool {
1385 if lib := c.library; lib != nil {
1386 return lib.isStubsImplementationRequired()
1387 }
1388 return false
1389}
1390
Colin Cross0477b422020-10-13 18:43:54 -07001391// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1392// the implementation. If it is an implementation library it returns its own name.
1393func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1394 name := ctx.OtherModuleName(c)
1395 if versioned, ok := c.linker.(versionedInterface); ok {
1396 name = versioned.implementationModuleName(name)
1397 }
1398 return name
1399}
1400
Martin Stjernholm2856c662020-12-02 15:03:42 +00001401// Similar to ImplementationModuleName, but uses the Make variant of the module
1402// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1403// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1404// under the premise that the prebuilt module overrides its source counterpart
1405// if it is exposed to Make).
1406func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1407 name := c.BaseModuleName()
1408 if versioned, ok := c.linker.(versionedInterface); ok {
1409 name = versioned.implementationModuleName(name)
1410 }
1411 return name
1412}
1413
Jiyong Park7d55b612021-06-11 17:22:09 +09001414func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001415 return Bool(c.Properties.Bootstrap)
1416}
1417
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001418func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001419 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1420 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1421 return false
1422 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001423 return c.linker != nil && c.linker.nativeCoverage()
1424}
1425
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001426func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001427 if p, ok := c.linker.(SnapshotInterface); ok {
1428 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001429 }
1430 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001431}
1432
Bill Peckham945441c2020-08-31 16:07:58 -07001433func (c *Module) ExcludeFromVendorSnapshot() bool {
1434 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1435}
1436
Jose Galmesf7294582020-11-13 12:07:36 -08001437func (c *Module) ExcludeFromRecoverySnapshot() bool {
1438 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1439}
1440
Jiyong Parkf1194352019-02-25 11:05:47 +09001441func isBionic(name string) bool {
1442 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001443 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001444 return true
1445 }
1446 return false
1447}
1448
Martin Stjernholm279de572019-09-10 23:18:20 +01001449func InstallToBootstrap(name string, config android.Config) bool {
Colin Cross4c4c1be2022-02-10 11:41:18 -08001450 if name == "libclang_rt.hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001451 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001452 }
1453 return isBionic(name)
1454}
1455
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001456func (c *Module) XrefCcFiles() android.Paths {
1457 return c.kytheFiles
1458}
1459
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001460func (c *Module) isCfiAssemblySupportEnabled() bool {
1461 return c.sanitize != nil &&
1462 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1463}
1464
Inseob Kim800d1142021-06-14 12:03:51 +09001465func (c *Module) InstallInRoot() bool {
1466 return c.installer != nil && c.installer.installInRoot()
1467}
1468
Colin Crossca860ac2016-01-04 14:34:37 -08001469type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001470 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001471 moduleContextImpl
1472}
1473
Colin Cross37047f12016-12-13 17:06:13 -08001474type depsContext struct {
1475 android.BottomUpMutatorContext
1476 moduleContextImpl
1477}
1478
Colin Crossca860ac2016-01-04 14:34:37 -08001479type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001480 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001481 moduleContextImpl
1482}
1483
1484type moduleContextImpl struct {
1485 mod *Module
1486 ctx BaseModuleContext
1487}
1488
Colin Crossb98c8b02016-07-29 13:44:28 -07001489func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001490 return ctx.mod.toolchain(ctx.ctx)
1491}
1492
1493func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001494 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001495}
1496
1497func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001498 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001499}
1500
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001501func (ctx *moduleContextImpl) testBinary() bool {
1502 return ctx.mod.testBinary()
1503}
1504
Yi Kong56fc1b62022-09-06 16:24:00 +08001505func (ctx *moduleContextImpl) testLibrary() bool {
1506 return ctx.mod.testLibrary()
1507}
1508
Jiyong Park1d1119f2019-07-29 21:27:18 +09001509func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001510 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001511}
1512
Inseob Kim7f283f42020-06-01 21:53:49 +09001513func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001514 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001515}
1516
Inseob Kim1042d292020-06-01 23:23:05 +09001517func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001518 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001519}
1520
Jooyung Hanccce2f22020-03-07 03:45:53 +09001521func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001522 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001523}
1524
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001525func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001526 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001527}
1528
1529func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001530 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001531 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001532 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001533 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001534 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001535 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001536 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001537 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001538 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001539 }
1540 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001541}
1542
Jiyong Parkb35a8192020-08-10 15:59:36 +09001543func (ctx *moduleContextImpl) minSdkVersion() string {
1544 ver := ctx.mod.MinSdkVersion()
1545 if ver == "apex_inherit" && !ctx.isForPlatform() {
1546 ver = ctx.apexSdkVersion().String()
1547 }
1548 if ver == "apex_inherit" || ver == "" {
1549 ver = ctx.sdkVersion()
1550 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001551 // For crt objects, the meaning of min_sdk_version is very different from other types of
1552 // module. For them, min_sdk_version defines the oldest version that the build system will
1553 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1554 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1555 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001556 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1557 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1558 // support such an old version. The version is set to the later version in case when the
1559 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1560 // it's for an APEX.
1561 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1562 if ctx.isForPlatform() {
1563 ver = strconv.Itoa(android.FutureApiLevelInt)
1564 } else { // for apex
1565 ver = ctx.apexSdkVersion().String()
1566 if ver == "" { // in case when min_sdk_version was not set by the APEX
1567 ver = ctx.sdkVersion()
1568 }
1569 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001570 }
1571
Jiyong Parkb35a8192020-08-10 15:59:36 +09001572 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1573 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1574 minSdkVersionInt, err2 := strconv.Atoi(ver)
1575 if err == nil && err2 == nil {
1576 if sdkVersionInt < minSdkVersionInt {
1577 return strconv.Itoa(sdkVersionInt)
1578 }
1579 }
1580 return ver
1581}
1582
1583func (ctx *moduleContextImpl) isSdkVariant() bool {
1584 return ctx.mod.IsSdkVariant()
1585}
1586
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001587func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001588 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001589}
Justin Yun8effde42017-06-23 19:24:43 +09001590
Colin Cross95f1ca02020-10-29 20:47:22 -07001591func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1592 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001593}
1594
Colin Cross127bb8b2020-12-16 16:46:01 -08001595func (ctx *moduleContextImpl) IsLlndk() bool {
1596 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001597}
1598
Colin Cross127bb8b2020-12-16 16:46:01 -08001599func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1600 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001601}
1602
Colin Cross127bb8b2020-12-16 16:46:01 -08001603func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1604 return ctx.mod.isImplementationForLLNDKPublic()
1605}
1606
1607func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1608 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001609}
1610
Logan Chienf3511742017-10-31 18:04:35 +08001611func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001612 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001613}
1614
Yi Kong4ef54592022-02-14 20:00:10 +08001615func (ctx *moduleContextImpl) isAfdoCompile() bool {
1616 return ctx.mod.isAfdoCompile()
1617}
1618
Yi Kong7e53c572018-02-14 18:16:12 +08001619func (ctx *moduleContextImpl) isPgoCompile() bool {
1620 return ctx.mod.isPgoCompile()
1621}
1622
Yi Kongc702ebd2022-08-19 16:02:45 +08001623func (ctx *moduleContextImpl) isCfi() bool {
1624 return ctx.mod.isCfi()
1625}
1626
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001627func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1628 return ctx.mod.isNDKStubLibrary()
1629}
1630
Justin Yun8effde42017-06-23 19:24:43 +09001631func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001632 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001633}
1634
Ivan Lozanof9e21722020-12-02 09:00:51 -05001635func (ctx *moduleContextImpl) IsVndkExt() bool {
1636 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001637}
1638
Colin Cross5271fea2021-04-27 13:06:04 -07001639func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1640 return ctx.mod.IsVendorPublicLibrary()
1641}
1642
Vic Yangefd249e2018-11-12 20:19:56 -08001643func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001644 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001645}
1646
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001647func (ctx *moduleContextImpl) selectedStl() string {
1648 if stl := ctx.mod.stl; stl != nil {
1649 return stl.Properties.SelectedStl
1650 }
1651 return ""
1652}
1653
Ivan Lozanobd721262018-11-27 14:33:03 -08001654func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1655 return ctx.mod.linker.useClangLld(actx)
1656}
1657
Colin Crossce75d2c2016-10-06 16:12:58 -07001658func (ctx *moduleContextImpl) baseModuleName() string {
1659 return ctx.mod.ModuleBase.BaseModuleName()
1660}
1661
Logan Chienf3511742017-10-31 18:04:35 +08001662func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1663 return ctx.mod.getVndkExtendsModuleName()
1664}
1665
Logan Chiene274fc92019-12-03 11:18:32 -08001666func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001667 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001668}
1669
Colin Crosse07f2312020-08-13 11:24:56 -07001670func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001671 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001672}
1673
Dan Albertc8060532020-07-22 22:32:17 -07001674func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001675 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001676}
1677
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001678func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001679 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001680}
1681
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001682func (ctx *moduleContextImpl) nativeCoverage() bool {
1683 return ctx.mod.nativeCoverage()
1684}
1685
Colin Cross56a83212020-09-15 18:30:11 -07001686func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1687 return ctx.mod.DirectlyInAnyApex()
1688}
1689
Colin Cross95b07f22020-12-16 11:06:50 -08001690func (ctx *moduleContextImpl) isPreventInstall() bool {
1691 return ctx.mod.Properties.PreventInstall
1692}
1693
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001694func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1695 shared := &ctx.mod.sharedFlags
1696 if shared.flagsMap == nil {
1697 shared.numSharedFlags = 0
1698 shared.flagsMap = make(map[string]string)
1699 }
1700 return shared
1701}
1702
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001703func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1704 return ctx.mod.isCfiAssemblySupportEnabled()
1705}
1706
Colin Cross635c3b02016-05-18 15:37:25 -07001707func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001708 return &Module{
1709 hod: hod,
1710 multilib: multilib,
1711 }
1712}
1713
Colin Cross635c3b02016-05-18 15:37:25 -07001714func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001715 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001716 module.features = []feature{
1717 &tidyFeature{},
1718 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001719 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001720 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001721 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001722 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001723 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001724 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001725 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001726 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001727 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001728 return module
1729}
1730
Colin Crossce75d2c2016-10-06 16:12:58 -07001731func (c *Module) Prebuilt() *android.Prebuilt {
1732 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1733 return p.prebuilt()
1734 }
1735 return nil
1736}
1737
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001738func (c *Module) IsPrebuilt() bool {
1739 return c.Prebuilt() != nil
1740}
1741
Colin Crossce75d2c2016-10-06 16:12:58 -07001742func (c *Module) Name() string {
1743 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001744 if p, ok := c.linker.(interface {
1745 Name(string) string
1746 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001747 name = p.Name(name)
1748 }
1749 return name
1750}
1751
Alex Light3d673592019-01-18 14:37:31 -08001752func (c *Module) Symlinks() []string {
1753 if p, ok := c.installer.(interface {
1754 symlinkList() []string
1755 }); ok {
1756 return p.symlinkList()
1757 }
1758 return nil
1759}
1760
Roland Levillainf89cd092019-07-29 16:22:59 +01001761func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1762 test, ok := c.linker.(testPerSrc)
1763 return ok && test.isAllTestsVariation()
1764}
1765
Chris Parsons216e10a2020-07-09 17:12:52 -04001766func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001767 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001768 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001769 }); ok {
1770 return p.dataPaths()
1771 }
1772 return nil
1773}
1774
Ivan Lozanof1868af2022-04-12 13:08:36 -04001775func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001776 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1777 // "current", it will append the VNDK version to the name suffix.
1778 var vndkVersion string
1779 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001780 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001781 if c.ProductSpecific() {
1782 // If the module is product specific with 'product_specific: true',
1783 // do not add a name suffix because it is a base module.
1784 return ""
1785 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001786 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001787 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001788 } else {
1789 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001790 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001791 }
1792 if vndkVersion == "current" {
1793 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1794 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001795 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001796 // add version suffix only if the module is using different vndk version than the
1797 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001798 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001799 }
1800 return nameSuffix
1801}
1802
Ivan Lozanof1868af2022-04-12 13:08:36 -04001803func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1804 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001805
1806 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001807 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001808 }
1809
Colin Cross127bb8b2020-12-16 16:46:01 -08001810 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001811 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001812 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1813 // added for product variant only when we have vendor and product variants with core
1814 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001815 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001816 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001817 subName += vendorPublicLibrarySuffix
1818 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001819 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1820 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001821 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001822 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001823 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001824 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001825 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001826 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001827 subName += RecoverySuffix
1828 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1829 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001830 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001831 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001832 }
Inseob Kim64c43952019-08-26 16:52:35 +09001833 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001834
1835 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001836}
1837
Chris Parsonsf874e462022-05-10 13:50:12 -04001838var _ android.MixedBuildBuildable = (*Module)(nil)
1839
1840func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001841 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001842 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001843 // cc_library is a special case in bp2build; two targets are generated -- one for each
1844 // of the shared and static variants. The shared variant keeps the module name, but the
1845 // static variant uses a different suffixed name.
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001846 bazelModuleLabel = bazelLabelForStaticModule(ctx, c)
1847 } else {
1848 bazelModuleLabel = c.GetBazelLabel(ctx, c)
Chris Parsonsf874e462022-05-10 13:50:12 -04001849 }
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001850 labelNoPrebuilt := bazelModuleLabel
1851 if c.IsPrebuilt() {
1852 labelNoPrebuilt = android.RemoveOptionalPrebuiltPrefixFromBazelLabel(bazelModuleLabel)
1853 }
1854 return labelNoPrebuilt
Chris Parsonsf874e462022-05-10 13:50:12 -04001855}
1856
1857func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1858 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1859}
1860
1861func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
1862 return c.bazelHandler != nil
1863}
1864
1865func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
1866 bazelModuleLabel := c.getBazelModuleLabel(ctx)
1867
Sam Delmerico9a9f6522022-11-07 16:41:43 -05001868 bazelCtx := ctx.Config().BazelContext
1869 if ccInfo, err := bazelCtx.GetCcInfo(bazelModuleLabel, android.GetConfigKey(ctx)); err == nil {
1870 c.tidyFiles = android.PathsForBazelOut(ctx, ccInfo.TidyFiles)
1871 }
1872
Chris Parsonsf874e462022-05-10 13:50:12 -04001873 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
1874
1875 c.Properties.SubName = GetSubnameProperty(ctx, c)
1876 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1877 if !apexInfo.IsForPlatform() {
1878 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05001879 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05001880
Chris Parsonsf874e462022-05-10 13:50:12 -04001881 c.makeLinkType = GetMakeLinkType(ctx, c)
1882
1883 mctx := &moduleContext{
1884 ModuleContext: ctx,
1885 moduleContextImpl: moduleContextImpl{
1886 mod: c,
1887 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05001888 }
Chris Parsonsf874e462022-05-10 13:50:12 -04001889 mctx.ctx = mctx
1890
1891 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001892}
1893
1894func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001895 // Handle the case of a test module split by `test_per_src` mutator.
1896 //
1897 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1898 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1899 // module and return early, as this module does not produce an output file per se.
1900 if c.IsTestPerSrcAllTestsVariation() {
1901 c.outputFile = android.OptionalPath{}
1902 return
1903 }
1904
Ivan Lozanof1868af2022-04-12 13:08:36 -04001905 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001906 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1907 if !apexInfo.IsForPlatform() {
1908 c.hideApexVariantFromMake = true
1909 }
1910
Chris Parsonseefc9e62021-04-02 17:36:47 -04001911 c.makeLinkType = GetMakeLinkType(actx, c)
1912
Colin Crossca860ac2016-01-04 14:34:37 -08001913 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001914 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001915 moduleContextImpl: moduleContextImpl{
1916 mod: c,
1917 },
1918 }
1919 ctx.ctx = ctx
1920
Colin Crossf18e1102017-11-16 14:33:08 -08001921 deps := c.depsToPaths(ctx)
1922 if ctx.Failed() {
1923 return
1924 }
1925
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001926 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1927 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001928 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1929 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001930 }
1931
Colin Crossca860ac2016-01-04 14:34:37 -08001932 flags := Flags{
1933 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001934 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001935 }
Colin Crossca860ac2016-01-04 14:34:37 -08001936 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001937 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001938 }
1939 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001940 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001941 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001942 if c.stl != nil {
1943 flags = c.stl.flags(ctx, flags)
1944 }
Colin Cross16b23492016-01-06 14:41:07 -08001945 if c.sanitize != nil {
1946 flags = c.sanitize.flags(ctx, flags)
1947 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001948 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001949 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001950 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001951 if c.fuzzer != nil {
1952 flags = c.fuzzer.flags(ctx, flags)
1953 }
Stephen Craneba090d12017-05-09 15:44:35 -07001954 if c.lto != nil {
1955 flags = c.lto.flags(ctx, flags)
1956 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001957 if c.afdo != nil {
1958 flags = c.afdo.flags(ctx, flags)
1959 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001960 if c.pgo != nil {
1961 flags = c.pgo.flags(ctx, flags)
1962 }
Colin Crossca860ac2016-01-04 14:34:37 -08001963 for _, feature := range c.features {
1964 flags = feature.flags(ctx, flags)
1965 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001966 if ctx.Failed() {
1967 return
1968 }
1969
Colin Cross4af21ed2019-11-04 09:37:55 -08001970 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1971 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1972 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001973
Colin Cross4af21ed2019-11-04 09:37:55 -08001974 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001975
1976 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001977 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001978 }
1979 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001980 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001981 }
1982
Colin Cross3e5e7782022-06-17 22:17:05 +00001983 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
1984
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001985 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001986 // We need access to all the flags seen by a source file.
1987 if c.sabi != nil {
1988 flags = c.sabi.flags(ctx, flags)
1989 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001990
Colin Cross4af21ed2019-11-04 09:37:55 -08001991 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001992
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001993 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001994 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001995 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001996 if ctx.Failed() {
1997 return
1998 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001999 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002000 c.objFiles = objs.objFiles
2001 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002002 }
2003
Colin Crossca860ac2016-01-04 14:34:37 -08002004 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002005 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002006 if ctx.Failed() {
2007 return
2008 }
Colin Cross635c3b02016-05-18 15:37:25 -07002009 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002010
Chris Parsons94a0bba2021-06-04 15:03:47 -04002011 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002012
Jose Galmes6f843bc2020-12-11 13:36:29 -08002013 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2014 // RECOVERY_SNAPSHOT_VERSION is current.
2015 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002016 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002017 i.collectHeadersForSnapshot(ctx)
2018 }
2019 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002020 }
Colin Cross5049f022015-03-18 13:28:46 -07002021
Chris Parsons94a0bba2021-06-04 15:03:47 -04002022 c.maybeInstall(ctx, apexInfo)
2023}
2024
2025func (c *Module) maybeUnhideFromMake() {
2026 // If a lib is directly included in any of the APEXes or is not available to the
2027 // platform (which is often the case when the stub is provided as a prebuilt),
2028 // unhide the stubs variant having the latest version gets visible to make. In
2029 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2030 // force anything in the make world to link against the stubs library. (unless it
2031 // is explicitly referenced via .bootstrap suffix or the module is marked with
2032 // 'bootstrap: true').
2033 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
2034 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
2035 c.IsStubs() && !c.InVendorRamdisk() {
2036 c.Properties.HideFromMake = false // unhide
2037 // Note: this is still non-installable
2038 }
2039}
2040
2041func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002042 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002043 // If the module has been specifically configure to not be installed then
2044 // hide from make as otherwise it will break when running inside make
2045 // as the output path to install will not be specified. Not all uninstallable
2046 // modules can be hidden from make as some are needed for resolving make side
2047 // dependencies.
2048 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002049 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002050 c.SkipInstall()
2051 }
2052
2053 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2054 // to allow using the outputs in a genrule.
2055 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002056 c.installer.install(ctx, c.outputFile.Path())
2057 if ctx.Failed() {
2058 return
Colin Crossca860ac2016-01-04 14:34:37 -08002059 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002060 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002061}
2062
Colin Cross0ea8ba82019-06-06 14:33:29 -07002063func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002064 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002065 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002066 }
Colin Crossca860ac2016-01-04 14:34:37 -08002067 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002068}
2069
Colin Crossca860ac2016-01-04 14:34:37 -08002070func (c *Module) begin(ctx BaseModuleContext) {
2071 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002072 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002073 }
Colin Crossca860ac2016-01-04 14:34:37 -08002074 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002075 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002076 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002077 if c.stl != nil {
2078 c.stl.begin(ctx)
2079 }
Colin Cross16b23492016-01-06 14:41:07 -08002080 if c.sanitize != nil {
2081 c.sanitize.begin(ctx)
2082 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002083 if c.coverage != nil {
2084 c.coverage.begin(ctx)
2085 }
Stephen Craneba090d12017-05-09 15:44:35 -07002086 if c.lto != nil {
2087 c.lto.begin(ctx)
2088 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002089 if c.afdo != nil {
2090 c.afdo.begin(ctx)
2091 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002092 if c.pgo != nil {
2093 c.pgo.begin(ctx)
2094 }
Dan Albert92fe7402020-07-15 13:33:30 -07002095 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002096 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002097 if err != nil {
2098 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002099 c.Properties.Sdk_version = nil
2100 } else {
2101 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002102 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002103 }
Colin Crossca860ac2016-01-04 14:34:37 -08002104}
2105
Colin Cross37047f12016-12-13 17:06:13 -08002106func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002107 deps := Deps{}
2108
2109 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002110 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002111 }
2112 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002113 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002114 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002115 if c.stl != nil {
2116 deps = c.stl.deps(ctx, deps)
2117 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002118 if c.coverage != nil {
2119 deps = c.coverage.deps(ctx, deps)
2120 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002121
Colin Crossb6715442017-10-24 11:13:31 -07002122 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2123 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2124 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2125 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2126 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2127 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002128 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002129
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002130 for _, lib := range deps.ReexportSharedLibHeaders {
2131 if !inList(lib, deps.SharedLibs) {
2132 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2133 }
2134 }
2135
2136 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002137 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2138 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 -07002139 }
2140 }
2141
Colin Cross5950f382016-12-13 12:50:57 -08002142 for _, lib := range deps.ReexportHeaderLibHeaders {
2143 if !inList(lib, deps.HeaderLibs) {
2144 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2145 }
2146 }
2147
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002148 for _, gen := range deps.ReexportGeneratedHeaders {
2149 if !inList(gen, deps.GeneratedHeaders) {
2150 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2151 }
2152 }
2153
Colin Crossc99deeb2016-04-11 15:06:20 -07002154 return deps
2155}
2156
Dan Albert7e9d2952016-08-04 13:02:36 -07002157func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002158 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002159 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002160 moduleContextImpl: moduleContextImpl{
2161 mod: c,
2162 },
2163 }
2164 ctx.ctx = ctx
2165
Colin Crossca860ac2016-01-04 14:34:37 -08002166 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002167}
2168
Jiyong Park7ed9de32018-10-15 22:25:07 +09002169// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002170func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002171 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2172 version := name[sharp+1:]
2173 libname := name[:sharp]
2174 return libname, version
2175 }
2176 return name, ""
2177}
2178
Dan Albert92fe7402020-07-15 13:33:30 -07002179func GetCrtVariations(ctx android.BottomUpMutatorContext,
2180 m LinkableInterface) []blueprint.Variation {
2181 if ctx.Os() != android.Android {
2182 return nil
2183 }
2184 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002185 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2186 minSdkVersion := m.MinSdkVersion()
2187 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2188 minSdkVersion = m.SdkVersion()
2189 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002190 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2191 if err != nil {
2192 ctx.PropertyErrorf("min_sdk_version", err.Error())
2193 }
Dan Albert92fe7402020-07-15 13:33:30 -07002194 return []blueprint.Variation{
2195 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002196 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002197 }
2198 }
2199 return []blueprint.Variation{
2200 {Mutator: "sdk", Variation: ""},
2201 }
2202}
2203
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002204func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2205 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002206
2207 variations = append([]blueprint.Variation(nil), variations...)
2208
Liz Kammer23942242022-04-08 15:41:00 -04002209 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002210 // Version is explicitly specified. i.e. libFoo#30
2211 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002212 if tag, ok := depTag.(libraryDependencyTag); ok {
2213 tag.explicitlyVersioned = true
2214 } else {
2215 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2216 }
Colin Crosse7257d22020-09-24 09:56:18 -07002217 }
Colin Crosse7257d22020-09-24 09:56:18 -07002218
Colin Cross0de8a1e2020-09-18 14:15:30 -07002219 if far {
2220 ctx.AddFarVariationDependencies(variations, depTag, name)
2221 } else {
2222 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002223 }
2224}
2225
Kiyoung Kim487689e2022-07-26 09:48:22 +09002226func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2227 apiImportInfo := multitree.ApiImportInfo{}
2228
2229 if c.Device() {
2230 var apiImportModule []blueprint.Module
2231 if actx.OtherModuleExists("api_imports") {
2232 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2233 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
2234 apiInfo := actx.OtherModuleProvider(apiImportModule[0], multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2235 apiImportInfo = apiInfo
2236 actx.SetProvider(multitree.ApiImportsProvider, apiInfo)
2237 }
2238 }
2239 }
2240
2241 return apiImportInfo
2242}
2243
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002244func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002245 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002246 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002247 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002248 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2249 // between the modules in the snapshot and the snapshot itself.
2250 var snapshotModule []blueprint.Module
2251 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2252 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2253 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2254 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2255 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002256 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002257 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2258 *snapshotInfo = &snapshot
2259 // republish the snapshot for use in later mutators on this module
2260 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002261 }
2262 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002263 if *snapshotInfo == nil {
2264 *snapshotInfo = &SnapshotInfo{}
2265 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002266 return **snapshotInfo
2267}
2268
Kiyoung Kim487689e2022-07-26 09:48:22 +09002269func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2270 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002271 return snapshot
2272 }
2273
2274 return lib
2275}
2276
2277// RewriteLibs takes a list of names of shared libraries and scans it for three types
2278// of names:
2279//
2280// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002281//
2282// For each of these, it adds the name of the prebuilt module (which will be in
2283// prebuilts/ndk) to the list of nonvariant libs.
2284//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002285// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002286//
2287// For each of these, it adds the name of the ndk_library module to the list of
2288// variant libs.
2289//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002290// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002291//
2292// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002293//
2294// The caller can then know to add the variantLibs dependencies differently from the
2295// nonvariantLibs
2296func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2297 variantLibs = []string{}
2298
2299 nonvariantLibs = []string{}
2300 for _, entry := range list {
2301 // strip #version suffix out
2302 name, _ := StubsLibNameAndVersion(entry)
2303 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002304 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002305 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2306 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2307 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002308 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002309 } else {
2310 // put name#version back
2311 nonvariantLibs = append(nonvariantLibs, entry)
2312 }
2313 }
2314 return nonvariantLibs, variantLibs
2315}
2316
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002317func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2318 nonVariantLibs := []string{}
2319 variantLibs := []string{}
2320
2321 for _, lib := range libs {
2322 replaceLibName := GetReplaceModuleName(lib, replaceList)
2323 if replaceLibName == lib {
2324 // Do not handle any libs which are not in API imports
2325 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2326 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2327 variantLibs = append(variantLibs, replaceLibName)
2328 } else {
2329 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2330 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002331 }
2332
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002333 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002334}
2335
Colin Cross1e676be2016-10-12 14:38:15 -07002336func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002337 if !c.Enabled() {
2338 return
2339 }
2340
Colin Cross37047f12016-12-13 17:06:13 -08002341 ctx := &depsContext{
2342 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002343 moduleContextImpl: moduleContextImpl{
2344 mod: c,
2345 },
2346 }
2347 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002348
Colin Crossc99deeb2016-04-11 15:06:20 -07002349 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002350 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002351
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002352 apiNdkLibs := []string{}
2353 apiLateNdkLibs := []string{}
2354
Kiyoung Kim11d91082022-10-19 19:20:57 +09002355 if ctx.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002356 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2357 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2358 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2359 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2360 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002361 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002362
Yo Chiang219968c2020-09-22 18:45:04 +08002363 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2364
Colin Crosse0edaf92021-01-11 17:31:17 -08002365 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002366
Dan Albert914449f2016-06-17 16:45:24 -07002367 variantNdkLibs := []string{}
2368 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002369 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002370 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2371 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2372 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002373
2374 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002375 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002376 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002377 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002378
Colin Cross32ec36c2016-12-15 07:39:51 -08002379 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002380 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002381 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002382 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002383 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002384
Kiyoung Kim51279d32022-08-24 14:10:46 +09002385 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim11d91082022-10-19 19:20:57 +09002386 if ctx.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2387 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2388 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002389 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002390
Spandan Das73bcafc2022-08-18 23:26:00 +00002391 if c.isNDKStubLibrary() {
2392 // ndk_headers do not have any variations
2393 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002394 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002395 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002396 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002397 } else {
2398 actx.AddVariationDependencies(nil, depTag, lib)
2399 }
2400 }
2401
Dan Albertf1d14c72020-07-30 14:32:55 -07002402 if c.isNDKStubLibrary() {
2403 // NDK stubs depend on their implementation because the ABI dumps are
2404 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002405 apiImportName := c.BaseModuleName() + multitree.GetApiImportSuffix()
2406
2407 // If original library exists as imported API, set dependency on the imported library
2408 if actx.OtherModuleExists(apiImportName) {
2409 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2410 c.ImageVariation(),
2411 blueprint.Variation{Mutator: "link", Variation: "shared"},
2412 ), stubImplementation, apiImportName)
2413 } else {
2414 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2415 c.ImageVariation(),
2416 blueprint.Variation{Mutator: "link", Variation: "shared"},
2417 ), stubImplementation, c.BaseModuleName())
2418 }
Dan Albertf1d14c72020-07-30 14:32:55 -07002419 }
2420
Jiyong Park5d1598f2019-02-25 22:14:17 +09002421 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002422 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002423
Kiyoung Kim487689e2022-07-26 09:48:22 +09002424 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002425
Jiyong Park5d1598f2019-02-25 22:14:17 +09002426 actx.AddVariationDependencies([]blueprint.Variation{
2427 {Mutator: "link", Variation: "static"},
2428 }, depTag, lib)
2429 }
2430
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002431 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002432 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002433 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002434 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002435 }
Jiyong Parke3867542020-12-03 17:28:25 +09002436 if inList(lib, deps.ExcludeLibsForApex) {
2437 depTag.excludeInApex = true
2438 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002439
Kiyoung Kim487689e2022-07-26 09:48:22 +09002440 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002441
Dan Willemsen59339a22018-07-22 21:18:45 -07002442 actx.AddVariationDependencies([]blueprint.Variation{
2443 {Mutator: "link", Variation: "static"},
2444 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002445 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002446
Jooyung Han75568392020-03-20 04:29:24 +09002447 // staticUnwinderDep is treated as staticDep for Q apexes
2448 // so that native libraries/binaries are linked with static unwinder
2449 // because Q libc doesn't have unwinder APIs
2450 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002451 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002452 actx.AddVariationDependencies([]blueprint.Variation{
2453 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002454 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002455 }
2456
Jiyong Park7ed9de32018-10-15 22:25:07 +09002457 // shared lib names without the #version suffix
2458 var sharedLibNames []string
2459
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002460 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002461 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002462 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002463 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002464 }
Jiyong Parke3867542020-12-03 17:28:25 +09002465 if inList(lib, deps.ExcludeLibsForApex) {
2466 depTag.excludeInApex = true
2467 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002468
Jiyong Park73c54ee2019-10-22 20:31:18 +09002469 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002470 sharedLibNames = append(sharedLibNames, name)
2471
Colin Crosse7257d22020-09-24 09:56:18 -07002472 variations := []blueprint.Variation{
2473 {Mutator: "link", Variation: "shared"},
2474 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002475 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002476 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002477
Colin Crossfe9acfe2021-06-14 16:13:03 -07002478 for _, lib := range deps.LateStaticLibs {
2479 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2480 actx.AddVariationDependencies([]blueprint.Variation{
2481 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002482 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002483 }
2484
Colin Cross3e5e7782022-06-17 22:17:05 +00002485 for _, lib := range deps.UnexportedStaticLibs {
2486 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2487 actx.AddVariationDependencies([]blueprint.Variation{
2488 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002489 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002490 }
2491
Jiyong Park7ed9de32018-10-15 22:25:07 +09002492 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002493 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002494 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2495 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2496 // linking against both the stubs lib and the non-stubs lib at the same time.
2497 continue
2498 }
Colin Cross6e511a92020-07-27 21:26:48 -07002499 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002500 variations := []blueprint.Variation{
2501 {Mutator: "link", Variation: "shared"},
2502 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002503 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002504 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002505
Dan Willemsen59339a22018-07-22 21:18:45 -07002506 actx.AddVariationDependencies([]blueprint.Variation{
2507 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002508 }, dataLibDepTag, deps.DataLibs...)
2509
Colin Crossc8caa062021-09-24 16:50:14 -07002510 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2511
Chris Parsons79d66a52020-06-05 17:26:16 -04002512 actx.AddVariationDependencies([]blueprint.Variation{
2513 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002514 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002515
Colin Cross68861832016-07-08 10:41:41 -07002516 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002517
2518 for _, gen := range deps.GeneratedHeaders {
2519 depTag := genHeaderDepTag
2520 if inList(gen, deps.ReexportGeneratedHeaders) {
2521 depTag = genHeaderExportDepTag
2522 }
2523 actx.AddDependency(c, depTag, gen)
2524 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002525
Dan Albert92fe7402020-07-15 13:33:30 -07002526 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002527 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002528 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002529 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002530 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002531 }
Colin Crossc465efd2021-06-11 18:00:04 -07002532 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002533 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002534 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002535 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002536 if deps.DynamicLinker != "" {
2537 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002538 }
Dan Albert914449f2016-06-17 16:45:24 -07002539
2540 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002541
2542 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002543 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002544 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002545 {Mutator: "link", Variation: "shared"},
2546 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002547 actx.AddVariationDependencies([]blueprint.Variation{
2548 {Mutator: "version", Variation: version},
2549 {Mutator: "link", Variation: "shared"},
2550 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002551
2552 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002553 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002554 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002555 {Mutator: "link", Variation: "shared"},
2556 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002557 actx.AddVariationDependencies([]blueprint.Variation{
2558 {Mutator: "version", Variation: version},
2559 {Mutator: "link", Variation: "shared"},
2560 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002561
2562 if vndkdep := c.vndkdep; vndkdep != nil {
2563 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002564 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002565 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002566 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002567 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002568 }
2569 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002570
2571 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002572}
Colin Cross21b9a242015-03-24 14:15:58 -07002573
Colin Crosse40b4ea2018-10-02 22:25:58 -07002574func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002575 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2576 c.beginMutator(ctx)
2577 }
2578}
2579
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002580// Whether a module can link to another module, taking into
2581// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002582func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002583 tag blueprint.DependencyTag) {
2584
2585 switch t := tag.(type) {
2586 case dependencyTag:
2587 if t != vndkExtDepTag {
2588 return
2589 }
2590 case libraryDependencyTag:
2591 default:
2592 return
2593 }
2594
Ivan Lozanof9e21722020-12-02 09:00:51 -05002595 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002596 // Host code is not restricted
2597 return
2598 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002599
2600 // VNDK is cc.Module supported only for now.
2601 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002602 // Though allowed dependency is limited by the image mutator,
2603 // each vendor and product module needs to check link-type
2604 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002605 if ccTo, ok := to.(*Module); ok {
2606 if ccFrom.vndkdep != nil {
2607 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2608 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002609 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002610 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002611 }
2612 return
2613 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002614 // TODO(b/244244438) : Remove this once all variants are implemented
2615 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2616 return
2617 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002618 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002619 // Platform code can link to anything
2620 return
2621 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002622 if from.InRamdisk() {
2623 // Ramdisk code is not NDK
2624 return
2625 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002626 if from.InVendorRamdisk() {
2627 // Vendor ramdisk code is not NDK
2628 return
2629 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002630 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002631 // Recovery code is not NDK
2632 return
2633 }
Colin Cross31076b32020-10-23 17:22:06 -07002634 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002635 if c.NdkPrebuiltStl() {
2636 // These are allowed, but they don't set sdk_version
2637 return
2638 }
2639 if c.StubDecorator() {
2640 // These aren't real libraries, but are the stub shared libraries that are included in
2641 // the NDK.
2642 return
2643 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002644 if c.isImportedApiLibrary() {
2645 // Imported library from the API surface is a stub library built against interface definition.
2646 return
2647 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002648 }
Logan Chien834b9a62019-01-14 15:39:03 +08002649
Ivan Lozano52767be2019-10-18 14:49:46 -07002650 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002651 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2652 // to link to libc++ (non-NDK and without sdk_version).
2653 return
2654 }
2655
Ivan Lozano52767be2019-10-18 14:49:46 -07002656 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002657 // NDK code linking to platform code is never okay.
2658 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002659 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002660 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002661 }
2662
2663 // At this point we know we have two NDK libraries, but we need to
2664 // check that we're not linking against anything built against a higher
2665 // API level, as it is only valid to link against older or equivalent
2666 // APIs.
2667
Inseob Kim01a28722018-04-11 09:48:45 +09002668 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002669 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002670 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002671 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002672 // Current can't be linked against by anything else.
2673 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002674 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002675 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002676 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002677 if err != nil {
2678 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002679 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002680 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002681 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002682 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002683 if err != nil {
2684 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002685 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002686 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002687 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002688
Inseob Kim01a28722018-04-11 09:48:45 +09002689 if toApi > fromApi {
2690 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002691 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002692 }
2693 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002694 }
Dan Albert202fe492017-12-15 13:56:59 -08002695
2696 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002697 fromStl := from.SelectedStl()
2698 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002699 if fromStl == "" || toStl == "" {
2700 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002701 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002702 // We can be permissive with the system "STL" since it is only the C++
2703 // ABI layer, but in the future we should make sure that everyone is
2704 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002705 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002706 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002707 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2708 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002709 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002710}
2711
Jooyung Han479ca172020-10-19 18:51:07 +09002712func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2713 if c, ok := ctx.Module().(*Module); ok {
2714 ctx.VisitDirectDeps(func(dep android.Module) {
2715 depTag := ctx.OtherModuleDependencyTag(dep)
2716 ccDep, ok := dep.(LinkableInterface)
2717 if ok {
2718 checkLinkType(ctx, c, ccDep, depTag)
2719 }
2720 })
2721 }
2722}
2723
Jiyong Park5fb8c102018-04-09 12:03:06 +09002724// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002725// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2726// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002727// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002728func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2729 check := func(child, parent android.Module) bool {
2730 to, ok := child.(*Module)
2731 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002732 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002733 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002734
Jooyung Hana70f0672019-01-18 15:20:43 +09002735 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2736 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002737 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002738
Jiyong Park0474e1f2021-01-14 14:26:06 +09002739 // These dependencies are not excercised at runtime. Tracking these will give us
2740 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002741 depTag := ctx.OtherModuleDependencyTag(child)
2742 if IsHeaderDepTag(depTag) {
2743 return false
2744 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002745 if depTag == staticVariantTag {
2746 return false
2747 }
2748 if depTag == stubImplDepTag {
2749 return false
2750 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002751
Justin Yun63e9ec72020-10-29 16:49:43 +09002752 // Even if target lib has no vendor variant, keep checking dependency
2753 // graph in case it depends on vendor_available or product_available
2754 // but not double_loadable transtively.
2755 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002756 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002757 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002758
Jiyong Park0474e1f2021-01-14 14:26:06 +09002759 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2760 // one.
2761 if Bool(to.VendorProperties.Double_loadable) {
2762 return true
2763 }
2764
Ivan Lozanod7586b62021-04-01 09:49:36 -04002765 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002766 return false
2767 }
2768
Jooyung Hana70f0672019-01-18 15:20:43 +09002769 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2770 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002771 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002772 return false
2773 }
2774 if module, ok := ctx.Module().(*Module); ok {
2775 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002776 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002777 ctx.WalkDeps(check)
2778 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002779 }
2780 }
2781}
2782
Colin Crossc99deeb2016-04-11 15:06:20 -07002783// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002784func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002785 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002786
Colin Cross0de8a1e2020-09-18 14:15:30 -07002787 var directStaticDeps []StaticLibraryInfo
2788 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002789
Colin Cross0de8a1e2020-09-18 14:15:30 -07002790 reexportExporter := func(exporter FlagExporterInfo) {
2791 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2792 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2793 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2794 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2795 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002796 }
2797
Jooyung Hande34d232020-07-23 13:04:15 +09002798 // For the dependency from platform to apex, use the latest stubs
2799 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002800 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2801 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002802 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002803 }
2804
2805 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2806 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2807 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2808 // (b/144430859)
2809 c.apexSdkVersion = android.FutureApiLevel
2810 }
2811
Colin Crossd11fcda2017-10-23 17:59:01 -07002812 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002813 depName := ctx.OtherModuleName(dep)
2814 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002815
Dan Willemsen47450072021-10-19 20:24:49 -07002816 if depTag == android.DarwinUniversalVariantTag {
2817 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2818 return
2819 }
2820
Ivan Lozano52767be2019-10-18 14:49:46 -07002821 ccDep, ok := dep.(LinkableInterface)
2822 if !ok {
2823
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002824 // handling for a few module types that aren't cc Module but that are also supported
2825 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002826 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002827 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002828 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2829 genRule.GeneratedSourceFiles()...)
2830 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002831 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002832 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002833 // Support exported headers from a generated_sources dependency
2834 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002835 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002836 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002837 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002838 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002839 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002840 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002841 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002842 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002843 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2844 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002845 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002846 // 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 +09002847 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002848
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002849 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002850 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002851 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002852 }
Colin Crosscef792e2021-06-11 18:01:26 -07002853 case CrtBeginDepTag:
2854 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2855 case CrtEndDepTag:
2856 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002857 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002858 return
2859 }
2860
Colin Crossfe17f6f2019-03-28 19:30:56 -07002861 if depTag == android.ProtoPluginDepTag {
2862 return
2863 }
2864
Colin Crossd11fcda2017-10-23 17:59:01 -07002865 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002866 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2867 return
2868 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002869 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002870 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2871 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002872 return
2873 }
2874
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002875 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002876 // Skip reused objects for stub libraries, they use their own stub object file instead.
2877 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2878 // version mutator, so the stubs variant is created from the shared variant that
2879 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002880 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002881 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2882 objs := staticAnalogue.ReuseObjects
2883 depPaths.Objs = depPaths.Objs.Append(objs)
2884 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2885 reexportExporter(depExporterInfo)
2886 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002887 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002888 }
2889
Colin Cross6e511a92020-07-27 21:26:48 -07002890 linkFile := ccDep.OutputFile()
2891
2892 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2893 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002894 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002895 return
2896 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002897
Jiyong Parke3867542020-12-03 17:28:25 +09002898 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2899 return
2900 }
2901
Colin Cross0de8a1e2020-09-18 14:15:30 -07002902 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002903
Colin Cross6e511a92020-07-27 21:26:48 -07002904 var ptr *android.Paths
2905 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002906
Colin Cross6e511a92020-07-27 21:26:48 -07002907 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002908
Colin Cross6e511a92020-07-27 21:26:48 -07002909 switch {
2910 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002911 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2912 if !ctx.Config().AllowMissingDependencies() {
2913 ctx.ModuleErrorf("module %q is not a header library", depName)
2914 } else {
2915 ctx.AddMissingDependencies([]string{depName})
2916 }
2917 return
2918 }
Colin Cross6e511a92020-07-27 21:26:48 -07002919 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002920 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2921 if !ctx.Config().AllowMissingDependencies() {
2922 ctx.ModuleErrorf("module %q is not a shared library", depName)
2923 } else {
2924 ctx.AddMissingDependencies([]string{depName})
2925 }
2926 return
2927 }
Jiyong Parke3867542020-12-03 17:28:25 +09002928
Jiyong Park7d55b612021-06-11 17:22:09 +09002929 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
2930 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002931
Jiyong Park1ad8e162020-12-01 23:40:09 +09002932 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2933 // linkFile, depFile, and ptr.
2934 if c.IsStubs() {
2935 break
2936 }
2937
Colin Cross0de8a1e2020-09-18 14:15:30 -07002938 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2939 depFile = sharedLibraryInfo.TableOfContents
2940
Colin Cross6e511a92020-07-27 21:26:48 -07002941 ptr = &depPaths.SharedLibs
2942 switch libDepTag.Order {
2943 case earlyLibraryDependency:
2944 ptr = &depPaths.EarlySharedLibs
2945 depPtr = &depPaths.EarlySharedLibsDeps
2946 case normalLibraryDependency:
2947 ptr = &depPaths.SharedLibs
2948 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002949 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002950 case lateLibraryDependency:
2951 ptr = &depPaths.LateSharedLibs
2952 depPtr = &depPaths.LateSharedLibsDeps
2953 default:
2954 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002955 }
Colin Cross6e511a92020-07-27 21:26:48 -07002956 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002957 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2958 if !ctx.Config().AllowMissingDependencies() {
2959 ctx.ModuleErrorf("module %q is not a static library", depName)
2960 } else {
2961 ctx.AddMissingDependencies([]string{depName})
2962 }
2963 return
2964 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002965
2966 // Stubs lib doesn't link to the static lib dependencies. Don't set
2967 // linkFile, depFile, and ptr.
2968 if c.IsStubs() {
2969 break
2970 }
2971
Colin Cross0de8a1e2020-09-18 14:15:30 -07002972 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2973 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002974 if libDepTag.wholeStatic {
2975 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002976 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2977 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002978 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002979 // This case normally catches prebuilt static
2980 // libraries, but it can also occur when
2981 // AllowMissingDependencies is on and the
2982 // dependencies has no sources of its own
2983 // but has a whole_static_libs dependency
2984 // on a missing library. We want to depend
2985 // on the .a file so that there is something
2986 // in the dependency tree that contains the
2987 // error rule for the missing transitive
2988 // dependency.
2989 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002990 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08002991 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
2992 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07002993 } else {
2994 switch libDepTag.Order {
2995 case earlyLibraryDependency:
2996 panic(fmt.Errorf("early static libs not suppported"))
2997 case normalLibraryDependency:
2998 // static dependencies will be handled separately so they can be ordered
2999 // using transitive dependencies.
3000 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003001 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003002 case lateLibraryDependency:
3003 ptr = &depPaths.LateStaticLibs
3004 default:
3005 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003006 }
3007 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003008 if libDepTag.unexportedSymbols {
3009 depPaths.LdFlags = append(depPaths.LdFlags,
3010 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3011 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003012 }
3013
Colin Cross6e511a92020-07-27 21:26:48 -07003014 if libDepTag.static() && !libDepTag.wholeStatic {
3015 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3016 ctx.ModuleErrorf("module %q not a static library", depName)
3017 return
3018 }
Logan Chien43d34c32017-12-20 01:17:32 +08003019
Colin Cross6e511a92020-07-27 21:26:48 -07003020 // When combining coverage files for shared libraries and executables, coverage files
3021 // in static libraries act as if they were whole static libraries. The same goes for
3022 // source based Abi dump files.
3023 if c, ok := ccDep.(*Module); ok {
3024 staticLib := c.linker.(libraryInterface)
3025 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3026 staticLib.objs().coverageFiles...)
3027 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3028 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003029 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003030 // Handle non-CC modules here
3031 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003032 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003033 }
3034 }
3035
Colin Cross6e511a92020-07-27 21:26:48 -07003036 if ptr != nil {
3037 if !linkFile.Valid() {
3038 if !ctx.Config().AllowMissingDependencies() {
3039 ctx.ModuleErrorf("module %q missing output file", depName)
3040 } else {
3041 ctx.AddMissingDependencies([]string{depName})
3042 }
3043 return
3044 }
3045 *ptr = append(*ptr, linkFile.Path())
3046 }
3047
3048 if depPtr != nil {
3049 dep := depFile
3050 if !dep.Valid() {
3051 dep = linkFile
3052 }
3053 *depPtr = append(*depPtr, dep.Path())
3054 }
3055
Colin Cross0de8a1e2020-09-18 14:15:30 -07003056 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3057 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3058 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3059 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3060
3061 if libDepTag.reexportFlags {
3062 reexportExporter(depExporterInfo)
3063 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3064 // Re-exported shared library headers must be included as well since they can help us with type information
3065 // about template instantiations (instantiated from their headers).
3066 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3067 // scripts.
3068 c.sabi.Properties.ReexportedIncludes = append(
3069 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3070 }
3071
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003072 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003073 switch {
3074 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003075 c.Properties.AndroidMkHeaderLibs = append(
3076 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003077 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003078 if lib := moduleLibraryInterface(dep); lib != nil {
3079 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003080 // Add the dependency to the APEX(es) providing the library so that
3081 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07003082 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09003083 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003084 c.Properties.ApexesProvidingSharedLibs = append(
3085 c.Properties.ApexesProvidingSharedLibs, an)
3086 }
3087 }
3088 }
3089
3090 // Note: the order of libs in this list is not important because
3091 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003092 c.Properties.AndroidMkSharedLibs = append(
3093 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003094 // Record BaseLibName for snapshots.
3095 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003096 case libDepTag.static():
3097 if libDepTag.wholeStatic {
3098 c.Properties.AndroidMkWholeStaticLibs = append(
3099 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3100 } else {
3101 c.Properties.AndroidMkStaticLibs = append(
3102 c.Properties.AndroidMkStaticLibs, makeLibName)
3103 }
Justin Yun5e035862021-06-29 20:50:37 +09003104 // Record BaseLibName for snapshots.
3105 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003106 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003107 } else if !c.IsStubs() {
3108 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3109
Colin Cross6e511a92020-07-27 21:26:48 -07003110 switch depTag {
3111 case runtimeDepTag:
3112 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003113 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003114 // Record BaseLibName for snapshots.
3115 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003116 case objDepTag:
3117 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3118 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003119 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003120 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003121 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003122 case dynamicLinkerDepTag:
3123 depPaths.DynamicLinker = linkFile
3124 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003125 }
Colin Crossca860ac2016-01-04 14:34:37 -08003126 })
3127
Jeff Gaston294356f2017-09-27 17:05:30 -07003128 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003129 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3130 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3131 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003132
Colin Crossdd84e052017-05-17 13:44:16 -07003133 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003134 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003135 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3136 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003137 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003138 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3139 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003140 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003141 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003142 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003143
3144 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003145 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003146 }
Colin Crossdd84e052017-05-17 13:44:16 -07003147
Colin Crossca860ac2016-01-04 14:34:37 -08003148 return depPaths
3149}
3150
Jiyong Park7d55b612021-06-11 17:22:09 +09003151// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3152// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3153// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3154// has different level of updatability. For example, if a library foo in an APEX depends on a
3155// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3156// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3157// same APEX as foo, the non-stub variant of bar is used.
3158func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3159 depName := ctx.OtherModuleName(dep)
3160 depTag := ctx.OtherModuleDependencyTag(dep)
3161 libDepTag, ok := depTag.(libraryDependencyTag)
3162 if !ok || !libDepTag.shared() {
3163 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3164 }
3165
3166 thisModule, ok := ctx.Module().(android.ApexModule)
3167 if !ok {
3168 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3169 }
3170
3171 useVndk := false
3172 bootstrap := false
3173 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3174 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3175 } else {
3176 useVndk = linkable.UseVndk()
3177 bootstrap = linkable.Bootstrap()
3178 }
3179
3180 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3181 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3182 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
3183 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3184
3185 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
3186 useStubs := false
3187
3188 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3189 if !apexInfo.IsForPlatform() {
3190 // For platform libraries, use current version of LLNDK
3191 // If this is for use_vendor apex we will apply the same rules
3192 // of apex sdk enforcement below to choose right version.
3193 useStubs = true
3194 }
Jiyong Park9477c262021-06-22 20:23:05 +09003195 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3196 // If not building for APEX or the containing APEX allows the use of
3197 // platform APIs, use stubs only when it is from an APEX (and not from
3198 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3199 // bootstrap modules, always link to non-stub variant
Jiyong Park7d55b612021-06-11 17:22:09 +09003200 useStubs = dep.(android.ApexModule).NotInPlatform() && !bootstrap
3201 if useStubs {
3202 // Another exception: if this module is a test for an APEX, then
3203 // it is linked with the non-stub variant of a module in the APEX
3204 // as if this is part of the APEX.
3205 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3206 for _, apexContents := range testFor.ApexContents {
3207 if apexContents.DirectlyInApex(depName) {
3208 useStubs = false
3209 break
3210 }
3211 }
3212 }
3213 if useStubs {
3214 // Yet another exception: If this module and the dependency are
3215 // available to the same APEXes then skip stubs between their
3216 // platform variants. This complements the test_for case above,
3217 // which avoids the stubs on a direct APEX library dependency, by
3218 // avoiding stubs for indirect test dependencies as well.
3219 //
3220 // TODO(b/183882457): This doesn't work if the two libraries have
3221 // only partially overlapping apex_available. For that test_for
3222 // modules would need to be split into APEX variants and resolved
3223 // separately for each APEX they have access to.
3224 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3225 useStubs = false
3226 }
3227 }
3228 } else {
3229 // If building for APEX, use stubs when the parent is in any APEX that
3230 // the child is not in.
3231 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3232 }
3233
3234 // when to use (unspecified) stubs, use the latest one.
3235 if useStubs {
3236 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3237 toUse := stubs[len(stubs)-1]
3238 sharedLibraryInfo = toUse.SharedLibraryInfo
3239 depExporterInfo = toUse.FlagExporterInfo
3240 }
3241 }
3242 return sharedLibraryInfo, depExporterInfo
3243}
3244
Colin Cross0de8a1e2020-09-18 14:15:30 -07003245// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3246// to match the topological order of the dependency tree, including any static analogues of
3247// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3248// of the transitive dependencies.
3249func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3250 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3251 var staticPaths android.Paths
3252 for _, staticDep := range staticDeps {
3253 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3254 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3255 }
3256 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003257 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3258 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003259 }
3260 }
3261 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3262
3263 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3264
3265 // reorder the dependencies based on transitive dependencies
3266 staticPaths = android.FirstUniquePaths(staticPaths)
3267 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3268
3269 if len(orderedStaticPaths) != len(staticPaths) {
3270 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3271 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3272 }
3273
3274 return orderedStaticPaths, transitiveStaticLibs
3275}
3276
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003277// BaseLibName trims known prefixes and suffixes
3278func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003279 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3280 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003281 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003282 return libName
3283}
3284
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003285func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003286 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003287 ccDepModule, _ := ccDep.(*Module)
3288 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003289 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003290
Justin Yuncbca3732021-02-03 19:24:13 +09003291 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003292 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07003293 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003294 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003295 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003296
Ivan Lozanod1dec542021-05-26 15:33:11 -04003297 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003298 }
3299 }
3300
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003301 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3302 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003303 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3304 // core module instead.
3305 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003306 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003307 // The vendor and product modules in Make will have been renamed to not conflict with the
3308 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003309 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003310 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003311 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003312 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003313 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003314 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003315 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003316 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003317 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003318 } else {
3319 return libName
3320 }
3321}
3322
Colin Crossca860ac2016-01-04 14:34:37 -08003323func (c *Module) InstallInData() bool {
3324 if c.installer == nil {
3325 return false
3326 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003327 return c.installer.inData()
3328}
3329
3330func (c *Module) InstallInSanitizerDir() bool {
3331 if c.installer == nil {
3332 return false
3333 }
3334 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003335 return true
3336 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003337 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003338}
3339
Yifan Hong1b3348d2020-01-21 15:53:22 -08003340func (c *Module) InstallInRamdisk() bool {
3341 return c.InRamdisk()
3342}
3343
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003344func (c *Module) InstallInVendorRamdisk() bool {
3345 return c.InVendorRamdisk()
3346}
3347
Jiyong Parkf9332f12018-02-01 00:54:12 +09003348func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003349 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003350}
3351
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003352func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003353 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003354 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003355 return
3356 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003357 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003358}
3359
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003360func (c *Module) HostToolPath() android.OptionalPath {
3361 if c.installer == nil {
3362 return android.OptionalPath{}
3363 }
3364 return c.installer.hostToolPath()
3365}
3366
Nan Zhangd4e641b2017-07-12 12:55:28 -07003367func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3368 return c.outputFile
3369}
3370
Colin Cross41955e82019-05-29 14:40:35 -07003371func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3372 switch tag {
3373 case "":
3374 if c.outputFile.Valid() {
3375 return android.Paths{c.outputFile.Path()}, nil
3376 }
3377 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003378 case "unstripped":
3379 if c.linker != nil {
3380 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3381 }
3382 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003383 default:
3384 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003385 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003386}
3387
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003388func (c *Module) static() bool {
3389 if static, ok := c.linker.(interface {
3390 static() bool
3391 }); ok {
3392 return static.static()
3393 }
3394 return false
3395}
3396
Jiyong Park379de2f2018-12-19 02:47:14 +09003397func (c *Module) staticBinary() bool {
3398 if static, ok := c.linker.(interface {
3399 staticBinary() bool
3400 }); ok {
3401 return static.staticBinary()
3402 }
3403 return false
3404}
3405
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003406func (c *Module) testBinary() bool {
3407 if test, ok := c.linker.(interface {
3408 testBinary() bool
3409 }); ok {
3410 return test.testBinary()
3411 }
3412 return false
3413}
3414
Jingwen Chen537242c2022-08-24 11:53:27 +00003415func (c *Module) testLibrary() bool {
3416 if test, ok := c.linker.(interface {
3417 testLibrary() bool
3418 }); ok {
3419 return test.testLibrary()
3420 }
3421 return false
3422}
3423
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003424func (c *Module) benchmarkBinary() bool {
3425 if b, ok := c.linker.(interface {
3426 benchmarkBinary() bool
3427 }); ok {
3428 return b.benchmarkBinary()
3429 }
3430 return false
3431}
3432
3433func (c *Module) fuzzBinary() bool {
3434 if f, ok := c.linker.(interface {
3435 fuzzBinary() bool
3436 }); ok {
3437 return f.fuzzBinary()
3438 }
3439 return false
3440}
3441
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003442// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3443func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003444 if h, ok := c.linker.(interface {
3445 header() bool
3446 }); ok {
3447 return h.header()
3448 }
3449 return false
3450}
3451
Ivan Lozanod7586b62021-04-01 09:49:36 -04003452func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003453 if b, ok := c.linker.(interface {
3454 binary() bool
3455 }); ok {
3456 return b.binary()
3457 }
3458 return false
3459}
3460
Justin Yun5e035862021-06-29 20:50:37 +09003461func (c *Module) StaticExecutable() bool {
3462 if b, ok := c.linker.(*binaryDecorator); ok {
3463 return b.static()
3464 }
3465 return false
3466}
3467
Ivan Lozanod7586b62021-04-01 09:49:36 -04003468func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003469 if o, ok := c.linker.(interface {
3470 object() bool
3471 }); ok {
3472 return o.object()
3473 }
3474 return false
3475}
3476
Ivan Lozanof9e21722020-12-02 09:00:51 -05003477func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003478 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003479 if c.IsLlndk() {
3480 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003481 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003482 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003483 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003484 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003485 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003486 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003487 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003488 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003489 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003490 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003491 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003492 return "native:product"
3493 }
Jooyung Han38002912019-05-16 04:01:54 +09003494 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003495 } else if c.InRamdisk() {
3496 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003497 } else if c.InVendorRamdisk() {
3498 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003499 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003500 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003501 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003502 return "native:ndk:none:none"
3503 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3504 //family, link := getNdkStlFamilyAndLinkType(c)
3505 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003506 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003507 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003508 } else {
3509 return "native:platform"
3510 }
3511}
3512
Jiyong Park9d452992018-10-03 00:38:19 +09003513// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003514// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003515func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003516 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003517 // Stub libs and prebuilt libs in a versioned SDK are not
3518 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003519 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003520 } else if _, ok := c.linker.(testPerSrc); ok {
3521 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003522 }
3523 return false
3524}
3525
Jiyong Parka90ca002019-10-07 15:47:24 +09003526func (c *Module) AvailableFor(what string) bool {
3527 if linker, ok := c.linker.(interface {
3528 availableFor(string) bool
3529 }); ok {
3530 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3531 } else {
3532 return c.ApexModuleBase.AvailableFor(what)
3533 }
3534}
3535
Jiyong Park62304bb2020-04-13 16:19:48 +09003536func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003537 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003538}
3539
Paul Duffin0cb37b92020-03-04 14:52:46 +00003540func (c *Module) EverInstallable() bool {
3541 return c.installer != nil &&
3542 // Check to see whether the module is actually ever installable.
3543 c.installer.everInstallable()
3544}
3545
Ivan Lozanod7586b62021-04-01 09:49:36 -04003546func (c *Module) PreventInstall() bool {
3547 return c.Properties.PreventInstall
3548}
3549
3550func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003551 if c.library != nil {
3552 if i := c.library.installable(); i != nil {
3553 return i
3554 }
3555 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003556 return c.Properties.Installable
3557}
3558
3559func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003560 ret := c.EverInstallable() &&
3561 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003562 proptools.BoolDefault(c.Installable(), true) &&
3563 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003564
3565 // The platform variant doesn't need further condition. Apex variants however might not
3566 // be installable because it will likely to be included in the APEX and won't appear
3567 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003568 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003569 return ret
3570 }
3571
3572 // Special case for modules that are configured to be installed to /data, which includes
3573 // test modules. For these modules, both APEX and non-APEX variants are considered as
3574 // installable. This is because even the APEX variants won't be included in the APEX, but
3575 // will anyway be installed to /data/*.
3576 // See b/146995717
3577 if c.InstallInData() {
3578 return ret
3579 }
3580
3581 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003582}
3583
Logan Chien41eabe62019-04-10 13:33:58 +08003584func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3585 if c.linker != nil {
3586 if library, ok := c.linker.(*libraryDecorator); ok {
3587 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3588 }
3589 }
3590}
3591
Jiyong Park45bf82e2020-12-15 22:29:02 +09003592var _ android.ApexModule = (*Module)(nil)
3593
3594// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003595func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003596 depTag := ctx.OtherModuleDependencyTag(dep)
3597 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3598
3599 if cc, ok := dep.(*Module); ok {
3600 if cc.HasStubsVariants() {
3601 if isLibDepTag && libDepTag.shared() {
3602 // dynamic dep to a stubs lib crosses APEX boundary
3603 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003604 }
Colin Cross6e511a92020-07-27 21:26:48 -07003605 if IsRuntimeDepTag(depTag) {
3606 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003607 return false
3608 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003609 }
Zhijun Heec285872021-04-24 10:47:08 -07003610 if cc.IsLlndk() {
3611 return false
3612 }
Colin Crossaac32222020-07-29 12:51:56 -07003613 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003614 // shared_lib dependency from a static lib is considered as crossing
3615 // the APEX boundary because the dependency doesn't actually is
3616 // linked; the dependency is used only during the compilation phase.
3617 return false
3618 }
Jiyong Parke3867542020-12-03 17:28:25 +09003619
3620 if isLibDepTag && libDepTag.excludeInApex {
3621 return false
3622 }
Colin Cross6e511a92020-07-27 21:26:48 -07003623 }
Colin Crossc1b36442021-05-06 13:42:48 -07003624 if depTag == stubImplDepTag {
3625 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003626 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003627 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003628 if depTag == staticVariantTag {
3629 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3630 // actually mean that the static lib (and its dependencies) are copied into the
3631 // APEX.
3632 return false
3633 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003634 return true
3635}
3636
Jiyong Park45bf82e2020-12-15 22:29:02 +09003637// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003638func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3639 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003640 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3641 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3642 return nil
3643 }
Jooyung Han749dc692020-04-15 11:03:39 +09003644 // We don't check for prebuilt modules
3645 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3646 return nil
3647 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003648
Jooyung Han749dc692020-04-15 11:03:39 +09003649 minSdkVersion := c.MinSdkVersion()
3650 if minSdkVersion == "apex_inherit" {
3651 return nil
3652 }
3653 if minSdkVersion == "" {
3654 // JNI libs within APK-in-APEX fall into here
3655 // Those are okay to set sdk_version instead
3656 // We don't have to check if this is a SDK variant because
3657 // non-SDK variant resets sdk_version, which works too.
3658 minSdkVersion = c.SdkVersion()
3659 }
Dan Albertc8060532020-07-22 22:32:17 -07003660 if minSdkVersion == "" {
3661 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3662 }
3663 // Not using nativeApiLevelFromUser because the context here is not
3664 // necessarily a native context.
3665 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003666 if err != nil {
3667 return err
3668 }
Dan Albertc8060532020-07-22 22:32:17 -07003669
Colin Cross8ca61c12022-10-06 21:00:14 -07003670 // A dependency only needs to support a min_sdk_version at least
3671 // as high as the api level that the architecture was introduced in.
3672 // This allows introducing new architectures in the platform that
3673 // need to be included in apexes that normally require an older
3674 // min_sdk_version.
3675 minApiForArch := minApiForArch(ctx, c.Target().Arch.ArchType)
3676 if sdkVersion.LessThan(minApiForArch) {
3677 sdkVersion = minApiForArch
3678 }
3679
Dan Albertc8060532020-07-22 22:32:17 -07003680 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003681 return fmt.Errorf("newer SDK(%v)", ver)
3682 }
3683 return nil
3684}
3685
Paul Duffinb5769c12021-05-12 16:16:51 +01003686// Implements android.ApexModule
3687func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3688 // stub libraries and native bridge libraries are always available to platform
3689 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3690}
3691
Jooyung Han91f92032022-02-04 12:36:33 +09003692// Overrides android.ApexModuleBase.UniqueApexVariations
3693func (c *Module) UniqueApexVariations() bool {
3694 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3695 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3696 // variation of the VNDK lib because APEX variations are merged/grouped.
3697 return c.UseVndk() && c.IsVndk()
3698}
3699
Inseob Kima1888ce2022-10-04 14:42:02 +09003700func (c *Module) overriddenModules() []string {
3701 if o, ok := c.linker.(overridable); ok {
3702 return o.overriddenModules()
3703 }
3704 return nil
3705}
3706
Rob Seymour925aa092021-08-10 20:42:03 +00003707var _ snapshot.RelativeInstallPath = (*Module)(nil)
3708
Liz Kammer35ca77e2021-12-22 15:31:40 -05003709type moduleType int
3710
3711const (
3712 unknownType moduleType = iota
3713 binary
3714 object
3715 fullLibrary
3716 staticLibrary
3717 sharedLibrary
3718 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003719 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003720 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003721)
3722
3723func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003724 if c.testBinary() {
3725 // testBinary is also a binary, so this comes before the c.Binary()
3726 // conditional. A testBinary has additional implicit dependencies and
3727 // other test-only semantics.
3728 return testBin
3729 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003730 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003731 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003732 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003733 } else if c.testLibrary() {
3734 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3735 // will let them add implicit compile deps on gtest, for example.
3736 //
3737 // For now, treat them as regular shared libraries.
3738 return sharedLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003739 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003740 static := false
3741 shared := false
3742 if library, ok := c.linker.(*libraryDecorator); ok {
3743 static = library.MutatedProperties.BuildStatic
3744 shared = library.MutatedProperties.BuildShared
3745 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3746 static = library.MutatedProperties.BuildStatic
3747 shared = library.MutatedProperties.BuildShared
3748 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003749 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003750 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003751 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003752 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003753 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003754 return staticLibrary
3755 }
3756 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003757 } else if c.isNDKStubLibrary() {
3758 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003759 }
3760 return unknownType
3761}
3762
3763// ConvertWithBp2build converts Module to Bazel for bp2build.
3764func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
3765 prebuilt := c.IsPrebuilt()
3766 switch c.typ() {
3767 case binary:
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxb12ff592022-09-01 15:04:04 +00003768 if prebuilt {
3769 prebuiltBinaryBp2Build(ctx, c)
3770 } else {
Jingwen Chen537242c2022-08-24 11:53:27 +00003771 binaryBp2build(ctx, c)
3772 }
3773 case testBin:
3774 if !prebuilt {
3775 testBinaryBp2build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003776 }
3777 case object:
3778 if !prebuilt {
3779 objectBp2Build(ctx, c)
3780 }
3781 case fullLibrary:
3782 if !prebuilt {
3783 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003784 } else {
3785 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003786 }
3787 case headerLibrary:
3788 libraryHeadersBp2Build(ctx, c)
3789 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05003790 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003791 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003792 } else {
3793 sharedOrStaticLibraryBp2Build(ctx, c, true)
3794 }
3795 case sharedLibrary:
3796 if prebuilt {
3797 prebuiltLibrarySharedBp2Build(ctx, c)
3798 } else {
3799 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003800 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00003801 }
3802}
3803
3804var _ android.ApiProvider = (*Module)(nil)
3805
3806func (c *Module) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) {
Spandan Das4238c652022-09-09 01:38:47 +00003807 if c.IsPrebuilt() {
3808 return
3809 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00003810 switch c.typ() {
Spandan Das4238c652022-09-09 01:38:47 +00003811 case fullLibrary:
3812 apiContributionBp2Build(ctx, c)
3813 case sharedLibrary:
3814 apiContributionBp2Build(ctx, c)
3815 case headerLibrary:
3816 // Aggressively generate api targets for all header modules
3817 // This is necessary since the header module does not know if it is a dep of API surface stub library
3818 apiLibraryHeadersBp2Build(ctx, c)
Spandan Das1278c2c2022-08-19 18:17:28 +00003819 case ndkLibrary:
3820 ndkLibraryBp2build(ctx, c)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003821 }
3822}
3823
Colin Crosscfad1192015-11-02 16:43:11 -08003824// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003825type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003826 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003827 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003828 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003829}
3830
Patrice Arrudac249c712019-03-19 17:00:29 -07003831// cc_defaults provides a set of properties that can be inherited by other cc
3832// modules. A module can use the properties from a cc_defaults using
3833// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3834// merged (when possible) by prepending the default module's values to the
3835// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003836func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003837 return DefaultsFactory()
3838}
3839
Colin Cross36242852017-06-23 15:06:31 -07003840func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003841 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003842
Colin Cross36242852017-06-23 15:06:31 -07003843 module.AddProperties(props...)
3844 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003845 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003846 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003847 &BaseCompilerProperties{},
3848 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003849 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003850 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003851 &StaticProperties{},
3852 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003853 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003854 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003855 &TestLinkerProperties{},
3856 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003857 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003858 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003859 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003860 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003861 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003862 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003863 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003864 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003865 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003866 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003867 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003868 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003869 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003870 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003871 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003872 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3873 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003874 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003875 )
Colin Crosscfad1192015-11-02 16:43:11 -08003876
Jooyung Hancc372c52019-09-25 15:18:44 +09003877 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003878
3879 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003880}
3881
Jiyong Park2286afd2020-06-16 21:58:53 +09003882func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003883 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003884}
3885
Kiyoung Kim51279d32022-08-24 14:10:46 +09003886func (c *Module) isImportedApiLibrary() bool {
3887 _, ok := c.linker.(*apiLibraryDecorator)
3888 return ok
3889}
3890
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003891func kytheExtractAllFactory() android.Singleton {
3892 return &kytheExtractAllSingleton{}
3893}
3894
3895type kytheExtractAllSingleton struct {
3896}
3897
3898func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3899 var xrefTargets android.Paths
3900 ctx.VisitAllModules(func(module android.Module) {
3901 if ccModule, ok := module.(xref); ok {
3902 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3903 }
3904 })
3905 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3906 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003907 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003908 }
3909}
3910
Jihoon Kangf78a8902022-09-01 22:47:07 +00003911func (c *Module) Partition() string {
3912 if p, ok := c.installer.(interface {
3913 getPartition() string
3914 }); ok {
3915 return p.getPartition()
3916 }
3917 return ""
3918}
3919
Colin Cross06a931b2015-10-28 17:23:31 -07003920var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003921var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003922var BoolPtr = proptools.BoolPtr
3923var String = proptools.String
3924var StringPtr = proptools.StringPtr