blob: bc958134fd99e20d5fbcf15181e5621dea54b97e [file] [log] [blame]
Colin Cross5049f022015-03-18 13:28:46 -07001// Copyright 2015 Google Inc. All rights reserved.
Colin Cross3f40fa42015-01-30 17:27:36 -08002//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17// This file contains the module types for compiling C/C++ for Android, and converts the properties
18// into the flags and filenames necessary to pass to the compiler. The final creation of the rules
19// is handled in builder.go
20
21import (
Colin Cross41955e82019-05-29 14:40:35 -070022 "fmt"
Logan Chien41eabe62019-04-10 13:33:58 +080023 "io"
Dan Albert9e10cd42016-08-03 14:12:14 -070024 "strconv"
Colin Cross3f40fa42015-01-30 17:27:36 -080025 "strings"
26
Colin Cross97ba0732015-03-23 17:50:24 -070027 "github.com/google/blueprint"
Colin Cross06a931b2015-10-28 17:23:31 -070028 "github.com/google/blueprint/proptools"
Colin Cross97ba0732015-03-23 17:50:24 -070029
Colin Cross635c3b02016-05-18 15:37:25 -070030 "android/soong/android"
Colin Crossb98c8b02016-07-29 13:44:28 -070031 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070032 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070033 "android/soong/genrule"
Rob Seymour925aa092021-08-10 20:42:03 +000034 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080035)
36
Colin Cross463a90e2015-06-17 14:20:06 -070037func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000038 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070039
Paul Duffin036e7002019-12-19 19:16:28 +000040 pctx.Import("android/soong/cc/config")
41}
42
43func RegisterCCBuildComponents(ctx android.RegistrationContext) {
44 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
45
46 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000047 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090048 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070049 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010050 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070051 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070052 ctx.BottomUp("begin", BeginMutator).Parallel()
Inseob Kimac1e9862019-12-09 18:15:47 +090053 ctx.BottomUp("sysprop_cc", SyspropMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070054 })
Colin Cross16b23492016-01-06 14:41:07 -080055
Paul Duffin036e7002019-12-19 19:16:28 +000056 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040057 for _, san := range Sanitizers {
58 san.registerMutators(ctx)
59 }
Dan Willemsen581341d2017-02-09 16:16:31 -080060
Colin Cross0b908332019-06-19 23:00:20 -070061 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090062 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080063
Cory Barkera1da26f2022-06-07 20:12:06 +000064 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
65 ctx.BottomUp("fuzz", fuzzMutator)
66
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080067 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070068
Yi Kongeb8efc92021-12-09 18:06:29 +080069 ctx.TopDown("afdo_deps", afdoDepsMutator)
70 ctx.BottomUp("afdo", afdoMutator).Parallel()
71
Stephen Craneba090d12017-05-09 15:44:35 -070072 ctx.TopDown("lto_deps", ltoDepsMutator)
73 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090074
Jooyung Han479ca172020-10-19 18:51:07 +090075 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090076 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070077 })
Colin Crossb98c8b02016-07-29 13:44:28 -070078
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080079 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
80 // sabi mutator needs to be run after apex mutator finishes.
81 ctx.TopDown("sabi_deps", sabiDepsMutator)
82 })
83
Colin Cross57898582020-10-29 18:25:19 -070084 ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070085}
86
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050087// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
88// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
89// edges to these modules.
90// This object is constructed in DepsMutator, by calling to various module delegates to set
91// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
92// dependencies.
93// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
94// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080095type Deps struct {
96 SharedLibs, LateSharedLibs []string
97 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080098 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +080099 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700100
Colin Cross3e5e7782022-06-17 22:17:05 +0000101 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
102 // prevent automatically exporting symbols.
103 UnexportedStaticLibs []string
104
Chris Parsons79d66a52020-06-05 17:26:16 -0400105 // Used for data dependencies adjacent to tests
106 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700107 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400108
Yo Chiang219968c2020-09-22 18:45:04 +0800109 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
110 SystemSharedLibs []string
111
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500112 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800113 StaticUnwinderIfLegacy bool
114
Colin Cross5950f382016-12-13 12:50:57 -0800115 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700116
Colin Cross81413472016-04-11 14:37:39 -0700117 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700118
Dan Willemsenb40aab62016-04-20 14:21:14 -0700119 GeneratedSources []string
120 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900121 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700122
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700123 ReexportGeneratedHeaders []string
124
Colin Crossc465efd2021-06-11 18:00:04 -0700125 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700126
127 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700128 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900129
130 // List of libs that need to be excluded for APEX variant
131 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700132}
133
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500134// PathDeps is a struct containing file paths to dependencies of a module.
135// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
136// It's used to construct flags for various build statements (such as for compiling and linking).
137// It is then passed to module decorator functions responsible for registering build statements
138// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800139type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700140 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900141 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700142 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900143 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700144 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700145 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700146
Colin Cross0de8a1e2020-09-18 14:15:30 -0700147 // Transitive static library dependencies of static libraries for use in ordering.
148 TranstiveStaticLibrariesForOrdering *android.DepSet
149
Colin Cross26c34ed2016-09-30 17:10:16 -0700150 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100151 Objs Objects
152 // Paths to .o files in dependencies that provide them. Note that these lists
153 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800154 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700155 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700156
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100157 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
158 // the libs from all whole_static_lib dependencies.
159 WholeStaticLibsFromPrebuilts android.Paths
160
Colin Cross26c34ed2016-09-30 17:10:16 -0700161 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700162 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900163 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700164
Inseob Kimd110f872019-12-06 13:15:38 +0900165 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000166 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900167 IncludeDirs android.Paths
168 SystemIncludeDirs android.Paths
169 ReexportedDirs android.Paths
170 ReexportedSystemDirs android.Paths
171 ReexportedFlags []string
172 ReexportedGeneratedHeaders android.Paths
173 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700174
Colin Cross26c34ed2016-09-30 17:10:16 -0700175 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700176 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700177
Dan Willemsena0790e32018-10-12 00:24:23 -0700178 // Path to the dynamic linker binary
179 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700180
181 // For Darwin builds, the path to the second architecture's output that should
182 // be combined with this architectures's output into a FAT MachO file.
183 DarwinSecondArchOutput android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700184}
185
Colin Cross4af21ed2019-11-04 09:37:55 -0800186// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
187// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
188// command line so they can be overridden by the local module flags).
189type LocalOrGlobalFlags struct {
190 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700191 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800192 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700193 CFlags []string // Flags that apply to C and C++ source files
194 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
195 ConlyFlags []string // Flags that apply to C source files
196 CppFlags []string // Flags that apply to C++ source files
197 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700198 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800199}
200
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500201// Flags contains various types of command line flags (and settings) for use in building build
202// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800203type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500204 // Local flags (which individual modules are responsible for). These may override global flags.
205 Local LocalOrGlobalFlags
206 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800207 Global LocalOrGlobalFlags
208
209 aidlFlags []string // Flags that apply to aidl source files
210 rsFlags []string // Flags that apply to renderscript source files
211 libFlags []string // Flags to add libraries early to the link order
212 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
213 TidyFlags []string // Flags that apply to clang-tidy
214 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700215
Colin Crossc3199482017-03-30 15:03:04 -0700216 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800217 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700218 SystemIncludeFlags []string
219
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800220 Toolchain config.Toolchain
221 Tidy bool // True if ninja .tidy rules should be generated.
222 NeedTidyFiles bool // True if module link should depend on .tidy files
223 GcovCoverage bool // True if coverage files should be generated.
224 SAbiDump bool // True if header abi dumps should be generated.
225 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800226
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500227 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800228 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500229 // The target-device system path to the dynamic linker.
230 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800231
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700232 CFlagsDeps android.Paths // Files depended on by compiler flags
233 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800234
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500235 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700236 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800237
Colin Cross19878da2019-03-28 14:45:07 -0700238 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700239 protoC bool // Whether to use C instead of C++
240 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700241
242 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200243 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700244}
245
Colin Crossca860ac2016-01-04 14:34:37 -0800246// Properties used to compile all C or C++ modules
247type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700248 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800249 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700250
Jiyong Parkb35a8192020-08-10 15:59:36 +0900251 // The API level that this module is built against. The APIs of this API level will be
252 // visible at build time, but use of any APIs newer than min_sdk_version will render the
253 // module unloadable on older devices. In the future it will be possible to weakly-link new
254 // APIs, making the behavior match Java: such modules will load on older devices, but
255 // calling new APIs on devices that do not support them will result in a crash.
256 //
257 // This property has the same behavior as sdk_version does for Java modules. For those
258 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
259 // does for Java code.
260 //
261 // In addition, setting this property causes two variants to be built, one for the platform
262 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800263 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700264
Jiyong Parkb35a8192020-08-10 15:59:36 +0900265 // Minimum OS API level supported by this C or C++ module. This property becomes the value
266 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
267 // this property is also used to ensure that the min_sdk_version of the containing module is
268 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
269 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
270 // min_sdk_version of the containing APEX. When the module
271 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900272 Min_sdk_version *string
273
Colin Crossc511bc52020-04-07 16:50:32 +0000274 // If true, always create an sdk variant and don't create a platform variant.
275 Sdk_variant_only *bool
276
Jiyong Parkde866cb2018-12-07 23:08:36 +0900277 AndroidMkSharedLibs []string `blueprint:"mutated"`
278 AndroidMkStaticLibs []string `blueprint:"mutated"`
279 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
280 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700281 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900282 HideFromMake bool `blueprint:"mutated"`
283 PreventInstall bool `blueprint:"mutated"`
284 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700285
Yo Chiang219968c2020-09-22 18:45:04 +0800286 // Set by DepsMutator.
287 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
288
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200289 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900290 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200291
292 // The VNDK version this module is built against. If empty, the module is not
293 // build against the VNDK.
294 VndkVersion string `blueprint:"mutated"`
295
296 // Suffix for the name of Android.mk entries generated by this module
297 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800298
299 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
300 // file
301 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900302
Yifan Hong39143a92020-10-26 12:43:12 -0700303 // Make this module available when building for ramdisk.
304 // On device without a dedicated recovery partition, the module is only
305 // available after switching root into
306 // /first_stage_ramdisk. To expose the module before switching root, install
307 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800308 Ramdisk_available *bool
309
Yifan Hong39143a92020-10-26 12:43:12 -0700310 // Make this module available when building for vendor ramdisk.
311 // On device without a dedicated recovery partition, the module is only
312 // available after switching root into
313 // /first_stage_ramdisk. To expose the module before switching root, install
314 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700315 Vendor_ramdisk_available *bool
316
Jiyong Parkf9332f12018-02-01 00:54:12 +0900317 // Make this module available when building for recovery
318 Recovery_available *bool
319
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200320 // Used by imageMutator, set by ImageMutatorBegin()
321 CoreVariantNeeded bool `blueprint:"mutated"`
322 RamdiskVariantNeeded bool `blueprint:"mutated"`
323 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
324 RecoveryVariantNeeded bool `blueprint:"mutated"`
325
326 // A list of variations for the "image" mutator of the form
327 //<image name> '.' <version char>, for example, 'vendor.S'
328 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900329
330 // Allows this module to use non-APEX version of libraries. Useful
331 // for building binaries that are started before APEXes are activated.
332 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900333
334 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
335 // see soong/cc/config/vndk.go
336 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900337
338 // Used by vendor snapshot to record dependencies from snapshot modules.
339 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900340 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900341 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000342
Colin Cross1bc94122021-10-28 13:25:54 -0700343 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000344
345 // Set by factories of module types that can only be referenced from variants compiled against
346 // the SDK.
347 AlwaysSdk bool `blueprint:"mutated"`
348
349 // Variant is an SDK variant created by sdkMutator
350 IsSdkVariant bool `blueprint:"mutated"`
351 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
352 // variant to have a ".sdk" suffix.
353 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700354
355 // Normally Soong uses the directory structure to decide which modules
356 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800357 // different snapshots (vendor, recovery, etc.), but this property
358 // allows a partner to exclude a module normally thought of as a
359 // framework module from the vendor snapshot.
360 Exclude_from_vendor_snapshot *bool
361
362 // Normally Soong uses the directory structure to decide which modules
363 // should be included (framework) or excluded (non-framework) from the
364 // different snapshots (vendor, recovery, etc.), but this property
365 // allows a partner to exclude a module normally thought of as a
366 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800367 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900368
369 // List of APEXes that this module has private access to for testing purpose. The module
370 // can depend on libraries that are not exported by the APEXes and use private symbols
371 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000372 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800373
374 Target struct {
375 Platform struct {
376 // List of modules required by the core variant.
377 Required []string `android:"arch_variant"`
378
379 // List of modules not required by the core variant.
380 Exclude_required []string `android:"arch_variant"`
381 } `android:"arch_variant"`
382
383 Recovery struct {
384 // List of modules required by the recovery variant.
385 Required []string `android:"arch_variant"`
386
387 // List of modules not required by the recovery variant.
388 Exclude_required []string `android:"arch_variant"`
389 } `android:"arch_variant"`
390 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700391}
392
393type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900394 // whether this module should be allowed to be directly depended by other
395 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900396 // If set to true, two variants will be built separately, one like
397 // normal, and the other limited to the set of libraries and headers
398 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700399 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900400 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700401 // so it shouldn't have any unversioned runtime dependencies, or
402 // make assumptions about the system that may not be true in the
403 // future.
404 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900405 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900406 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900407 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900408 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900409 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700410 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
411 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900412
Justin Yunebcf0c52021-01-08 18:00:19 +0900413 // This is the same as the "vendor_available" except that the install path
414 // of the vendor variant is /odm or /vendor/odm.
415 // By replacing "vendor_available: true" with "odm_available: true", the
416 // module will install its vendor variant to the /odm partition or /vendor/odm.
417 // As the modules with "odm_available: true" still create the vendor variants,
418 // they can link to the other vendor modules as the vendor_available modules do.
419 // Also, the vendor modules can link to odm_available modules.
420 //
421 // It may not be used for VNDK modules.
422 Odm_available *bool
423
Justin Yun63e9ec72020-10-29 16:49:43 +0900424 // whether this module should be allowed to be directly depended by other
425 // modules with `product_specific: true` or `product_available: true`.
426 // If set to true, an additional product variant will be built separately
427 // that is limited to the set of libraries and headers that are exposed to
428 // /product modules.
429 //
430 // The product variant may be used with a different (newer) /system,
431 // so it shouldn't have any unversioned runtime dependencies, or
432 // make assumptions about the system that may not be true in the
433 // future.
434 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900435 // If set to false, this module becomes inaccessible from /product modules.
436 //
437 // Different from the 'vendor_available' property, the modules with
438 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
439 // library without 'product_available' may not be depended on by any other
440 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900441 //
442 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
443 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
444 Product_available *bool
445
Jiyong Park5fb8c102018-04-09 12:03:06 +0900446 // whether this module is capable of being loaded with other instance
447 // (possibly an older version) of the same module in the same process.
448 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
449 // can be double loaded in a vendor process if the library is also a
450 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
451 // explicitly marked as `double_loadable: true` by the owner, or the dependency
452 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
453 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800454
455 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
456 IsLLNDK bool `blueprint:"mutated"`
457
Colin Cross78212242021-01-06 14:51:30 -0800458 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
459 // set and the module is not listed in VndkMustUseVendorVariantList.
460 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
461
462 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
463 IsVNDKCore bool `blueprint:"mutated"`
464
465 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
466 IsVNDKSP bool `blueprint:"mutated"`
467
468 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
469 // module sets the llndk.private property.
470 IsVNDKPrivate bool `blueprint:"mutated"`
471
472 // IsVNDKProduct is set if a VNDK module sets the product_available property.
473 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700474
475 // IsVendorPublicLibrary is set for the core and product variants of a library that has
476 // vendor_public_library stubs.
477 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800478}
479
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500480// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
481// to understanding details about the type of the current module.
482// For example, one might call these functions to determine whether the current module is a static
483// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800484type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800485 static() bool
486 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700487 testBinary() 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
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800517 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800518 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800519 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700520 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700521 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900522 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800523 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700524 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700525 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800526 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800527 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800528 getSharedFlags() *SharedFlags
529}
530
531type SharedFlags struct {
532 numSharedFlags int
533 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800534}
535
536type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700537 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800538 ModuleContextIntf
539}
540
541type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700542 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800543 ModuleContextIntf
544}
545
Colin Cross37047f12016-12-13 17:06:13 -0800546type DepsContext interface {
547 android.BottomUpMutatorContext
548 ModuleContextIntf
549}
550
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500551// feature represents additional (optional) steps to building cc-related modules, such as invocation
552// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800553type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800554 flags(ctx ModuleContext, flags Flags) Flags
555 props() []interface{}
556}
557
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500558// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500559// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800560type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700561 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800562 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800563 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700564 compilerProps() []interface{}
565
Colin Cross76fada02016-07-27 10:31:13 -0700566 appendCflags([]string)
567 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700568 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800569}
570
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500571// linker is the interface for a linker decorator object. Individual module types can provide
572// their own implementation for this decorator, and thus specify custom logic regarding build
573// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800574type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700575 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800576 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700577 linkerFlags(ctx ModuleContext, flags Flags) Flags
578 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800579 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700580
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700581 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700582 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900583 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700584
585 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900586 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000587
588 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000589 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
590}
591
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500592// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000593type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500594 sharedLibs []string
595 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
596 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700597 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800598}
599
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500600// installer is the interface for an installer helper object. This helper is responsible for
601// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800602type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700603 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700604 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000605 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800606 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700607 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700608 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900609 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100610 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900611 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800612}
613
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800614type xref interface {
615 XrefCcFiles() android.Paths
616}
617
Colin Cross6e511a92020-07-27 21:26:48 -0700618type libraryDependencyKind int
619
620const (
621 headerLibraryDependency = iota
622 sharedLibraryDependency
623 staticLibraryDependency
624)
625
626func (k libraryDependencyKind) String() string {
627 switch k {
628 case headerLibraryDependency:
629 return "headerLibraryDependency"
630 case sharedLibraryDependency:
631 return "sharedLibraryDependency"
632 case staticLibraryDependency:
633 return "staticLibraryDependency"
634 default:
635 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
636 }
637}
638
639type libraryDependencyOrder int
640
641const (
642 earlyLibraryDependency = -1
643 normalLibraryDependency = 0
644 lateLibraryDependency = 1
645)
646
647func (o libraryDependencyOrder) String() string {
648 switch o {
649 case earlyLibraryDependency:
650 return "earlyLibraryDependency"
651 case normalLibraryDependency:
652 return "normalLibraryDependency"
653 case lateLibraryDependency:
654 return "lateLibraryDependency"
655 default:
656 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
657 }
658}
659
660// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
661// tags that have a set of predefined tag objects that are reused for each dependency, a
662// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
663// That means that comparing a libraryDependencyTag for equality will only be equal if all
664// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
665// then check individual metadata fields instead.
666type libraryDependencyTag struct {
667 blueprint.BaseDependencyTag
668
669 // These are exported so that fmt.Printf("%#v") can call their String methods.
670 Kind libraryDependencyKind
671 Order libraryDependencyOrder
672
673 wholeStatic bool
674
675 reexportFlags bool
676 explicitlyVersioned bool
677 dataLib bool
678 ndk bool
679
680 staticUnwinder bool
681
682 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900683
Cindy Zhou18417cb2020-12-10 07:12:38 -0800684 // Whether or not this dependency should skip the apex dependency check
685 skipApexAllowedDependenciesCheck bool
686
Jiyong Parke3867542020-12-03 17:28:25 +0900687 // Whether or not this dependency has to be followed for the apex variants
688 excludeInApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000689
690 // If true, don't automatically export symbols from the static library into a shared library.
691 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700692}
693
694// header returns true if the libraryDependencyTag is tagging a header lib dependency.
695func (d libraryDependencyTag) header() bool {
696 return d.Kind == headerLibraryDependency
697}
698
699// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
700func (d libraryDependencyTag) shared() bool {
701 return d.Kind == sharedLibraryDependency
702}
703
704// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
705func (d libraryDependencyTag) static() bool {
706 return d.Kind == staticLibraryDependency
707}
708
Colin Cross65cb3142021-12-10 23:05:02 +0000709func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
710 if d.shared() {
711 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
712 }
713 return nil
714}
715
716var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
717
Colin Crosse9fe2942020-11-10 18:12:15 -0800718// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
719// binaries or other shared libraries are installed as dependencies.
720func (d libraryDependencyTag) InstallDepNeeded() bool {
721 return d.shared()
722}
723
724var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
725
726// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700727// libraryDependencyTag. Each tag object is created globally and reused for multiple
728// dependencies (although since the object contains no references, assigning a tag to a
729// variable and modifying it will not modify the original). Users can compare the tag
730// returned by ctx.OtherModuleDependencyTag against the global original
731type dependencyTag struct {
732 blueprint.BaseDependencyTag
733 name string
734}
735
Colin Crosse9fe2942020-11-10 18:12:15 -0800736// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
737// libraryDependencyTag, but where the dependency needs to be installed when the parent is
738// installed.
739type installDependencyTag struct {
740 blueprint.BaseDependencyTag
741 android.InstallAlwaysNeededDependencyTag
742 name string
743}
744
Colin Crossc99deeb2016-04-11 15:06:20 -0700745var (
Colin Cross6e511a92020-07-27 21:26:48 -0700746 genSourceDepTag = dependencyTag{name: "gen source"}
747 genHeaderDepTag = dependencyTag{name: "gen header"}
748 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
749 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900750 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700751 reuseObjTag = dependencyTag{name: "reuse objects"}
752 staticVariantTag = dependencyTag{name: "static variant"}
753 vndkExtDepTag = dependencyTag{name: "vndk extends"}
754 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700755 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800756 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700757 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700758 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000759 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700760)
761
Roland Levillainf89cd092019-07-29 16:22:59 +0100762func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700763 ccLibDepTag, ok := depTag.(libraryDependencyTag)
764 return ok && ccLibDepTag.shared()
765}
766
767func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
768 ccLibDepTag, ok := depTag.(libraryDependencyTag)
769 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100770}
771
Zach Johnson3df4e632020-11-06 11:56:27 -0800772func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
773 ccLibDepTag, ok := depTag.(libraryDependencyTag)
774 return ok && ccLibDepTag.header()
775}
776
Roland Levillainf89cd092019-07-29 16:22:59 +0100777func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800778 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100779}
780
781func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700782 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100783 return ok && ccDepTag == testPerSrcDepTag
784}
785
Chris Parsonsf874e462022-05-10 13:50:12 -0400786// bazelHandler is the interface for a helper object related to deferring to Bazel for
787// processing a cc module (during Bazel mixed builds). Individual module types should define
788// their own bazel handler if they support being handled by Bazel.
789type BazelHandler interface {
790 // QueueBazelCall invokes request-queueing functions on the BazelContext
791 //so that these requests are handled when Bazel's cquery is invoked.
792 QueueBazelCall(ctx android.BaseModuleContext, label string)
793
794 // ProcessBazelQueryResponse uses information retrieved from Bazel to set properties
795 // on the current module with given label.
796 ProcessBazelQueryResponse(ctx android.ModuleContext, label string)
797}
798
Colin Crossca860ac2016-01-04 14:34:37 -0800799// Module contains the properties and members used by all C/C++ module types, and implements
800// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500801// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
802// interface.
803//
804// To define a C/C++ related module, construct a new Module object and point its delegates to
805// type-specific structs. These delegates will be invoked to register module-specific build
806// statements which may be unique to the module type. For example, module.compiler.compile() should
807// be defined so as to register build statements which are responsible for compiling the module.
808//
809// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
810// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
811// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
812// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800813type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700814 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700815
Jiyong Parkd1063c12019-07-17 20:08:41 +0900816 android.SdkBase
Liz Kammerea6666f2021-02-17 10:17:28 -0500817 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700818
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700819 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700820 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700821
Colin Crossca860ac2016-01-04 14:34:37 -0800822 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400823 hod android.HostOrDeviceSupported
824 multilib android.Multilib
825 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700826
Paul Duffina0843f62019-12-13 19:50:38 +0000827 // Allowable SdkMemberTypes of this module type.
828 sdkMemberTypes []android.SdkMemberType
829
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500830 // decorator delegates, initialize before calling Init
831 // these may contain module-specific implementations, and effectively allow for custom
832 // type-specific logic. These members may reference different objects or the same object.
833 // Functions of these decorators will be invoked to initialize and register type-specific
834 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500835 compiler compiler
836 linker linker
837 installer installer
Chris Parsonsf874e462022-05-10 13:50:12 -0400838 bazelHandler BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500839
840 features []feature
841 stl *stl
842 sanitize *sanitize
843 coverage *coverage
Cory Barkera1da26f2022-06-07 20:12:06 +0000844 fuzzer *fuzzer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500845 sabi *sabi
846 vndkdep *vndkdep
847 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800848 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500849 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800850
Colin Cross31076b32020-10-23 17:22:06 -0700851 library libraryInterface
852
Colin Cross635c3b02016-05-18 15:37:25 -0700853 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800854
Colin Crossb98c8b02016-07-29 13:44:28 -0700855 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700856
857 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800858
859 // Flags used to compile this module
860 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700861
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800862 // Shared flags among build rules of this module
863 sharedFlags SharedFlags
864
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800865 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700866 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900867
868 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800869 // Kythe (source file indexer) paths for this compilation module
870 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700871 // Object .o file output paths for this compilation module
872 objFiles android.Paths
873 // Tidy .tidy file output paths for this compilation module
874 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900875
876 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700877 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700878
879 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700880}
881
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200882func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400883 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
884 if b, ok := c.compiler.(*baseCompiler); ok {
885 hasAidl = b.hasSrcExt(".aidl")
886 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
887 hasProto = b.hasSrcExt(".proto")
888 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
889 hasSysprop = b.hasSrcExt(".sysprop")
890 hasWinMsg = b.hasSrcExt(".mc")
891 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
892 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200893 c.AndroidModuleBase().AddJSONData(d)
894 (*d)["Cc"] = map[string]interface{}{
895 "SdkVersion": c.SdkVersion(),
896 "MinSdkVersion": c.MinSdkVersion(),
897 "VndkVersion": c.VndkVersion(),
898 "ProductSpecific": c.ProductSpecific(),
899 "SocSpecific": c.SocSpecific(),
900 "DeviceSpecific": c.DeviceSpecific(),
901 "InProduct": c.InProduct(),
902 "InVendor": c.InVendor(),
903 "InRamdisk": c.InRamdisk(),
904 "InVendorRamdisk": c.InVendorRamdisk(),
905 "InRecovery": c.InRecovery(),
906 "VendorAvailable": c.VendorAvailable(),
907 "ProductAvailable": c.ProductAvailable(),
908 "RamdiskAvailable": c.RamdiskAvailable(),
909 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
910 "RecoveryAvailable": c.RecoveryAvailable(),
911 "OdmAvailable": c.OdmAvailable(),
912 "InstallInData": c.InstallInData(),
913 "InstallInRamdisk": c.InstallInRamdisk(),
914 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
915 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
916 "InstallInRecovery": c.InstallInRecovery(),
917 "InstallInRoot": c.InstallInRoot(),
918 "IsVndk": c.IsVndk(),
919 "IsVndkExt": c.IsVndkExt(),
920 "IsVndkPrivate": c.IsVndkPrivate(),
921 "IsVndkSp": c.IsVndkSp(),
922 "IsLlndk": c.IsLlndk(),
923 "IsLlndkPublic": c.IsLlndkPublic(),
924 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
925 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
926 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
927 "ApexSdkVersion": c.apexSdkVersion,
928 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400929 "AidlSrcs": hasAidl,
930 "LexSrcs": hasLex,
931 "ProtoSrcs": hasProto,
932 "RenderscriptSrcs": hasRenderscript,
933 "SyspropSrcs": hasSysprop,
934 "WinMsgSrcs": hasWinMsg,
935 "YaccSrsc": hasYacc,
936 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200937 }
938}
939
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500940func (c *Module) SetPreventInstall() {
941 c.Properties.PreventInstall = true
942}
943
944func (c *Module) SetHideFromMake() {
945 c.Properties.HideFromMake = true
946}
947
Ivan Lozanod7586b62021-04-01 09:49:36 -0400948func (c *Module) HiddenFromMake() bool {
949 return c.Properties.HideFromMake
950}
951
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800952func (c *Module) RequiredModuleNames() []string {
953 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
954 if c.ImageVariation().Variation == android.CoreVariation {
955 required = append(required, c.Properties.Target.Platform.Required...)
956 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
957 } else if c.InRecovery() {
958 required = append(required, c.Properties.Target.Recovery.Required...)
959 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
960 }
961 return android.FirstUniqueStrings(required)
962}
963
Ivan Lozano52767be2019-10-18 14:49:46 -0700964func (c *Module) Toc() android.OptionalPath {
965 if c.linker != nil {
966 if library, ok := c.linker.(libraryInterface); ok {
967 return library.toc()
968 }
969 }
970 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
971}
972
973func (c *Module) ApiLevel() string {
974 if c.linker != nil {
975 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700976 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700977 }
978 }
979 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
980}
981
982func (c *Module) Static() bool {
983 if c.linker != nil {
984 if library, ok := c.linker.(libraryInterface); ok {
985 return library.static()
986 }
987 }
988 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
989}
990
991func (c *Module) Shared() bool {
992 if c.linker != nil {
993 if library, ok := c.linker.(libraryInterface); ok {
994 return library.shared()
995 }
996 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +0200997
Ivan Lozano52767be2019-10-18 14:49:46 -0700998 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
999}
1000
1001func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001002 if c.stl != nil {
1003 return c.stl.Properties.SelectedStl
1004 }
1005 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001006}
1007
Ivan Lozano52767be2019-10-18 14:49:46 -07001008func (c *Module) NdkPrebuiltStl() bool {
1009 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1010 return true
1011 }
1012 return false
1013}
1014
1015func (c *Module) StubDecorator() bool {
1016 if _, ok := c.linker.(*stubDecorator); ok {
1017 return true
1018 }
1019 return false
1020}
1021
1022func (c *Module) SdkVersion() string {
1023 return String(c.Properties.Sdk_version)
1024}
1025
Artur Satayev480e25b2020-04-27 18:53:18 +01001026func (c *Module) MinSdkVersion() string {
1027 return String(c.Properties.Min_sdk_version)
1028}
1029
Jiyong Park5df7bd32021-08-25 16:18:46 +09001030func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001031 if linker, ok := c.linker.(*objectLinker); ok {
1032 return linker.isCrt()
1033 }
1034 return false
1035}
1036
Jiyong Park5df7bd32021-08-25 16:18:46 +09001037func (c *Module) SplitPerApiLevel() bool {
1038 return c.canUseSdk() && c.isCrt()
1039}
1040
Colin Crossc511bc52020-04-07 16:50:32 +00001041func (c *Module) AlwaysSdk() bool {
1042 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1043}
1044
Ivan Lozano183a3212019-10-18 14:18:45 -07001045func (c *Module) CcLibrary() bool {
1046 if c.linker != nil {
1047 if _, ok := c.linker.(*libraryDecorator); ok {
1048 return true
1049 }
Colin Crossd48fe732020-09-23 20:37:24 -07001050 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1051 return true
1052 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001053 }
1054 return false
1055}
1056
1057func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001058 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001059 return true
1060 }
1061 return false
1062}
1063
Ivan Lozano2b262972019-11-21 12:30:50 -08001064func (c *Module) NonCcVariants() bool {
1065 return false
1066}
1067
Ivan Lozano183a3212019-10-18 14:18:45 -07001068func (c *Module) SetStatic() {
1069 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001070 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001071 library.setStatic()
1072 return
1073 }
1074 }
1075 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1076}
1077
1078func (c *Module) SetShared() {
1079 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001080 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001081 library.setShared()
1082 return
1083 }
1084 }
1085 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1086}
1087
1088func (c *Module) BuildStaticVariant() bool {
1089 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001090 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001091 return library.buildStatic()
1092 }
1093 }
1094 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1095}
1096
1097func (c *Module) BuildSharedVariant() bool {
1098 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001099 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001100 return library.buildShared()
1101 }
1102 }
1103 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1104}
1105
1106func (c *Module) Module() android.Module {
1107 return c
1108}
1109
Jiyong Parkc20eee32018-09-05 22:36:17 +09001110func (c *Module) OutputFile() android.OptionalPath {
1111 return c.outputFile
1112}
1113
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001114func (c *Module) CoverageFiles() android.Paths {
1115 if c.linker != nil {
1116 if library, ok := c.linker.(libraryInterface); ok {
1117 return library.objs().coverageFiles
1118 }
1119 }
1120 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1121}
1122
Ivan Lozano183a3212019-10-18 14:18:45 -07001123var _ LinkableInterface = (*Module)(nil)
1124
Jiyong Park719b4462019-01-13 00:39:51 +09001125func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001126 if c.linker != nil {
1127 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001128 }
1129 return nil
1130}
1131
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001132func (c *Module) CoverageOutputFile() android.OptionalPath {
1133 if c.linker != nil {
1134 return c.linker.coverageOutputFilePath()
1135 }
1136 return android.OptionalPath{}
1137}
1138
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001139func (c *Module) RelativeInstallPath() string {
1140 if c.installer != nil {
1141 return c.installer.relativeInstallPath()
1142 }
1143 return ""
1144}
1145
Jooyung Han344d5432019-08-23 11:17:39 +09001146func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001147 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001148}
1149
Colin Cross36242852017-06-23 15:06:31 -07001150func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001151 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001152 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001153 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001154 }
1155 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001156 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001157 }
1158 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001159 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001160 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001161 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001162 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001163 }
Colin Cross16b23492016-01-06 14:41:07 -08001164 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001165 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001166 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001167 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001168 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001169 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001170 if c.fuzzer != nil {
1171 c.AddProperties(c.fuzzer.props()...)
1172 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001173 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001174 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001175 }
Justin Yun8effde42017-06-23 19:24:43 +09001176 if c.vndkdep != nil {
1177 c.AddProperties(c.vndkdep.props()...)
1178 }
Stephen Craneba090d12017-05-09 15:44:35 -07001179 if c.lto != nil {
1180 c.AddProperties(c.lto.props()...)
1181 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001182 if c.afdo != nil {
1183 c.AddProperties(c.afdo.props()...)
1184 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001185 if c.pgo != nil {
1186 c.AddProperties(c.pgo.props()...)
1187 }
Colin Crossca860ac2016-01-04 14:34:37 -08001188 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001189 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001190 }
Colin Crossc472d572015-03-17 15:06:21 -07001191
Colin Cross36242852017-06-23 15:06:31 -07001192 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001193 if c.bazelable {
1194 android.InitBazelModule(c)
1195 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001196 android.InitApexModule(c)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001197 android.InitSdkAwareModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001198 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001199
Colin Cross36242852017-06-23 15:06:31 -07001200 return c
Colin Crossc472d572015-03-17 15:06:21 -07001201}
1202
Ivan Lozano52767be2019-10-18 14:49:46 -07001203func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001204 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001205}
1206
Colin Crossc511bc52020-04-07 16:50:32 +00001207func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001208 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1209 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001210}
1211
1212func (c *Module) UseSdk() bool {
1213 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001214 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001215 }
1216 return false
1217}
1218
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001219func (c *Module) isCoverageVariant() bool {
1220 return c.coverage.Properties.IsCoverageVariant
1221}
1222
Colin Cross95f1ca02020-10-29 20:47:22 -07001223func (c *Module) IsNdk(config android.Config) bool {
1224 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001225}
1226
Colin Cross127bb8b2020-12-16 16:46:01 -08001227func (c *Module) IsLlndk() bool {
1228 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001229}
1230
Colin Cross127bb8b2020-12-16 16:46:01 -08001231func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001232 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001233}
1234
Colin Cross1f3f1302021-04-26 18:37:44 -07001235func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001236 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001237 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001238}
1239
Colin Cross5271fea2021-04-27 13:06:04 -07001240func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1241 lib := moduleLibraryInterface(m)
1242 return lib != nil && (lib.hasVendorPublicLibrary())
1243}
1244
1245// IsVendorPublicLibrary returns true for vendor public libraries.
1246func (c *Module) IsVendorPublicLibrary() bool {
1247 return c.VendorProperties.IsVendorPublicLibrary
1248}
1249
Ivan Lozanof1868af2022-04-12 13:08:36 -04001250func (c *Module) IsVndkPrebuiltLibrary() bool {
1251 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1252 return true
1253 }
1254 return false
1255}
1256
1257func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1258 return c.Properties.SdkAndPlatformVariantVisibleToMake
1259}
1260
Ivan Lozanod7586b62021-04-01 09:49:36 -04001261func (c *Module) HasLlndkStubs() bool {
1262 lib := moduleLibraryInterface(c)
1263 return lib != nil && lib.hasLLNDKStubs()
1264}
1265
1266func (c *Module) StubsVersion() string {
1267 if lib, ok := c.linker.(versionedInterface); ok {
1268 return lib.stubsVersion()
1269 }
1270 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1271}
1272
Colin Cross127bb8b2020-12-16 16:46:01 -08001273// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1274// and does not set llndk.vendor_available: false.
1275func (c *Module) isImplementationForLLNDKPublic() bool {
1276 library, _ := c.library.(*libraryDecorator)
1277 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001278 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001279}
1280
Justin Yunfd9e8042020-12-23 18:23:14 +09001281// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001282func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001283 // Check if VNDK-core-private or VNDK-SP-private
1284 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001285 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001286 }
1287
1288 // Check if LLNDK-private
1289 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001290 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001291 }
1292
1293 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001294}
1295
Ivan Lozano52767be2019-10-18 14:49:46 -07001296func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001297 if vndkdep := c.vndkdep; vndkdep != nil {
1298 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001299 }
1300 return false
1301}
1302
Yi Kong4ef54592022-02-14 20:00:10 +08001303func (c *Module) isAfdoCompile() bool {
1304 if afdo := c.afdo; afdo != nil {
1305 return afdo.Properties.AfdoTarget != nil
1306 }
1307 return false
1308}
1309
Yi Kong7e53c572018-02-14 18:16:12 +08001310func (c *Module) isPgoCompile() bool {
1311 if pgo := c.pgo; pgo != nil {
1312 return pgo.Properties.PgoCompile
1313 }
1314 return false
1315}
1316
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001317func (c *Module) isNDKStubLibrary() bool {
1318 if _, ok := c.compiler.(*stubDecorator); ok {
1319 return true
1320 }
1321 return false
1322}
1323
Ivan Lozanod7586b62021-04-01 09:49:36 -04001324func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001325 if vndkdep := c.vndkdep; vndkdep != nil {
1326 return vndkdep.isVndkSp()
1327 }
1328 return false
1329}
1330
Ivan Lozanof9e21722020-12-02 09:00:51 -05001331func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001332 if vndkdep := c.vndkdep; vndkdep != nil {
1333 return vndkdep.isVndkExt()
1334 }
1335 return false
1336}
1337
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001338func (c *Module) SubName() string {
1339 return c.Properties.SubName
1340}
1341
Ivan Lozano52767be2019-10-18 14:49:46 -07001342func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001343 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001344}
1345
Logan Chienf3511742017-10-31 18:04:35 +08001346func (c *Module) getVndkExtendsModuleName() string {
1347 if vndkdep := c.vndkdep; vndkdep != nil {
1348 return vndkdep.getVndkExtendsModuleName()
1349 }
1350 return ""
1351}
1352
Jiyong Park25fc6a92018-11-18 18:02:45 +09001353func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001354 if lib := c.library; lib != nil {
1355 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001356 }
1357 return false
1358}
1359
1360func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001361 if lib := c.library; lib != nil {
1362 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001363 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001364 return false
1365}
1366
Colin Cross0477b422020-10-13 18:43:54 -07001367// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1368// the implementation. If it is an implementation library it returns its own name.
1369func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1370 name := ctx.OtherModuleName(c)
1371 if versioned, ok := c.linker.(versionedInterface); ok {
1372 name = versioned.implementationModuleName(name)
1373 }
1374 return name
1375}
1376
Martin Stjernholm2856c662020-12-02 15:03:42 +00001377// Similar to ImplementationModuleName, but uses the Make variant of the module
1378// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1379// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1380// under the premise that the prebuilt module overrides its source counterpart
1381// if it is exposed to Make).
1382func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1383 name := c.BaseModuleName()
1384 if versioned, ok := c.linker.(versionedInterface); ok {
1385 name = versioned.implementationModuleName(name)
1386 }
1387 return name
1388}
1389
Jiyong Park7d55b612021-06-11 17:22:09 +09001390func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001391 return Bool(c.Properties.Bootstrap)
1392}
1393
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001394func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001395 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1396 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1397 return false
1398 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001399 return c.linker != nil && c.linker.nativeCoverage()
1400}
1401
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001402func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001403 if p, ok := c.linker.(SnapshotInterface); ok {
1404 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001405 }
1406 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001407}
1408
Bill Peckham945441c2020-08-31 16:07:58 -07001409func (c *Module) ExcludeFromVendorSnapshot() bool {
1410 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1411}
1412
Jose Galmesf7294582020-11-13 12:07:36 -08001413func (c *Module) ExcludeFromRecoverySnapshot() bool {
1414 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1415}
1416
Jiyong Parkf1194352019-02-25 11:05:47 +09001417func isBionic(name string) bool {
1418 switch name {
Kiyoung Kim4098c7e2020-11-30 14:42:14 +09001419 case "libc", "libm", "libdl", "libdl_android", "linker", "linkerconfig":
Jiyong Parkf1194352019-02-25 11:05:47 +09001420 return true
1421 }
1422 return false
1423}
1424
Martin Stjernholm279de572019-09-10 23:18:20 +01001425func InstallToBootstrap(name string, config android.Config) bool {
Colin Cross4c4c1be2022-02-10 11:41:18 -08001426 if name == "libclang_rt.hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001427 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001428 }
1429 return isBionic(name)
1430}
1431
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001432func (c *Module) XrefCcFiles() android.Paths {
1433 return c.kytheFiles
1434}
1435
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001436func (c *Module) isCfiAssemblySupportEnabled() bool {
1437 return c.sanitize != nil &&
1438 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1439}
1440
Inseob Kim800d1142021-06-14 12:03:51 +09001441func (c *Module) InstallInRoot() bool {
1442 return c.installer != nil && c.installer.installInRoot()
1443}
1444
Colin Crossca860ac2016-01-04 14:34:37 -08001445type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001446 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001447 moduleContextImpl
1448}
1449
Colin Cross37047f12016-12-13 17:06:13 -08001450type depsContext struct {
1451 android.BottomUpMutatorContext
1452 moduleContextImpl
1453}
1454
Colin Crossca860ac2016-01-04 14:34:37 -08001455type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001456 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001457 moduleContextImpl
1458}
1459
1460type moduleContextImpl struct {
1461 mod *Module
1462 ctx BaseModuleContext
1463}
1464
Colin Crossb98c8b02016-07-29 13:44:28 -07001465func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001466 return ctx.mod.toolchain(ctx.ctx)
1467}
1468
1469func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001470 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001471}
1472
1473func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001474 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001475}
1476
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001477func (ctx *moduleContextImpl) testBinary() bool {
1478 return ctx.mod.testBinary()
1479}
1480
Jiyong Park1d1119f2019-07-29 21:27:18 +09001481func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001482 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001483}
1484
Inseob Kim7f283f42020-06-01 21:53:49 +09001485func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001486 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001487}
1488
Inseob Kim1042d292020-06-01 23:23:05 +09001489func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001490 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001491}
1492
Jooyung Hanccce2f22020-03-07 03:45:53 +09001493func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001494 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001495}
1496
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001497func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001498 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001499}
1500
1501func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001502 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001503 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001504 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001505 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001506 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001507 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001508 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001509 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001510 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001511 }
1512 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001513}
1514
Jiyong Parkb35a8192020-08-10 15:59:36 +09001515func (ctx *moduleContextImpl) minSdkVersion() string {
1516 ver := ctx.mod.MinSdkVersion()
1517 if ver == "apex_inherit" && !ctx.isForPlatform() {
1518 ver = ctx.apexSdkVersion().String()
1519 }
1520 if ver == "apex_inherit" || ver == "" {
1521 ver = ctx.sdkVersion()
1522 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001523 // For crt objects, the meaning of min_sdk_version is very different from other types of
1524 // module. For them, min_sdk_version defines the oldest version that the build system will
1525 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1526 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1527 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001528 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1529 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1530 // support such an old version. The version is set to the later version in case when the
1531 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1532 // it's for an APEX.
1533 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1534 if ctx.isForPlatform() {
1535 ver = strconv.Itoa(android.FutureApiLevelInt)
1536 } else { // for apex
1537 ver = ctx.apexSdkVersion().String()
1538 if ver == "" { // in case when min_sdk_version was not set by the APEX
1539 ver = ctx.sdkVersion()
1540 }
1541 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001542 }
1543
Jiyong Parkb35a8192020-08-10 15:59:36 +09001544 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1545 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1546 minSdkVersionInt, err2 := strconv.Atoi(ver)
1547 if err == nil && err2 == nil {
1548 if sdkVersionInt < minSdkVersionInt {
1549 return strconv.Itoa(sdkVersionInt)
1550 }
1551 }
1552 return ver
1553}
1554
1555func (ctx *moduleContextImpl) isSdkVariant() bool {
1556 return ctx.mod.IsSdkVariant()
1557}
1558
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001559func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001560 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001561}
Justin Yun8effde42017-06-23 19:24:43 +09001562
Colin Cross95f1ca02020-10-29 20:47:22 -07001563func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1564 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001565}
1566
Colin Cross127bb8b2020-12-16 16:46:01 -08001567func (ctx *moduleContextImpl) IsLlndk() bool {
1568 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001569}
1570
Colin Cross127bb8b2020-12-16 16:46:01 -08001571func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1572 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001573}
1574
Colin Cross127bb8b2020-12-16 16:46:01 -08001575func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1576 return ctx.mod.isImplementationForLLNDKPublic()
1577}
1578
1579func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1580 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001581}
1582
Logan Chienf3511742017-10-31 18:04:35 +08001583func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001584 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001585}
1586
Yi Kong4ef54592022-02-14 20:00:10 +08001587func (ctx *moduleContextImpl) isAfdoCompile() bool {
1588 return ctx.mod.isAfdoCompile()
1589}
1590
Yi Kong7e53c572018-02-14 18:16:12 +08001591func (ctx *moduleContextImpl) isPgoCompile() bool {
1592 return ctx.mod.isPgoCompile()
1593}
1594
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001595func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1596 return ctx.mod.isNDKStubLibrary()
1597}
1598
Justin Yun8effde42017-06-23 19:24:43 +09001599func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001600 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001601}
1602
Ivan Lozanof9e21722020-12-02 09:00:51 -05001603func (ctx *moduleContextImpl) IsVndkExt() bool {
1604 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001605}
1606
Colin Cross5271fea2021-04-27 13:06:04 -07001607func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1608 return ctx.mod.IsVendorPublicLibrary()
1609}
1610
Vic Yangefd249e2018-11-12 20:19:56 -08001611func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001612 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001613}
1614
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001615func (ctx *moduleContextImpl) selectedStl() string {
1616 if stl := ctx.mod.stl; stl != nil {
1617 return stl.Properties.SelectedStl
1618 }
1619 return ""
1620}
1621
Ivan Lozanobd721262018-11-27 14:33:03 -08001622func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1623 return ctx.mod.linker.useClangLld(actx)
1624}
1625
Colin Crossce75d2c2016-10-06 16:12:58 -07001626func (ctx *moduleContextImpl) baseModuleName() string {
1627 return ctx.mod.ModuleBase.BaseModuleName()
1628}
1629
Logan Chienf3511742017-10-31 18:04:35 +08001630func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1631 return ctx.mod.getVndkExtendsModuleName()
1632}
1633
Logan Chiene274fc92019-12-03 11:18:32 -08001634func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001635 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001636}
1637
Colin Crosse07f2312020-08-13 11:24:56 -07001638func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001639 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001640}
1641
Dan Albertc8060532020-07-22 22:32:17 -07001642func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001643 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001644}
1645
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001646func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001647 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001648}
1649
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001650func (ctx *moduleContextImpl) nativeCoverage() bool {
1651 return ctx.mod.nativeCoverage()
1652}
1653
Colin Cross56a83212020-09-15 18:30:11 -07001654func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1655 return ctx.mod.DirectlyInAnyApex()
1656}
1657
Colin Cross95b07f22020-12-16 11:06:50 -08001658func (ctx *moduleContextImpl) isPreventInstall() bool {
1659 return ctx.mod.Properties.PreventInstall
1660}
1661
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001662func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1663 shared := &ctx.mod.sharedFlags
1664 if shared.flagsMap == nil {
1665 shared.numSharedFlags = 0
1666 shared.flagsMap = make(map[string]string)
1667 }
1668 return shared
1669}
1670
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001671func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1672 return ctx.mod.isCfiAssemblySupportEnabled()
1673}
1674
Colin Cross635c3b02016-05-18 15:37:25 -07001675func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001676 return &Module{
1677 hod: hod,
1678 multilib: multilib,
1679 }
1680}
1681
Colin Cross635c3b02016-05-18 15:37:25 -07001682func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001683 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001684 module.features = []feature{
1685 &tidyFeature{},
1686 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001687 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001688 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001689 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001690 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001691 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001692 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001693 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001694 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001695 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001696 return module
1697}
1698
Colin Crossce75d2c2016-10-06 16:12:58 -07001699func (c *Module) Prebuilt() *android.Prebuilt {
1700 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1701 return p.prebuilt()
1702 }
1703 return nil
1704}
1705
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001706func (c *Module) IsPrebuilt() bool {
1707 return c.Prebuilt() != nil
1708}
1709
Colin Crossce75d2c2016-10-06 16:12:58 -07001710func (c *Module) Name() string {
1711 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001712 if p, ok := c.linker.(interface {
1713 Name(string) string
1714 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001715 name = p.Name(name)
1716 }
1717 return name
1718}
1719
Alex Light3d673592019-01-18 14:37:31 -08001720func (c *Module) Symlinks() []string {
1721 if p, ok := c.installer.(interface {
1722 symlinkList() []string
1723 }); ok {
1724 return p.symlinkList()
1725 }
1726 return nil
1727}
1728
Roland Levillainf89cd092019-07-29 16:22:59 +01001729func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1730 test, ok := c.linker.(testPerSrc)
1731 return ok && test.isAllTestsVariation()
1732}
1733
Chris Parsons216e10a2020-07-09 17:12:52 -04001734func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001735 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001736 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001737 }); ok {
1738 return p.dataPaths()
1739 }
1740 return nil
1741}
1742
Ivan Lozanof1868af2022-04-12 13:08:36 -04001743func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001744 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1745 // "current", it will append the VNDK version to the name suffix.
1746 var vndkVersion string
1747 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001748 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001749 if c.ProductSpecific() {
1750 // If the module is product specific with 'product_specific: true',
1751 // do not add a name suffix because it is a base module.
1752 return ""
1753 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001754 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001755 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001756 } else {
1757 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001758 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001759 }
1760 if vndkVersion == "current" {
1761 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1762 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001763 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001764 // add version suffix only if the module is using different vndk version than the
1765 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001766 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001767 }
1768 return nameSuffix
1769}
1770
Ivan Lozanof1868af2022-04-12 13:08:36 -04001771func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1772 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001773
1774 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001775 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001776 }
1777
Colin Cross127bb8b2020-12-16 16:46:01 -08001778 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001779 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001780 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1781 // added for product variant only when we have vendor and product variants with core
1782 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001783 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001784 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001785 subName += vendorPublicLibrarySuffix
1786 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001787 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1788 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001789 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001790 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001791 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001792 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001793 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001794 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001795 subName += RecoverySuffix
1796 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1797 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001798 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001799 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001800 }
Inseob Kim64c43952019-08-26 16:52:35 +09001801 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001802
1803 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001804}
1805
Chris Parsonsf874e462022-05-10 13:50:12 -04001806var _ android.MixedBuildBuildable = (*Module)(nil)
1807
1808func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001809 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001810 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001811 // cc_library is a special case in bp2build; two targets are generated -- one for each
1812 // of the shared and static variants. The shared variant keeps the module name, but the
1813 // static variant uses a different suffixed name.
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001814 bazelModuleLabel = bazelLabelForStaticModule(ctx, c)
1815 } else {
1816 bazelModuleLabel = c.GetBazelLabel(ctx, c)
Chris Parsonsf874e462022-05-10 13:50:12 -04001817 }
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001818 labelNoPrebuilt := bazelModuleLabel
1819 if c.IsPrebuilt() {
1820 labelNoPrebuilt = android.RemoveOptionalPrebuiltPrefixFromBazelLabel(bazelModuleLabel)
1821 }
1822 return labelNoPrebuilt
Chris Parsonsf874e462022-05-10 13:50:12 -04001823}
1824
1825func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1826 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1827}
1828
1829func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
1830 return c.bazelHandler != nil
1831}
1832
1833func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
1834 bazelModuleLabel := c.getBazelModuleLabel(ctx)
1835
1836 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
1837
1838 c.Properties.SubName = GetSubnameProperty(ctx, c)
1839 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1840 if !apexInfo.IsForPlatform() {
1841 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05001842 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05001843
Chris Parsonsf874e462022-05-10 13:50:12 -04001844 c.makeLinkType = GetMakeLinkType(ctx, c)
1845
1846 mctx := &moduleContext{
1847 ModuleContext: ctx,
1848 moduleContextImpl: moduleContextImpl{
1849 mod: c,
1850 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05001851 }
Chris Parsonsf874e462022-05-10 13:50:12 -04001852 mctx.ctx = mctx
1853
1854 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001855}
1856
1857func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001858 // Handle the case of a test module split by `test_per_src` mutator.
1859 //
1860 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1861 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1862 // module and return early, as this module does not produce an output file per se.
1863 if c.IsTestPerSrcAllTestsVariation() {
1864 c.outputFile = android.OptionalPath{}
1865 return
1866 }
1867
Ivan Lozanof1868af2022-04-12 13:08:36 -04001868 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001869 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1870 if !apexInfo.IsForPlatform() {
1871 c.hideApexVariantFromMake = true
1872 }
1873
Chris Parsonseefc9e62021-04-02 17:36:47 -04001874 c.makeLinkType = GetMakeLinkType(actx, c)
1875
Colin Crossca860ac2016-01-04 14:34:37 -08001876 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001877 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001878 moduleContextImpl: moduleContextImpl{
1879 mod: c,
1880 },
1881 }
1882 ctx.ctx = ctx
1883
Colin Crossf18e1102017-11-16 14:33:08 -08001884 deps := c.depsToPaths(ctx)
1885 if ctx.Failed() {
1886 return
1887 }
1888
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001889 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1890 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
1891 }
1892
Colin Crossca860ac2016-01-04 14:34:37 -08001893 flags := Flags{
1894 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001895 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001896 }
Colin Crossca860ac2016-01-04 14:34:37 -08001897 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08001898 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001899 }
1900 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07001901 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08001902 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001903 if c.stl != nil {
1904 flags = c.stl.flags(ctx, flags)
1905 }
Colin Cross16b23492016-01-06 14:41:07 -08001906 if c.sanitize != nil {
1907 flags = c.sanitize.flags(ctx, flags)
1908 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001909 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07001910 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08001911 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001912 if c.fuzzer != nil {
1913 flags = c.fuzzer.flags(ctx, flags)
1914 }
Stephen Craneba090d12017-05-09 15:44:35 -07001915 if c.lto != nil {
1916 flags = c.lto.flags(ctx, flags)
1917 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001918 if c.afdo != nil {
1919 flags = c.afdo.flags(ctx, flags)
1920 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001921 if c.pgo != nil {
1922 flags = c.pgo.flags(ctx, flags)
1923 }
Colin Crossca860ac2016-01-04 14:34:37 -08001924 for _, feature := range c.features {
1925 flags = feature.flags(ctx, flags)
1926 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001927 if ctx.Failed() {
1928 return
1929 }
1930
Colin Cross4af21ed2019-11-04 09:37:55 -08001931 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
1932 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
1933 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08001934
Colin Cross4af21ed2019-11-04 09:37:55 -08001935 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09001936
1937 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001938 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001939 }
1940 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08001941 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09001942 }
1943
Colin Cross3e5e7782022-06-17 22:17:05 +00001944 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
1945
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08001946 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07001947 // We need access to all the flags seen by a source file.
1948 if c.sabi != nil {
1949 flags = c.sabi.flags(ctx, flags)
1950 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07001951
Colin Cross4af21ed2019-11-04 09:37:55 -08001952 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07001953
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001954 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08001955 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001956 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08001957 if ctx.Failed() {
1958 return
1959 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001960 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07001961 c.objFiles = objs.objFiles
1962 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001963 }
1964
Colin Crossca860ac2016-01-04 14:34:37 -08001965 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07001966 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08001967 if ctx.Failed() {
1968 return
1969 }
Colin Cross635c3b02016-05-18 15:37:25 -07001970 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09001971
Chris Parsons94a0bba2021-06-04 15:03:47 -04001972 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001973
Jose Galmes6f843bc2020-12-11 13:36:29 -08001974 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
1975 // RECOVERY_SNAPSHOT_VERSION is current.
1976 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001977 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09001978 i.collectHeadersForSnapshot(ctx)
1979 }
1980 }
Colin Crossce75d2c2016-10-06 16:12:58 -07001981 }
Colin Cross5049f022015-03-18 13:28:46 -07001982
Chris Parsons94a0bba2021-06-04 15:03:47 -04001983 c.maybeInstall(ctx, apexInfo)
1984}
1985
1986func (c *Module) maybeUnhideFromMake() {
1987 // If a lib is directly included in any of the APEXes or is not available to the
1988 // platform (which is often the case when the stub is provided as a prebuilt),
1989 // unhide the stubs variant having the latest version gets visible to make. In
1990 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
1991 // force anything in the make world to link against the stubs library. (unless it
1992 // is explicitly referenced via .bootstrap suffix or the module is marked with
1993 // 'bootstrap: true').
1994 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
1995 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
1996 c.IsStubs() && !c.InVendorRamdisk() {
1997 c.Properties.HideFromMake = false // unhide
1998 // Note: this is still non-installable
1999 }
2000}
2001
2002func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002003 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002004 // If the module has been specifically configure to not be installed then
2005 // hide from make as otherwise it will break when running inside make
2006 // as the output path to install will not be specified. Not all uninstallable
2007 // modules can be hidden from make as some are needed for resolving make side
2008 // dependencies.
2009 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002010 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002011 c.SkipInstall()
2012 }
2013
2014 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2015 // to allow using the outputs in a genrule.
2016 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002017 c.installer.install(ctx, c.outputFile.Path())
2018 if ctx.Failed() {
2019 return
Colin Crossca860ac2016-01-04 14:34:37 -08002020 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002021 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002022}
2023
Colin Cross0ea8ba82019-06-06 14:33:29 -07002024func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002025 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002026 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002027 }
Colin Crossca860ac2016-01-04 14:34:37 -08002028 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002029}
2030
Colin Crossca860ac2016-01-04 14:34:37 -08002031func (c *Module) begin(ctx BaseModuleContext) {
2032 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002033 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002034 }
Colin Crossca860ac2016-01-04 14:34:37 -08002035 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002036 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002037 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002038 if c.stl != nil {
2039 c.stl.begin(ctx)
2040 }
Colin Cross16b23492016-01-06 14:41:07 -08002041 if c.sanitize != nil {
2042 c.sanitize.begin(ctx)
2043 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002044 if c.coverage != nil {
2045 c.coverage.begin(ctx)
2046 }
Stephen Craneba090d12017-05-09 15:44:35 -07002047 if c.lto != nil {
2048 c.lto.begin(ctx)
2049 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002050 if c.afdo != nil {
2051 c.afdo.begin(ctx)
2052 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002053 if c.pgo != nil {
2054 c.pgo.begin(ctx)
2055 }
Dan Albert92fe7402020-07-15 13:33:30 -07002056 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002057 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002058 if err != nil {
2059 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002060 c.Properties.Sdk_version = nil
2061 } else {
2062 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002063 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002064 }
Colin Crossca860ac2016-01-04 14:34:37 -08002065}
2066
Colin Cross37047f12016-12-13 17:06:13 -08002067func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002068 deps := Deps{}
2069
2070 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002071 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002072 }
2073 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002074 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002075 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002076 if c.stl != nil {
2077 deps = c.stl.deps(ctx, deps)
2078 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002079 if c.coverage != nil {
2080 deps = c.coverage.deps(ctx, deps)
2081 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002082
Colin Crossb6715442017-10-24 11:13:31 -07002083 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2084 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2085 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2086 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2087 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2088 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002089 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002090
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002091 for _, lib := range deps.ReexportSharedLibHeaders {
2092 if !inList(lib, deps.SharedLibs) {
2093 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2094 }
2095 }
2096
2097 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002098 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2099 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 -07002100 }
2101 }
2102
Colin Cross5950f382016-12-13 12:50:57 -08002103 for _, lib := range deps.ReexportHeaderLibHeaders {
2104 if !inList(lib, deps.HeaderLibs) {
2105 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2106 }
2107 }
2108
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002109 for _, gen := range deps.ReexportGeneratedHeaders {
2110 if !inList(gen, deps.GeneratedHeaders) {
2111 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2112 }
2113 }
2114
Colin Crossc99deeb2016-04-11 15:06:20 -07002115 return deps
2116}
2117
Dan Albert7e9d2952016-08-04 13:02:36 -07002118func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002119 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002120 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002121 moduleContextImpl: moduleContextImpl{
2122 mod: c,
2123 },
2124 }
2125 ctx.ctx = ctx
2126
Colin Crossca860ac2016-01-04 14:34:37 -08002127 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002128}
2129
Jiyong Park7ed9de32018-10-15 22:25:07 +09002130// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002131func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002132 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2133 version := name[sharp+1:]
2134 libname := name[:sharp]
2135 return libname, version
2136 }
2137 return name, ""
2138}
2139
Dan Albert92fe7402020-07-15 13:33:30 -07002140func GetCrtVariations(ctx android.BottomUpMutatorContext,
2141 m LinkableInterface) []blueprint.Variation {
2142 if ctx.Os() != android.Android {
2143 return nil
2144 }
2145 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002146 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2147 minSdkVersion := m.MinSdkVersion()
2148 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2149 minSdkVersion = m.SdkVersion()
2150 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002151 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2152 if err != nil {
2153 ctx.PropertyErrorf("min_sdk_version", err.Error())
2154 }
Dan Albert92fe7402020-07-15 13:33:30 -07002155 return []blueprint.Variation{
2156 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002157 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002158 }
2159 }
2160 return []blueprint.Variation{
2161 {Mutator: "sdk", Variation: ""},
2162 }
2163}
2164
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002165func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2166 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002167
2168 variations = append([]blueprint.Variation(nil), variations...)
2169
Liz Kammer23942242022-04-08 15:41:00 -04002170 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002171 // Version is explicitly specified. i.e. libFoo#30
2172 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002173 if tag, ok := depTag.(libraryDependencyTag); ok {
2174 tag.explicitlyVersioned = true
2175 } else {
2176 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2177 }
Colin Crosse7257d22020-09-24 09:56:18 -07002178 }
Colin Crosse7257d22020-09-24 09:56:18 -07002179
Colin Cross0de8a1e2020-09-18 14:15:30 -07002180 if far {
2181 ctx.AddFarVariationDependencies(variations, depTag, name)
2182 } else {
2183 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002184 }
2185}
2186
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002187func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002188 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002189 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002190 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002191 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2192 // between the modules in the snapshot and the snapshot itself.
2193 var snapshotModule []blueprint.Module
2194 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2195 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2196 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2197 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2198 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002199 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002200 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2201 *snapshotInfo = &snapshot
2202 // republish the snapshot for use in later mutators on this module
2203 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002204 }
2205 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002206 if *snapshotInfo == nil {
2207 *snapshotInfo = &SnapshotInfo{}
2208 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002209 return **snapshotInfo
2210}
2211
2212func RewriteSnapshotLib(lib string, snapshotMap map[string]string) string {
2213 if snapshot, ok := snapshotMap[lib]; ok {
2214 return snapshot
2215 }
2216
2217 return lib
2218}
2219
2220// RewriteLibs takes a list of names of shared libraries and scans it for three types
2221// of names:
2222//
2223// 1. Name of an NDK library that refers to a prebuilt module.
2224// For each of these, it adds the name of the prebuilt module (which will be in
2225// prebuilts/ndk) to the list of nonvariant libs.
2226// 2. Name of an NDK library that refers to an ndk_library module.
2227// For each of these, it adds the name of the ndk_library module to the list of
2228// variant libs.
2229// 3. Anything else (so anything that isn't an NDK library).
2230// It adds these to the nonvariantLibs list.
2231//
2232// The caller can then know to add the variantLibs dependencies differently from the
2233// nonvariantLibs
2234func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2235 variantLibs = []string{}
2236
2237 nonvariantLibs = []string{}
2238 for _, entry := range list {
2239 // strip #version suffix out
2240 name, _ := StubsLibNameAndVersion(entry)
2241 if c.InRecovery() {
2242 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2243 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2244 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2245 } else if c.UseVndk() {
2246 nonvariantLibs = append(nonvariantLibs, RewriteSnapshotLib(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
2247 } else {
2248 // put name#version back
2249 nonvariantLibs = append(nonvariantLibs, entry)
2250 }
2251 }
2252 return nonvariantLibs, variantLibs
2253}
2254
Colin Cross1e676be2016-10-12 14:38:15 -07002255func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002256 if !c.Enabled() {
2257 return
2258 }
2259
Colin Cross37047f12016-12-13 17:06:13 -08002260 ctx := &depsContext{
2261 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002262 moduleContextImpl: moduleContextImpl{
2263 mod: c,
2264 },
2265 }
2266 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002267
Colin Crossc99deeb2016-04-11 15:06:20 -07002268 deps := c.deps(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002269
Yo Chiang219968c2020-09-22 18:45:04 +08002270 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2271
Colin Crosse0edaf92021-01-11 17:31:17 -08002272 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002273
Dan Albert914449f2016-06-17 16:45:24 -07002274 variantNdkLibs := []string{}
2275 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002276 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002277 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2278 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2279 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002280
2281 for idx, lib := range deps.RuntimeLibs {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002282 deps.RuntimeLibs[idx] = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002283 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002284 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002285
Colin Cross32ec36c2016-12-15 07:39:51 -08002286 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002287 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002288 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002289 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002290 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002291
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002292 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002293
Jiyong Park1ad8e162020-12-01 23:40:09 +09002294 if c.IsStubs() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002295 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002296 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002297 } else {
2298 actx.AddVariationDependencies(nil, depTag, lib)
2299 }
2300 }
2301
Dan Albertf1d14c72020-07-30 14:32:55 -07002302 if c.isNDKStubLibrary() {
2303 // NDK stubs depend on their implementation because the ABI dumps are
2304 // generated from the implementation library.
2305 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2306 c.ImageVariation(),
2307 blueprint.Variation{Mutator: "link", Variation: "shared"},
2308 ), stubImplementation, c.BaseModuleName())
2309 }
2310
Inseob Kim07def122020-11-23 14:43:02 +09002311 // sysprop_library has to support both C++ and Java. So sysprop_library internally creates one
2312 // C++ implementation library and one Java implementation library. When a module links against
2313 // sysprop_library, the C++ implementation library has to be linked. syspropImplLibraries is a
2314 // map from sysprop_library to implementation library; it will be used in whole_static_libs,
2315 // static_libs, and shared_libs.
Inseob Kimc0907f12019-02-08 21:00:45 +09002316 syspropImplLibraries := syspropImplLibraries(actx.Config())
2317
Jiyong Park5d1598f2019-02-25 22:14:17 +09002318 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002319 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Jiyong Park5d1598f2019-02-25 22:14:17 +09002320 if impl, ok := syspropImplLibraries[lib]; ok {
2321 lib = impl
2322 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002323
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002324 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002325
Jiyong Park5d1598f2019-02-25 22:14:17 +09002326 actx.AddVariationDependencies([]blueprint.Variation{
2327 {Mutator: "link", Variation: "static"},
2328 }, depTag, lib)
2329 }
2330
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002331 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002332 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002333 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002334 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002335 }
Jiyong Parke3867542020-12-03 17:28:25 +09002336 if inList(lib, deps.ExcludeLibsForApex) {
2337 depTag.excludeInApex = true
2338 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002339
2340 if impl, ok := syspropImplLibraries[lib]; ok {
2341 lib = impl
2342 }
2343
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002344 lib = RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002345
Dan Willemsen59339a22018-07-22 21:18:45 -07002346 actx.AddVariationDependencies([]blueprint.Variation{
2347 {Mutator: "link", Variation: "static"},
2348 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002349 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002350
Jooyung Han75568392020-03-20 04:29:24 +09002351 // staticUnwinderDep is treated as staticDep for Q apexes
2352 // so that native libraries/binaries are linked with static unwinder
2353 // because Q libc doesn't have unwinder APIs
2354 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002355 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002356 actx.AddVariationDependencies([]blueprint.Variation{
2357 {Mutator: "link", Variation: "static"},
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002358 }, depTag, RewriteSnapshotLib(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002359 }
2360
Jiyong Park7ed9de32018-10-15 22:25:07 +09002361 // shared lib names without the #version suffix
2362 var sharedLibNames []string
2363
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002364 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002365 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002366 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002367 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002368 }
Jiyong Parke3867542020-12-03 17:28:25 +09002369 if inList(lib, deps.ExcludeLibsForApex) {
2370 depTag.excludeInApex = true
2371 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002372
2373 if impl, ok := syspropImplLibraries[lib]; ok {
2374 lib = impl
2375 }
2376
Jiyong Park73c54ee2019-10-22 20:31:18 +09002377 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002378 sharedLibNames = append(sharedLibNames, name)
2379
Colin Crosse7257d22020-09-24 09:56:18 -07002380 variations := []blueprint.Variation{
2381 {Mutator: "link", Variation: "shared"},
2382 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002383 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002384 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002385
Colin Crossfe9acfe2021-06-14 16:13:03 -07002386 for _, lib := range deps.LateStaticLibs {
2387 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2388 actx.AddVariationDependencies([]blueprint.Variation{
2389 {Mutator: "link", Variation: "static"},
2390 }, depTag, RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
2391 }
2392
Colin Cross3e5e7782022-06-17 22:17:05 +00002393 for _, lib := range deps.UnexportedStaticLibs {
2394 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2395 actx.AddVariationDependencies([]blueprint.Variation{
2396 {Mutator: "link", Variation: "static"},
2397 }, depTag, RewriteSnapshotLib(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
2398 }
2399
Jiyong Park7ed9de32018-10-15 22:25:07 +09002400 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002401 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002402 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2403 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2404 // linking against both the stubs lib and the non-stubs lib at the same time.
2405 continue
2406 }
Colin Cross6e511a92020-07-27 21:26:48 -07002407 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002408 variations := []blueprint.Variation{
2409 {Mutator: "link", Variation: "shared"},
2410 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002411 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002412 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002413
Dan Willemsen59339a22018-07-22 21:18:45 -07002414 actx.AddVariationDependencies([]blueprint.Variation{
2415 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002416 }, dataLibDepTag, deps.DataLibs...)
2417
Colin Crossc8caa062021-09-24 16:50:14 -07002418 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2419
Chris Parsons79d66a52020-06-05 17:26:16 -04002420 actx.AddVariationDependencies([]blueprint.Variation{
2421 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002422 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002423
Colin Cross68861832016-07-08 10:41:41 -07002424 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002425
2426 for _, gen := range deps.GeneratedHeaders {
2427 depTag := genHeaderDepTag
2428 if inList(gen, deps.ReexportGeneratedHeaders) {
2429 depTag = genHeaderExportDepTag
2430 }
2431 actx.AddDependency(c, depTag, gen)
2432 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002433
Dan Albert92fe7402020-07-15 13:33:30 -07002434 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002435 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002436 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002437 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002438 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002439 }
Colin Crossc465efd2021-06-11 18:00:04 -07002440 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002441 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Colin Crossc465efd2021-06-11 18:00:04 -07002442 RewriteSnapshotLib(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002443 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002444 if deps.DynamicLinker != "" {
2445 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002446 }
Dan Albert914449f2016-06-17 16:45:24 -07002447
2448 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002449
2450 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002451 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002452 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002453 {Mutator: "link", Variation: "shared"},
2454 }, ndkStubDepTag, variantNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002455
2456 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002457 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002458 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002459 {Mutator: "link", Variation: "shared"},
2460 }, ndkLateStubDepTag, variantLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002461
2462 if vndkdep := c.vndkdep; vndkdep != nil {
2463 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002464 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002465 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002466 {Mutator: "link", Variation: "shared"},
Justin Yun27b95722021-07-28 17:04:44 +09002467 }, vndkExtDepTag, RewriteSnapshotLib(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002468 }
2469 }
Colin Cross6362e272015-10-29 15:25:03 -07002470}
Colin Cross21b9a242015-03-24 14:15:58 -07002471
Colin Crosse40b4ea2018-10-02 22:25:58 -07002472func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002473 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2474 c.beginMutator(ctx)
2475 }
2476}
2477
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002478// Whether a module can link to another module, taking into
2479// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002480func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002481 tag blueprint.DependencyTag) {
2482
2483 switch t := tag.(type) {
2484 case dependencyTag:
2485 if t != vndkExtDepTag {
2486 return
2487 }
2488 case libraryDependencyTag:
2489 default:
2490 return
2491 }
2492
Ivan Lozanof9e21722020-12-02 09:00:51 -05002493 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002494 // Host code is not restricted
2495 return
2496 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002497
2498 // VNDK is cc.Module supported only for now.
2499 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002500 // Though allowed dependency is limited by the image mutator,
2501 // each vendor and product module needs to check link-type
2502 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002503 if ccTo, ok := to.(*Module); ok {
2504 if ccFrom.vndkdep != nil {
2505 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2506 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002507 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002508 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002509 }
2510 return
2511 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002512 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002513 // Platform code can link to anything
2514 return
2515 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002516 if from.InRamdisk() {
2517 // Ramdisk code is not NDK
2518 return
2519 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002520 if from.InVendorRamdisk() {
2521 // Vendor ramdisk code is not NDK
2522 return
2523 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002524 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002525 // Recovery code is not NDK
2526 return
2527 }
Colin Cross31076b32020-10-23 17:22:06 -07002528 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002529 if c.NdkPrebuiltStl() {
2530 // These are allowed, but they don't set sdk_version
2531 return
2532 }
2533 if c.StubDecorator() {
2534 // These aren't real libraries, but are the stub shared libraries that are included in
2535 // the NDK.
2536 return
2537 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002538 }
Logan Chien834b9a62019-01-14 15:39:03 +08002539
Ivan Lozano52767be2019-10-18 14:49:46 -07002540 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002541 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2542 // to link to libc++ (non-NDK and without sdk_version).
2543 return
2544 }
2545
Ivan Lozano52767be2019-10-18 14:49:46 -07002546 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002547 // NDK code linking to platform code is never okay.
2548 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002549 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002550 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002551 }
2552
2553 // At this point we know we have two NDK libraries, but we need to
2554 // check that we're not linking against anything built against a higher
2555 // API level, as it is only valid to link against older or equivalent
2556 // APIs.
2557
Inseob Kim01a28722018-04-11 09:48:45 +09002558 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002559 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002560 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002561 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002562 // Current can't be linked against by anything else.
2563 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002564 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002565 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002566 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002567 if err != nil {
2568 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002569 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002570 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002571 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002572 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002573 if err != nil {
2574 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002575 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002576 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002577 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002578
Inseob Kim01a28722018-04-11 09:48:45 +09002579 if toApi > fromApi {
2580 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002581 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002582 }
2583 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002584 }
Dan Albert202fe492017-12-15 13:56:59 -08002585
2586 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002587 fromStl := from.SelectedStl()
2588 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002589 if fromStl == "" || toStl == "" {
2590 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002591 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002592 // We can be permissive with the system "STL" since it is only the C++
2593 // ABI layer, but in the future we should make sure that everyone is
2594 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002595 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002596 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002597 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2598 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002599 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002600}
2601
Jooyung Han479ca172020-10-19 18:51:07 +09002602func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2603 if c, ok := ctx.Module().(*Module); ok {
2604 ctx.VisitDirectDeps(func(dep android.Module) {
2605 depTag := ctx.OtherModuleDependencyTag(dep)
2606 ccDep, ok := dep.(LinkableInterface)
2607 if ok {
2608 checkLinkType(ctx, c, ccDep, depTag)
2609 }
2610 })
2611 }
2612}
2613
Jiyong Park5fb8c102018-04-09 12:03:06 +09002614// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002615// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2616// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002617// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002618func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2619 check := func(child, parent android.Module) bool {
2620 to, ok := child.(*Module)
2621 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002622 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002623 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002624
Jooyung Hana70f0672019-01-18 15:20:43 +09002625 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2626 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002627 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002628
Jiyong Park0474e1f2021-01-14 14:26:06 +09002629 // These dependencies are not excercised at runtime. Tracking these will give us
2630 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002631 depTag := ctx.OtherModuleDependencyTag(child)
2632 if IsHeaderDepTag(depTag) {
2633 return false
2634 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002635 if depTag == staticVariantTag {
2636 return false
2637 }
2638 if depTag == stubImplDepTag {
2639 return false
2640 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002641
Justin Yun63e9ec72020-10-29 16:49:43 +09002642 // Even if target lib has no vendor variant, keep checking dependency
2643 // graph in case it depends on vendor_available or product_available
2644 // but not double_loadable transtively.
2645 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002646 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002647 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002648
Jiyong Park0474e1f2021-01-14 14:26:06 +09002649 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2650 // one.
2651 if Bool(to.VendorProperties.Double_loadable) {
2652 return true
2653 }
2654
Ivan Lozanod7586b62021-04-01 09:49:36 -04002655 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002656 return false
2657 }
2658
Jooyung Hana70f0672019-01-18 15:20:43 +09002659 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2660 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002661 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002662 return false
2663 }
2664 if module, ok := ctx.Module().(*Module); ok {
2665 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002666 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002667 ctx.WalkDeps(check)
2668 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002669 }
2670 }
2671}
2672
Colin Crossc99deeb2016-04-11 15:06:20 -07002673// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002674func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002675 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002676
Colin Cross0de8a1e2020-09-18 14:15:30 -07002677 var directStaticDeps []StaticLibraryInfo
2678 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002679
Colin Cross0de8a1e2020-09-18 14:15:30 -07002680 reexportExporter := func(exporter FlagExporterInfo) {
2681 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2682 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2683 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2684 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2685 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002686 }
2687
Jooyung Hande34d232020-07-23 13:04:15 +09002688 // For the dependency from platform to apex, use the latest stubs
2689 c.apexSdkVersion = android.FutureApiLevel
Colin Cross56a83212020-09-15 18:30:11 -07002690 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
2691 if !apexInfo.IsForPlatform() {
Jiyong Park4eab21d2021-04-15 15:17:54 +09002692 c.apexSdkVersion = apexInfo.MinSdkVersion
Jooyung Hande34d232020-07-23 13:04:15 +09002693 }
2694
2695 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2696 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2697 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2698 // (b/144430859)
2699 c.apexSdkVersion = android.FutureApiLevel
2700 }
2701
Colin Crossd11fcda2017-10-23 17:59:01 -07002702 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002703 depName := ctx.OtherModuleName(dep)
2704 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002705
Dan Willemsen47450072021-10-19 20:24:49 -07002706 if depTag == android.DarwinUniversalVariantTag {
2707 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2708 return
2709 }
2710
Ivan Lozano52767be2019-10-18 14:49:46 -07002711 ccDep, ok := dep.(LinkableInterface)
2712 if !ok {
2713
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002714 // handling for a few module types that aren't cc Module but that are also supported
2715 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002716 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002717 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002718 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2719 genRule.GeneratedSourceFiles()...)
2720 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002721 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002722 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002723 // Support exported headers from a generated_sources dependency
2724 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002725 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002726 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002727 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002728 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002729 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002730 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002731 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002732 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002733 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2734 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002735 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002736 // 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 +09002737 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002738
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002739 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002740 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002741 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002742 }
Colin Crosscef792e2021-06-11 18:01:26 -07002743 case CrtBeginDepTag:
2744 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2745 case CrtEndDepTag:
2746 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002747 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002748 return
2749 }
2750
Colin Crossfe17f6f2019-03-28 19:30:56 -07002751 if depTag == android.ProtoPluginDepTag {
2752 return
2753 }
2754
Colin Crossd11fcda2017-10-23 17:59:01 -07002755 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002756 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2757 return
2758 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002759 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002760 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2761 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002762 return
2763 }
2764
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002765 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002766 // Skip reused objects for stub libraries, they use their own stub object file instead.
2767 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2768 // version mutator, so the stubs variant is created from the shared variant that
2769 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002770 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002771 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2772 objs := staticAnalogue.ReuseObjects
2773 depPaths.Objs = depPaths.Objs.Append(objs)
2774 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2775 reexportExporter(depExporterInfo)
2776 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002777 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002778 }
2779
Colin Cross6e511a92020-07-27 21:26:48 -07002780 linkFile := ccDep.OutputFile()
2781
2782 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2783 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002784 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002785 return
2786 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002787
Jiyong Parke3867542020-12-03 17:28:25 +09002788 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2789 return
2790 }
2791
Colin Cross0de8a1e2020-09-18 14:15:30 -07002792 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002793
Colin Cross6e511a92020-07-27 21:26:48 -07002794 var ptr *android.Paths
2795 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002796
Colin Cross6e511a92020-07-27 21:26:48 -07002797 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002798
Colin Cross6e511a92020-07-27 21:26:48 -07002799 switch {
2800 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002801 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2802 if !ctx.Config().AllowMissingDependencies() {
2803 ctx.ModuleErrorf("module %q is not a header library", depName)
2804 } else {
2805 ctx.AddMissingDependencies([]string{depName})
2806 }
2807 return
2808 }
Colin Cross6e511a92020-07-27 21:26:48 -07002809 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002810 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
2811 if !ctx.Config().AllowMissingDependencies() {
2812 ctx.ModuleErrorf("module %q is not a shared library", depName)
2813 } else {
2814 ctx.AddMissingDependencies([]string{depName})
2815 }
2816 return
2817 }
Jiyong Parke3867542020-12-03 17:28:25 +09002818
Jiyong Park7d55b612021-06-11 17:22:09 +09002819 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
2820 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07002821
Jiyong Park1ad8e162020-12-01 23:40:09 +09002822 // Stubs lib doesn't link to the shared lib dependencies. Don't set
2823 // linkFile, depFile, and ptr.
2824 if c.IsStubs() {
2825 break
2826 }
2827
Colin Cross0de8a1e2020-09-18 14:15:30 -07002828 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
2829 depFile = sharedLibraryInfo.TableOfContents
2830
Colin Cross6e511a92020-07-27 21:26:48 -07002831 ptr = &depPaths.SharedLibs
2832 switch libDepTag.Order {
2833 case earlyLibraryDependency:
2834 ptr = &depPaths.EarlySharedLibs
2835 depPtr = &depPaths.EarlySharedLibsDeps
2836 case normalLibraryDependency:
2837 ptr = &depPaths.SharedLibs
2838 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07002839 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002840 case lateLibraryDependency:
2841 ptr = &depPaths.LateSharedLibs
2842 depPtr = &depPaths.LateSharedLibsDeps
2843 default:
2844 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07002845 }
Colin Cross6e511a92020-07-27 21:26:48 -07002846 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07002847 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
2848 if !ctx.Config().AllowMissingDependencies() {
2849 ctx.ModuleErrorf("module %q is not a static library", depName)
2850 } else {
2851 ctx.AddMissingDependencies([]string{depName})
2852 }
2853 return
2854 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002855
2856 // Stubs lib doesn't link to the static lib dependencies. Don't set
2857 // linkFile, depFile, and ptr.
2858 if c.IsStubs() {
2859 break
2860 }
2861
Colin Cross0de8a1e2020-09-18 14:15:30 -07002862 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2863 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07002864 if libDepTag.wholeStatic {
2865 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07002866 if len(staticLibraryInfo.Objects.objFiles) > 0 {
2867 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09002868 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07002869 // This case normally catches prebuilt static
2870 // libraries, but it can also occur when
2871 // AllowMissingDependencies is on and the
2872 // dependencies has no sources of its own
2873 // but has a whole_static_libs dependency
2874 // on a missing library. We want to depend
2875 // on the .a file so that there is something
2876 // in the dependency tree that contains the
2877 // error rule for the missing transitive
2878 // dependency.
2879 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07002880 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08002881 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
2882 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07002883 } else {
2884 switch libDepTag.Order {
2885 case earlyLibraryDependency:
2886 panic(fmt.Errorf("early static libs not suppported"))
2887 case normalLibraryDependency:
2888 // static dependencies will be handled separately so they can be ordered
2889 // using transitive dependencies.
2890 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07002891 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07002892 case lateLibraryDependency:
2893 ptr = &depPaths.LateStaticLibs
2894 default:
2895 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09002896 }
2897 }
Colin Cross3e5e7782022-06-17 22:17:05 +00002898 if libDepTag.unexportedSymbols {
2899 depPaths.LdFlags = append(depPaths.LdFlags,
2900 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
2901 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002902 }
2903
Colin Cross6e511a92020-07-27 21:26:48 -07002904 if libDepTag.static() && !libDepTag.wholeStatic {
2905 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
2906 ctx.ModuleErrorf("module %q not a static library", depName)
2907 return
2908 }
Logan Chien43d34c32017-12-20 01:17:32 +08002909
Colin Cross6e511a92020-07-27 21:26:48 -07002910 // When combining coverage files for shared libraries and executables, coverage files
2911 // in static libraries act as if they were whole static libraries. The same goes for
2912 // source based Abi dump files.
2913 if c, ok := ccDep.(*Module); ok {
2914 staticLib := c.linker.(libraryInterface)
2915 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
2916 staticLib.objs().coverageFiles...)
2917 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
2918 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07002919 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07002920 // Handle non-CC modules here
2921 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07002922 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09002923 }
2924 }
2925
Colin Cross6e511a92020-07-27 21:26:48 -07002926 if ptr != nil {
2927 if !linkFile.Valid() {
2928 if !ctx.Config().AllowMissingDependencies() {
2929 ctx.ModuleErrorf("module %q missing output file", depName)
2930 } else {
2931 ctx.AddMissingDependencies([]string{depName})
2932 }
2933 return
2934 }
2935 *ptr = append(*ptr, linkFile.Path())
2936 }
2937
2938 if depPtr != nil {
2939 dep := depFile
2940 if !dep.Valid() {
2941 dep = linkFile
2942 }
2943 *depPtr = append(*depPtr, dep.Path())
2944 }
2945
Colin Cross0de8a1e2020-09-18 14:15:30 -07002946 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
2947 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
2948 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
2949 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
2950
2951 if libDepTag.reexportFlags {
2952 reexportExporter(depExporterInfo)
2953 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
2954 // Re-exported shared library headers must be included as well since they can help us with type information
2955 // about template instantiations (instantiated from their headers).
2956 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
2957 // scripts.
2958 c.sabi.Properties.ReexportedIncludes = append(
2959 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
2960 }
2961
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002962 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07002963 switch {
2964 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07002965 c.Properties.AndroidMkHeaderLibs = append(
2966 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07002967 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07002968 if lib := moduleLibraryInterface(dep); lib != nil {
2969 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07002970 // Add the dependency to the APEX(es) providing the library so that
2971 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07002972 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09002973 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07002974 c.Properties.ApexesProvidingSharedLibs = append(
2975 c.Properties.ApexesProvidingSharedLibs, an)
2976 }
2977 }
2978 }
2979
2980 // Note: the order of libs in this list is not important because
2981 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07002982 c.Properties.AndroidMkSharedLibs = append(
2983 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002984 // Record BaseLibName for snapshots.
2985 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002986 case libDepTag.static():
2987 if libDepTag.wholeStatic {
2988 c.Properties.AndroidMkWholeStaticLibs = append(
2989 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
2990 } else {
2991 c.Properties.AndroidMkStaticLibs = append(
2992 c.Properties.AndroidMkStaticLibs, makeLibName)
2993 }
Justin Yun5e035862021-06-29 20:50:37 +09002994 // Record BaseLibName for snapshots.
2995 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07002996 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002997 } else if !c.IsStubs() {
2998 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
2999
Colin Cross6e511a92020-07-27 21:26:48 -07003000 switch depTag {
3001 case runtimeDepTag:
3002 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003003 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003004 // Record BaseLibName for snapshots.
3005 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003006 case objDepTag:
3007 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3008 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003009 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003010 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003011 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003012 case dynamicLinkerDepTag:
3013 depPaths.DynamicLinker = linkFile
3014 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003015 }
Colin Crossca860ac2016-01-04 14:34:37 -08003016 })
3017
Jeff Gaston294356f2017-09-27 17:05:30 -07003018 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003019 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3020 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3021 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003022
Colin Crossdd84e052017-05-17 13:44:16 -07003023 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003024 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003025 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3026 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003027 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003028 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3029 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003030 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003031 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003032 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003033
3034 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003035 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003036 }
Colin Crossdd84e052017-05-17 13:44:16 -07003037
Colin Crossca860ac2016-01-04 14:34:37 -08003038 return depPaths
3039}
3040
Jiyong Park7d55b612021-06-11 17:22:09 +09003041// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3042// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3043// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3044// has different level of updatability. For example, if a library foo in an APEX depends on a
3045// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3046// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3047// same APEX as foo, the non-stub variant of bar is used.
3048func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3049 depName := ctx.OtherModuleName(dep)
3050 depTag := ctx.OtherModuleDependencyTag(dep)
3051 libDepTag, ok := depTag.(libraryDependencyTag)
3052 if !ok || !libDepTag.shared() {
3053 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3054 }
3055
3056 thisModule, ok := ctx.Module().(android.ApexModule)
3057 if !ok {
3058 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3059 }
3060
3061 useVndk := false
3062 bootstrap := false
3063 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3064 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3065 } else {
3066 useVndk = linkable.UseVndk()
3067 bootstrap = linkable.Bootstrap()
3068 }
3069
3070 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3071 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3072 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
3073 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3074
3075 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
3076 useStubs := false
3077
3078 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3079 if !apexInfo.IsForPlatform() {
3080 // For platform libraries, use current version of LLNDK
3081 // If this is for use_vendor apex we will apply the same rules
3082 // of apex sdk enforcement below to choose right version.
3083 useStubs = true
3084 }
Jiyong Park9477c262021-06-22 20:23:05 +09003085 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3086 // If not building for APEX or the containing APEX allows the use of
3087 // platform APIs, use stubs only when it is from an APEX (and not from
3088 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3089 // bootstrap modules, always link to non-stub variant
Jiyong Park7d55b612021-06-11 17:22:09 +09003090 useStubs = dep.(android.ApexModule).NotInPlatform() && !bootstrap
3091 if useStubs {
3092 // Another exception: if this module is a test for an APEX, then
3093 // it is linked with the non-stub variant of a module in the APEX
3094 // as if this is part of the APEX.
3095 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3096 for _, apexContents := range testFor.ApexContents {
3097 if apexContents.DirectlyInApex(depName) {
3098 useStubs = false
3099 break
3100 }
3101 }
3102 }
3103 if useStubs {
3104 // Yet another exception: If this module and the dependency are
3105 // available to the same APEXes then skip stubs between their
3106 // platform variants. This complements the test_for case above,
3107 // which avoids the stubs on a direct APEX library dependency, by
3108 // avoiding stubs for indirect test dependencies as well.
3109 //
3110 // TODO(b/183882457): This doesn't work if the two libraries have
3111 // only partially overlapping apex_available. For that test_for
3112 // modules would need to be split into APEX variants and resolved
3113 // separately for each APEX they have access to.
3114 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3115 useStubs = false
3116 }
3117 }
3118 } else {
3119 // If building for APEX, use stubs when the parent is in any APEX that
3120 // the child is not in.
3121 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3122 }
3123
3124 // when to use (unspecified) stubs, use the latest one.
3125 if useStubs {
3126 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3127 toUse := stubs[len(stubs)-1]
3128 sharedLibraryInfo = toUse.SharedLibraryInfo
3129 depExporterInfo = toUse.FlagExporterInfo
3130 }
3131 }
3132 return sharedLibraryInfo, depExporterInfo
3133}
3134
Colin Cross0de8a1e2020-09-18 14:15:30 -07003135// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3136// to match the topological order of the dependency tree, including any static analogues of
3137// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3138// of the transitive dependencies.
3139func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3140 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3141 var staticPaths android.Paths
3142 for _, staticDep := range staticDeps {
3143 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3144 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3145 }
3146 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003147 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3148 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003149 }
3150 }
3151 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3152
3153 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3154
3155 // reorder the dependencies based on transitive dependencies
3156 staticPaths = android.FirstUniquePaths(staticPaths)
3157 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3158
3159 if len(orderedStaticPaths) != len(staticPaths) {
3160 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3161 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3162 }
3163
3164 return orderedStaticPaths, transitiveStaticLibs
3165}
3166
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003167// BaseLibName trims known prefixes and suffixes
3168func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003169 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3170 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003171 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003172 return libName
3173}
3174
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003175func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003176 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003177 ccDepModule, _ := ccDep.(*Module)
3178 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003179 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003180
Justin Yuncbca3732021-02-03 19:24:13 +09003181 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003182 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07003183 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003184 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003185 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003186
Ivan Lozanod1dec542021-05-26 15:33:11 -04003187 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003188 }
3189 }
3190
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003191 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3192 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003193 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3194 // core module instead.
3195 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003196 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003197 // The vendor and product modules in Make will have been renamed to not conflict with the
3198 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003199 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003200 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003201 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003202 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003203 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003204 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003205 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003206 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003207 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003208 } else {
3209 return libName
3210 }
3211}
3212
Colin Crossca860ac2016-01-04 14:34:37 -08003213func (c *Module) InstallInData() bool {
3214 if c.installer == nil {
3215 return false
3216 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003217 return c.installer.inData()
3218}
3219
3220func (c *Module) InstallInSanitizerDir() bool {
3221 if c.installer == nil {
3222 return false
3223 }
3224 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003225 return true
3226 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003227 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003228}
3229
Yifan Hong1b3348d2020-01-21 15:53:22 -08003230func (c *Module) InstallInRamdisk() bool {
3231 return c.InRamdisk()
3232}
3233
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003234func (c *Module) InstallInVendorRamdisk() bool {
3235 return c.InVendorRamdisk()
3236}
3237
Jiyong Parkf9332f12018-02-01 00:54:12 +09003238func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003239 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003240}
3241
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003242func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003243 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003244 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003245 return
3246 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003247 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003248}
3249
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003250func (c *Module) HostToolPath() android.OptionalPath {
3251 if c.installer == nil {
3252 return android.OptionalPath{}
3253 }
3254 return c.installer.hostToolPath()
3255}
3256
Nan Zhangd4e641b2017-07-12 12:55:28 -07003257func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3258 return c.outputFile
3259}
3260
Colin Cross41955e82019-05-29 14:40:35 -07003261func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3262 switch tag {
3263 case "":
3264 if c.outputFile.Valid() {
3265 return android.Paths{c.outputFile.Path()}, nil
3266 }
3267 return android.Paths{}, nil
3268 default:
3269 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003270 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003271}
3272
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003273func (c *Module) static() bool {
3274 if static, ok := c.linker.(interface {
3275 static() bool
3276 }); ok {
3277 return static.static()
3278 }
3279 return false
3280}
3281
Jiyong Park379de2f2018-12-19 02:47:14 +09003282func (c *Module) staticBinary() bool {
3283 if static, ok := c.linker.(interface {
3284 staticBinary() bool
3285 }); ok {
3286 return static.staticBinary()
3287 }
3288 return false
3289}
3290
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003291func (c *Module) testBinary() bool {
3292 if test, ok := c.linker.(interface {
3293 testBinary() bool
3294 }); ok {
3295 return test.testBinary()
3296 }
3297 return false
3298}
3299
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003300func (c *Module) benchmarkBinary() bool {
3301 if b, ok := c.linker.(interface {
3302 benchmarkBinary() bool
3303 }); ok {
3304 return b.benchmarkBinary()
3305 }
3306 return false
3307}
3308
3309func (c *Module) fuzzBinary() bool {
3310 if f, ok := c.linker.(interface {
3311 fuzzBinary() bool
3312 }); ok {
3313 return f.fuzzBinary()
3314 }
3315 return false
3316}
3317
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003318// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3319func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003320 if h, ok := c.linker.(interface {
3321 header() bool
3322 }); ok {
3323 return h.header()
3324 }
3325 return false
3326}
3327
Ivan Lozanod7586b62021-04-01 09:49:36 -04003328func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003329 if b, ok := c.linker.(interface {
3330 binary() bool
3331 }); ok {
3332 return b.binary()
3333 }
3334 return false
3335}
3336
Justin Yun5e035862021-06-29 20:50:37 +09003337func (c *Module) StaticExecutable() bool {
3338 if b, ok := c.linker.(*binaryDecorator); ok {
3339 return b.static()
3340 }
3341 return false
3342}
3343
Ivan Lozanod7586b62021-04-01 09:49:36 -04003344func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003345 if o, ok := c.linker.(interface {
3346 object() bool
3347 }); ok {
3348 return o.object()
3349 }
3350 return false
3351}
3352
Ivan Lozanof9e21722020-12-02 09:00:51 -05003353func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003354 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003355 if c.IsLlndk() {
3356 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003357 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003358 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003359 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003360 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003361 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003362 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003363 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003364 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003365 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003366 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003367 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003368 return "native:product"
3369 }
Jooyung Han38002912019-05-16 04:01:54 +09003370 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003371 } else if c.InRamdisk() {
3372 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003373 } else if c.InVendorRamdisk() {
3374 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003375 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003376 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003377 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003378 return "native:ndk:none:none"
3379 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3380 //family, link := getNdkStlFamilyAndLinkType(c)
3381 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003382 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003383 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003384 } else {
3385 return "native:platform"
3386 }
3387}
3388
Jiyong Park9d452992018-10-03 00:38:19 +09003389// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003390// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003391func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003392 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003393 // Stub libs and prebuilt libs in a versioned SDK are not
3394 // installable to APEX even though they are shared libs.
Colin Cross31076b32020-10-23 17:22:06 -07003395 return lib.shared() && !lib.buildStubs() && c.ContainingSdk().Unversioned()
Roland Levillainf89cd092019-07-29 16:22:59 +01003396 } else if _, ok := c.linker.(testPerSrc); ok {
3397 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003398 }
3399 return false
3400}
3401
Jiyong Parka90ca002019-10-07 15:47:24 +09003402func (c *Module) AvailableFor(what string) bool {
3403 if linker, ok := c.linker.(interface {
3404 availableFor(string) bool
3405 }); ok {
3406 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3407 } else {
3408 return c.ApexModuleBase.AvailableFor(what)
3409 }
3410}
3411
Jiyong Park62304bb2020-04-13 16:19:48 +09003412func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003413 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003414}
3415
Paul Duffin0cb37b92020-03-04 14:52:46 +00003416func (c *Module) EverInstallable() bool {
3417 return c.installer != nil &&
3418 // Check to see whether the module is actually ever installable.
3419 c.installer.everInstallable()
3420}
3421
Ivan Lozanod7586b62021-04-01 09:49:36 -04003422func (c *Module) PreventInstall() bool {
3423 return c.Properties.PreventInstall
3424}
3425
3426func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003427 if c.library != nil {
3428 if i := c.library.installable(); i != nil {
3429 return i
3430 }
3431 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003432 return c.Properties.Installable
3433}
3434
3435func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003436 ret := c.EverInstallable() &&
3437 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003438 proptools.BoolDefault(c.Installable(), true) &&
3439 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003440
3441 // The platform variant doesn't need further condition. Apex variants however might not
3442 // be installable because it will likely to be included in the APEX and won't appear
3443 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003444 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003445 return ret
3446 }
3447
3448 // Special case for modules that are configured to be installed to /data, which includes
3449 // test modules. For these modules, both APEX and non-APEX variants are considered as
3450 // installable. This is because even the APEX variants won't be included in the APEX, but
3451 // will anyway be installed to /data/*.
3452 // See b/146995717
3453 if c.InstallInData() {
3454 return ret
3455 }
3456
3457 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003458}
3459
Logan Chien41eabe62019-04-10 13:33:58 +08003460func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3461 if c.linker != nil {
3462 if library, ok := c.linker.(*libraryDecorator); ok {
3463 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3464 }
3465 }
3466}
3467
Jiyong Park45bf82e2020-12-15 22:29:02 +09003468var _ android.ApexModule = (*Module)(nil)
3469
3470// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003471func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003472 depTag := ctx.OtherModuleDependencyTag(dep)
3473 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3474
3475 if cc, ok := dep.(*Module); ok {
3476 if cc.HasStubsVariants() {
3477 if isLibDepTag && libDepTag.shared() {
3478 // dynamic dep to a stubs lib crosses APEX boundary
3479 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003480 }
Colin Cross6e511a92020-07-27 21:26:48 -07003481 if IsRuntimeDepTag(depTag) {
3482 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003483 return false
3484 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003485 }
Zhijun Heec285872021-04-24 10:47:08 -07003486 if cc.IsLlndk() {
3487 return false
3488 }
Colin Crossaac32222020-07-29 12:51:56 -07003489 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003490 // shared_lib dependency from a static lib is considered as crossing
3491 // the APEX boundary because the dependency doesn't actually is
3492 // linked; the dependency is used only during the compilation phase.
3493 return false
3494 }
Jiyong Parke3867542020-12-03 17:28:25 +09003495
3496 if isLibDepTag && libDepTag.excludeInApex {
3497 return false
3498 }
Colin Cross6e511a92020-07-27 21:26:48 -07003499 }
Colin Crossc1b36442021-05-06 13:42:48 -07003500 if depTag == stubImplDepTag {
3501 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003502 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003503 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003504 if depTag == staticVariantTag {
3505 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3506 // actually mean that the static lib (and its dependencies) are copied into the
3507 // APEX.
3508 return false
3509 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003510 return true
3511}
3512
Jiyong Park45bf82e2020-12-15 22:29:02 +09003513// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003514func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3515 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003516 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3517 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3518 return nil
3519 }
Jooyung Han749dc692020-04-15 11:03:39 +09003520 // We don't check for prebuilt modules
3521 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3522 return nil
3523 }
3524 minSdkVersion := c.MinSdkVersion()
3525 if minSdkVersion == "apex_inherit" {
3526 return nil
3527 }
3528 if minSdkVersion == "" {
3529 // JNI libs within APK-in-APEX fall into here
3530 // Those are okay to set sdk_version instead
3531 // We don't have to check if this is a SDK variant because
3532 // non-SDK variant resets sdk_version, which works too.
3533 minSdkVersion = c.SdkVersion()
3534 }
Dan Albertc8060532020-07-22 22:32:17 -07003535 if minSdkVersion == "" {
3536 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3537 }
3538 // Not using nativeApiLevelFromUser because the context here is not
3539 // necessarily a native context.
3540 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003541 if err != nil {
3542 return err
3543 }
Dan Albertc8060532020-07-22 22:32:17 -07003544
3545 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003546 return fmt.Errorf("newer SDK(%v)", ver)
3547 }
3548 return nil
3549}
3550
Paul Duffinb5769c12021-05-12 16:16:51 +01003551// Implements android.ApexModule
3552func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3553 // stub libraries and native bridge libraries are always available to platform
3554 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3555}
3556
Jooyung Han91f92032022-02-04 12:36:33 +09003557// Overrides android.ApexModuleBase.UniqueApexVariations
3558func (c *Module) UniqueApexVariations() bool {
3559 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3560 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3561 // variation of the VNDK lib because APEX variations are merged/grouped.
3562 return c.UseVndk() && c.IsVndk()
3563}
3564
Rob Seymour925aa092021-08-10 20:42:03 +00003565var _ snapshot.RelativeInstallPath = (*Module)(nil)
3566
Liz Kammer35ca77e2021-12-22 15:31:40 -05003567type moduleType int
3568
3569const (
3570 unknownType moduleType = iota
3571 binary
3572 object
3573 fullLibrary
3574 staticLibrary
3575 sharedLibrary
3576 headerLibrary
3577)
3578
3579func (c *Module) typ() moduleType {
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003580 if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003581 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003582 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003583 return object
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003584 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003585 static := false
3586 shared := false
3587 if library, ok := c.linker.(*libraryDecorator); ok {
3588 static = library.MutatedProperties.BuildStatic
3589 shared = library.MutatedProperties.BuildShared
3590 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3591 static = library.MutatedProperties.BuildStatic
3592 shared = library.MutatedProperties.BuildShared
3593 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003594 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003595 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003596 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003597 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003598 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003599 return staticLibrary
3600 }
3601 return sharedLibrary
3602 }
3603 return unknownType
3604}
3605
3606// ConvertWithBp2build converts Module to Bazel for bp2build.
3607func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
3608 prebuilt := c.IsPrebuilt()
3609 switch c.typ() {
3610 case binary:
3611 if !prebuilt {
3612 binaryBp2build(ctx, c, ctx.ModuleType())
3613 }
3614 case object:
3615 if !prebuilt {
3616 objectBp2Build(ctx, c)
3617 }
3618 case fullLibrary:
3619 if !prebuilt {
3620 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003621 } else {
3622 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003623 }
3624 case headerLibrary:
3625 libraryHeadersBp2Build(ctx, c)
3626 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05003627 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003628 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003629 } else {
3630 sharedOrStaticLibraryBp2Build(ctx, c, true)
3631 }
3632 case sharedLibrary:
3633 if prebuilt {
3634 prebuiltLibrarySharedBp2Build(ctx, c)
3635 } else {
3636 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003637 }
3638 }
3639}
3640
Colin Cross2ba19d92015-05-07 15:44:20 -07003641//
Colin Crosscfad1192015-11-02 16:43:11 -08003642// Defaults
3643//
Colin Crossca860ac2016-01-04 14:34:37 -08003644type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003645 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003646 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003647 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003648}
3649
Patrice Arrudac249c712019-03-19 17:00:29 -07003650// cc_defaults provides a set of properties that can be inherited by other cc
3651// modules. A module can use the properties from a cc_defaults using
3652// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3653// merged (when possible) by prepending the default module's values to the
3654// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003655func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003656 return DefaultsFactory()
3657}
3658
Colin Cross36242852017-06-23 15:06:31 -07003659func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003660 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003661
Colin Cross36242852017-06-23 15:06:31 -07003662 module.AddProperties(props...)
3663 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003664 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003665 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003666 &BaseCompilerProperties{},
3667 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003668 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003669 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003670 &StaticProperties{},
3671 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003672 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003673 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003674 &TestLinkerProperties{},
3675 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003676 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003677 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003678 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003679 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003680 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003681 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003682 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003683 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003684 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003685 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003686 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003687 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003688 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003689 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003690 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003691 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3692 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003693 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003694 )
Colin Crosscfad1192015-11-02 16:43:11 -08003695
Jooyung Hancc372c52019-09-25 15:18:44 +09003696 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003697
3698 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003699}
3700
Jiyong Park2286afd2020-06-16 21:58:53 +09003701func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003702 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003703}
3704
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003705func kytheExtractAllFactory() android.Singleton {
3706 return &kytheExtractAllSingleton{}
3707}
3708
3709type kytheExtractAllSingleton struct {
3710}
3711
3712func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3713 var xrefTargets android.Paths
3714 ctx.VisitAllModules(func(module android.Module) {
3715 if ccModule, ok := module.(xref); ok {
3716 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3717 }
3718 })
3719 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3720 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003721 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003722 }
3723}
3724
Colin Cross06a931b2015-10-28 17:23:31 -07003725var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07003726var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08003727var BoolPtr = proptools.BoolPtr
3728var String = proptools.String
3729var StringPtr = proptools.StringPtr