blob: 5bb13ffff85d5ddf13fc8a1adaed0488a45fc416 [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"
Sam Delmerico5fb794a2023-01-27 16:01:37 -050031 "android/soong/bazel/cquery"
Colin Crossb98c8b02016-07-29 13:44:28 -070032 "android/soong/cc/config"
hamzehc0a671f2021-07-22 12:05:08 -070033 "android/soong/fuzz"
Colin Cross5049f022015-03-18 13:28:46 -070034 "android/soong/genrule"
Kiyoung Kim487689e2022-07-26 09:48:22 +090035 "android/soong/multitree"
Rob Seymour925aa092021-08-10 20:42:03 +000036 "android/soong/snapshot"
Colin Cross3f40fa42015-01-30 17:27:36 -080037)
38
Colin Cross463a90e2015-06-17 14:20:06 -070039func init() {
Paul Duffin036e7002019-12-19 19:16:28 +000040 RegisterCCBuildComponents(android.InitRegistrationContext)
Colin Cross463a90e2015-06-17 14:20:06 -070041
Paul Duffin036e7002019-12-19 19:16:28 +000042 pctx.Import("android/soong/cc/config")
43}
44
45func RegisterCCBuildComponents(ctx android.RegistrationContext) {
46 ctx.RegisterModuleType("cc_defaults", defaultsFactory)
47
48 ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
Colin Crossc511bc52020-04-07 16:50:32 +000049 ctx.BottomUp("sdk", sdkMutator).Parallel()
Inseob Kim64c43952019-08-26 16:52:35 +090050 ctx.BottomUp("vndk", VndkMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070051 ctx.BottomUp("link", LinkageMutator).Parallel()
Roland Levillain9b5fde92019-06-28 15:41:19 +010052 ctx.BottomUp("test_per_src", TestPerSrcMutator).Parallel()
Colin Crossd1f898e2020-08-18 18:35:15 -070053 ctx.BottomUp("version", versionMutator).Parallel()
Colin Crosse40b4ea2018-10-02 22:25:58 -070054 ctx.BottomUp("begin", BeginMutator).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070055 })
Colin Cross16b23492016-01-06 14:41:07 -080056
Paul Duffin036e7002019-12-19 19:16:28 +000057 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040058 for _, san := range Sanitizers {
59 san.registerMutators(ctx)
60 }
Dan Willemsen581341d2017-02-09 16:16:31 -080061
Colin Cross0b908332019-06-19 23:00:20 -070062 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090063 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080064
Cory Barkera1da26f2022-06-07 20:12:06 +000065 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000066
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
Yi Kong56fc1b62022-09-06 16:24:00 +0800488 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900489 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900490 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900491 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700492 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900493 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700494 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800495 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900496 minSdkVersion() string
497 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700498 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700499 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800500 IsLlndk() bool
501 IsLlndkPublic() bool
502 isImplementationForLLNDKPublic() bool
503 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900504 isVndk() bool
505 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500506 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700507 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900508 inProduct() bool
509 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800510 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700511 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900512 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700513 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700514 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800515 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800516 isAfdoCompile() bool
Yi Kong7e53c572018-02-14 18:16:12 +0800517 isPgoCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800518 isCfi() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800519 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800520 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800521 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700522 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700523 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900524 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800525 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700526 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700527 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800528 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800529 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800530 getSharedFlags() *SharedFlags
531}
532
533type SharedFlags struct {
534 numSharedFlags int
535 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800536}
537
538type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700539 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800540 ModuleContextIntf
541}
542
543type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700544 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800545 ModuleContextIntf
546}
547
Colin Cross37047f12016-12-13 17:06:13 -0800548type DepsContext interface {
549 android.BottomUpMutatorContext
550 ModuleContextIntf
551}
552
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500553// feature represents additional (optional) steps to building cc-related modules, such as invocation
554// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800555type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800556 flags(ctx ModuleContext, flags Flags) Flags
557 props() []interface{}
558}
559
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500560// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500561// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800562type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700563 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800564 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800565 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700566 compilerProps() []interface{}
567
Colin Cross76fada02016-07-27 10:31:13 -0700568 appendCflags([]string)
569 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700570 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800571}
572
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500573// linker is the interface for a linker decorator object. Individual module types can provide
574// their own implementation for this decorator, and thus specify custom logic regarding build
575// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800576type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700577 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800578 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700579 linkerFlags(ctx ModuleContext, flags Flags) Flags
580 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800581 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700582
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700583 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700584 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900585 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700586
587 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900588 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000589
590 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000591 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
592}
593
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500594// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000595type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500596 sharedLibs []string
597 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
598 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700599 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800600}
601
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500602// installer is the interface for an installer helper object. This helper is responsible for
603// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800604type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700605 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700606 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000607 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800608 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700609 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700610 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900611 relativeInstallPath() string
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +0100612 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900613 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800614}
615
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800616type xref interface {
617 XrefCcFiles() android.Paths
618}
619
Inseob Kima1888ce2022-10-04 14:42:02 +0900620type overridable interface {
621 overriddenModules() []string
622}
623
Colin Cross6e511a92020-07-27 21:26:48 -0700624type libraryDependencyKind int
625
626const (
627 headerLibraryDependency = iota
628 sharedLibraryDependency
629 staticLibraryDependency
630)
631
632func (k libraryDependencyKind) String() string {
633 switch k {
634 case headerLibraryDependency:
635 return "headerLibraryDependency"
636 case sharedLibraryDependency:
637 return "sharedLibraryDependency"
638 case staticLibraryDependency:
639 return "staticLibraryDependency"
640 default:
641 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
642 }
643}
644
645type libraryDependencyOrder int
646
647const (
648 earlyLibraryDependency = -1
649 normalLibraryDependency = 0
650 lateLibraryDependency = 1
651)
652
653func (o libraryDependencyOrder) String() string {
654 switch o {
655 case earlyLibraryDependency:
656 return "earlyLibraryDependency"
657 case normalLibraryDependency:
658 return "normalLibraryDependency"
659 case lateLibraryDependency:
660 return "lateLibraryDependency"
661 default:
662 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
663 }
664}
665
666// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
667// tags that have a set of predefined tag objects that are reused for each dependency, a
668// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
669// That means that comparing a libraryDependencyTag for equality will only be equal if all
670// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
671// then check individual metadata fields instead.
672type libraryDependencyTag struct {
673 blueprint.BaseDependencyTag
674
675 // These are exported so that fmt.Printf("%#v") can call their String methods.
676 Kind libraryDependencyKind
677 Order libraryDependencyOrder
678
679 wholeStatic bool
680
681 reexportFlags bool
682 explicitlyVersioned bool
683 dataLib bool
684 ndk bool
685
686 staticUnwinder bool
687
688 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900689
Cindy Zhou18417cb2020-12-10 07:12:38 -0800690 // Whether or not this dependency should skip the apex dependency check
691 skipApexAllowedDependenciesCheck bool
692
Jiyong Parke3867542020-12-03 17:28:25 +0900693 // Whether or not this dependency has to be followed for the apex variants
694 excludeInApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000695
696 // If true, don't automatically export symbols from the static library into a shared library.
697 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700698}
699
700// header returns true if the libraryDependencyTag is tagging a header lib dependency.
701func (d libraryDependencyTag) header() bool {
702 return d.Kind == headerLibraryDependency
703}
704
705// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
706func (d libraryDependencyTag) shared() bool {
707 return d.Kind == sharedLibraryDependency
708}
709
710// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
711func (d libraryDependencyTag) static() bool {
712 return d.Kind == staticLibraryDependency
713}
714
Colin Cross65cb3142021-12-10 23:05:02 +0000715func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
716 if d.shared() {
717 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
718 }
719 return nil
720}
721
722var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
723
Colin Crosse9fe2942020-11-10 18:12:15 -0800724// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
725// binaries or other shared libraries are installed as dependencies.
726func (d libraryDependencyTag) InstallDepNeeded() bool {
727 return d.shared()
728}
729
730var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
731
732// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700733// libraryDependencyTag. Each tag object is created globally and reused for multiple
734// dependencies (although since the object contains no references, assigning a tag to a
735// variable and modifying it will not modify the original). Users can compare the tag
736// returned by ctx.OtherModuleDependencyTag against the global original
737type dependencyTag struct {
738 blueprint.BaseDependencyTag
739 name string
740}
741
Colin Crosse9fe2942020-11-10 18:12:15 -0800742// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
743// libraryDependencyTag, but where the dependency needs to be installed when the parent is
744// installed.
745type installDependencyTag struct {
746 blueprint.BaseDependencyTag
747 android.InstallAlwaysNeededDependencyTag
748 name string
749}
750
Colin Crossc99deeb2016-04-11 15:06:20 -0700751var (
Colin Cross6e511a92020-07-27 21:26:48 -0700752 genSourceDepTag = dependencyTag{name: "gen source"}
753 genHeaderDepTag = dependencyTag{name: "gen header"}
754 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
755 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900756 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700757 reuseObjTag = dependencyTag{name: "reuse objects"}
758 staticVariantTag = dependencyTag{name: "static variant"}
759 vndkExtDepTag = dependencyTag{name: "vndk extends"}
760 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700761 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800762 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700763 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700764 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000765 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700766)
767
Roland Levillainf89cd092019-07-29 16:22:59 +0100768func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700769 ccLibDepTag, ok := depTag.(libraryDependencyTag)
770 return ok && ccLibDepTag.shared()
771}
772
773func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
774 ccLibDepTag, ok := depTag.(libraryDependencyTag)
775 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100776}
777
Zach Johnson3df4e632020-11-06 11:56:27 -0800778func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
779 ccLibDepTag, ok := depTag.(libraryDependencyTag)
780 return ok && ccLibDepTag.header()
781}
782
Roland Levillainf89cd092019-07-29 16:22:59 +0100783func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800784 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100785}
786
787func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700788 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100789 return ok && ccDepTag == testPerSrcDepTag
790}
791
Chris Parsonsf874e462022-05-10 13:50:12 -0400792// bazelHandler is the interface for a helper object related to deferring to Bazel for
793// processing a cc module (during Bazel mixed builds). Individual module types should define
794// their own bazel handler if they support being handled by Bazel.
795type BazelHandler interface {
796 // QueueBazelCall invokes request-queueing functions on the BazelContext
797 //so that these requests are handled when Bazel's cquery is invoked.
798 QueueBazelCall(ctx android.BaseModuleContext, label string)
799
800 // ProcessBazelQueryResponse uses information retrieved from Bazel to set properties
801 // on the current module with given label.
802 ProcessBazelQueryResponse(ctx android.ModuleContext, label string)
803}
804
Colin Crossca860ac2016-01-04 14:34:37 -0800805// Module contains the properties and members used by all C/C++ module types, and implements
806// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500807// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
808// interface.
809//
810// To define a C/C++ related module, construct a new Module object and point its delegates to
811// type-specific structs. These delegates will be invoked to register module-specific build
812// statements which may be unique to the module type. For example, module.compiler.compile() should
813// be defined so as to register build statements which are responsible for compiling the module.
814//
815// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
816// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
817// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
818// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800819type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700820 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700821
Liz Kammerea6666f2021-02-17 10:17:28 -0500822 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700823
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700824 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700825 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700826
Colin Crossca860ac2016-01-04 14:34:37 -0800827 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400828 hod android.HostOrDeviceSupported
829 multilib android.Multilib
830 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700831
Paul Duffina0843f62019-12-13 19:50:38 +0000832 // Allowable SdkMemberTypes of this module type.
833 sdkMemberTypes []android.SdkMemberType
834
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500835 // decorator delegates, initialize before calling Init
836 // these may contain module-specific implementations, and effectively allow for custom
837 // type-specific logic. These members may reference different objects or the same object.
838 // Functions of these decorators will be invoked to initialize and register type-specific
839 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500840 compiler compiler
841 linker linker
842 installer installer
Chris Parsonsf874e462022-05-10 13:50:12 -0400843 bazelHandler BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500844
845 features []feature
846 stl *stl
847 sanitize *sanitize
848 coverage *coverage
Cory Barkera1da26f2022-06-07 20:12:06 +0000849 fuzzer *fuzzer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500850 sabi *sabi
851 vndkdep *vndkdep
852 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800853 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500854 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800855
Colin Cross31076b32020-10-23 17:22:06 -0700856 library libraryInterface
857
Colin Cross635c3b02016-05-18 15:37:25 -0700858 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800859
Colin Crossb98c8b02016-07-29 13:44:28 -0700860 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700861
862 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800863
864 // Flags used to compile this module
865 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700866
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800867 // Shared flags among build rules of this module
868 sharedFlags SharedFlags
869
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800870 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700871 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900872
873 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800874 // Kythe (source file indexer) paths for this compilation module
875 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700876 // Object .o file output paths for this compilation module
877 objFiles android.Paths
878 // Tidy .tidy file output paths for this compilation module
879 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900880
881 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700882 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700883
884 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700885}
886
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200887func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400888 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
889 if b, ok := c.compiler.(*baseCompiler); ok {
890 hasAidl = b.hasSrcExt(".aidl")
891 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
892 hasProto = b.hasSrcExt(".proto")
893 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
894 hasSysprop = b.hasSrcExt(".sysprop")
895 hasWinMsg = b.hasSrcExt(".mc")
896 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
897 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200898 c.AndroidModuleBase().AddJSONData(d)
899 (*d)["Cc"] = map[string]interface{}{
900 "SdkVersion": c.SdkVersion(),
901 "MinSdkVersion": c.MinSdkVersion(),
902 "VndkVersion": c.VndkVersion(),
903 "ProductSpecific": c.ProductSpecific(),
904 "SocSpecific": c.SocSpecific(),
905 "DeviceSpecific": c.DeviceSpecific(),
906 "InProduct": c.InProduct(),
907 "InVendor": c.InVendor(),
908 "InRamdisk": c.InRamdisk(),
909 "InVendorRamdisk": c.InVendorRamdisk(),
910 "InRecovery": c.InRecovery(),
911 "VendorAvailable": c.VendorAvailable(),
912 "ProductAvailable": c.ProductAvailable(),
913 "RamdiskAvailable": c.RamdiskAvailable(),
914 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
915 "RecoveryAvailable": c.RecoveryAvailable(),
916 "OdmAvailable": c.OdmAvailable(),
917 "InstallInData": c.InstallInData(),
918 "InstallInRamdisk": c.InstallInRamdisk(),
919 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
920 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
921 "InstallInRecovery": c.InstallInRecovery(),
922 "InstallInRoot": c.InstallInRoot(),
923 "IsVndk": c.IsVndk(),
924 "IsVndkExt": c.IsVndkExt(),
925 "IsVndkPrivate": c.IsVndkPrivate(),
926 "IsVndkSp": c.IsVndkSp(),
927 "IsLlndk": c.IsLlndk(),
928 "IsLlndkPublic": c.IsLlndkPublic(),
929 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
930 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
931 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
932 "ApexSdkVersion": c.apexSdkVersion,
933 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400934 "AidlSrcs": hasAidl,
935 "LexSrcs": hasLex,
936 "ProtoSrcs": hasProto,
937 "RenderscriptSrcs": hasRenderscript,
938 "SyspropSrcs": hasSysprop,
939 "WinMsgSrcs": hasWinMsg,
940 "YaccSrsc": hasYacc,
941 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200942 }
943}
944
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500945func (c *Module) SetPreventInstall() {
946 c.Properties.PreventInstall = true
947}
948
949func (c *Module) SetHideFromMake() {
950 c.Properties.HideFromMake = true
951}
952
Ivan Lozanod7586b62021-04-01 09:49:36 -0400953func (c *Module) HiddenFromMake() bool {
954 return c.Properties.HideFromMake
955}
956
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800957func (c *Module) RequiredModuleNames() []string {
958 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
959 if c.ImageVariation().Variation == android.CoreVariation {
960 required = append(required, c.Properties.Target.Platform.Required...)
961 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
962 } else if c.InRecovery() {
963 required = append(required, c.Properties.Target.Recovery.Required...)
964 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
965 }
966 return android.FirstUniqueStrings(required)
967}
968
Ivan Lozano52767be2019-10-18 14:49:46 -0700969func (c *Module) Toc() android.OptionalPath {
970 if c.linker != nil {
971 if library, ok := c.linker.(libraryInterface); ok {
972 return library.toc()
973 }
974 }
975 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
976}
977
978func (c *Module) ApiLevel() string {
979 if c.linker != nil {
980 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700981 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700982 }
983 }
984 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
985}
986
987func (c *Module) Static() bool {
988 if c.linker != nil {
989 if library, ok := c.linker.(libraryInterface); ok {
990 return library.static()
991 }
992 }
993 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
994}
995
996func (c *Module) Shared() bool {
997 if c.linker != nil {
998 if library, ok := c.linker.(libraryInterface); ok {
999 return library.shared()
1000 }
1001 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001002
Ivan Lozano52767be2019-10-18 14:49:46 -07001003 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1004}
1005
1006func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001007 if c.stl != nil {
1008 return c.stl.Properties.SelectedStl
1009 }
1010 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001011}
1012
Ivan Lozano52767be2019-10-18 14:49:46 -07001013func (c *Module) NdkPrebuiltStl() bool {
1014 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1015 return true
1016 }
1017 return false
1018}
1019
1020func (c *Module) StubDecorator() bool {
1021 if _, ok := c.linker.(*stubDecorator); ok {
1022 return true
1023 }
1024 return false
1025}
1026
1027func (c *Module) SdkVersion() string {
1028 return String(c.Properties.Sdk_version)
1029}
1030
Artur Satayev480e25b2020-04-27 18:53:18 +01001031func (c *Module) MinSdkVersion() string {
1032 return String(c.Properties.Min_sdk_version)
1033}
1034
Jiyong Park5df7bd32021-08-25 16:18:46 +09001035func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001036 if linker, ok := c.linker.(*objectLinker); ok {
1037 return linker.isCrt()
1038 }
1039 return false
1040}
1041
Jiyong Park5df7bd32021-08-25 16:18:46 +09001042func (c *Module) SplitPerApiLevel() bool {
1043 return c.canUseSdk() && c.isCrt()
1044}
1045
Colin Crossc511bc52020-04-07 16:50:32 +00001046func (c *Module) AlwaysSdk() bool {
1047 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1048}
1049
Ivan Lozano183a3212019-10-18 14:18:45 -07001050func (c *Module) CcLibrary() bool {
1051 if c.linker != nil {
1052 if _, ok := c.linker.(*libraryDecorator); ok {
1053 return true
1054 }
Colin Crossd48fe732020-09-23 20:37:24 -07001055 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1056 return true
1057 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001058 }
1059 return false
1060}
1061
1062func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001063 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001064 return true
1065 }
1066 return false
1067}
1068
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001069func (c *Module) IsFuzzModule() bool {
1070 if _, ok := c.compiler.(*fuzzBinary); ok {
1071 return true
1072 }
1073 return false
1074}
1075
1076func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1077 return c.FuzzModule
1078}
1079
1080func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1081 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1082 return fuzzer.fuzzPackagedModule
1083 }
1084 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1085}
1086
1087func (c *Module) FuzzSharedLibraries() android.Paths {
1088 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1089 return fuzzer.sharedLibraries
1090 }
1091 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1092}
1093
Ivan Lozano2b262972019-11-21 12:30:50 -08001094func (c *Module) NonCcVariants() bool {
1095 return false
1096}
1097
Ivan Lozano183a3212019-10-18 14:18:45 -07001098func (c *Module) SetStatic() {
1099 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001100 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001101 library.setStatic()
1102 return
1103 }
1104 }
1105 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1106}
1107
1108func (c *Module) SetShared() {
1109 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001110 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001111 library.setShared()
1112 return
1113 }
1114 }
1115 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1116}
1117
1118func (c *Module) BuildStaticVariant() bool {
1119 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001120 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001121 return library.buildStatic()
1122 }
1123 }
1124 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1125}
1126
1127func (c *Module) BuildSharedVariant() bool {
1128 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001129 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001130 return library.buildShared()
1131 }
1132 }
1133 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1134}
1135
1136func (c *Module) Module() android.Module {
1137 return c
1138}
1139
Jiyong Parkc20eee32018-09-05 22:36:17 +09001140func (c *Module) OutputFile() android.OptionalPath {
1141 return c.outputFile
1142}
1143
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001144func (c *Module) CoverageFiles() android.Paths {
1145 if c.linker != nil {
1146 if library, ok := c.linker.(libraryInterface); ok {
1147 return library.objs().coverageFiles
1148 }
1149 }
1150 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1151}
1152
Ivan Lozano183a3212019-10-18 14:18:45 -07001153var _ LinkableInterface = (*Module)(nil)
1154
Jiyong Park719b4462019-01-13 00:39:51 +09001155func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001156 if c.linker != nil {
1157 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001158 }
1159 return nil
1160}
1161
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001162func (c *Module) CoverageOutputFile() android.OptionalPath {
1163 if c.linker != nil {
1164 return c.linker.coverageOutputFilePath()
1165 }
1166 return android.OptionalPath{}
1167}
1168
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001169func (c *Module) RelativeInstallPath() string {
1170 if c.installer != nil {
1171 return c.installer.relativeInstallPath()
1172 }
1173 return ""
1174}
1175
Jooyung Han344d5432019-08-23 11:17:39 +09001176func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001177 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001178}
1179
Colin Cross36242852017-06-23 15:06:31 -07001180func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001181 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001182 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001183 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001184 }
1185 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001186 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001187 }
1188 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001189 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001190 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001191 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001192 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001193 }
Colin Cross16b23492016-01-06 14:41:07 -08001194 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001195 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001196 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001197 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001198 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001199 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001200 if c.fuzzer != nil {
1201 c.AddProperties(c.fuzzer.props()...)
1202 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001203 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001204 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001205 }
Justin Yun8effde42017-06-23 19:24:43 +09001206 if c.vndkdep != nil {
1207 c.AddProperties(c.vndkdep.props()...)
1208 }
Stephen Craneba090d12017-05-09 15:44:35 -07001209 if c.lto != nil {
1210 c.AddProperties(c.lto.props()...)
1211 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001212 if c.afdo != nil {
1213 c.AddProperties(c.afdo.props()...)
1214 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001215 if c.pgo != nil {
1216 c.AddProperties(c.pgo.props()...)
1217 }
Colin Crossca860ac2016-01-04 14:34:37 -08001218 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001219 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001220 }
Colin Crossc472d572015-03-17 15:06:21 -07001221
Colin Cross36242852017-06-23 15:06:31 -07001222 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001223 if c.bazelable {
1224 android.InitBazelModule(c)
1225 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001226 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001227 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001228
Colin Cross36242852017-06-23 15:06:31 -07001229 return c
Colin Crossc472d572015-03-17 15:06:21 -07001230}
1231
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001232// UseVndk() returns true if this module is built against VNDK.
1233// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001234func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001235 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001236}
1237
Colin Crossc511bc52020-04-07 16:50:32 +00001238func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001239 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1240 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001241}
1242
1243func (c *Module) UseSdk() bool {
1244 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001245 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001246 }
1247 return false
1248}
1249
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001250func (c *Module) isCoverageVariant() bool {
1251 return c.coverage.Properties.IsCoverageVariant
1252}
1253
Colin Cross95f1ca02020-10-29 20:47:22 -07001254func (c *Module) IsNdk(config android.Config) bool {
1255 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001256}
1257
Colin Cross127bb8b2020-12-16 16:46:01 -08001258func (c *Module) IsLlndk() bool {
1259 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001260}
1261
Colin Cross127bb8b2020-12-16 16:46:01 -08001262func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001263 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001264}
1265
Colin Cross1f3f1302021-04-26 18:37:44 -07001266func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001267 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001268 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001269}
1270
Colin Cross5271fea2021-04-27 13:06:04 -07001271func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1272 lib := moduleLibraryInterface(m)
1273 return lib != nil && (lib.hasVendorPublicLibrary())
1274}
1275
1276// IsVendorPublicLibrary returns true for vendor public libraries.
1277func (c *Module) IsVendorPublicLibrary() bool {
1278 return c.VendorProperties.IsVendorPublicLibrary
1279}
1280
Ivan Lozanof1868af2022-04-12 13:08:36 -04001281func (c *Module) IsVndkPrebuiltLibrary() bool {
1282 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1283 return true
1284 }
1285 return false
1286}
1287
1288func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1289 return c.Properties.SdkAndPlatformVariantVisibleToMake
1290}
1291
Ivan Lozanod7586b62021-04-01 09:49:36 -04001292func (c *Module) HasLlndkStubs() bool {
1293 lib := moduleLibraryInterface(c)
1294 return lib != nil && lib.hasLLNDKStubs()
1295}
1296
1297func (c *Module) StubsVersion() string {
1298 if lib, ok := c.linker.(versionedInterface); ok {
1299 return lib.stubsVersion()
1300 }
1301 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1302}
1303
Colin Cross127bb8b2020-12-16 16:46:01 -08001304// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1305// and does not set llndk.vendor_available: false.
1306func (c *Module) isImplementationForLLNDKPublic() bool {
1307 library, _ := c.library.(*libraryDecorator)
1308 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001309 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001310}
1311
Justin Yunfd9e8042020-12-23 18:23:14 +09001312// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001313func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001314 // Check if VNDK-core-private or VNDK-SP-private
1315 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001316 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001317 }
1318
1319 // Check if LLNDK-private
1320 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001321 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001322 }
1323
1324 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001325}
1326
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001327// IsVndk() returns true if this module has a vndk variant.
1328// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1329// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001330func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001331 if vndkdep := c.vndkdep; vndkdep != nil {
1332 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001333 }
1334 return false
1335}
1336
Yi Kong4ef54592022-02-14 20:00:10 +08001337func (c *Module) isAfdoCompile() bool {
1338 if afdo := c.afdo; afdo != nil {
1339 return afdo.Properties.AfdoTarget != nil
1340 }
1341 return false
1342}
1343
Yi Kong7e53c572018-02-14 18:16:12 +08001344func (c *Module) isPgoCompile() bool {
1345 if pgo := c.pgo; pgo != nil {
1346 return pgo.Properties.PgoCompile
1347 }
1348 return false
1349}
1350
Yi Kongc702ebd2022-08-19 16:02:45 +08001351func (c *Module) isCfi() bool {
1352 if sanitize := c.sanitize; sanitize != nil {
1353 return Bool(sanitize.Properties.Sanitize.Cfi)
1354 }
1355 return false
1356}
1357
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001358func (c *Module) isNDKStubLibrary() bool {
1359 if _, ok := c.compiler.(*stubDecorator); ok {
1360 return true
1361 }
1362 return false
1363}
1364
Ivan Lozanod7586b62021-04-01 09:49:36 -04001365func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001366 if vndkdep := c.vndkdep; vndkdep != nil {
1367 return vndkdep.isVndkSp()
1368 }
1369 return false
1370}
1371
Ivan Lozanof9e21722020-12-02 09:00:51 -05001372func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001373 if vndkdep := c.vndkdep; vndkdep != nil {
1374 return vndkdep.isVndkExt()
1375 }
1376 return false
1377}
1378
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001379func (c *Module) SubName() string {
1380 return c.Properties.SubName
1381}
1382
Ivan Lozano52767be2019-10-18 14:49:46 -07001383func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001384 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001385}
1386
Logan Chienf3511742017-10-31 18:04:35 +08001387func (c *Module) getVndkExtendsModuleName() string {
1388 if vndkdep := c.vndkdep; vndkdep != nil {
1389 return vndkdep.getVndkExtendsModuleName()
1390 }
1391 return ""
1392}
1393
Jiyong Park25fc6a92018-11-18 18:02:45 +09001394func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001395 if lib := c.library; lib != nil {
1396 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001397 }
1398 return false
1399}
1400
1401func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001402 if lib := c.library; lib != nil {
1403 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001404 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001405 return false
1406}
1407
Alan Stokes73feba32022-11-14 12:21:24 +00001408func (c *Module) IsStubsImplementationRequired() bool {
1409 if lib := c.library; lib != nil {
1410 return lib.isStubsImplementationRequired()
1411 }
1412 return false
1413}
1414
Colin Cross0477b422020-10-13 18:43:54 -07001415// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1416// the implementation. If it is an implementation library it returns its own name.
1417func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1418 name := ctx.OtherModuleName(c)
1419 if versioned, ok := c.linker.(versionedInterface); ok {
1420 name = versioned.implementationModuleName(name)
1421 }
1422 return name
1423}
1424
Martin Stjernholm2856c662020-12-02 15:03:42 +00001425// Similar to ImplementationModuleName, but uses the Make variant of the module
1426// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1427// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1428// under the premise that the prebuilt module overrides its source counterpart
1429// if it is exposed to Make).
1430func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1431 name := c.BaseModuleName()
1432 if versioned, ok := c.linker.(versionedInterface); ok {
1433 name = versioned.implementationModuleName(name)
1434 }
1435 return name
1436}
1437
Jiyong Park7d55b612021-06-11 17:22:09 +09001438func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001439 return Bool(c.Properties.Bootstrap)
1440}
1441
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001442func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001443 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1444 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1445 return false
1446 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001447 return c.linker != nil && c.linker.nativeCoverage()
1448}
1449
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001450func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001451 if p, ok := c.linker.(SnapshotInterface); ok {
1452 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001453 }
1454 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001455}
1456
Bill Peckham945441c2020-08-31 16:07:58 -07001457func (c *Module) ExcludeFromVendorSnapshot() bool {
1458 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1459}
1460
Jose Galmesf7294582020-11-13 12:07:36 -08001461func (c *Module) ExcludeFromRecoverySnapshot() bool {
1462 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1463}
1464
Jiyong Parkf1194352019-02-25 11:05:47 +09001465func isBionic(name string) bool {
1466 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001467 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001468 return true
1469 }
1470 return false
1471}
1472
Martin Stjernholm279de572019-09-10 23:18:20 +01001473func InstallToBootstrap(name string, config android.Config) bool {
Jingwen Chen29743c82023-01-25 17:49:46 +00001474 // NOTE: also update //build/bazel/rules/apex/cc.bzl#_installed_to_bootstrap
1475 // if this list is updated.
Colin Cross4c4c1be2022-02-10 11:41:18 -08001476 if name == "libclang_rt.hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001477 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001478 }
1479 return isBionic(name)
1480}
1481
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001482func (c *Module) XrefCcFiles() android.Paths {
1483 return c.kytheFiles
1484}
1485
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001486func (c *Module) isCfiAssemblySupportEnabled() bool {
1487 return c.sanitize != nil &&
1488 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1489}
1490
Inseob Kim800d1142021-06-14 12:03:51 +09001491func (c *Module) InstallInRoot() bool {
1492 return c.installer != nil && c.installer.installInRoot()
1493}
1494
Colin Crossca860ac2016-01-04 14:34:37 -08001495type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001496 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001497 moduleContextImpl
1498}
1499
Colin Cross37047f12016-12-13 17:06:13 -08001500type depsContext struct {
1501 android.BottomUpMutatorContext
1502 moduleContextImpl
1503}
1504
Colin Crossca860ac2016-01-04 14:34:37 -08001505type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001506 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001507 moduleContextImpl
1508}
1509
1510type moduleContextImpl struct {
1511 mod *Module
1512 ctx BaseModuleContext
1513}
1514
Colin Crossb98c8b02016-07-29 13:44:28 -07001515func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001516 return ctx.mod.toolchain(ctx.ctx)
1517}
1518
1519func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001520 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001521}
1522
1523func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001524 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001525}
1526
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001527func (ctx *moduleContextImpl) testBinary() bool {
1528 return ctx.mod.testBinary()
1529}
1530
Yi Kong56fc1b62022-09-06 16:24:00 +08001531func (ctx *moduleContextImpl) testLibrary() bool {
1532 return ctx.mod.testLibrary()
1533}
1534
Jiyong Park1d1119f2019-07-29 21:27:18 +09001535func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001536 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001537}
1538
Inseob Kim7f283f42020-06-01 21:53:49 +09001539func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001540 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001541}
1542
Inseob Kim1042d292020-06-01 23:23:05 +09001543func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001544 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001545}
1546
Jooyung Hanccce2f22020-03-07 03:45:53 +09001547func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001548 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001549}
1550
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001551func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001552 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001553}
1554
1555func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001556 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001557 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001558 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001559 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001560 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001561 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001562 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001563 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001564 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001565 }
1566 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001567}
1568
Jiyong Parkb35a8192020-08-10 15:59:36 +09001569func (ctx *moduleContextImpl) minSdkVersion() string {
1570 ver := ctx.mod.MinSdkVersion()
1571 if ver == "apex_inherit" && !ctx.isForPlatform() {
1572 ver = ctx.apexSdkVersion().String()
1573 }
1574 if ver == "apex_inherit" || ver == "" {
1575 ver = ctx.sdkVersion()
1576 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001577 // For crt objects, the meaning of min_sdk_version is very different from other types of
1578 // module. For them, min_sdk_version defines the oldest version that the build system will
1579 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1580 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1581 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001582 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1583 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1584 // support such an old version. The version is set to the later version in case when the
1585 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1586 // it's for an APEX.
1587 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1588 if ctx.isForPlatform() {
1589 ver = strconv.Itoa(android.FutureApiLevelInt)
1590 } else { // for apex
1591 ver = ctx.apexSdkVersion().String()
1592 if ver == "" { // in case when min_sdk_version was not set by the APEX
1593 ver = ctx.sdkVersion()
1594 }
1595 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001596 }
1597
Jiyong Parkb35a8192020-08-10 15:59:36 +09001598 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1599 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1600 minSdkVersionInt, err2 := strconv.Atoi(ver)
1601 if err == nil && err2 == nil {
1602 if sdkVersionInt < minSdkVersionInt {
1603 return strconv.Itoa(sdkVersionInt)
1604 }
1605 }
1606 return ver
1607}
1608
1609func (ctx *moduleContextImpl) isSdkVariant() bool {
1610 return ctx.mod.IsSdkVariant()
1611}
1612
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001613func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001614 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001615}
Justin Yun8effde42017-06-23 19:24:43 +09001616
Colin Cross95f1ca02020-10-29 20:47:22 -07001617func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1618 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001619}
1620
Colin Cross127bb8b2020-12-16 16:46:01 -08001621func (ctx *moduleContextImpl) IsLlndk() bool {
1622 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001623}
1624
Colin Cross127bb8b2020-12-16 16:46:01 -08001625func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1626 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001627}
1628
Colin Cross127bb8b2020-12-16 16:46:01 -08001629func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1630 return ctx.mod.isImplementationForLLNDKPublic()
1631}
1632
1633func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1634 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001635}
1636
Logan Chienf3511742017-10-31 18:04:35 +08001637func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001638 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001639}
1640
Yi Kong4ef54592022-02-14 20:00:10 +08001641func (ctx *moduleContextImpl) isAfdoCompile() bool {
1642 return ctx.mod.isAfdoCompile()
1643}
1644
Yi Kong7e53c572018-02-14 18:16:12 +08001645func (ctx *moduleContextImpl) isPgoCompile() bool {
1646 return ctx.mod.isPgoCompile()
1647}
1648
Yi Kongc702ebd2022-08-19 16:02:45 +08001649func (ctx *moduleContextImpl) isCfi() bool {
1650 return ctx.mod.isCfi()
1651}
1652
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001653func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1654 return ctx.mod.isNDKStubLibrary()
1655}
1656
Justin Yun8effde42017-06-23 19:24:43 +09001657func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001658 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001659}
1660
Ivan Lozanof9e21722020-12-02 09:00:51 -05001661func (ctx *moduleContextImpl) IsVndkExt() bool {
1662 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001663}
1664
Colin Cross5271fea2021-04-27 13:06:04 -07001665func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1666 return ctx.mod.IsVendorPublicLibrary()
1667}
1668
Vic Yangefd249e2018-11-12 20:19:56 -08001669func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001670 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001671}
1672
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001673func (ctx *moduleContextImpl) selectedStl() string {
1674 if stl := ctx.mod.stl; stl != nil {
1675 return stl.Properties.SelectedStl
1676 }
1677 return ""
1678}
1679
Ivan Lozanobd721262018-11-27 14:33:03 -08001680func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1681 return ctx.mod.linker.useClangLld(actx)
1682}
1683
Colin Crossce75d2c2016-10-06 16:12:58 -07001684func (ctx *moduleContextImpl) baseModuleName() string {
1685 return ctx.mod.ModuleBase.BaseModuleName()
1686}
1687
Logan Chienf3511742017-10-31 18:04:35 +08001688func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1689 return ctx.mod.getVndkExtendsModuleName()
1690}
1691
Logan Chiene274fc92019-12-03 11:18:32 -08001692func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001693 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001694}
1695
Colin Crosse07f2312020-08-13 11:24:56 -07001696func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001697 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001698}
1699
Dan Albertc8060532020-07-22 22:32:17 -07001700func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001701 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001702}
1703
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001704func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001705 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001706}
1707
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001708func (ctx *moduleContextImpl) nativeCoverage() bool {
1709 return ctx.mod.nativeCoverage()
1710}
1711
Colin Cross56a83212020-09-15 18:30:11 -07001712func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1713 return ctx.mod.DirectlyInAnyApex()
1714}
1715
Colin Cross95b07f22020-12-16 11:06:50 -08001716func (ctx *moduleContextImpl) isPreventInstall() bool {
1717 return ctx.mod.Properties.PreventInstall
1718}
1719
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001720func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1721 shared := &ctx.mod.sharedFlags
1722 if shared.flagsMap == nil {
1723 shared.numSharedFlags = 0
1724 shared.flagsMap = make(map[string]string)
1725 }
1726 return shared
1727}
1728
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001729func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1730 return ctx.mod.isCfiAssemblySupportEnabled()
1731}
1732
Colin Cross635c3b02016-05-18 15:37:25 -07001733func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001734 return &Module{
1735 hod: hod,
1736 multilib: multilib,
1737 }
1738}
1739
Colin Cross635c3b02016-05-18 15:37:25 -07001740func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001741 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001742 module.features = []feature{
1743 &tidyFeature{},
1744 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001745 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001746 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001747 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001748 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001749 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001750 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001751 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001752 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001753 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001754 return module
1755}
1756
Colin Crossce75d2c2016-10-06 16:12:58 -07001757func (c *Module) Prebuilt() *android.Prebuilt {
1758 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1759 return p.prebuilt()
1760 }
1761 return nil
1762}
1763
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001764func (c *Module) IsPrebuilt() bool {
1765 return c.Prebuilt() != nil
1766}
1767
Colin Crossce75d2c2016-10-06 16:12:58 -07001768func (c *Module) Name() string {
1769 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001770 if p, ok := c.linker.(interface {
1771 Name(string) string
1772 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001773 name = p.Name(name)
1774 }
1775 return name
1776}
1777
Alex Light3d673592019-01-18 14:37:31 -08001778func (c *Module) Symlinks() []string {
1779 if p, ok := c.installer.(interface {
1780 symlinkList() []string
1781 }); ok {
1782 return p.symlinkList()
1783 }
1784 return nil
1785}
1786
Roland Levillainf89cd092019-07-29 16:22:59 +01001787func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1788 test, ok := c.linker.(testPerSrc)
1789 return ok && test.isAllTestsVariation()
1790}
1791
Chris Parsons216e10a2020-07-09 17:12:52 -04001792func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001793 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001794 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001795 }); ok {
1796 return p.dataPaths()
1797 }
1798 return nil
1799}
1800
Ivan Lozanof1868af2022-04-12 13:08:36 -04001801func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001802 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1803 // "current", it will append the VNDK version to the name suffix.
1804 var vndkVersion string
1805 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001806 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001807 if c.ProductSpecific() {
1808 // If the module is product specific with 'product_specific: true',
1809 // do not add a name suffix because it is a base module.
1810 return ""
1811 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001812 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001813 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001814 } else {
1815 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001816 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001817 }
1818 if vndkVersion == "current" {
1819 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1820 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001821 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001822 // add version suffix only if the module is using different vndk version than the
1823 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001824 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001825 }
1826 return nameSuffix
1827}
1828
Ivan Lozanof1868af2022-04-12 13:08:36 -04001829func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1830 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001831
1832 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001833 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001834 }
1835
Colin Cross127bb8b2020-12-16 16:46:01 -08001836 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001837 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001838 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1839 // added for product variant only when we have vendor and product variants with core
1840 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001841 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001842 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001843 subName += vendorPublicLibrarySuffix
1844 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001845 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1846 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001847 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001848 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001849 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001850 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001851 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001852 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001853 subName += RecoverySuffix
1854 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1855 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001856 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001857 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001858 }
Inseob Kim64c43952019-08-26 16:52:35 +09001859 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001860
1861 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001862}
1863
Chris Parsonsf874e462022-05-10 13:50:12 -04001864var _ android.MixedBuildBuildable = (*Module)(nil)
1865
1866func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001867 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001868 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001869 // cc_library is a special case in bp2build; two targets are generated -- one for each
1870 // of the shared and static variants. The shared variant keeps the module name, but the
1871 // static variant uses a different suffixed name.
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001872 bazelModuleLabel = bazelLabelForStaticModule(ctx, c)
1873 } else {
1874 bazelModuleLabel = c.GetBazelLabel(ctx, c)
Chris Parsonsf874e462022-05-10 13:50:12 -04001875 }
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001876 labelNoPrebuilt := bazelModuleLabel
1877 if c.IsPrebuilt() {
1878 labelNoPrebuilt = android.RemoveOptionalPrebuiltPrefixFromBazelLabel(bazelModuleLabel)
1879 }
1880 return labelNoPrebuilt
Chris Parsonsf874e462022-05-10 13:50:12 -04001881}
1882
1883func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1884 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1885}
1886
Jingwen Chen3952a902022-12-12 12:20:58 +00001887var (
1888 mixedBuildSupportedCcTest = []string{
1889 "adbd_test",
Liz Kammer9c667412023-01-24 10:47:18 -05001890 "adb_crypto_test",
1891 "adb_pairing_auth_test",
1892 "adb_pairing_connection_test",
1893 "adb_tls_connection_test",
Jingwen Chen3952a902022-12-12 12:20:58 +00001894 }
1895)
1896
1897// IsMixedBuildSupported returns true if the module should be analyzed by Bazel
1898// in any of the --bazel-mode(s). This filters at the module level and takes
1899// precedence over the allowlists in allowlists/allowlists.go.
Chris Parsonsf874e462022-05-10 13:50:12 -04001900func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
Sam Delmerico4e115cc2023-01-19 15:36:52 -05001901 _, isForTesting := ctx.Config().BazelContext.(android.MockBazelContext)
1902 if c.testBinary() && !android.InList(c.Name(), mixedBuildSupportedCcTest) && !isForTesting {
Jingwen Chen3952a902022-12-12 12:20:58 +00001903 // Per-module rollout of mixed-builds for cc_test modules.
1904 return false
1905 }
1906
Trevor Radcliffedb7e0262022-10-28 16:48:18 +00001907 // TODO(b/261058727): Remove this (enable mixed builds for modules with UBSan)
Yu Liue4312402023-01-18 09:15:31 -08001908 // Currently we can only support ubsan when minimum runtime is used.
1909 return c.bazelHandler != nil && (!isUbsanEnabled(c) || c.MinimalRuntimeNeeded())
1910}
1911
1912func isUbsanEnabled(c *Module) bool {
1913 if c.sanitize == nil {
1914 return false
1915 }
1916 sanitizeProps := &c.sanitize.Properties.SanitizeMutated
1917 return Bool(sanitizeProps.Integer_overflow) || len(sanitizeProps.Misc_undefined) > 0
1918}
1919
1920func GetApexConfigKey(ctx android.BaseModuleContext) *android.ApexConfigKey {
1921 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1922 if !apexInfo.IsForPlatform() {
1923 apexKey := android.ApexConfigKey{
1924 WithinApex: true,
1925 ApexSdkVersion: findApexSdkVersion(ctx, apexInfo).String(),
1926 }
1927 return &apexKey
1928 }
1929
1930 return nil
Chris Parsonsf874e462022-05-10 13:50:12 -04001931}
1932
1933func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
1934 bazelModuleLabel := c.getBazelModuleLabel(ctx)
Chris Parsonsf874e462022-05-10 13:50:12 -04001935 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
1936
1937 c.Properties.SubName = GetSubnameProperty(ctx, c)
1938 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1939 if !apexInfo.IsForPlatform() {
1940 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05001941 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05001942
Chris Parsonsf874e462022-05-10 13:50:12 -04001943 c.makeLinkType = GetMakeLinkType(ctx, c)
1944
1945 mctx := &moduleContext{
1946 ModuleContext: ctx,
1947 moduleContextImpl: moduleContextImpl{
1948 mod: c,
1949 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05001950 }
Chris Parsonsf874e462022-05-10 13:50:12 -04001951 mctx.ctx = mctx
1952
Jingwen Chen3952a902022-12-12 12:20:58 +00001953 // TODO(b/244432500): Get the tradefed config from the bazel target instead
1954 // of generating it with Soong.
Chris Parsonsf874e462022-05-10 13:50:12 -04001955 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001956}
1957
1958func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001959 // Handle the case of a test module split by `test_per_src` mutator.
1960 //
1961 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1962 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1963 // module and return early, as this module does not produce an output file per se.
1964 if c.IsTestPerSrcAllTestsVariation() {
1965 c.outputFile = android.OptionalPath{}
1966 return
1967 }
1968
Ivan Lozanof1868af2022-04-12 13:08:36 -04001969 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001970 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1971 if !apexInfo.IsForPlatform() {
1972 c.hideApexVariantFromMake = true
1973 }
1974
Chris Parsonseefc9e62021-04-02 17:36:47 -04001975 c.makeLinkType = GetMakeLinkType(actx, c)
1976
Colin Crossca860ac2016-01-04 14:34:37 -08001977 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001978 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001979 moduleContextImpl: moduleContextImpl{
1980 mod: c,
1981 },
1982 }
1983 ctx.ctx = ctx
1984
Colin Crossf18e1102017-11-16 14:33:08 -08001985 deps := c.depsToPaths(ctx)
1986 if ctx.Failed() {
1987 return
1988 }
1989
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001990 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1991 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001992 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1993 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001994 }
1995
Colin Crossca860ac2016-01-04 14:34:37 -08001996 flags := Flags{
1997 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001998 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08001999 }
Colin Crossca860ac2016-01-04 14:34:37 -08002000 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002001 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002002 }
2003 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002004 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002005 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002006 if c.stl != nil {
2007 flags = c.stl.flags(ctx, flags)
2008 }
Colin Cross16b23492016-01-06 14:41:07 -08002009 if c.sanitize != nil {
2010 flags = c.sanitize.flags(ctx, flags)
2011 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002012 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002013 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002014 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002015 if c.fuzzer != nil {
2016 flags = c.fuzzer.flags(ctx, flags)
2017 }
Stephen Craneba090d12017-05-09 15:44:35 -07002018 if c.lto != nil {
2019 flags = c.lto.flags(ctx, flags)
2020 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002021 if c.afdo != nil {
2022 flags = c.afdo.flags(ctx, flags)
2023 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002024 if c.pgo != nil {
2025 flags = c.pgo.flags(ctx, flags)
2026 }
Colin Crossca860ac2016-01-04 14:34:37 -08002027 for _, feature := range c.features {
2028 flags = feature.flags(ctx, flags)
2029 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002030 if ctx.Failed() {
2031 return
2032 }
2033
Colin Cross4af21ed2019-11-04 09:37:55 -08002034 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2035 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2036 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002037
Colin Cross4af21ed2019-11-04 09:37:55 -08002038 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002039
2040 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002041 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002042 }
2043 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002044 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002045 }
2046
Colin Cross3e5e7782022-06-17 22:17:05 +00002047 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2048
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002049 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002050 // We need access to all the flags seen by a source file.
2051 if c.sabi != nil {
2052 flags = c.sabi.flags(ctx, flags)
2053 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002054
Colin Cross4af21ed2019-11-04 09:37:55 -08002055 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002056
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002057 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002058 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002059 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002060 if ctx.Failed() {
2061 return
2062 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002063 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002064 c.objFiles = objs.objFiles
2065 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002066 }
2067
Colin Crossca860ac2016-01-04 14:34:37 -08002068 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002069 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002070 if ctx.Failed() {
2071 return
2072 }
Colin Cross635c3b02016-05-18 15:37:25 -07002073 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002074
Chris Parsons94a0bba2021-06-04 15:03:47 -04002075 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002076
Jose Galmes6f843bc2020-12-11 13:36:29 -08002077 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2078 // RECOVERY_SNAPSHOT_VERSION is current.
2079 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002080 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002081 i.collectHeadersForSnapshot(ctx)
2082 }
2083 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002084 }
Colin Cross5049f022015-03-18 13:28:46 -07002085
Chris Parsons94a0bba2021-06-04 15:03:47 -04002086 c.maybeInstall(ctx, apexInfo)
2087}
2088
2089func (c *Module) maybeUnhideFromMake() {
2090 // If a lib is directly included in any of the APEXes or is not available to the
2091 // platform (which is often the case when the stub is provided as a prebuilt),
2092 // unhide the stubs variant having the latest version gets visible to make. In
2093 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2094 // force anything in the make world to link against the stubs library. (unless it
2095 // is explicitly referenced via .bootstrap suffix or the module is marked with
2096 // 'bootstrap: true').
2097 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
2098 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
2099 c.IsStubs() && !c.InVendorRamdisk() {
2100 c.Properties.HideFromMake = false // unhide
2101 // Note: this is still non-installable
2102 }
2103}
2104
Jingwen Chen3952a902022-12-12 12:20:58 +00002105// maybeInstall is called at the end of both GenerateAndroidBuildActions and
2106// ProcessBazelQueryResponse to run the install hooks for installable modules,
2107// like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002108func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002109 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002110 // If the module has been specifically configure to not be installed then
2111 // hide from make as otherwise it will break when running inside make
2112 // as the output path to install will not be specified. Not all uninstallable
2113 // modules can be hidden from make as some are needed for resolving make side
2114 // dependencies.
2115 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002116 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002117 c.SkipInstall()
2118 }
2119
2120 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2121 // to allow using the outputs in a genrule.
2122 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002123 c.installer.install(ctx, c.outputFile.Path())
2124 if ctx.Failed() {
2125 return
Colin Crossca860ac2016-01-04 14:34:37 -08002126 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002127 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002128}
2129
Sam Delmerico5fb794a2023-01-27 16:01:37 -05002130func (c *Module) setAndroidMkVariablesFromCquery(info cquery.CcAndroidMkInfo) {
2131 c.Properties.AndroidMkSharedLibs = info.LocalSharedLibs
2132 c.Properties.AndroidMkStaticLibs = info.LocalStaticLibs
2133 c.Properties.AndroidMkWholeStaticLibs = info.LocalWholeStaticLibs
2134}
2135
Colin Cross0ea8ba82019-06-06 14:33:29 -07002136func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002137 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002138 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002139 }
Colin Crossca860ac2016-01-04 14:34:37 -08002140 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002141}
2142
Colin Crossca860ac2016-01-04 14:34:37 -08002143func (c *Module) begin(ctx BaseModuleContext) {
2144 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002145 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002146 }
Colin Crossca860ac2016-01-04 14:34:37 -08002147 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002148 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002149 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002150 if c.stl != nil {
2151 c.stl.begin(ctx)
2152 }
Colin Cross16b23492016-01-06 14:41:07 -08002153 if c.sanitize != nil {
2154 c.sanitize.begin(ctx)
2155 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002156 if c.coverage != nil {
2157 c.coverage.begin(ctx)
2158 }
Stephen Craneba090d12017-05-09 15:44:35 -07002159 if c.lto != nil {
2160 c.lto.begin(ctx)
2161 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002162 if c.afdo != nil {
2163 c.afdo.begin(ctx)
2164 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002165 if c.pgo != nil {
2166 c.pgo.begin(ctx)
2167 }
Dan Albert92fe7402020-07-15 13:33:30 -07002168 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002169 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002170 if err != nil {
2171 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002172 c.Properties.Sdk_version = nil
2173 } else {
2174 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002175 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002176 }
Colin Crossca860ac2016-01-04 14:34:37 -08002177}
2178
Colin Cross37047f12016-12-13 17:06:13 -08002179func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002180 deps := Deps{}
2181
2182 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002183 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002184 }
2185 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002186 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002187 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002188 if c.stl != nil {
2189 deps = c.stl.deps(ctx, deps)
2190 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002191 if c.coverage != nil {
2192 deps = c.coverage.deps(ctx, deps)
2193 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002194
Colin Crossb6715442017-10-24 11:13:31 -07002195 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2196 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2197 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2198 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2199 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2200 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002201 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002202
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002203 for _, lib := range deps.ReexportSharedLibHeaders {
2204 if !inList(lib, deps.SharedLibs) {
2205 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2206 }
2207 }
2208
2209 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002210 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2211 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 -07002212 }
2213 }
2214
Colin Cross5950f382016-12-13 12:50:57 -08002215 for _, lib := range deps.ReexportHeaderLibHeaders {
2216 if !inList(lib, deps.HeaderLibs) {
2217 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2218 }
2219 }
2220
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002221 for _, gen := range deps.ReexportGeneratedHeaders {
2222 if !inList(gen, deps.GeneratedHeaders) {
2223 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2224 }
2225 }
2226
Colin Crossc99deeb2016-04-11 15:06:20 -07002227 return deps
2228}
2229
Dan Albert7e9d2952016-08-04 13:02:36 -07002230func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002231 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002232 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002233 moduleContextImpl: moduleContextImpl{
2234 mod: c,
2235 },
2236 }
2237 ctx.ctx = ctx
2238
Colin Crossca860ac2016-01-04 14:34:37 -08002239 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002240}
2241
Jiyong Park7ed9de32018-10-15 22:25:07 +09002242// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002243func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002244 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2245 version := name[sharp+1:]
2246 libname := name[:sharp]
2247 return libname, version
2248 }
2249 return name, ""
2250}
2251
Dan Albert92fe7402020-07-15 13:33:30 -07002252func GetCrtVariations(ctx android.BottomUpMutatorContext,
2253 m LinkableInterface) []blueprint.Variation {
2254 if ctx.Os() != android.Android {
2255 return nil
2256 }
2257 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002258 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2259 minSdkVersion := m.MinSdkVersion()
2260 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2261 minSdkVersion = m.SdkVersion()
2262 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002263 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2264 if err != nil {
2265 ctx.PropertyErrorf("min_sdk_version", err.Error())
2266 }
Colin Cross363ec762023-01-13 13:45:14 -08002267
2268 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002269 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002270 if apiLevel.LessThan(minApiForArch) {
2271 apiLevel = minApiForArch
2272 }
2273
Dan Albert92fe7402020-07-15 13:33:30 -07002274 return []blueprint.Variation{
2275 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002276 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002277 }
2278 }
2279 return []blueprint.Variation{
2280 {Mutator: "sdk", Variation: ""},
2281 }
2282}
2283
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002284func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2285 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002286
2287 variations = append([]blueprint.Variation(nil), variations...)
2288
Liz Kammer23942242022-04-08 15:41:00 -04002289 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002290 // Version is explicitly specified. i.e. libFoo#30
2291 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002292 if tag, ok := depTag.(libraryDependencyTag); ok {
2293 tag.explicitlyVersioned = true
2294 } else {
2295 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2296 }
Colin Crosse7257d22020-09-24 09:56:18 -07002297 }
Colin Crosse7257d22020-09-24 09:56:18 -07002298
Colin Cross0de8a1e2020-09-18 14:15:30 -07002299 if far {
2300 ctx.AddFarVariationDependencies(variations, depTag, name)
2301 } else {
2302 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002303 }
2304}
2305
Kiyoung Kim487689e2022-07-26 09:48:22 +09002306func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2307 apiImportInfo := multitree.ApiImportInfo{}
2308
2309 if c.Device() {
2310 var apiImportModule []blueprint.Module
2311 if actx.OtherModuleExists("api_imports") {
2312 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2313 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
2314 apiInfo := actx.OtherModuleProvider(apiImportModule[0], multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2315 apiImportInfo = apiInfo
2316 actx.SetProvider(multitree.ApiImportsProvider, apiInfo)
2317 }
2318 }
2319 }
2320
2321 return apiImportInfo
2322}
2323
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002324func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002325 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002326 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002327 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002328 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2329 // between the modules in the snapshot and the snapshot itself.
2330 var snapshotModule []blueprint.Module
2331 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2332 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2333 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2334 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2335 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002336 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002337 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2338 *snapshotInfo = &snapshot
2339 // republish the snapshot for use in later mutators on this module
2340 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002341 }
2342 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002343 if *snapshotInfo == nil {
2344 *snapshotInfo = &SnapshotInfo{}
2345 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002346 return **snapshotInfo
2347}
2348
Kiyoung Kim487689e2022-07-26 09:48:22 +09002349func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2350 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002351 return snapshot
2352 }
2353
2354 return lib
2355}
2356
2357// RewriteLibs takes a list of names of shared libraries and scans it for three types
2358// of names:
2359//
2360// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002361//
2362// For each of these, it adds the name of the prebuilt module (which will be in
2363// prebuilts/ndk) to the list of nonvariant libs.
2364//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002365// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002366//
2367// For each of these, it adds the name of the ndk_library module to the list of
2368// variant libs.
2369//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002370// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002371//
2372// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002373//
2374// The caller can then know to add the variantLibs dependencies differently from the
2375// nonvariantLibs
2376func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2377 variantLibs = []string{}
2378
2379 nonvariantLibs = []string{}
2380 for _, entry := range list {
2381 // strip #version suffix out
2382 name, _ := StubsLibNameAndVersion(entry)
2383 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002384 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002385 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2386 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2387 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002388 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002389 } else {
2390 // put name#version back
2391 nonvariantLibs = append(nonvariantLibs, entry)
2392 }
2393 }
2394 return nonvariantLibs, variantLibs
2395}
2396
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002397func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2398 nonVariantLibs := []string{}
2399 variantLibs := []string{}
2400
2401 for _, lib := range libs {
2402 replaceLibName := GetReplaceModuleName(lib, replaceList)
2403 if replaceLibName == lib {
2404 // Do not handle any libs which are not in API imports
2405 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2406 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2407 variantLibs = append(variantLibs, replaceLibName)
2408 } else {
2409 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2410 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002411 }
2412
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002413 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002414}
2415
Colin Cross1e676be2016-10-12 14:38:15 -07002416func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002417 if !c.Enabled() {
2418 return
2419 }
2420
Colin Cross37047f12016-12-13 17:06:13 -08002421 ctx := &depsContext{
2422 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002423 moduleContextImpl: moduleContextImpl{
2424 mod: c,
2425 },
2426 }
2427 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002428
Colin Crossc99deeb2016-04-11 15:06:20 -07002429 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002430 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002431
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002432 apiNdkLibs := []string{}
2433 apiLateNdkLibs := []string{}
2434
Kiyoung Kim11d91082022-10-19 19:20:57 +09002435 if ctx.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002436 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2437 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2438 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2439 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2440 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002441 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002442
Yo Chiang219968c2020-09-22 18:45:04 +08002443 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2444
Colin Crosse0edaf92021-01-11 17:31:17 -08002445 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002446
Dan Albert914449f2016-06-17 16:45:24 -07002447 variantNdkLibs := []string{}
2448 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002449 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002450 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2451 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2452 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002453
2454 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002455 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002456 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002457 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002458
Colin Cross32ec36c2016-12-15 07:39:51 -08002459 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002460 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002461 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002462 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002463 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002464
Kiyoung Kim51279d32022-08-24 14:10:46 +09002465 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim11d91082022-10-19 19:20:57 +09002466 if ctx.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2467 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2468 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002469 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002470
Spandan Das73bcafc2022-08-18 23:26:00 +00002471 if c.isNDKStubLibrary() {
2472 // ndk_headers do not have any variations
2473 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002474 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002475 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002476 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002477 } else {
2478 actx.AddVariationDependencies(nil, depTag, lib)
2479 }
2480 }
2481
Dan Albertf1d14c72020-07-30 14:32:55 -07002482 if c.isNDKStubLibrary() {
2483 // NDK stubs depend on their implementation because the ABI dumps are
2484 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002485 apiImportName := c.BaseModuleName() + multitree.GetApiImportSuffix()
2486
2487 // If original library exists as imported API, set dependency on the imported library
2488 if actx.OtherModuleExists(apiImportName) {
2489 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2490 c.ImageVariation(),
2491 blueprint.Variation{Mutator: "link", Variation: "shared"},
2492 ), stubImplementation, apiImportName)
2493 } else {
2494 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2495 c.ImageVariation(),
2496 blueprint.Variation{Mutator: "link", Variation: "shared"},
2497 ), stubImplementation, c.BaseModuleName())
2498 }
Dan Albertf1d14c72020-07-30 14:32:55 -07002499 }
2500
Jiyong Park5d1598f2019-02-25 22:14:17 +09002501 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002502 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002503
Kiyoung Kim487689e2022-07-26 09:48:22 +09002504 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002505
Jiyong Park5d1598f2019-02-25 22:14:17 +09002506 actx.AddVariationDependencies([]blueprint.Variation{
2507 {Mutator: "link", Variation: "static"},
2508 }, depTag, lib)
2509 }
2510
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002511 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002512 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002513 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002514 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002515 }
Jiyong Parke3867542020-12-03 17:28:25 +09002516 if inList(lib, deps.ExcludeLibsForApex) {
2517 depTag.excludeInApex = true
2518 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002519
Kiyoung Kim487689e2022-07-26 09:48:22 +09002520 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002521
Dan Willemsen59339a22018-07-22 21:18:45 -07002522 actx.AddVariationDependencies([]blueprint.Variation{
2523 {Mutator: "link", Variation: "static"},
2524 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002525 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002526
Jooyung Han75568392020-03-20 04:29:24 +09002527 // staticUnwinderDep is treated as staticDep for Q apexes
2528 // so that native libraries/binaries are linked with static unwinder
2529 // because Q libc doesn't have unwinder APIs
2530 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002531 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002532 actx.AddVariationDependencies([]blueprint.Variation{
2533 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002534 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002535 }
2536
Jiyong Park7ed9de32018-10-15 22:25:07 +09002537 // shared lib names without the #version suffix
2538 var sharedLibNames []string
2539
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002540 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002541 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002542 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002543 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002544 }
Jiyong Parke3867542020-12-03 17:28:25 +09002545 if inList(lib, deps.ExcludeLibsForApex) {
2546 depTag.excludeInApex = true
2547 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002548
Jiyong Park73c54ee2019-10-22 20:31:18 +09002549 name, version := StubsLibNameAndVersion(lib)
Inseob Kimc0907f12019-02-08 21:00:45 +09002550 sharedLibNames = append(sharedLibNames, name)
2551
Colin Crosse7257d22020-09-24 09:56:18 -07002552 variations := []blueprint.Variation{
2553 {Mutator: "link", Variation: "shared"},
2554 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002555 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002556 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002557
Colin Crossfe9acfe2021-06-14 16:13:03 -07002558 for _, lib := range deps.LateStaticLibs {
2559 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2560 actx.AddVariationDependencies([]blueprint.Variation{
2561 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002562 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002563 }
2564
Colin Cross3e5e7782022-06-17 22:17:05 +00002565 for _, lib := range deps.UnexportedStaticLibs {
2566 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2567 actx.AddVariationDependencies([]blueprint.Variation{
2568 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002569 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002570 }
2571
Jiyong Park7ed9de32018-10-15 22:25:07 +09002572 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002573 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002574 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2575 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2576 // linking against both the stubs lib and the non-stubs lib at the same time.
2577 continue
2578 }
Colin Cross6e511a92020-07-27 21:26:48 -07002579 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002580 variations := []blueprint.Variation{
2581 {Mutator: "link", Variation: "shared"},
2582 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002583 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002584 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002585
Dan Willemsen59339a22018-07-22 21:18:45 -07002586 actx.AddVariationDependencies([]blueprint.Variation{
2587 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002588 }, dataLibDepTag, deps.DataLibs...)
2589
Colin Crossc8caa062021-09-24 16:50:14 -07002590 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2591
Chris Parsons79d66a52020-06-05 17:26:16 -04002592 actx.AddVariationDependencies([]blueprint.Variation{
2593 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002594 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002595
Colin Cross68861832016-07-08 10:41:41 -07002596 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002597
2598 for _, gen := range deps.GeneratedHeaders {
2599 depTag := genHeaderDepTag
2600 if inList(gen, deps.ReexportGeneratedHeaders) {
2601 depTag = genHeaderExportDepTag
2602 }
2603 actx.AddDependency(c, depTag, gen)
2604 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002605
Dan Albert92fe7402020-07-15 13:33:30 -07002606 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002607 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002608 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002609 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002610 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002611 }
Colin Crossc465efd2021-06-11 18:00:04 -07002612 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002613 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002614 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002615 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002616 if deps.DynamicLinker != "" {
2617 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002618 }
Dan Albert914449f2016-06-17 16:45:24 -07002619
2620 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002621
2622 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002623 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002624 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002625 {Mutator: "link", Variation: "shared"},
2626 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002627 actx.AddVariationDependencies([]blueprint.Variation{
2628 {Mutator: "version", Variation: version},
2629 {Mutator: "link", Variation: "shared"},
2630 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002631
2632 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002633 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002634 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002635 {Mutator: "link", Variation: "shared"},
2636 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002637 actx.AddVariationDependencies([]blueprint.Variation{
2638 {Mutator: "version", Variation: version},
2639 {Mutator: "link", Variation: "shared"},
2640 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002641
2642 if vndkdep := c.vndkdep; vndkdep != nil {
2643 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002644 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002645 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002646 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002647 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002648 }
2649 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002650
2651 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002652}
Colin Cross21b9a242015-03-24 14:15:58 -07002653
Colin Crosse40b4ea2018-10-02 22:25:58 -07002654func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002655 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2656 c.beginMutator(ctx)
2657 }
2658}
2659
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002660// Whether a module can link to another module, taking into
2661// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002662func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002663 tag blueprint.DependencyTag) {
2664
2665 switch t := tag.(type) {
2666 case dependencyTag:
2667 if t != vndkExtDepTag {
2668 return
2669 }
2670 case libraryDependencyTag:
2671 default:
2672 return
2673 }
2674
Ivan Lozanof9e21722020-12-02 09:00:51 -05002675 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002676 // Host code is not restricted
2677 return
2678 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002679
2680 // VNDK is cc.Module supported only for now.
2681 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002682 // Though allowed dependency is limited by the image mutator,
2683 // each vendor and product module needs to check link-type
2684 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002685 if ccTo, ok := to.(*Module); ok {
2686 if ccFrom.vndkdep != nil {
2687 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2688 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002689 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002690 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002691 }
2692 return
2693 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002694 // TODO(b/244244438) : Remove this once all variants are implemented
2695 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2696 return
2697 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002698 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002699 // Platform code can link to anything
2700 return
2701 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002702 if from.InRamdisk() {
2703 // Ramdisk code is not NDK
2704 return
2705 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002706 if from.InVendorRamdisk() {
2707 // Vendor ramdisk code is not NDK
2708 return
2709 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002710 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002711 // Recovery code is not NDK
2712 return
2713 }
Colin Cross31076b32020-10-23 17:22:06 -07002714 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002715 if c.NdkPrebuiltStl() {
2716 // These are allowed, but they don't set sdk_version
2717 return
2718 }
2719 if c.StubDecorator() {
2720 // These aren't real libraries, but are the stub shared libraries that are included in
2721 // the NDK.
2722 return
2723 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002724 if c.isImportedApiLibrary() {
2725 // Imported library from the API surface is a stub library built against interface definition.
2726 return
2727 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002728 }
Logan Chien834b9a62019-01-14 15:39:03 +08002729
Ivan Lozano52767be2019-10-18 14:49:46 -07002730 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002731 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2732 // to link to libc++ (non-NDK and without sdk_version).
2733 return
2734 }
2735
Ivan Lozano52767be2019-10-18 14:49:46 -07002736 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002737 // NDK code linking to platform code is never okay.
2738 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002739 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002740 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002741 }
2742
2743 // At this point we know we have two NDK libraries, but we need to
2744 // check that we're not linking against anything built against a higher
2745 // API level, as it is only valid to link against older or equivalent
2746 // APIs.
2747
Inseob Kim01a28722018-04-11 09:48:45 +09002748 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002749 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002750 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002751 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002752 // Current can't be linked against by anything else.
2753 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002754 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002755 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002756 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002757 if err != nil {
2758 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002759 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002760 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002761 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002762 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002763 if err != nil {
2764 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002765 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002766 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002767 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002768
Inseob Kim01a28722018-04-11 09:48:45 +09002769 if toApi > fromApi {
2770 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002771 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002772 }
2773 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002774 }
Dan Albert202fe492017-12-15 13:56:59 -08002775
2776 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002777 fromStl := from.SelectedStl()
2778 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002779 if fromStl == "" || toStl == "" {
2780 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002781 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002782 // We can be permissive with the system "STL" since it is only the C++
2783 // ABI layer, but in the future we should make sure that everyone is
2784 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002785 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002786 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002787 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2788 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002789 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002790}
2791
Jooyung Han479ca172020-10-19 18:51:07 +09002792func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2793 if c, ok := ctx.Module().(*Module); ok {
2794 ctx.VisitDirectDeps(func(dep android.Module) {
2795 depTag := ctx.OtherModuleDependencyTag(dep)
2796 ccDep, ok := dep.(LinkableInterface)
2797 if ok {
2798 checkLinkType(ctx, c, ccDep, depTag)
2799 }
2800 })
2801 }
2802}
2803
Jiyong Park5fb8c102018-04-09 12:03:06 +09002804// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002805// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2806// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002807// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002808func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2809 check := func(child, parent android.Module) bool {
2810 to, ok := child.(*Module)
2811 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002812 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002813 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002814
Jooyung Hana70f0672019-01-18 15:20:43 +09002815 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2816 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002817 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002818
Jiyong Park0474e1f2021-01-14 14:26:06 +09002819 // These dependencies are not excercised at runtime. Tracking these will give us
2820 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002821 depTag := ctx.OtherModuleDependencyTag(child)
2822 if IsHeaderDepTag(depTag) {
2823 return false
2824 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002825 if depTag == staticVariantTag {
2826 return false
2827 }
2828 if depTag == stubImplDepTag {
2829 return false
2830 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002831
Justin Yun63e9ec72020-10-29 16:49:43 +09002832 // Even if target lib has no vendor variant, keep checking dependency
2833 // graph in case it depends on vendor_available or product_available
2834 // but not double_loadable transtively.
2835 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002836 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002837 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002838
Jiyong Park0474e1f2021-01-14 14:26:06 +09002839 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2840 // one.
2841 if Bool(to.VendorProperties.Double_loadable) {
2842 return true
2843 }
2844
Ivan Lozanod7586b62021-04-01 09:49:36 -04002845 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002846 return false
2847 }
2848
Jooyung Hana70f0672019-01-18 15:20:43 +09002849 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2850 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002851 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002852 return false
2853 }
2854 if module, ok := ctx.Module().(*Module); ok {
2855 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002856 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002857 ctx.WalkDeps(check)
2858 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002859 }
2860 }
2861}
2862
Yu Liue4312402023-01-18 09:15:31 -08002863func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2864 // For the dependency from platform to apex, use the latest stubs
2865 apexSdkVersion := android.FutureApiLevel
2866 if !apexInfo.IsForPlatform() {
2867 apexSdkVersion = apexInfo.MinSdkVersion
2868 }
2869
2870 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2871 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2872 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2873 // (b/144430859)
2874 apexSdkVersion = android.FutureApiLevel
2875 }
2876
2877 return apexSdkVersion
2878}
2879
Colin Crossc99deeb2016-04-11 15:06:20 -07002880// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002881func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002882 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002883
Colin Cross0de8a1e2020-09-18 14:15:30 -07002884 var directStaticDeps []StaticLibraryInfo
2885 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002886
Colin Cross0de8a1e2020-09-18 14:15:30 -07002887 reexportExporter := func(exporter FlagExporterInfo) {
2888 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2889 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2890 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2891 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2892 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002893 }
2894
Colin Cross56a83212020-09-15 18:30:11 -07002895 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
Yu Liue4312402023-01-18 09:15:31 -08002896 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002897
Colin Crossd11fcda2017-10-23 17:59:01 -07002898 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002899 depName := ctx.OtherModuleName(dep)
2900 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002901
Dan Willemsen47450072021-10-19 20:24:49 -07002902 if depTag == android.DarwinUniversalVariantTag {
2903 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2904 return
2905 }
2906
Ivan Lozano52767be2019-10-18 14:49:46 -07002907 ccDep, ok := dep.(LinkableInterface)
2908 if !ok {
2909
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002910 // handling for a few module types that aren't cc Module but that are also supported
2911 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002912 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002913 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002914 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2915 genRule.GeneratedSourceFiles()...)
2916 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002917 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002918 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002919 // Support exported headers from a generated_sources dependency
2920 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002921 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002922 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002923 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08002924 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09002925 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09002926 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002927 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09002928 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09002929 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
2930 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09002931 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002932 // 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 +09002933 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07002934
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002935 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002936 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002937 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002938 }
Colin Crosscef792e2021-06-11 18:01:26 -07002939 case CrtBeginDepTag:
2940 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
2941 case CrtEndDepTag:
2942 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08002943 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002944 return
2945 }
2946
Colin Crossfe17f6f2019-03-28 19:30:56 -07002947 if depTag == android.ProtoPluginDepTag {
2948 return
2949 }
2950
Colin Crossd11fcda2017-10-23 17:59:01 -07002951 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002952 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
2953 return
2954 }
Colin Crossd11fcda2017-10-23 17:59:01 -07002955 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00002956 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
2957 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07002958 return
2959 }
2960
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002961 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07002962 // Skip reused objects for stub libraries, they use their own stub object file instead.
2963 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
2964 // version mutator, so the stubs variant is created from the shared variant that
2965 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07002966 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07002967 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
2968 objs := staticAnalogue.ReuseObjects
2969 depPaths.Objs = depPaths.Objs.Append(objs)
2970 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
2971 reexportExporter(depExporterInfo)
2972 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07002973 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09002974 }
2975
Colin Cross6e511a92020-07-27 21:26:48 -07002976 linkFile := ccDep.OutputFile()
2977
2978 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
2979 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07002980 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002981 return
2982 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002983
Jiyong Parke3867542020-12-03 17:28:25 +09002984 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
2985 return
2986 }
2987
Colin Cross0de8a1e2020-09-18 14:15:30 -07002988 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07002989
Colin Cross6e511a92020-07-27 21:26:48 -07002990 var ptr *android.Paths
2991 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07002992
Colin Cross6e511a92020-07-27 21:26:48 -07002993 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07002994
Colin Cross6e511a92020-07-27 21:26:48 -07002995 switch {
2996 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08002997 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
2998 if !ctx.Config().AllowMissingDependencies() {
2999 ctx.ModuleErrorf("module %q is not a header library", depName)
3000 } else {
3001 ctx.AddMissingDependencies([]string{depName})
3002 }
3003 return
3004 }
Colin Cross6e511a92020-07-27 21:26:48 -07003005 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003006 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
3007 if !ctx.Config().AllowMissingDependencies() {
3008 ctx.ModuleErrorf("module %q is not a shared library", depName)
3009 } else {
3010 ctx.AddMissingDependencies([]string{depName})
3011 }
3012 return
3013 }
Jiyong Parke3867542020-12-03 17:28:25 +09003014
Jiyong Park7d55b612021-06-11 17:22:09 +09003015 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3016 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003017
Jiyong Park1ad8e162020-12-01 23:40:09 +09003018 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3019 // linkFile, depFile, and ptr.
3020 if c.IsStubs() {
3021 break
3022 }
3023
Colin Cross0de8a1e2020-09-18 14:15:30 -07003024 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3025 depFile = sharedLibraryInfo.TableOfContents
3026
Colin Cross6e511a92020-07-27 21:26:48 -07003027 ptr = &depPaths.SharedLibs
3028 switch libDepTag.Order {
3029 case earlyLibraryDependency:
3030 ptr = &depPaths.EarlySharedLibs
3031 depPtr = &depPaths.EarlySharedLibsDeps
3032 case normalLibraryDependency:
3033 ptr = &depPaths.SharedLibs
3034 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003035 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003036 case lateLibraryDependency:
3037 ptr = &depPaths.LateSharedLibs
3038 depPtr = &depPaths.LateSharedLibsDeps
3039 default:
3040 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003041 }
Colin Cross6e511a92020-07-27 21:26:48 -07003042 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003043 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
3044 if !ctx.Config().AllowMissingDependencies() {
3045 ctx.ModuleErrorf("module %q is not a static library", depName)
3046 } else {
3047 ctx.AddMissingDependencies([]string{depName})
3048 }
3049 return
3050 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003051
3052 // Stubs lib doesn't link to the static lib dependencies. Don't set
3053 // linkFile, depFile, and ptr.
3054 if c.IsStubs() {
3055 break
3056 }
3057
Colin Cross0de8a1e2020-09-18 14:15:30 -07003058 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3059 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003060 if libDepTag.wholeStatic {
3061 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003062 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3063 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003064 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003065 // This case normally catches prebuilt static
3066 // libraries, but it can also occur when
3067 // AllowMissingDependencies is on and the
3068 // dependencies has no sources of its own
3069 // but has a whole_static_libs dependency
3070 // on a missing library. We want to depend
3071 // on the .a file so that there is something
3072 // in the dependency tree that contains the
3073 // error rule for the missing transitive
3074 // dependency.
3075 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003076 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003077 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3078 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003079 } else {
3080 switch libDepTag.Order {
3081 case earlyLibraryDependency:
3082 panic(fmt.Errorf("early static libs not suppported"))
3083 case normalLibraryDependency:
3084 // static dependencies will be handled separately so they can be ordered
3085 // using transitive dependencies.
3086 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003087 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003088 case lateLibraryDependency:
3089 ptr = &depPaths.LateStaticLibs
3090 default:
3091 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003092 }
3093 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003094 if libDepTag.unexportedSymbols {
3095 depPaths.LdFlags = append(depPaths.LdFlags,
3096 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3097 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003098 }
3099
Colin Cross6e511a92020-07-27 21:26:48 -07003100 if libDepTag.static() && !libDepTag.wholeStatic {
3101 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3102 ctx.ModuleErrorf("module %q not a static library", depName)
3103 return
3104 }
Logan Chien43d34c32017-12-20 01:17:32 +08003105
Colin Cross6e511a92020-07-27 21:26:48 -07003106 // When combining coverage files for shared libraries and executables, coverage files
3107 // in static libraries act as if they were whole static libraries. The same goes for
3108 // source based Abi dump files.
3109 if c, ok := ccDep.(*Module); ok {
3110 staticLib := c.linker.(libraryInterface)
3111 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3112 staticLib.objs().coverageFiles...)
3113 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3114 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003115 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003116 // Handle non-CC modules here
3117 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003118 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003119 }
3120 }
3121
Colin Cross6e511a92020-07-27 21:26:48 -07003122 if ptr != nil {
3123 if !linkFile.Valid() {
3124 if !ctx.Config().AllowMissingDependencies() {
3125 ctx.ModuleErrorf("module %q missing output file", depName)
3126 } else {
3127 ctx.AddMissingDependencies([]string{depName})
3128 }
3129 return
3130 }
3131 *ptr = append(*ptr, linkFile.Path())
3132 }
3133
3134 if depPtr != nil {
3135 dep := depFile
3136 if !dep.Valid() {
3137 dep = linkFile
3138 }
3139 *depPtr = append(*depPtr, dep.Path())
3140 }
3141
Colin Cross0de8a1e2020-09-18 14:15:30 -07003142 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3143 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3144 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3145 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3146
3147 if libDepTag.reexportFlags {
3148 reexportExporter(depExporterInfo)
3149 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3150 // Re-exported shared library headers must be included as well since they can help us with type information
3151 // about template instantiations (instantiated from their headers).
3152 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3153 // scripts.
3154 c.sabi.Properties.ReexportedIncludes = append(
3155 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3156 }
3157
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003158 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003159 switch {
3160 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003161 c.Properties.AndroidMkHeaderLibs = append(
3162 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003163 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003164 if lib := moduleLibraryInterface(dep); lib != nil {
3165 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003166 // Add the dependency to the APEX(es) providing the library so that
3167 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07003168 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09003169 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003170 c.Properties.ApexesProvidingSharedLibs = append(
3171 c.Properties.ApexesProvidingSharedLibs, an)
3172 }
3173 }
3174 }
3175
3176 // Note: the order of libs in this list is not important because
3177 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003178 c.Properties.AndroidMkSharedLibs = append(
3179 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003180 // Record BaseLibName for snapshots.
3181 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003182 case libDepTag.static():
3183 if libDepTag.wholeStatic {
3184 c.Properties.AndroidMkWholeStaticLibs = append(
3185 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3186 } else {
3187 c.Properties.AndroidMkStaticLibs = append(
3188 c.Properties.AndroidMkStaticLibs, makeLibName)
3189 }
Justin Yun5e035862021-06-29 20:50:37 +09003190 // Record BaseLibName for snapshots.
3191 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003192 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003193 } else if !c.IsStubs() {
3194 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3195
Colin Cross6e511a92020-07-27 21:26:48 -07003196 switch depTag {
3197 case runtimeDepTag:
3198 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003199 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003200 // Record BaseLibName for snapshots.
3201 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003202 case objDepTag:
3203 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3204 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003205 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003206 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003207 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003208 case dynamicLinkerDepTag:
3209 depPaths.DynamicLinker = linkFile
3210 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003211 }
Colin Crossca860ac2016-01-04 14:34:37 -08003212 })
3213
Jeff Gaston294356f2017-09-27 17:05:30 -07003214 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003215 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3216 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3217 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003218
Colin Crossdd84e052017-05-17 13:44:16 -07003219 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003220 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003221 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3222 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003223 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003224 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3225 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003226 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003227 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003228 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003229
3230 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003231 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003232 }
Colin Crossdd84e052017-05-17 13:44:16 -07003233
Colin Crossca860ac2016-01-04 14:34:37 -08003234 return depPaths
3235}
3236
Jiyong Park7d55b612021-06-11 17:22:09 +09003237// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3238// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3239// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3240// has different level of updatability. For example, if a library foo in an APEX depends on a
3241// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3242// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3243// same APEX as foo, the non-stub variant of bar is used.
3244func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3245 depName := ctx.OtherModuleName(dep)
3246 depTag := ctx.OtherModuleDependencyTag(dep)
3247 libDepTag, ok := depTag.(libraryDependencyTag)
3248 if !ok || !libDepTag.shared() {
3249 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3250 }
3251
3252 thisModule, ok := ctx.Module().(android.ApexModule)
3253 if !ok {
3254 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3255 }
3256
3257 useVndk := false
3258 bootstrap := false
3259 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3260 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3261 } else {
3262 useVndk = linkable.UseVndk()
3263 bootstrap = linkable.Bootstrap()
3264 }
3265
3266 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3267 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3268 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
3269 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3270
3271 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
3272 useStubs := false
3273
3274 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3275 if !apexInfo.IsForPlatform() {
3276 // For platform libraries, use current version of LLNDK
3277 // If this is for use_vendor apex we will apply the same rules
3278 // of apex sdk enforcement below to choose right version.
3279 useStubs = true
3280 }
Jiyong Park9477c262021-06-22 20:23:05 +09003281 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3282 // If not building for APEX or the containing APEX allows the use of
3283 // platform APIs, use stubs only when it is from an APEX (and not from
3284 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3285 // bootstrap modules, always link to non-stub variant
Jiyong Park7d55b612021-06-11 17:22:09 +09003286 useStubs = dep.(android.ApexModule).NotInPlatform() && !bootstrap
3287 if useStubs {
3288 // Another exception: if this module is a test for an APEX, then
3289 // it is linked with the non-stub variant of a module in the APEX
3290 // as if this is part of the APEX.
3291 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3292 for _, apexContents := range testFor.ApexContents {
3293 if apexContents.DirectlyInApex(depName) {
3294 useStubs = false
3295 break
3296 }
3297 }
3298 }
3299 if useStubs {
3300 // Yet another exception: If this module and the dependency are
3301 // available to the same APEXes then skip stubs between their
3302 // platform variants. This complements the test_for case above,
3303 // which avoids the stubs on a direct APEX library dependency, by
3304 // avoiding stubs for indirect test dependencies as well.
3305 //
3306 // TODO(b/183882457): This doesn't work if the two libraries have
3307 // only partially overlapping apex_available. For that test_for
3308 // modules would need to be split into APEX variants and resolved
3309 // separately for each APEX they have access to.
3310 if android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3311 useStubs = false
3312 }
3313 }
3314 } else {
3315 // If building for APEX, use stubs when the parent is in any APEX that
3316 // the child is not in.
3317 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3318 }
3319
3320 // when to use (unspecified) stubs, use the latest one.
3321 if useStubs {
3322 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3323 toUse := stubs[len(stubs)-1]
3324 sharedLibraryInfo = toUse.SharedLibraryInfo
3325 depExporterInfo = toUse.FlagExporterInfo
3326 }
3327 }
3328 return sharedLibraryInfo, depExporterInfo
3329}
3330
Colin Cross0de8a1e2020-09-18 14:15:30 -07003331// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3332// to match the topological order of the dependency tree, including any static analogues of
3333// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3334// of the transitive dependencies.
3335func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3336 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3337 var staticPaths android.Paths
3338 for _, staticDep := range staticDeps {
3339 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3340 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3341 }
3342 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003343 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3344 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003345 }
3346 }
3347 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3348
3349 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3350
3351 // reorder the dependencies based on transitive dependencies
3352 staticPaths = android.FirstUniquePaths(staticPaths)
3353 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3354
3355 if len(orderedStaticPaths) != len(staticPaths) {
3356 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3357 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3358 }
3359
3360 return orderedStaticPaths, transitiveStaticLibs
3361}
3362
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003363// BaseLibName trims known prefixes and suffixes
3364func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003365 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3366 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003367 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003368 return libName
3369}
3370
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003371func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003372 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003373 ccDepModule, _ := ccDep.(*Module)
3374 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003375 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003376
Justin Yuncbca3732021-02-03 19:24:13 +09003377 if ccDepModule != nil {
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003378 // TODO(ivanlozano) Support snapshots for Rust-produced C library variants.
Colin Cross6e511a92020-07-27 21:26:48 -07003379 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003380 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003381 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003382
Ivan Lozanod1dec542021-05-26 15:33:11 -04003383 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003384 }
3385 }
3386
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003387 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3388 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003389 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3390 // core module instead.
3391 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003392 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003393 // The vendor and product modules in Make will have been renamed to not conflict with the
3394 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003395 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003396 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003397 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003398 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003399 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003400 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003401 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003402 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003403 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003404 } else {
3405 return libName
3406 }
3407}
3408
Colin Crossca860ac2016-01-04 14:34:37 -08003409func (c *Module) InstallInData() bool {
3410 if c.installer == nil {
3411 return false
3412 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003413 return c.installer.inData()
3414}
3415
3416func (c *Module) InstallInSanitizerDir() bool {
3417 if c.installer == nil {
3418 return false
3419 }
3420 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003421 return true
3422 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003423 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003424}
3425
Yifan Hong1b3348d2020-01-21 15:53:22 -08003426func (c *Module) InstallInRamdisk() bool {
3427 return c.InRamdisk()
3428}
3429
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003430func (c *Module) InstallInVendorRamdisk() bool {
3431 return c.InVendorRamdisk()
3432}
3433
Jiyong Parkf9332f12018-02-01 00:54:12 +09003434func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003435 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003436}
3437
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003438func (c *Module) MakeUninstallable() {
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003439 if c.installer == nil {
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003440 c.ModuleBase.MakeUninstallable()
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003441 return
3442 }
Martin Stjernholm9e9bb7f2020-08-06 22:34:42 +01003443 c.installer.makeUninstallable(c)
Martin Stjernholmbf37d162020-03-31 16:05:34 +01003444}
3445
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003446func (c *Module) HostToolPath() android.OptionalPath {
3447 if c.installer == nil {
3448 return android.OptionalPath{}
3449 }
3450 return c.installer.hostToolPath()
3451}
3452
Nan Zhangd4e641b2017-07-12 12:55:28 -07003453func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3454 return c.outputFile
3455}
3456
Colin Cross41955e82019-05-29 14:40:35 -07003457func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3458 switch tag {
3459 case "":
3460 if c.outputFile.Valid() {
3461 return android.Paths{c.outputFile.Path()}, nil
3462 }
3463 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003464 case "unstripped":
3465 if c.linker != nil {
3466 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3467 }
3468 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003469 default:
3470 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003471 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003472}
3473
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003474func (c *Module) static() bool {
3475 if static, ok := c.linker.(interface {
3476 static() bool
3477 }); ok {
3478 return static.static()
3479 }
3480 return false
3481}
3482
Jiyong Park379de2f2018-12-19 02:47:14 +09003483func (c *Module) staticBinary() bool {
3484 if static, ok := c.linker.(interface {
3485 staticBinary() bool
3486 }); ok {
3487 return static.staticBinary()
3488 }
3489 return false
3490}
3491
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003492func (c *Module) testBinary() bool {
3493 if test, ok := c.linker.(interface {
3494 testBinary() bool
3495 }); ok {
3496 return test.testBinary()
3497 }
3498 return false
3499}
3500
Jingwen Chen537242c2022-08-24 11:53:27 +00003501func (c *Module) testLibrary() bool {
3502 if test, ok := c.linker.(interface {
3503 testLibrary() bool
3504 }); ok {
3505 return test.testLibrary()
3506 }
3507 return false
3508}
3509
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003510func (c *Module) benchmarkBinary() bool {
3511 if b, ok := c.linker.(interface {
3512 benchmarkBinary() bool
3513 }); ok {
3514 return b.benchmarkBinary()
3515 }
3516 return false
3517}
3518
3519func (c *Module) fuzzBinary() bool {
3520 if f, ok := c.linker.(interface {
3521 fuzzBinary() bool
3522 }); ok {
3523 return f.fuzzBinary()
3524 }
3525 return false
3526}
3527
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003528// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3529func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003530 if h, ok := c.linker.(interface {
3531 header() bool
3532 }); ok {
3533 return h.header()
3534 }
3535 return false
3536}
3537
Ivan Lozanod7586b62021-04-01 09:49:36 -04003538func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003539 if b, ok := c.linker.(interface {
3540 binary() bool
3541 }); ok {
3542 return b.binary()
3543 }
3544 return false
3545}
3546
Justin Yun5e035862021-06-29 20:50:37 +09003547func (c *Module) StaticExecutable() bool {
3548 if b, ok := c.linker.(*binaryDecorator); ok {
3549 return b.static()
3550 }
3551 return false
3552}
3553
Ivan Lozanod7586b62021-04-01 09:49:36 -04003554func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003555 if o, ok := c.linker.(interface {
3556 object() bool
3557 }); ok {
3558 return o.object()
3559 }
3560 return false
3561}
3562
Ivan Lozanof9e21722020-12-02 09:00:51 -05003563func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003564 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003565 if c.IsLlndk() {
3566 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003567 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003568 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003569 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003570 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003571 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003572 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003573 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003574 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003575 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003576 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003577 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003578 return "native:product"
3579 }
Jooyung Han38002912019-05-16 04:01:54 +09003580 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003581 } else if c.InRamdisk() {
3582 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003583 } else if c.InVendorRamdisk() {
3584 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003585 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003586 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003587 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003588 return "native:ndk:none:none"
3589 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3590 //family, link := getNdkStlFamilyAndLinkType(c)
3591 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003592 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003593 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003594 } else {
3595 return "native:platform"
3596 }
3597}
3598
Jiyong Park9d452992018-10-03 00:38:19 +09003599// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003600// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003601func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003602 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003603 // Stub libs and prebuilt libs in a versioned SDK are not
3604 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003605 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003606 } else if _, ok := c.linker.(testPerSrc); ok {
3607 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003608 }
3609 return false
3610}
3611
Jiyong Parka90ca002019-10-07 15:47:24 +09003612func (c *Module) AvailableFor(what string) bool {
3613 if linker, ok := c.linker.(interface {
3614 availableFor(string) bool
3615 }); ok {
3616 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3617 } else {
3618 return c.ApexModuleBase.AvailableFor(what)
3619 }
3620}
3621
Jiyong Park62304bb2020-04-13 16:19:48 +09003622func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003623 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003624}
3625
Paul Duffin0cb37b92020-03-04 14:52:46 +00003626func (c *Module) EverInstallable() bool {
3627 return c.installer != nil &&
3628 // Check to see whether the module is actually ever installable.
3629 c.installer.everInstallable()
3630}
3631
Ivan Lozanod7586b62021-04-01 09:49:36 -04003632func (c *Module) PreventInstall() bool {
3633 return c.Properties.PreventInstall
3634}
3635
3636func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003637 if c.library != nil {
3638 if i := c.library.installable(); i != nil {
3639 return i
3640 }
3641 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003642 return c.Properties.Installable
3643}
3644
3645func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003646 ret := c.EverInstallable() &&
3647 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003648 proptools.BoolDefault(c.Installable(), true) &&
3649 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003650
3651 // The platform variant doesn't need further condition. Apex variants however might not
3652 // be installable because it will likely to be included in the APEX and won't appear
3653 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003654 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003655 return ret
3656 }
3657
3658 // Special case for modules that are configured to be installed to /data, which includes
3659 // test modules. For these modules, both APEX and non-APEX variants are considered as
3660 // installable. This is because even the APEX variants won't be included in the APEX, but
3661 // will anyway be installed to /data/*.
3662 // See b/146995717
3663 if c.InstallInData() {
3664 return ret
3665 }
3666
3667 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003668}
3669
Logan Chien41eabe62019-04-10 13:33:58 +08003670func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3671 if c.linker != nil {
3672 if library, ok := c.linker.(*libraryDecorator); ok {
3673 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3674 }
3675 }
3676}
3677
Jiyong Park45bf82e2020-12-15 22:29:02 +09003678var _ android.ApexModule = (*Module)(nil)
3679
3680// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003681func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003682 depTag := ctx.OtherModuleDependencyTag(dep)
3683 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3684
3685 if cc, ok := dep.(*Module); ok {
3686 if cc.HasStubsVariants() {
3687 if isLibDepTag && libDepTag.shared() {
3688 // dynamic dep to a stubs lib crosses APEX boundary
3689 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003690 }
Colin Cross6e511a92020-07-27 21:26:48 -07003691 if IsRuntimeDepTag(depTag) {
3692 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003693 return false
3694 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003695 }
Zhijun Heec285872021-04-24 10:47:08 -07003696 if cc.IsLlndk() {
3697 return false
3698 }
Colin Crossaac32222020-07-29 12:51:56 -07003699 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003700 // shared_lib dependency from a static lib is considered as crossing
3701 // the APEX boundary because the dependency doesn't actually is
3702 // linked; the dependency is used only during the compilation phase.
3703 return false
3704 }
Jiyong Parke3867542020-12-03 17:28:25 +09003705
3706 if isLibDepTag && libDepTag.excludeInApex {
3707 return false
3708 }
Colin Cross6e511a92020-07-27 21:26:48 -07003709 }
Colin Crossc1b36442021-05-06 13:42:48 -07003710 if depTag == stubImplDepTag {
3711 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003712 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003713 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003714 if depTag == staticVariantTag {
3715 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3716 // actually mean that the static lib (and its dependencies) are copied into the
3717 // APEX.
3718 return false
3719 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003720 return true
3721}
3722
Jiyong Park45bf82e2020-12-15 22:29:02 +09003723// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003724func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3725 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003726 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3727 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3728 return nil
3729 }
Jooyung Han749dc692020-04-15 11:03:39 +09003730 // We don't check for prebuilt modules
3731 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3732 return nil
3733 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003734
Jooyung Han749dc692020-04-15 11:03:39 +09003735 minSdkVersion := c.MinSdkVersion()
3736 if minSdkVersion == "apex_inherit" {
3737 return nil
3738 }
3739 if minSdkVersion == "" {
3740 // JNI libs within APK-in-APEX fall into here
3741 // Those are okay to set sdk_version instead
3742 // We don't have to check if this is a SDK variant because
3743 // non-SDK variant resets sdk_version, which works too.
3744 minSdkVersion = c.SdkVersion()
3745 }
Dan Albertc8060532020-07-22 22:32:17 -07003746 if minSdkVersion == "" {
3747 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3748 }
3749 // Not using nativeApiLevelFromUser because the context here is not
3750 // necessarily a native context.
3751 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003752 if err != nil {
3753 return err
3754 }
Dan Albertc8060532020-07-22 22:32:17 -07003755
Colin Cross8ca61c12022-10-06 21:00:14 -07003756 // A dependency only needs to support a min_sdk_version at least
3757 // as high as the api level that the architecture was introduced in.
3758 // This allows introducing new architectures in the platform that
3759 // need to be included in apexes that normally require an older
3760 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003761 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003762 if sdkVersion.LessThan(minApiForArch) {
3763 sdkVersion = minApiForArch
3764 }
3765
Dan Albertc8060532020-07-22 22:32:17 -07003766 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003767 return fmt.Errorf("newer SDK(%v)", ver)
3768 }
3769 return nil
3770}
3771
Paul Duffinb5769c12021-05-12 16:16:51 +01003772// Implements android.ApexModule
3773func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3774 // stub libraries and native bridge libraries are always available to platform
3775 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3776}
3777
Jooyung Han91f92032022-02-04 12:36:33 +09003778// Overrides android.ApexModuleBase.UniqueApexVariations
3779func (c *Module) UniqueApexVariations() bool {
3780 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3781 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3782 // variation of the VNDK lib because APEX variations are merged/grouped.
3783 return c.UseVndk() && c.IsVndk()
3784}
3785
Inseob Kima1888ce2022-10-04 14:42:02 +09003786func (c *Module) overriddenModules() []string {
3787 if o, ok := c.linker.(overridable); ok {
3788 return o.overriddenModules()
3789 }
3790 return nil
3791}
3792
Rob Seymour925aa092021-08-10 20:42:03 +00003793var _ snapshot.RelativeInstallPath = (*Module)(nil)
3794
Liz Kammer35ca77e2021-12-22 15:31:40 -05003795type moduleType int
3796
3797const (
3798 unknownType moduleType = iota
3799 binary
3800 object
3801 fullLibrary
3802 staticLibrary
3803 sharedLibrary
3804 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003805 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003806 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003807)
3808
3809func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003810 if c.testBinary() {
3811 // testBinary is also a binary, so this comes before the c.Binary()
3812 // conditional. A testBinary has additional implicit dependencies and
3813 // other test-only semantics.
3814 return testBin
3815 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003816 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003817 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003818 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003819 } else if c.testLibrary() {
3820 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3821 // will let them add implicit compile deps on gtest, for example.
3822 //
3823 // For now, treat them as regular shared libraries.
3824 return sharedLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003825 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003826 static := false
3827 shared := false
3828 if library, ok := c.linker.(*libraryDecorator); ok {
3829 static = library.MutatedProperties.BuildStatic
3830 shared = library.MutatedProperties.BuildShared
3831 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3832 static = library.MutatedProperties.BuildStatic
3833 shared = library.MutatedProperties.BuildShared
3834 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003835 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003836 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003837 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003838 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003839 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003840 return staticLibrary
3841 }
3842 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003843 } else if c.isNDKStubLibrary() {
3844 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003845 }
3846 return unknownType
3847}
3848
3849// ConvertWithBp2build converts Module to Bazel for bp2build.
3850func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
3851 prebuilt := c.IsPrebuilt()
3852 switch c.typ() {
3853 case binary:
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxb12ff592022-09-01 15:04:04 +00003854 if prebuilt {
3855 prebuiltBinaryBp2Build(ctx, c)
3856 } else {
Jingwen Chen537242c2022-08-24 11:53:27 +00003857 binaryBp2build(ctx, c)
3858 }
3859 case testBin:
3860 if !prebuilt {
3861 testBinaryBp2build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003862 }
3863 case object:
Colin Crossc5075e92022-12-05 16:46:39 -08003864 if prebuilt {
3865 prebuiltObjectBp2Build(ctx, c)
3866 } else {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003867 objectBp2Build(ctx, c)
3868 }
3869 case fullLibrary:
3870 if !prebuilt {
3871 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003872 } else {
3873 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003874 }
3875 case headerLibrary:
3876 libraryHeadersBp2Build(ctx, c)
3877 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05003878 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003879 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003880 } else {
3881 sharedOrStaticLibraryBp2Build(ctx, c, true)
3882 }
3883 case sharedLibrary:
3884 if prebuilt {
3885 prebuiltLibrarySharedBp2Build(ctx, c)
3886 } else {
3887 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003888 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00003889 }
3890}
3891
3892var _ android.ApiProvider = (*Module)(nil)
3893
3894func (c *Module) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) {
Spandan Das4238c652022-09-09 01:38:47 +00003895 if c.IsPrebuilt() {
3896 return
3897 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00003898 switch c.typ() {
Spandan Das4238c652022-09-09 01:38:47 +00003899 case fullLibrary:
3900 apiContributionBp2Build(ctx, c)
3901 case sharedLibrary:
3902 apiContributionBp2Build(ctx, c)
3903 case headerLibrary:
3904 // Aggressively generate api targets for all header modules
3905 // This is necessary since the header module does not know if it is a dep of API surface stub library
3906 apiLibraryHeadersBp2Build(ctx, c)
Spandan Das1278c2c2022-08-19 18:17:28 +00003907 case ndkLibrary:
3908 ndkLibraryBp2build(ctx, c)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003909 }
3910}
3911
Colin Crosscfad1192015-11-02 16:43:11 -08003912// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08003913type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07003914 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07003915 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09003916 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08003917}
3918
Patrice Arrudac249c712019-03-19 17:00:29 -07003919// cc_defaults provides a set of properties that can be inherited by other cc
3920// modules. A module can use the properties from a cc_defaults using
3921// `defaults: ["<:default_module_name>"]`. Properties of both modules are
3922// merged (when possible) by prepending the default module's values to the
3923// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07003924func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07003925 return DefaultsFactory()
3926}
3927
Colin Cross36242852017-06-23 15:06:31 -07003928func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08003929 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08003930
Colin Cross36242852017-06-23 15:06:31 -07003931 module.AddProperties(props...)
3932 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08003933 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003934 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003935 &BaseCompilerProperties{},
3936 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01003937 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003938 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07003939 &StaticProperties{},
3940 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07003941 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003942 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00003943 &TestLinkerProperties{},
3944 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07003945 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07003946 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07003947 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08003948 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08003949 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07003950 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07003951 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07003952 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08003953 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08003954 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09003955 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07003956 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08003957 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07003958 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08003959 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04003960 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
3961 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07003962 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07003963 )
Colin Crosscfad1192015-11-02 16:43:11 -08003964
Jooyung Hancc372c52019-09-25 15:18:44 +09003965 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07003966
3967 return module
Colin Crosscfad1192015-11-02 16:43:11 -08003968}
3969
Jiyong Park2286afd2020-06-16 21:58:53 +09003970func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02003971 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09003972}
3973
Kiyoung Kim51279d32022-08-24 14:10:46 +09003974func (c *Module) isImportedApiLibrary() bool {
3975 _, ok := c.linker.(*apiLibraryDecorator)
3976 return ok
3977}
3978
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003979func kytheExtractAllFactory() android.Singleton {
3980 return &kytheExtractAllSingleton{}
3981}
3982
3983type kytheExtractAllSingleton struct {
3984}
3985
3986func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
3987 var xrefTargets android.Paths
3988 ctx.VisitAllModules(func(module android.Module) {
3989 if ccModule, ok := module.(xref); ok {
3990 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
3991 }
3992 })
3993 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
3994 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07003995 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08003996 }
3997}
3998
Jihoon Kangf78a8902022-09-01 22:47:07 +00003999func (c *Module) Partition() string {
4000 if p, ok := c.installer.(interface {
4001 getPartition() string
4002 }); ok {
4003 return p.getPartition()
4004 }
4005 return ""
4006}
4007
Colin Cross06a931b2015-10-28 17:23:31 -07004008var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004009var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004010var BoolPtr = proptools.BoolPtr
4011var String = proptools.String
4012var StringPtr = proptools.StringPtr