blob: 246444f16c12db3f5850382c95bbbf397b4de770 [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()
Vinh Tran44cb78c2023-03-09 22:07:19 -050055 ctx.BottomUp("fdo_profile", fdoProfileMutator)
Colin Cross1e676be2016-10-12 14:38:15 -070056 })
Colin Cross16b23492016-01-06 14:41:07 -080057
Paul Duffin036e7002019-12-19 19:16:28 +000058 ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
Liz Kammer75db9312021-07-07 16:41:50 -040059 for _, san := range Sanitizers {
60 san.registerMutators(ctx)
61 }
Dan Willemsen581341d2017-02-09 16:16:31 -080062
Colin Cross0b908332019-06-19 23:00:20 -070063 ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
Jiyong Park379de2f2018-12-19 02:47:14 +090064 ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()
Ivan Lozano30c5db22018-02-21 15:49:20 -080065
Cory Barkera1da26f2022-06-07 20:12:06 +000066 ctx.TopDown("fuzz_deps", fuzzMutatorDeps)
Cory Barkera1da26f2022-06-07 20:12:06 +000067
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -080068 ctx.BottomUp("coverage", coverageMutator).Parallel()
Stephen Craneba090d12017-05-09 15:44:35 -070069
Yi Kongeb8efc92021-12-09 18:06:29 +080070 ctx.TopDown("afdo_deps", afdoDepsMutator)
71 ctx.BottomUp("afdo", afdoMutator).Parallel()
72
Stephen Craneba090d12017-05-09 15:44:35 -070073 ctx.TopDown("lto_deps", ltoDepsMutator)
74 ctx.BottomUp("lto", ltoMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090075
Jooyung Han479ca172020-10-19 18:51:07 +090076 ctx.BottomUp("check_linktype", checkLinkTypeMutator).Parallel()
Jooyung Hana70f0672019-01-18 15:20:43 +090077 ctx.TopDown("double_loadable", checkDoubleLoadableLibraries).Parallel()
Colin Cross1e676be2016-10-12 14:38:15 -070078 })
Colin Crossb98c8b02016-07-29 13:44:28 -070079
Yo Chiang8aa4e3f2020-11-19 16:30:49 +080080 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
81 // sabi mutator needs to be run after apex mutator finishes.
82 ctx.TopDown("sabi_deps", sabiDepsMutator)
83 })
84
Colin Cross57898582020-10-29 18:25:19 -070085 ctx.RegisterSingletonType("kythe_extract_all", kytheExtractAllFactory)
Colin Cross463a90e2015-06-17 14:20:06 -070086}
87
Chris Parsonsef6e0cf2020-12-01 18:26:21 -050088// Deps is a struct containing module names of dependencies, separated by the kind of dependency.
89// Mutators should use `AddVariationDependencies` or its sibling methods to add actual dependency
90// edges to these modules.
91// This object is constructed in DepsMutator, by calling to various module delegates to set
92// relevant fields. For example, `module.compiler.compilerDeps()` may append type-specific
93// dependencies.
94// This is then consumed by the same DepsMutator, which will call `ctx.AddVariationDependencies()`
95// (or its sibling methods) to set real dependencies on the given modules.
Colin Crossca860ac2016-01-04 14:34:37 -080096type Deps struct {
97 SharedLibs, LateSharedLibs []string
98 StaticLibs, LateStaticLibs, WholeStaticLibs []string
Colin Cross5950f382016-12-13 12:50:57 -080099 HeaderLibs []string
Logan Chien43d34c32017-12-20 01:17:32 +0800100 RuntimeLibs []string
Colin Crossc472d572015-03-17 15:06:21 -0700101
Colin Cross3e5e7782022-06-17 22:17:05 +0000102 // UnexportedStaticLibs are static libraries that are also passed to -Wl,--exclude-libs= to
103 // prevent automatically exporting symbols.
104 UnexportedStaticLibs []string
105
Chris Parsons79d66a52020-06-05 17:26:16 -0400106 // Used for data dependencies adjacent to tests
107 DataLibs []string
Colin Crossc8caa062021-09-24 16:50:14 -0700108 DataBins []string
Chris Parsons79d66a52020-06-05 17:26:16 -0400109
Yo Chiang219968c2020-09-22 18:45:04 +0800110 // Used by DepsMutator to pass system_shared_libs information to check_elf_file.py.
111 SystemSharedLibs []string
112
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500113 // If true, statically link the unwinder into native libraries/binaries.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800114 StaticUnwinderIfLegacy bool
115
Colin Cross5950f382016-12-13 12:50:57 -0800116 ReexportSharedLibHeaders, ReexportStaticLibHeaders, ReexportHeaderLibHeaders []string
Dan Willemsen490a8dc2016-06-06 18:22:19 -0700117
Colin Cross81413472016-04-11 14:37:39 -0700118 ObjFiles []string
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700119
Dan Willemsenb40aab62016-04-20 14:21:14 -0700120 GeneratedSources []string
121 GeneratedHeaders []string
Inseob Kimd110f872019-12-06 13:15:38 +0900122 GeneratedDeps []string
Dan Willemsenb40aab62016-04-20 14:21:14 -0700123
Dan Willemsenb3454ab2016-09-28 17:34:58 -0700124 ReexportGeneratedHeaders []string
125
Colin Crossc465efd2021-06-11 18:00:04 -0700126 CrtBegin, CrtEnd []string
Dan Willemsena0790e32018-10-12 00:24:23 -0700127
128 // Used for host bionic
Colin Cross9cfe6112021-06-11 18:02:22 -0700129 DynamicLinker string
Jiyong Parke3867542020-12-03 17:28:25 +0900130
131 // List of libs that need to be excluded for APEX variant
132 ExcludeLibsForApex []string
Colin Crossc472d572015-03-17 15:06:21 -0700133}
134
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500135// PathDeps is a struct containing file paths to dependencies of a module.
136// It's constructed in depsToPath() by traversing the direct dependencies of the current module.
137// It's used to construct flags for various build statements (such as for compiling and linking).
138// It is then passed to module decorator functions responsible for registering build statements
139// (such as `module.compiler.compile()`).`
Colin Crossca860ac2016-01-04 14:34:37 -0800140type PathDeps struct {
Colin Cross26c34ed2016-09-30 17:10:16 -0700141 // Paths to .so files
Jiyong Park64a44f22019-01-18 14:37:08 +0900142 SharedLibs, EarlySharedLibs, LateSharedLibs android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700143 // Paths to the dependencies to use for .so files (.so.toc files)
Jiyong Park64a44f22019-01-18 14:37:08 +0900144 SharedLibsDeps, EarlySharedLibsDeps, LateSharedLibsDeps android.Paths
Colin Cross26c34ed2016-09-30 17:10:16 -0700145 // Paths to .a files
Colin Cross635c3b02016-05-18 15:37:25 -0700146 StaticLibs, LateStaticLibs, WholeStaticLibs android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700147
Colin Cross0de8a1e2020-09-18 14:15:30 -0700148 // Transitive static library dependencies of static libraries for use in ordering.
149 TranstiveStaticLibrariesForOrdering *android.DepSet
150
Colin Cross26c34ed2016-09-30 17:10:16 -0700151 // Paths to .o files
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100152 Objs Objects
153 // Paths to .o files in dependencies that provide them. Note that these lists
154 // aren't complete since prebuilt modules don't provide the .o files.
Dan Willemsen581341d2017-02-09 16:16:31 -0800155 StaticLibObjs Objects
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700156 WholeStaticLibObjs Objects
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700157
Martin Stjernholm391d94c2020-04-17 17:34:31 +0100158 // Paths to .a files in prebuilts. Complements WholeStaticLibObjs to contain
159 // the libs from all whole_static_lib dependencies.
160 WholeStaticLibsFromPrebuilts android.Paths
161
Colin Cross26c34ed2016-09-30 17:10:16 -0700162 // Paths to generated source files
Colin Cross635c3b02016-05-18 15:37:25 -0700163 GeneratedSources android.Paths
Inseob Kimd110f872019-12-06 13:15:38 +0900164 GeneratedDeps android.Paths
Dan Willemsenb40aab62016-04-20 14:21:14 -0700165
Inseob Kimd110f872019-12-06 13:15:38 +0900166 Flags []string
Colin Cross3e5e7782022-06-17 22:17:05 +0000167 LdFlags []string
Inseob Kimd110f872019-12-06 13:15:38 +0900168 IncludeDirs android.Paths
169 SystemIncludeDirs android.Paths
170 ReexportedDirs android.Paths
171 ReexportedSystemDirs android.Paths
172 ReexportedFlags []string
173 ReexportedGeneratedHeaders android.Paths
174 ReexportedDeps android.Paths
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700175
Colin Cross26c34ed2016-09-30 17:10:16 -0700176 // Paths to crt*.o files
Colin Crossc465efd2021-06-11 18:00:04 -0700177 CrtBegin, CrtEnd android.Paths
Dan Willemsena0790e32018-10-12 00:24:23 -0700178
Dan Willemsena0790e32018-10-12 00:24:23 -0700179 // Path to the dynamic linker binary
180 DynamicLinker android.OptionalPath
Dan Willemsen47450072021-10-19 20:24:49 -0700181
182 // For Darwin builds, the path to the second architecture's output that should
183 // be combined with this architectures's output into a FAT MachO file.
184 DarwinSecondArchOutput android.OptionalPath
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700185}
186
Colin Cross4af21ed2019-11-04 09:37:55 -0800187// LocalOrGlobalFlags contains flags that need to have values set globally by the build system or locally by the module
188// tracked separately, in order to maintain the required ordering (most of the global flags need to go first on the
189// command line so they can be overridden by the local module flags).
190type LocalOrGlobalFlags struct {
191 CommonFlags []string // Flags that apply to C, C++, and assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700192 AsFlags []string // Flags that apply to assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800193 YasmFlags []string // Flags that apply to yasm assembly source files
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700194 CFlags []string // Flags that apply to C and C++ source files
195 ToolingCFlags []string // Flags that apply to C and C++ source files parsed by clang LibTooling tools
196 ConlyFlags []string // Flags that apply to C source files
197 CppFlags []string // Flags that apply to C++ source files
198 ToolingCppFlags []string // Flags that apply to C++ source files parsed by clang LibTooling tools
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700199 LdFlags []string // Flags that apply to linker command lines
Colin Cross4af21ed2019-11-04 09:37:55 -0800200}
201
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500202// Flags contains various types of command line flags (and settings) for use in building build
203// statements related to C++.
Colin Cross4af21ed2019-11-04 09:37:55 -0800204type Flags struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500205 // Local flags (which individual modules are responsible for). These may override global flags.
206 Local LocalOrGlobalFlags
207 // Global flags (which build system or toolchain is responsible for).
Colin Cross4af21ed2019-11-04 09:37:55 -0800208 Global LocalOrGlobalFlags
209
210 aidlFlags []string // Flags that apply to aidl source files
211 rsFlags []string // Flags that apply to renderscript source files
212 libFlags []string // Flags to add libraries early to the link order
213 extraLibFlags []string // Flags to add libraries late in the link order after LdFlags
214 TidyFlags []string // Flags that apply to clang-tidy
215 SAbiFlags []string // Flags that apply to header-abi-dumper
Colin Cross28344522015-04-22 13:07:53 -0700216
Colin Crossc3199482017-03-30 15:03:04 -0700217 // Global include flags that apply to C, C++, and assembly source files
Colin Cross4af21ed2019-11-04 09:37:55 -0800218 // These must be after any module include flags, which will be in CommonFlags.
Colin Crossc3199482017-03-30 15:03:04 -0700219 SystemIncludeFlags []string
220
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800221 Toolchain config.Toolchain
222 Tidy bool // True if ninja .tidy rules should be generated.
223 NeedTidyFiles bool // True if module link should depend on .tidy files
224 GcovCoverage bool // True if coverage files should be generated.
225 SAbiDump bool // True if header abi dumps should be generated.
226 EmitXrefs bool // If true, generate Ninja rules to generate emitXrefs input files for Kythe
Colin Crossca860ac2016-01-04 14:34:37 -0800227
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500228 // The instruction set required for clang ("arm" or "thumb").
Colin Crossca860ac2016-01-04 14:34:37 -0800229 RequiredInstructionSet string
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500230 // The target-device system path to the dynamic linker.
231 DynamicLinker string
Colin Cross16b23492016-01-06 14:41:07 -0800232
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -0700233 CFlagsDeps android.Paths // Files depended on by compiler flags
234 LdFlagsDeps android.Paths // Files depended on by linker flags
Colin Cross18c0c5a2016-12-01 14:45:23 -0800235
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500236 // True if .s files should be processed with the c preprocessor.
Dan Willemsen98ab3112019-08-27 21:20:40 -0700237 AssemblerWithCpp bool
Dan Willemsen60e62f02018-11-16 21:05:32 -0800238
Colin Cross19878da2019-03-28 14:45:07 -0700239 proto android.ProtoFlags
Colin Cross19878da2019-03-28 14:45:07 -0700240 protoC bool // Whether to use C instead of C++
241 protoOptionsFile bool // Whether to look for a .options file next to the .proto
Dan Willemsen4e0aa232019-04-10 22:59:54 -0700242
243 Yacc *YaccProperties
Matthias Maennich22fd4d12020-07-15 10:58:56 +0200244 Lex *LexProperties
Colin Crossc472d572015-03-17 15:06:21 -0700245}
246
Colin Crossca860ac2016-01-04 14:34:37 -0800247// Properties used to compile all C or C++ modules
248type BaseProperties struct {
Dan Willemsen742a5452018-07-23 17:19:36 -0700249 // Deprecated. true is the default, false is invalid.
Colin Crossca860ac2016-01-04 14:34:37 -0800250 Clang *bool `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700251
Jiyong Parkb35a8192020-08-10 15:59:36 +0900252 // The API level that this module is built against. The APIs of this API level will be
253 // visible at build time, but use of any APIs newer than min_sdk_version will render the
254 // module unloadable on older devices. In the future it will be possible to weakly-link new
255 // APIs, making the behavior match Java: such modules will load on older devices, but
256 // calling new APIs on devices that do not support them will result in a crash.
257 //
258 // This property has the same behavior as sdk_version does for Java modules. For those
259 // familiar with Android Gradle, the property behaves similarly to how compileSdkVersion
260 // does for Java code.
261 //
262 // In addition, setting this property causes two variants to be built, one for the platform
263 // and one for apps.
Nan Zhang0007d812017-11-07 10:57:05 -0800264 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700265
Jiyong Parkb35a8192020-08-10 15:59:36 +0900266 // Minimum OS API level supported by this C or C++ module. This property becomes the value
267 // of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK,
268 // this property is also used to ensure that the min_sdk_version of the containing module is
269 // not older (i.e. less) than this module's min_sdk_version. When not set, this property
270 // defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks
271 // min_sdk_version of the containing APEX. When the module
272 // is not built for an APEX, "apex_inherit" defaults to sdk_version.
Jooyung Han379660c2020-04-21 15:24:00 +0900273 Min_sdk_version *string
274
Colin Crossc511bc52020-04-07 16:50:32 +0000275 // If true, always create an sdk variant and don't create a platform variant.
276 Sdk_variant_only *bool
277
Jiyong Parkde866cb2018-12-07 23:08:36 +0900278 AndroidMkSharedLibs []string `blueprint:"mutated"`
279 AndroidMkStaticLibs []string `blueprint:"mutated"`
280 AndroidMkRuntimeLibs []string `blueprint:"mutated"`
281 AndroidMkWholeStaticLibs []string `blueprint:"mutated"`
Bill Peckhama46de702020-04-21 17:23:37 -0700282 AndroidMkHeaderLibs []string `blueprint:"mutated"`
Jiyong Parkde866cb2018-12-07 23:08:36 +0900283 HideFromMake bool `blueprint:"mutated"`
284 PreventInstall bool `blueprint:"mutated"`
285 ApexesProvidingSharedLibs []string `blueprint:"mutated"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700286
Yo Chiang219968c2020-09-22 18:45:04 +0800287 // Set by DepsMutator.
288 AndroidMkSystemSharedLibs []string `blueprint:"mutated"`
289
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200290 // The name of the image this module is built for, suffixed with a '.'
Justin Yun5f7f7e82019-11-18 19:52:14 +0900291 ImageVariationPrefix string `blueprint:"mutated"`
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200292
293 // The VNDK version this module is built against. If empty, the module is not
294 // build against the VNDK.
295 VndkVersion string `blueprint:"mutated"`
296
297 // Suffix for the name of Android.mk entries generated by this module
298 SubName string `blueprint:"mutated"`
Colin Cross5beccee2017-12-07 15:28:59 -0800299
300 // *.logtags files, to combine together in order to generate the /system/etc/event-log-tags
301 // file
302 Logtags []string
Jiyong Parkf9332f12018-02-01 00:54:12 +0900303
Yifan Hong39143a92020-10-26 12:43:12 -0700304 // Make this module available when building for ramdisk.
305 // On device without a dedicated recovery partition, the module is only
306 // available after switching root into
307 // /first_stage_ramdisk. To expose the module before switching root, install
308 // the recovery variant instead.
Yifan Hong1b3348d2020-01-21 15:53:22 -0800309 Ramdisk_available *bool
310
Yifan Hong39143a92020-10-26 12:43:12 -0700311 // Make this module available when building for vendor ramdisk.
312 // On device without a dedicated recovery partition, the module is only
313 // available after switching root into
314 // /first_stage_ramdisk. To expose the module before switching root, install
315 // the recovery variant instead.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700316 Vendor_ramdisk_available *bool
317
Jiyong Parkf9332f12018-02-01 00:54:12 +0900318 // Make this module available when building for recovery
319 Recovery_available *bool
320
Lukacs T. Berki2f5c3402021-06-15 11:27:56 +0200321 // Used by imageMutator, set by ImageMutatorBegin()
322 CoreVariantNeeded bool `blueprint:"mutated"`
323 RamdiskVariantNeeded bool `blueprint:"mutated"`
324 VendorRamdiskVariantNeeded bool `blueprint:"mutated"`
325 RecoveryVariantNeeded bool `blueprint:"mutated"`
326
327 // A list of variations for the "image" mutator of the form
328 //<image name> '.' <version char>, for example, 'vendor.S'
329 ExtraVersionedImageVariations []string `blueprint:"mutated"`
Jiyong Parkb0788572018-12-20 22:10:17 +0900330
331 // Allows this module to use non-APEX version of libraries. Useful
332 // for building binaries that are started before APEXes are activated.
333 Bootstrap *bool
Jooyung Han097087b2019-10-22 19:32:18 +0900334
335 // Even if DeviceConfig().VndkUseCoreVariant() is set, this module must use vendor variant.
336 // see soong/cc/config/vndk.go
337 MustUseVendorVariant bool `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900338
339 // Used by vendor snapshot to record dependencies from snapshot modules.
340 SnapshotSharedLibs []string `blueprint:"mutated"`
Justin Yun5e035862021-06-29 20:50:37 +0900341 SnapshotStaticLibs []string `blueprint:"mutated"`
Inseob Kim8471cda2019-11-15 09:59:12 +0900342 SnapshotRuntimeLibs []string `blueprint:"mutated"`
Paul Duffin0cb37b92020-03-04 14:52:46 +0000343
Colin Cross1bc94122021-10-28 13:25:54 -0700344 Installable *bool `android:"arch_variant"`
Colin Crossc511bc52020-04-07 16:50:32 +0000345
346 // Set by factories of module types that can only be referenced from variants compiled against
347 // the SDK.
348 AlwaysSdk bool `blueprint:"mutated"`
349
350 // Variant is an SDK variant created by sdkMutator
351 IsSdkVariant bool `blueprint:"mutated"`
352 // Set when both SDK and platform variants are exported to Make to trigger renaming the SDK
353 // variant to have a ".sdk" suffix.
354 SdkAndPlatformVariantVisibleToMake bool `blueprint:"mutated"`
Bill Peckham945441c2020-08-31 16:07:58 -0700355
356 // Normally Soong uses the directory structure to decide which modules
357 // should be included (framework) or excluded (non-framework) from the
Jose Galmes6f843bc2020-12-11 13:36:29 -0800358 // different snapshots (vendor, recovery, etc.), but this property
359 // allows a partner to exclude a module normally thought of as a
360 // framework module from the vendor snapshot.
361 Exclude_from_vendor_snapshot *bool
362
363 // Normally Soong uses the directory structure to decide which modules
364 // should be included (framework) or excluded (non-framework) from the
365 // different snapshots (vendor, recovery, etc.), but this property
366 // allows a partner to exclude a module normally thought of as a
367 // framework module from the recovery snapshot.
Jose Galmesf7294582020-11-13 12:07:36 -0800368 Exclude_from_recovery_snapshot *bool
Jiyong Park46a512f2020-12-04 18:02:13 +0900369
370 // List of APEXes that this module has private access to for testing purpose. The module
371 // can depend on libraries that are not exported by the APEXes and use private symbols
372 // from the exported libraries.
Martin Stjernholm855e90b2021-03-25 02:33:14 +0000373 Test_for []string `android:"arch_variant"`
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800374
375 Target struct {
376 Platform struct {
377 // List of modules required by the core variant.
378 Required []string `android:"arch_variant"`
379
380 // List of modules not required by the core variant.
381 Exclude_required []string `android:"arch_variant"`
382 } `android:"arch_variant"`
383
384 Recovery struct {
385 // List of modules required by the recovery variant.
386 Required []string `android:"arch_variant"`
387
388 // List of modules not required by the recovery variant.
389 Exclude_required []string `android:"arch_variant"`
390 } `android:"arch_variant"`
391 } `android:"arch_variant"`
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700392}
393
394type VendorProperties struct {
Jiyong Park82e2bf32017-08-16 14:05:54 +0900395 // whether this module should be allowed to be directly depended by other
396 // modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`.
Justin Yun63e9ec72020-10-29 16:49:43 +0900397 // If set to true, two variants will be built separately, one like
398 // normal, and the other limited to the set of libraries and headers
399 // that are exposed to /vendor modules.
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700400 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900401 // The vendor variant may be used with a different (newer) /system,
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700402 // so it shouldn't have any unversioned runtime dependencies, or
403 // make assumptions about the system that may not be true in the
404 // future.
405 //
Justin Yun63e9ec72020-10-29 16:49:43 +0900406 // If set to false, this module becomes inaccessible from /vendor modules.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900407 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900408 // The modules with vndk: {enabled: true} must define 'vendor_available'
Justin Yun0b1db6d2021-01-08 15:22:34 +0900409 // to 'true'.
Jiyong Park82e2bf32017-08-16 14:05:54 +0900410 //
Dan Willemsen4416e5d2017-04-06 12:43:22 -0700411 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
412 Vendor_available *bool
Jiyong Park5fb8c102018-04-09 12:03:06 +0900413
Justin Yunebcf0c52021-01-08 18:00:19 +0900414 // This is the same as the "vendor_available" except that the install path
415 // of the vendor variant is /odm or /vendor/odm.
416 // By replacing "vendor_available: true" with "odm_available: true", the
417 // module will install its vendor variant to the /odm partition or /vendor/odm.
418 // As the modules with "odm_available: true" still create the vendor variants,
419 // they can link to the other vendor modules as the vendor_available modules do.
420 // Also, the vendor modules can link to odm_available modules.
421 //
422 // It may not be used for VNDK modules.
423 Odm_available *bool
424
Justin Yun63e9ec72020-10-29 16:49:43 +0900425 // whether this module should be allowed to be directly depended by other
426 // modules with `product_specific: true` or `product_available: true`.
427 // If set to true, an additional product variant will be built separately
428 // that is limited to the set of libraries and headers that are exposed to
429 // /product modules.
430 //
431 // The product variant may be used with a different (newer) /system,
432 // so it shouldn't have any unversioned runtime dependencies, or
433 // make assumptions about the system that may not be true in the
434 // future.
435 //
Justin Yun6977e8a2020-10-29 18:24:11 +0900436 // If set to false, this module becomes inaccessible from /product modules.
437 //
438 // Different from the 'vendor_available' property, the modules with
439 // vndk: {enabled: true} don't have to define 'product_available'. The VNDK
440 // library without 'product_available' may not be depended on by any other
441 // modules that has product variants including the product available VNDKs.
Justin Yun63e9ec72020-10-29 16:49:43 +0900442 //
443 // Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk
444 // and PRODUCT_PRODUCT_VNDK_VERSION isn't set.
445 Product_available *bool
446
Jiyong Park5fb8c102018-04-09 12:03:06 +0900447 // whether this module is capable of being loaded with other instance
448 // (possibly an older version) of the same module in the same process.
449 // Currently, a shared library that is a member of VNDK (vndk: {enabled: true})
450 // can be double loaded in a vendor process if the library is also a
451 // (direct and indirect) dependency of an LLNDK library. Such libraries must be
452 // explicitly marked as `double_loadable: true` by the owner, or the dependency
453 // from the LLNDK lib should be cut if the lib is not designed to be double loaded.
454 Double_loadable *bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800455
456 // IsLLNDK is set to true for the vendor variant of a cc_library module that has LLNDK stubs.
457 IsLLNDK bool `blueprint:"mutated"`
458
Colin Cross78212242021-01-06 14:51:30 -0800459 // IsVNDKUsingCoreVariant is true for VNDK modules if the global VndkUseCoreVariant option is
460 // set and the module is not listed in VndkMustUseVendorVariantList.
461 IsVNDKUsingCoreVariant bool `blueprint:"mutated"`
462
463 // IsVNDKCore is set if a VNDK module does not set the vndk.support_system_process property.
464 IsVNDKCore bool `blueprint:"mutated"`
465
466 // IsVNDKSP is set if a VNDK module sets the vndk.support_system_process property.
467 IsVNDKSP bool `blueprint:"mutated"`
468
469 // IsVNDKPrivate is set if a VNDK module sets the vndk.private property or an LLNDK
470 // module sets the llndk.private property.
471 IsVNDKPrivate bool `blueprint:"mutated"`
472
473 // IsVNDKProduct is set if a VNDK module sets the product_available property.
474 IsVNDKProduct bool `blueprint:"mutated"`
Colin Cross5271fea2021-04-27 13:06:04 -0700475
476 // IsVendorPublicLibrary is set for the core and product variants of a library that has
477 // vendor_public_library stubs.
478 IsVendorPublicLibrary bool `blueprint:"mutated"`
Colin Crossca860ac2016-01-04 14:34:37 -0800479}
480
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500481// ModuleContextIntf is an interface (on a module context helper) consisting of functions related
482// to understanding details about the type of the current module.
483// For example, one might call these functions to determine whether the current module is a static
484// library and/or is installed in vendor directories.
Colin Crossca860ac2016-01-04 14:34:37 -0800485type ModuleContextIntf interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800486 static() bool
487 staticBinary() bool
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700488 testBinary() bool
Yi Kong56fc1b62022-09-06 16:24:00 +0800489 testLibrary() bool
Jiyong Park1d1119f2019-07-29 21:27:18 +0900490 header() bool
Inseob Kim7f283f42020-06-01 21:53:49 +0900491 binary() bool
Inseob Kim1042d292020-06-01 23:23:05 +0900492 object() bool
Colin Crossb98c8b02016-07-29 13:44:28 -0700493 toolchain() config.Toolchain
Jooyung Hanccce2f22020-03-07 03:45:53 +0900494 canUseSdk() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700495 useSdk() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800496 sdkVersion() string
Jiyong Parkb35a8192020-08-10 15:59:36 +0900497 minSdkVersion() string
498 isSdkVariant() bool
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700499 useVndk() bool
Colin Cross95f1ca02020-10-29 20:47:22 -0700500 isNdk(config android.Config) bool
Colin Cross127bb8b2020-12-16 16:46:01 -0800501 IsLlndk() bool
502 IsLlndkPublic() bool
503 isImplementationForLLNDKPublic() bool
504 IsVndkPrivate() bool
Justin Yun8effde42017-06-23 19:24:43 +0900505 isVndk() bool
506 isVndkSp() bool
Ivan Lozanof9e21722020-12-02 09:00:51 -0500507 IsVndkExt() bool
Colin Cross5271fea2021-04-27 13:06:04 -0700508 IsVendorPublicLibrary() bool
Justin Yun5f7f7e82019-11-18 19:52:14 +0900509 inProduct() bool
510 inVendor() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -0800511 inRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700512 inVendorRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +0900513 inRecovery() bool
Dan Willemsen8146b2f2016-03-30 21:00:30 -0700514 selectedStl() string
Colin Crossce75d2c2016-10-06 16:12:58 -0700515 baseModuleName() string
Logan Chienf3511742017-10-31 18:04:35 +0800516 getVndkExtendsModuleName() string
Yi Kong4ef54592022-02-14 20:00:10 +0800517 isAfdoCompile() bool
Yi Kong7e53c572018-02-14 18:16:12 +0800518 isPgoCompile() bool
Yi Kongc702ebd2022-08-19 16:02:45 +0800519 isCfi() bool
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -0800520 isNDKStubLibrary() bool
Ivan Lozanobd721262018-11-27 14:33:03 -0800521 useClangLld(actx ModuleContext) bool
Logan Chiene274fc92019-12-03 11:18:32 -0800522 isForPlatform() bool
Colin Crosse07f2312020-08-13 11:24:56 -0700523 apexVariationName() string
Dan Albertc8060532020-07-22 22:32:17 -0700524 apexSdkVersion() android.ApiLevel
Jiyong Parka4b9dd02019-01-16 22:53:13 +0900525 bootstrap() bool
Vic Yangefd249e2018-11-12 20:19:56 -0800526 mustUseVendorVariant() bool
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700527 nativeCoverage() bool
Colin Cross56a83212020-09-15 18:30:11 -0700528 directlyInAnyApex() bool
Colin Cross95b07f22020-12-16 11:06:50 -0800529 isPreventInstall() bool
Cindy Zhou5d5cfc12021-01-09 08:25:22 -0800530 isCfiAssemblySupportEnabled() bool
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800531 getSharedFlags() *SharedFlags
532}
533
534type SharedFlags struct {
535 numSharedFlags int
536 flagsMap map[string]string
Colin Crossca860ac2016-01-04 14:34:37 -0800537}
538
539type ModuleContext interface {
Colin Cross635c3b02016-05-18 15:37:25 -0700540 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800541 ModuleContextIntf
542}
543
544type BaseModuleContext interface {
Colin Cross0ea8ba82019-06-06 14:33:29 -0700545 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -0800546 ModuleContextIntf
547}
548
Colin Cross37047f12016-12-13 17:06:13 -0800549type DepsContext interface {
550 android.BottomUpMutatorContext
551 ModuleContextIntf
552}
553
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500554// feature represents additional (optional) steps to building cc-related modules, such as invocation
555// of clang-tidy.
Colin Crossca860ac2016-01-04 14:34:37 -0800556type feature interface {
Colin Crossca860ac2016-01-04 14:34:37 -0800557 flags(ctx ModuleContext, flags Flags) Flags
558 props() []interface{}
559}
560
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500561// compiler is the interface for a compiler helper object. Different module decorators may implement
Liz Kammer718eb272022-01-07 10:53:37 -0500562// this helper differently.
Colin Crossca860ac2016-01-04 14:34:37 -0800563type compiler interface {
Colin Cross42742b82016-08-01 13:20:05 -0700564 compilerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800565 compilerDeps(ctx DepsContext, deps Deps) Deps
Colin Crossf18e1102017-11-16 14:33:08 -0800566 compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags
Colin Cross42742b82016-08-01 13:20:05 -0700567 compilerProps() []interface{}
568
Colin Cross76fada02016-07-27 10:31:13 -0700569 appendCflags([]string)
570 appendAsflags([]string)
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700571 compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects
Colin Crossca860ac2016-01-04 14:34:37 -0800572}
573
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500574// linker is the interface for a linker decorator object. Individual module types can provide
575// their own implementation for this decorator, and thus specify custom logic regarding build
576// statements pertaining to linking.
Colin Crossca860ac2016-01-04 14:34:37 -0800577type linker interface {
Colin Cross42742b82016-08-01 13:20:05 -0700578 linkerInit(ctx BaseModuleContext)
Colin Cross37047f12016-12-13 17:06:13 -0800579 linkerDeps(ctx DepsContext, deps Deps) Deps
Colin Cross42742b82016-08-01 13:20:05 -0700580 linkerFlags(ctx ModuleContext, flags Flags) Flags
581 linkerProps() []interface{}
Ivan Lozanobd721262018-11-27 14:33:03 -0800582 useClangLld(actx ModuleContext) bool
Colin Cross42742b82016-08-01 13:20:05 -0700583
Dan Willemsen5cb580f2016-09-26 17:33:01 -0700584 link(ctx ModuleContext, flags Flags, deps PathDeps, objs Objects) android.Path
Colin Cross76fada02016-07-27 10:31:13 -0700585 appendLdflags([]string)
Jiyong Parkaf6d8952019-01-31 12:21:23 +0900586 unstrippedOutputFilePath() android.Path
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -0700587
588 nativeCoverage() bool
Jiyong Parkee9a98d2019-08-09 14:44:36 +0900589 coverageOutputFilePath() android.OptionalPath
Paul Duffin13f02712020-03-06 12:30:43 +0000590
591 // Get the deps that have been explicitly specified in the properties.
Paul Duffin13f02712020-03-06 12:30:43 +0000592 linkerSpecifiedDeps(specifiedDeps specifiedDeps) specifiedDeps
593}
594
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500595// specifiedDeps is a tuple struct representing dependencies of a linked binary owned by the linker.
Paul Duffin13f02712020-03-06 12:30:43 +0000596type specifiedDeps struct {
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500597 sharedLibs []string
598 // Note nil and [] are semantically distinct. [] prevents linking against the defaults (usually
599 // libc, libm, etc.)
Colin Cross6b8f4252021-07-22 11:39:44 -0700600 systemSharedLibs []string
Colin Crossca860ac2016-01-04 14:34:37 -0800601}
602
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500603// installer is the interface for an installer helper object. This helper is responsible for
604// copying build outputs to the appropriate locations so that they may be installed on device.
Colin Crossca860ac2016-01-04 14:34:37 -0800605type installer interface {
Colin Cross42742b82016-08-01 13:20:05 -0700606 installerProps() []interface{}
Colin Cross635c3b02016-05-18 15:37:25 -0700607 install(ctx ModuleContext, path android.Path)
Paul Duffin0cb37b92020-03-04 14:52:46 +0000608 everInstallable() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800609 inData() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700610 inSanitizerDir() bool
Dan Willemsen4aa75ca2016-09-28 16:18:03 -0700611 hostToolPath() android.OptionalPath
Jiyong Parkb7c24df2019-02-01 12:03:59 +0900612 relativeInstallPath() string
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +0000613 makeUninstallable(mod *Module)
Inseob Kim800d1142021-06-14 12:03:51 +0900614 installInRoot() bool
Colin Crossca860ac2016-01-04 14:34:37 -0800615}
616
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800617type xref interface {
618 XrefCcFiles() android.Paths
619}
620
Inseob Kima1888ce2022-10-04 14:42:02 +0900621type overridable interface {
622 overriddenModules() []string
623}
624
Colin Cross6e511a92020-07-27 21:26:48 -0700625type libraryDependencyKind int
626
627const (
628 headerLibraryDependency = iota
629 sharedLibraryDependency
630 staticLibraryDependency
631)
632
633func (k libraryDependencyKind) String() string {
634 switch k {
635 case headerLibraryDependency:
636 return "headerLibraryDependency"
637 case sharedLibraryDependency:
638 return "sharedLibraryDependency"
639 case staticLibraryDependency:
640 return "staticLibraryDependency"
641 default:
642 panic(fmt.Errorf("unknown libraryDependencyKind %d", k))
643 }
644}
645
646type libraryDependencyOrder int
647
648const (
649 earlyLibraryDependency = -1
650 normalLibraryDependency = 0
651 lateLibraryDependency = 1
652)
653
654func (o libraryDependencyOrder) String() string {
655 switch o {
656 case earlyLibraryDependency:
657 return "earlyLibraryDependency"
658 case normalLibraryDependency:
659 return "normalLibraryDependency"
660 case lateLibraryDependency:
661 return "lateLibraryDependency"
662 default:
663 panic(fmt.Errorf("unknown libraryDependencyOrder %d", o))
664 }
665}
666
667// libraryDependencyTag is used to tag dependencies on libraries. Unlike many dependency
668// tags that have a set of predefined tag objects that are reused for each dependency, a
669// libraryDependencyTag is designed to contain extra metadata and is constructed as needed.
670// That means that comparing a libraryDependencyTag for equality will only be equal if all
671// of the metadata is equal. Most usages will want to type assert to libraryDependencyTag and
672// then check individual metadata fields instead.
673type libraryDependencyTag struct {
674 blueprint.BaseDependencyTag
675
676 // These are exported so that fmt.Printf("%#v") can call their String methods.
677 Kind libraryDependencyKind
678 Order libraryDependencyOrder
679
680 wholeStatic bool
681
682 reexportFlags bool
683 explicitlyVersioned bool
684 dataLib bool
685 ndk bool
686
687 staticUnwinder bool
688
689 makeSuffix string
Jiyong Parke3867542020-12-03 17:28:25 +0900690
Cindy Zhou18417cb2020-12-10 07:12:38 -0800691 // Whether or not this dependency should skip the apex dependency check
692 skipApexAllowedDependenciesCheck bool
693
Jiyong Parke3867542020-12-03 17:28:25 +0900694 // Whether or not this dependency has to be followed for the apex variants
695 excludeInApex bool
Colin Cross3e5e7782022-06-17 22:17:05 +0000696
697 // If true, don't automatically export symbols from the static library into a shared library.
698 unexportedSymbols bool
Colin Cross6e511a92020-07-27 21:26:48 -0700699}
700
701// header returns true if the libraryDependencyTag is tagging a header lib dependency.
702func (d libraryDependencyTag) header() bool {
703 return d.Kind == headerLibraryDependency
704}
705
706// shared returns true if the libraryDependencyTag is tagging a shared lib dependency.
707func (d libraryDependencyTag) shared() bool {
708 return d.Kind == sharedLibraryDependency
709}
710
711// shared returns true if the libraryDependencyTag is tagging a static lib dependency.
712func (d libraryDependencyTag) static() bool {
713 return d.Kind == staticLibraryDependency
714}
715
Colin Cross65cb3142021-12-10 23:05:02 +0000716func (d libraryDependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
717 if d.shared() {
718 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
719 }
720 return nil
721}
722
723var _ android.LicenseAnnotationsDependencyTag = libraryDependencyTag{}
724
Colin Crosse9fe2942020-11-10 18:12:15 -0800725// InstallDepNeeded returns true for shared libraries so that shared library dependencies of
726// binaries or other shared libraries are installed as dependencies.
727func (d libraryDependencyTag) InstallDepNeeded() bool {
728 return d.shared()
729}
730
731var _ android.InstallNeededDependencyTag = libraryDependencyTag{}
732
733// dependencyTag is used for tagging miscellaneous dependency types that don't fit into
Colin Cross6e511a92020-07-27 21:26:48 -0700734// libraryDependencyTag. Each tag object is created globally and reused for multiple
735// dependencies (although since the object contains no references, assigning a tag to a
736// variable and modifying it will not modify the original). Users can compare the tag
737// returned by ctx.OtherModuleDependencyTag against the global original
738type dependencyTag struct {
739 blueprint.BaseDependencyTag
740 name string
741}
742
Colin Crosse9fe2942020-11-10 18:12:15 -0800743// installDependencyTag is used for tagging miscellaneous dependency types that don't fit into
744// libraryDependencyTag, but where the dependency needs to be installed when the parent is
745// installed.
746type installDependencyTag struct {
747 blueprint.BaseDependencyTag
748 android.InstallAlwaysNeededDependencyTag
749 name string
750}
751
Colin Crossc99deeb2016-04-11 15:06:20 -0700752var (
Colin Cross6e511a92020-07-27 21:26:48 -0700753 genSourceDepTag = dependencyTag{name: "gen source"}
754 genHeaderDepTag = dependencyTag{name: "gen header"}
755 genHeaderExportDepTag = dependencyTag{name: "gen header export"}
756 objDepTag = dependencyTag{name: "obj"}
Jiyong Parkd630bdd2020-11-25 11:47:24 +0900757 dynamicLinkerDepTag = installDependencyTag{name: "dynamic linker"}
Colin Cross6e511a92020-07-27 21:26:48 -0700758 reuseObjTag = dependencyTag{name: "reuse objects"}
759 staticVariantTag = dependencyTag{name: "static variant"}
760 vndkExtDepTag = dependencyTag{name: "vndk extends"}
761 dataLibDepTag = dependencyTag{name: "data lib"}
Colin Crossc8caa062021-09-24 16:50:14 -0700762 dataBinDepTag = dependencyTag{name: "data bin"}
Colin Crosse9fe2942020-11-10 18:12:15 -0800763 runtimeDepTag = installDependencyTag{name: "runtime lib"}
Colin Cross6e511a92020-07-27 21:26:48 -0700764 testPerSrcDepTag = dependencyTag{name: "test_per_src"}
Colin Cross0de8a1e2020-09-18 14:15:30 -0700765 stubImplDepTag = dependencyTag{name: "stub_impl"}
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +0000766 JniFuzzLibTag = dependencyTag{name: "jni_fuzz_lib_tag"}
Vinh Tran44cb78c2023-03-09 22:07:19 -0500767 FdoProfileTag = dependencyTag{name: "fdo_profile"}
Colin Crossc99deeb2016-04-11 15:06:20 -0700768)
769
Roland Levillainf89cd092019-07-29 16:22:59 +0100770func IsSharedDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700771 ccLibDepTag, ok := depTag.(libraryDependencyTag)
772 return ok && ccLibDepTag.shared()
773}
774
775func IsStaticDepTag(depTag blueprint.DependencyTag) bool {
776 ccLibDepTag, ok := depTag.(libraryDependencyTag)
777 return ok && ccLibDepTag.static()
Roland Levillainf89cd092019-07-29 16:22:59 +0100778}
779
Zach Johnson3df4e632020-11-06 11:56:27 -0800780func IsHeaderDepTag(depTag blueprint.DependencyTag) bool {
781 ccLibDepTag, ok := depTag.(libraryDependencyTag)
782 return ok && ccLibDepTag.header()
783}
784
Roland Levillainf89cd092019-07-29 16:22:59 +0100785func IsRuntimeDepTag(depTag blueprint.DependencyTag) bool {
Colin Crosse9fe2942020-11-10 18:12:15 -0800786 return depTag == runtimeDepTag
Roland Levillainf89cd092019-07-29 16:22:59 +0100787}
788
789func IsTestPerSrcDepTag(depTag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -0700790 ccDepTag, ok := depTag.(dependencyTag)
Roland Levillainf89cd092019-07-29 16:22:59 +0100791 return ok && ccDepTag == testPerSrcDepTag
792}
793
Chris Parsonsf874e462022-05-10 13:50:12 -0400794// bazelHandler is the interface for a helper object related to deferring to Bazel for
795// processing a cc module (during Bazel mixed builds). Individual module types should define
796// their own bazel handler if they support being handled by Bazel.
797type BazelHandler interface {
798 // QueueBazelCall invokes request-queueing functions on the BazelContext
799 //so that these requests are handled when Bazel's cquery is invoked.
800 QueueBazelCall(ctx android.BaseModuleContext, label string)
801
802 // ProcessBazelQueryResponse uses information retrieved from Bazel to set properties
803 // on the current module with given label.
804 ProcessBazelQueryResponse(ctx android.ModuleContext, label string)
805}
806
Colin Crossca860ac2016-01-04 14:34:37 -0800807// Module contains the properties and members used by all C/C++ module types, and implements
808// the blueprint.Module interface. It delegates to compiler, linker, and installer interfaces
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500809// to construct the output file. Behavior can be customized with a Customizer, or "decorator",
810// interface.
811//
812// To define a C/C++ related module, construct a new Module object and point its delegates to
813// type-specific structs. These delegates will be invoked to register module-specific build
814// statements which may be unique to the module type. For example, module.compiler.compile() should
815// be defined so as to register build statements which are responsible for compiling the module.
816//
817// Another example: to construct a cc_binary module, one can create a `cc.binaryDecorator` struct
818// which implements the `linker` and `installer` interfaces, and points the `linker` and `installer`
819// members of the cc.Module to this decorator. Thus, a cc_binary module has custom linker and
820// installer logic.
Colin Crossca860ac2016-01-04 14:34:37 -0800821type Module struct {
hamzehc0a671f2021-07-22 12:05:08 -0700822 fuzz.FuzzModule
hamzeh41ad8812021-07-07 14:00:07 -0700823
Liz Kammerea6666f2021-02-17 10:17:28 -0500824 android.BazelModuleBase
Colin Crossc472d572015-03-17 15:06:21 -0700825
Dan Willemsen3e5bdf22017-09-13 18:37:08 -0700826 VendorProperties VendorProperties
hamzeh41ad8812021-07-07 14:00:07 -0700827 Properties BaseProperties
Colin Crossfa138792015-04-24 17:31:52 -0700828
Colin Crossca860ac2016-01-04 14:34:37 -0800829 // initialize before calling Init
Liz Kammerbe46fcc2021-11-01 15:32:43 -0400830 hod android.HostOrDeviceSupported
831 multilib android.Multilib
832 bazelable bool
Colin Crossc472d572015-03-17 15:06:21 -0700833
Paul Duffina0843f62019-12-13 19:50:38 +0000834 // Allowable SdkMemberTypes of this module type.
835 sdkMemberTypes []android.SdkMemberType
836
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500837 // decorator delegates, initialize before calling Init
838 // these may contain module-specific implementations, and effectively allow for custom
839 // type-specific logic. These members may reference different objects or the same object.
840 // Functions of these decorators will be invoked to initialize and register type-specific
841 // build statements.
Chris Parsons8d6e4332021-02-22 16:13:50 -0500842 compiler compiler
843 linker linker
844 installer installer
Chris Parsonsf874e462022-05-10 13:50:12 -0400845 bazelHandler BazelHandler
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500846
847 features []feature
848 stl *stl
849 sanitize *sanitize
850 coverage *coverage
Cory Barkera1da26f2022-06-07 20:12:06 +0000851 fuzzer *fuzzer
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500852 sabi *sabi
853 vndkdep *vndkdep
854 lto *lto
Yi Kongeb8efc92021-12-09 18:06:29 +0800855 afdo *afdo
Chris Parsonsef6e0cf2020-12-01 18:26:21 -0500856 pgo *pgo
Colin Cross16b23492016-01-06 14:41:07 -0800857
Colin Cross31076b32020-10-23 17:22:06 -0700858 library libraryInterface
859
Colin Cross635c3b02016-05-18 15:37:25 -0700860 outputFile android.OptionalPath
Colin Crossca860ac2016-01-04 14:34:37 -0800861
Colin Crossb98c8b02016-07-29 13:44:28 -0700862 cachedToolchain config.Toolchain
Colin Crossb916a382016-07-29 17:28:03 -0700863
864 subAndroidMkOnce map[subAndroidMkProvider]bool
Fabien Sanglardd61f1f42017-01-10 16:21:22 -0800865
866 // Flags used to compile this module
867 flags Flags
Jeff Gaston294356f2017-09-27 17:05:30 -0700868
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -0800869 // Shared flags among build rules of this module
870 sharedFlags SharedFlags
871
Jeff Gastonf5b6e8f2017-11-27 15:48:57 -0800872 // only non-nil when this is a shared library that reuses the objects of a static library
Colin Cross0de8a1e2020-09-18 14:15:30 -0700873 staticAnalogue *StaticLibraryInfo
Inseob Kim9516ee92019-05-09 10:56:13 +0900874
875 makeLinkType string
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800876 // Kythe (source file indexer) paths for this compilation module
877 kytheFiles android.Paths
Chih-Hung Hsieh80783772021-10-11 16:46:56 -0700878 // Object .o file output paths for this compilation module
879 objFiles android.Paths
880 // Tidy .tidy file output paths for this compilation module
881 tidyFiles android.Paths
Jooyung Han75568392020-03-20 04:29:24 +0900882
883 // For apex variants, this is set as apex.min_sdk_version
Dan Albertc8060532020-07-22 22:32:17 -0700884 apexSdkVersion android.ApiLevel
Colin Cross56a83212020-09-15 18:30:11 -0700885
886 hideApexVariantFromMake bool
Colin Crossc472d572015-03-17 15:06:21 -0700887}
888
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200889func (c *Module) AddJSONData(d *map[string]interface{}) {
Liz Kammer74ec1682021-08-17 17:29:51 -0400890 var hasAidl, hasLex, hasProto, hasRenderscript, hasSysprop, hasWinMsg, hasYacc bool
891 if b, ok := c.compiler.(*baseCompiler); ok {
892 hasAidl = b.hasSrcExt(".aidl")
893 hasLex = b.hasSrcExt(".l") || b.hasSrcExt(".ll")
894 hasProto = b.hasSrcExt(".proto")
895 hasRenderscript = b.hasSrcExt(".rscript") || b.hasSrcExt(".fs")
896 hasSysprop = b.hasSrcExt(".sysprop")
897 hasWinMsg = b.hasSrcExt(".mc")
898 hasYacc = b.hasSrcExt(".y") || b.hasSrcExt(".yy")
899 }
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200900 c.AndroidModuleBase().AddJSONData(d)
901 (*d)["Cc"] = map[string]interface{}{
902 "SdkVersion": c.SdkVersion(),
903 "MinSdkVersion": c.MinSdkVersion(),
904 "VndkVersion": c.VndkVersion(),
905 "ProductSpecific": c.ProductSpecific(),
906 "SocSpecific": c.SocSpecific(),
907 "DeviceSpecific": c.DeviceSpecific(),
908 "InProduct": c.InProduct(),
909 "InVendor": c.InVendor(),
910 "InRamdisk": c.InRamdisk(),
911 "InVendorRamdisk": c.InVendorRamdisk(),
912 "InRecovery": c.InRecovery(),
913 "VendorAvailable": c.VendorAvailable(),
914 "ProductAvailable": c.ProductAvailable(),
915 "RamdiskAvailable": c.RamdiskAvailable(),
916 "VendorRamdiskAvailable": c.VendorRamdiskAvailable(),
917 "RecoveryAvailable": c.RecoveryAvailable(),
918 "OdmAvailable": c.OdmAvailable(),
919 "InstallInData": c.InstallInData(),
920 "InstallInRamdisk": c.InstallInRamdisk(),
921 "InstallInSanitizerDir": c.InstallInSanitizerDir(),
922 "InstallInVendorRamdisk": c.InstallInVendorRamdisk(),
923 "InstallInRecovery": c.InstallInRecovery(),
924 "InstallInRoot": c.InstallInRoot(),
925 "IsVndk": c.IsVndk(),
926 "IsVndkExt": c.IsVndkExt(),
927 "IsVndkPrivate": c.IsVndkPrivate(),
928 "IsVndkSp": c.IsVndkSp(),
929 "IsLlndk": c.IsLlndk(),
930 "IsLlndkPublic": c.IsLlndkPublic(),
931 "IsSnapshotLibrary": c.IsSnapshotLibrary(),
932 "IsSnapshotPrebuilt": c.IsSnapshotPrebuilt(),
933 "IsVendorPublicLibrary": c.IsVendorPublicLibrary(),
934 "ApexSdkVersion": c.apexSdkVersion,
935 "TestFor": c.TestFor(),
Liz Kammer74ec1682021-08-17 17:29:51 -0400936 "AidlSrcs": hasAidl,
937 "LexSrcs": hasLex,
938 "ProtoSrcs": hasProto,
939 "RenderscriptSrcs": hasRenderscript,
940 "SyspropSrcs": hasSysprop,
941 "WinMsgSrcs": hasWinMsg,
942 "YaccSrsc": hasYacc,
943 "OnlyCSrcs": !(hasAidl || hasLex || hasProto || hasRenderscript || hasSysprop || hasWinMsg || hasYacc),
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200944 }
945}
946
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500947func (c *Module) SetPreventInstall() {
948 c.Properties.PreventInstall = true
949}
950
951func (c *Module) SetHideFromMake() {
952 c.Properties.HideFromMake = true
953}
954
Ivan Lozanod7586b62021-04-01 09:49:36 -0400955func (c *Module) HiddenFromMake() bool {
956 return c.Properties.HideFromMake
957}
958
Yi-Yo Chiangc7e044f2021-06-18 19:44:24 +0800959func (c *Module) RequiredModuleNames() []string {
960 required := android.CopyOf(c.ModuleBase.RequiredModuleNames())
961 if c.ImageVariation().Variation == android.CoreVariation {
962 required = append(required, c.Properties.Target.Platform.Required...)
963 required = removeListFromList(required, c.Properties.Target.Platform.Exclude_required)
964 } else if c.InRecovery() {
965 required = append(required, c.Properties.Target.Recovery.Required...)
966 required = removeListFromList(required, c.Properties.Target.Recovery.Exclude_required)
967 }
968 return android.FirstUniqueStrings(required)
969}
970
Ivan Lozano52767be2019-10-18 14:49:46 -0700971func (c *Module) Toc() android.OptionalPath {
972 if c.linker != nil {
973 if library, ok := c.linker.(libraryInterface); ok {
974 return library.toc()
975 }
976 }
977 panic(fmt.Errorf("Toc() called on non-library module: %q", c.BaseModuleName()))
978}
979
980func (c *Module) ApiLevel() string {
981 if c.linker != nil {
982 if stub, ok := c.linker.(*stubDecorator); ok {
Dan Albert1a246272020-07-06 14:49:35 -0700983 return stub.apiLevel.String()
Ivan Lozano52767be2019-10-18 14:49:46 -0700984 }
985 }
986 panic(fmt.Errorf("ApiLevel() called on non-stub library module: %q", c.BaseModuleName()))
987}
988
989func (c *Module) Static() bool {
990 if c.linker != nil {
991 if library, ok := c.linker.(libraryInterface); ok {
992 return library.static()
993 }
994 }
995 panic(fmt.Errorf("Static() called on non-library module: %q", c.BaseModuleName()))
996}
997
998func (c *Module) Shared() bool {
999 if c.linker != nil {
1000 if library, ok := c.linker.(libraryInterface); ok {
1001 return library.shared()
1002 }
1003 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001004
Ivan Lozano52767be2019-10-18 14:49:46 -07001005 panic(fmt.Errorf("Shared() called on non-library module: %q", c.BaseModuleName()))
1006}
1007
1008func (c *Module) SelectedStl() string {
Colin Crossc511bc52020-04-07 16:50:32 +00001009 if c.stl != nil {
1010 return c.stl.Properties.SelectedStl
1011 }
1012 return ""
Ivan Lozano52767be2019-10-18 14:49:46 -07001013}
1014
Ivan Lozano52767be2019-10-18 14:49:46 -07001015func (c *Module) NdkPrebuiltStl() bool {
1016 if _, ok := c.linker.(*ndkPrebuiltStlLinker); ok {
1017 return true
1018 }
1019 return false
1020}
1021
1022func (c *Module) StubDecorator() bool {
1023 if _, ok := c.linker.(*stubDecorator); ok {
1024 return true
1025 }
1026 return false
1027}
1028
1029func (c *Module) SdkVersion() string {
1030 return String(c.Properties.Sdk_version)
1031}
1032
Artur Satayev480e25b2020-04-27 18:53:18 +01001033func (c *Module) MinSdkVersion() string {
1034 return String(c.Properties.Min_sdk_version)
1035}
1036
Jiyong Park5df7bd32021-08-25 16:18:46 +09001037func (c *Module) isCrt() bool {
Dan Albert92fe7402020-07-15 13:33:30 -07001038 if linker, ok := c.linker.(*objectLinker); ok {
1039 return linker.isCrt()
1040 }
1041 return false
1042}
1043
Jiyong Park5df7bd32021-08-25 16:18:46 +09001044func (c *Module) SplitPerApiLevel() bool {
1045 return c.canUseSdk() && c.isCrt()
1046}
1047
Colin Crossc511bc52020-04-07 16:50:32 +00001048func (c *Module) AlwaysSdk() bool {
1049 return c.Properties.AlwaysSdk || Bool(c.Properties.Sdk_variant_only)
1050}
1051
Ivan Lozano183a3212019-10-18 14:18:45 -07001052func (c *Module) CcLibrary() bool {
1053 if c.linker != nil {
1054 if _, ok := c.linker.(*libraryDecorator); ok {
1055 return true
1056 }
Colin Crossd48fe732020-09-23 20:37:24 -07001057 if _, ok := c.linker.(*prebuiltLibraryLinker); ok {
1058 return true
1059 }
Ivan Lozano183a3212019-10-18 14:18:45 -07001060 }
1061 return false
1062}
1063
1064func (c *Module) CcLibraryInterface() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001065 if _, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001066 return true
1067 }
1068 return false
1069}
1070
Ivan Lozano0f9963e2023-02-06 13:31:02 -05001071func (c *Module) IsFuzzModule() bool {
1072 if _, ok := c.compiler.(*fuzzBinary); ok {
1073 return true
1074 }
1075 return false
1076}
1077
1078func (c *Module) FuzzModuleStruct() fuzz.FuzzModule {
1079 return c.FuzzModule
1080}
1081
1082func (c *Module) FuzzPackagedModule() fuzz.FuzzPackagedModule {
1083 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1084 return fuzzer.fuzzPackagedModule
1085 }
1086 panic(fmt.Errorf("FuzzPackagedModule called on non-fuzz module: %q", c.BaseModuleName()))
1087}
1088
1089func (c *Module) FuzzSharedLibraries() android.Paths {
1090 if fuzzer, ok := c.compiler.(*fuzzBinary); ok {
1091 return fuzzer.sharedLibraries
1092 }
1093 panic(fmt.Errorf("FuzzSharedLibraries called on non-fuzz module: %q", c.BaseModuleName()))
1094}
1095
Ivan Lozano2b262972019-11-21 12:30:50 -08001096func (c *Module) NonCcVariants() bool {
1097 return false
1098}
1099
Ivan Lozano183a3212019-10-18 14:18:45 -07001100func (c *Module) SetStatic() {
1101 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001102 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001103 library.setStatic()
1104 return
1105 }
1106 }
1107 panic(fmt.Errorf("SetStatic called on non-library module: %q", c.BaseModuleName()))
1108}
1109
1110func (c *Module) SetShared() {
1111 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001112 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001113 library.setShared()
1114 return
1115 }
1116 }
1117 panic(fmt.Errorf("SetShared called on non-library module: %q", c.BaseModuleName()))
1118}
1119
1120func (c *Module) BuildStaticVariant() bool {
1121 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001122 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001123 return library.buildStatic()
1124 }
1125 }
1126 panic(fmt.Errorf("BuildStaticVariant called on non-library module: %q", c.BaseModuleName()))
1127}
1128
1129func (c *Module) BuildSharedVariant() bool {
1130 if c.linker != nil {
Ivan Lozano52767be2019-10-18 14:49:46 -07001131 if library, ok := c.linker.(libraryInterface); ok {
Ivan Lozano183a3212019-10-18 14:18:45 -07001132 return library.buildShared()
1133 }
1134 }
1135 panic(fmt.Errorf("BuildSharedVariant called on non-library module: %q", c.BaseModuleName()))
1136}
1137
1138func (c *Module) Module() android.Module {
1139 return c
1140}
1141
Jiyong Parkc20eee32018-09-05 22:36:17 +09001142func (c *Module) OutputFile() android.OptionalPath {
1143 return c.outputFile
1144}
1145
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -04001146func (c *Module) CoverageFiles() android.Paths {
1147 if c.linker != nil {
1148 if library, ok := c.linker.(libraryInterface); ok {
1149 return library.objs().coverageFiles
1150 }
1151 }
1152 panic(fmt.Errorf("CoverageFiles called on non-library module: %q", c.BaseModuleName()))
1153}
1154
Ivan Lozano183a3212019-10-18 14:18:45 -07001155var _ LinkableInterface = (*Module)(nil)
1156
Jiyong Park719b4462019-01-13 00:39:51 +09001157func (c *Module) UnstrippedOutputFile() android.Path {
Jiyong Parkaf6d8952019-01-31 12:21:23 +09001158 if c.linker != nil {
1159 return c.linker.unstrippedOutputFilePath()
Jiyong Park719b4462019-01-13 00:39:51 +09001160 }
1161 return nil
1162}
1163
Jiyong Parkee9a98d2019-08-09 14:44:36 +09001164func (c *Module) CoverageOutputFile() android.OptionalPath {
1165 if c.linker != nil {
1166 return c.linker.coverageOutputFilePath()
1167 }
1168 return android.OptionalPath{}
1169}
1170
Jiyong Parkb7c24df2019-02-01 12:03:59 +09001171func (c *Module) RelativeInstallPath() string {
1172 if c.installer != nil {
1173 return c.installer.relativeInstallPath()
1174 }
1175 return ""
1176}
1177
Jooyung Han344d5432019-08-23 11:17:39 +09001178func (c *Module) VndkVersion() string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001179 return c.Properties.VndkVersion
Jooyung Han344d5432019-08-23 11:17:39 +09001180}
1181
Colin Cross36242852017-06-23 15:06:31 -07001182func (c *Module) Init() android.Module {
Dan Willemsenf923f2b2018-05-09 13:45:03 -07001183 c.AddProperties(&c.Properties, &c.VendorProperties)
Colin Crossca860ac2016-01-04 14:34:37 -08001184 if c.compiler != nil {
Colin Cross36242852017-06-23 15:06:31 -07001185 c.AddProperties(c.compiler.compilerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001186 }
1187 if c.linker != nil {
Colin Cross36242852017-06-23 15:06:31 -07001188 c.AddProperties(c.linker.linkerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001189 }
1190 if c.installer != nil {
Colin Cross36242852017-06-23 15:06:31 -07001191 c.AddProperties(c.installer.installerProps()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001192 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001193 if c.stl != nil {
Colin Cross36242852017-06-23 15:06:31 -07001194 c.AddProperties(c.stl.props()...)
Colin Crossa8e07cc2016-04-04 15:07:06 -07001195 }
Colin Cross16b23492016-01-06 14:41:07 -08001196 if c.sanitize != nil {
Colin Cross36242852017-06-23 15:06:31 -07001197 c.AddProperties(c.sanitize.props()...)
Colin Cross16b23492016-01-06 14:41:07 -08001198 }
Dan Willemsen581341d2017-02-09 16:16:31 -08001199 if c.coverage != nil {
Colin Cross36242852017-06-23 15:06:31 -07001200 c.AddProperties(c.coverage.props()...)
Dan Willemsen581341d2017-02-09 16:16:31 -08001201 }
Cory Barkera1da26f2022-06-07 20:12:06 +00001202 if c.fuzzer != nil {
1203 c.AddProperties(c.fuzzer.props()...)
1204 }
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001205 if c.sabi != nil {
Colin Cross36242852017-06-23 15:06:31 -07001206 c.AddProperties(c.sabi.props()...)
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001207 }
Justin Yun8effde42017-06-23 19:24:43 +09001208 if c.vndkdep != nil {
1209 c.AddProperties(c.vndkdep.props()...)
1210 }
Stephen Craneba090d12017-05-09 15:44:35 -07001211 if c.lto != nil {
1212 c.AddProperties(c.lto.props()...)
1213 }
Yi Kongeb8efc92021-12-09 18:06:29 +08001214 if c.afdo != nil {
1215 c.AddProperties(c.afdo.props()...)
1216 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001217 if c.pgo != nil {
1218 c.AddProperties(c.pgo.props()...)
1219 }
Colin Crossca860ac2016-01-04 14:34:37 -08001220 for _, feature := range c.features {
Colin Cross36242852017-06-23 15:06:31 -07001221 c.AddProperties(feature.props()...)
Colin Crossca860ac2016-01-04 14:34:37 -08001222 }
Colin Crossc472d572015-03-17 15:06:21 -07001223
Colin Cross36242852017-06-23 15:06:31 -07001224 android.InitAndroidArchModule(c, c.hod, c.multilib)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04001225 if c.bazelable {
1226 android.InitBazelModule(c)
1227 }
Jiyong Park7916bfc2019-09-30 19:13:12 +09001228 android.InitApexModule(c)
Jooyung Han18020ea2019-11-13 10:50:48 +09001229 android.InitDefaultableModule(c)
Jiyong Park9d452992018-10-03 00:38:19 +09001230
Colin Cross36242852017-06-23 15:06:31 -07001231 return c
Colin Crossc472d572015-03-17 15:06:21 -07001232}
1233
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001234// UseVndk() returns true if this module is built against VNDK.
1235// This means the vendor and product variants of a module.
Ivan Lozano52767be2019-10-18 14:49:46 -07001236func (c *Module) UseVndk() bool {
Inseob Kim64c43952019-08-26 16:52:35 +09001237 return c.Properties.VndkVersion != ""
Dan Willemsen4416e5d2017-04-06 12:43:22 -07001238}
1239
Colin Crossc511bc52020-04-07 16:50:32 +00001240func (c *Module) canUseSdk() bool {
Colin Cross94e347e2021-01-19 14:56:07 -08001241 return c.Os() == android.Android && c.Target().NativeBridge == android.NativeBridgeDisabled &&
1242 !c.UseVndk() && !c.InRamdisk() && !c.InRecovery() && !c.InVendorRamdisk()
Colin Crossc511bc52020-04-07 16:50:32 +00001243}
1244
1245func (c *Module) UseSdk() bool {
1246 if c.canUseSdk() {
Colin Cross1348ce32020-10-01 13:37:16 -07001247 return String(c.Properties.Sdk_version) != ""
Colin Crossc511bc52020-04-07 16:50:32 +00001248 }
1249 return false
1250}
1251
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001252func (c *Module) isCoverageVariant() bool {
1253 return c.coverage.Properties.IsCoverageVariant
1254}
1255
Colin Cross95f1ca02020-10-29 20:47:22 -07001256func (c *Module) IsNdk(config android.Config) bool {
1257 return inList(c.BaseModuleName(), *getNDKKnownLibs(config))
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001258}
1259
Colin Cross127bb8b2020-12-16 16:46:01 -08001260func (c *Module) IsLlndk() bool {
1261 return c.VendorProperties.IsLLNDK
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001262}
1263
Colin Cross127bb8b2020-12-16 16:46:01 -08001264func (c *Module) IsLlndkPublic() bool {
Colin Cross78212242021-01-06 14:51:30 -08001265 return c.VendorProperties.IsLLNDK && !c.VendorProperties.IsVNDKPrivate
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001266}
1267
Colin Cross1f3f1302021-04-26 18:37:44 -07001268func (m *Module) NeedsLlndkVariants() bool {
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001269 lib := moduleLibraryInterface(m)
Colin Cross1f3f1302021-04-26 18:37:44 -07001270 return lib != nil && (lib.hasLLNDKStubs() || lib.hasLLNDKHeaders())
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001271}
1272
Colin Cross5271fea2021-04-27 13:06:04 -07001273func (m *Module) NeedsVendorPublicLibraryVariants() bool {
1274 lib := moduleLibraryInterface(m)
1275 return lib != nil && (lib.hasVendorPublicLibrary())
1276}
1277
1278// IsVendorPublicLibrary returns true for vendor public libraries.
1279func (c *Module) IsVendorPublicLibrary() bool {
1280 return c.VendorProperties.IsVendorPublicLibrary
1281}
1282
Ivan Lozanof1868af2022-04-12 13:08:36 -04001283func (c *Module) IsVndkPrebuiltLibrary() bool {
1284 if _, ok := c.linker.(*vndkPrebuiltLibraryDecorator); ok {
1285 return true
1286 }
1287 return false
1288}
1289
1290func (c *Module) SdkAndPlatformVariantVisibleToMake() bool {
1291 return c.Properties.SdkAndPlatformVariantVisibleToMake
1292}
1293
Ivan Lozanod7586b62021-04-01 09:49:36 -04001294func (c *Module) HasLlndkStubs() bool {
1295 lib := moduleLibraryInterface(c)
1296 return lib != nil && lib.hasLLNDKStubs()
1297}
1298
1299func (c *Module) StubsVersion() string {
1300 if lib, ok := c.linker.(versionedInterface); ok {
1301 return lib.stubsVersion()
1302 }
1303 panic(fmt.Errorf("StubsVersion called on non-versioned module: %q", c.BaseModuleName()))
1304}
1305
Colin Cross127bb8b2020-12-16 16:46:01 -08001306// isImplementationForLLNDKPublic returns true for any variant of a cc_library that has LLNDK stubs
1307// and does not set llndk.vendor_available: false.
1308func (c *Module) isImplementationForLLNDKPublic() bool {
1309 library, _ := c.library.(*libraryDecorator)
1310 return library != nil && library.hasLLNDKStubs() &&
Colin Cross0fb7fcd2021-03-02 11:00:07 -08001311 !Bool(library.Properties.Llndk.Private)
Colin Cross127bb8b2020-12-16 16:46:01 -08001312}
1313
Justin Yunfd9e8042020-12-23 18:23:14 +09001314// Returns true for LLNDK-private, VNDK-SP-private, and VNDK-core-private.
Colin Cross127bb8b2020-12-16 16:46:01 -08001315func (c *Module) IsVndkPrivate() bool {
Justin Yunfd9e8042020-12-23 18:23:14 +09001316 // Check if VNDK-core-private or VNDK-SP-private
1317 if c.IsVndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001318 return Bool(c.vndkdep.Properties.Vndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001319 }
1320
1321 // Check if LLNDK-private
1322 if library, ok := c.library.(*libraryDecorator); ok && c.IsLlndk() {
Justin Yunc0d8c492021-01-07 17:45:31 +09001323 return Bool(library.Properties.Llndk.Private)
Justin Yunfd9e8042020-12-23 18:23:14 +09001324 }
1325
1326 return false
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001327}
1328
Yi-Yo Chiang1080f0c2022-11-22 18:24:14 +08001329// IsVndk() returns true if this module has a vndk variant.
1330// Note that IsVndk() returns true for all variants of vndk-enabled libraries. Not only vendor variant,
1331// but also platform and product variants of vndk-enabled libraries return true for IsVndk().
Ivan Lozano52767be2019-10-18 14:49:46 -07001332func (c *Module) IsVndk() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001333 if vndkdep := c.vndkdep; vndkdep != nil {
1334 return vndkdep.isVndk()
Justin Yun8effde42017-06-23 19:24:43 +09001335 }
1336 return false
1337}
1338
Yi Kong4ef54592022-02-14 20:00:10 +08001339func (c *Module) isAfdoCompile() bool {
1340 if afdo := c.afdo; afdo != nil {
Vinh Tran44cb78c2023-03-09 22:07:19 -05001341 return afdo.Properties.FdoProfilePath != nil
Yi Kong4ef54592022-02-14 20:00:10 +08001342 }
1343 return false
1344}
1345
Yi Kong7e53c572018-02-14 18:16:12 +08001346func (c *Module) isPgoCompile() bool {
1347 if pgo := c.pgo; pgo != nil {
1348 return pgo.Properties.PgoCompile
1349 }
1350 return false
1351}
1352
Yi Kongc702ebd2022-08-19 16:02:45 +08001353func (c *Module) isCfi() bool {
1354 if sanitize := c.sanitize; sanitize != nil {
1355 return Bool(sanitize.Properties.Sanitize.Cfi)
1356 }
1357 return false
1358}
1359
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001360func (c *Module) isNDKStubLibrary() bool {
1361 if _, ok := c.compiler.(*stubDecorator); ok {
1362 return true
1363 }
1364 return false
1365}
1366
Ivan Lozanod7586b62021-04-01 09:49:36 -04001367func (c *Module) IsVndkSp() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001368 if vndkdep := c.vndkdep; vndkdep != nil {
1369 return vndkdep.isVndkSp()
1370 }
1371 return false
1372}
1373
Ivan Lozanof9e21722020-12-02 09:00:51 -05001374func (c *Module) IsVndkExt() bool {
Logan Chienf3511742017-10-31 18:04:35 +08001375 if vndkdep := c.vndkdep; vndkdep != nil {
1376 return vndkdep.isVndkExt()
1377 }
1378 return false
1379}
1380
Ivan Lozanoc08897c2021-04-02 12:41:32 -04001381func (c *Module) SubName() string {
1382 return c.Properties.SubName
1383}
1384
Ivan Lozano52767be2019-10-18 14:49:46 -07001385func (c *Module) MustUseVendorVariant() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001386 return c.IsVndkSp() || c.Properties.MustUseVendorVariant
Vic Yangefd249e2018-11-12 20:19:56 -08001387}
1388
Logan Chienf3511742017-10-31 18:04:35 +08001389func (c *Module) getVndkExtendsModuleName() string {
1390 if vndkdep := c.vndkdep; vndkdep != nil {
1391 return vndkdep.getVndkExtendsModuleName()
1392 }
1393 return ""
1394}
1395
Jiyong Park25fc6a92018-11-18 18:02:45 +09001396func (c *Module) IsStubs() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001397 if lib := c.library; lib != nil {
1398 return lib.buildStubs()
Jiyong Park25fc6a92018-11-18 18:02:45 +09001399 }
1400 return false
1401}
1402
1403func (c *Module) HasStubsVariants() bool {
Colin Cross31076b32020-10-23 17:22:06 -07001404 if lib := c.library; lib != nil {
1405 return lib.hasStubsVariants()
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001406 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001407 return false
1408}
1409
Alan Stokes73feba32022-11-14 12:21:24 +00001410func (c *Module) IsStubsImplementationRequired() bool {
1411 if lib := c.library; lib != nil {
1412 return lib.isStubsImplementationRequired()
1413 }
1414 return false
1415}
1416
Colin Cross0477b422020-10-13 18:43:54 -07001417// If this is a stubs library, ImplementationModuleName returns the name of the module that contains
1418// the implementation. If it is an implementation library it returns its own name.
1419func (c *Module) ImplementationModuleName(ctx android.BaseModuleContext) string {
1420 name := ctx.OtherModuleName(c)
1421 if versioned, ok := c.linker.(versionedInterface); ok {
1422 name = versioned.implementationModuleName(name)
1423 }
1424 return name
1425}
1426
Martin Stjernholm2856c662020-12-02 15:03:42 +00001427// Similar to ImplementationModuleName, but uses the Make variant of the module
1428// name as base name, for use in AndroidMk output. E.g. for a prebuilt module
1429// where the Soong name is prebuilt_foo, this returns foo (which works in Make
1430// under the premise that the prebuilt module overrides its source counterpart
1431// if it is exposed to Make).
1432func (c *Module) ImplementationModuleNameForMake(ctx android.BaseModuleContext) string {
1433 name := c.BaseModuleName()
1434 if versioned, ok := c.linker.(versionedInterface); ok {
1435 name = versioned.implementationModuleName(name)
1436 }
1437 return name
1438}
1439
Jiyong Park7d55b612021-06-11 17:22:09 +09001440func (c *Module) Bootstrap() bool {
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001441 return Bool(c.Properties.Bootstrap)
1442}
1443
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001444func (c *Module) nativeCoverage() bool {
Pirama Arumuga Nainar5f69b9a2019-09-12 13:18:48 -07001445 // Bug: http://b/137883967 - native-bridge modules do not currently work with coverage
1446 if c.Target().NativeBridge == android.NativeBridgeEnabled {
1447 return false
1448 }
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001449 return c.linker != nil && c.linker.nativeCoverage()
1450}
1451
Ivan Lozano3a7d0002021-03-30 12:19:36 -04001452func (c *Module) IsSnapshotPrebuilt() bool {
Ivan Lozanod1dec542021-05-26 15:33:11 -04001453 if p, ok := c.linker.(SnapshotInterface); ok {
1454 return p.IsSnapshotPrebuilt()
Inseob Kimeec88e12020-01-22 11:11:29 +09001455 }
1456 return false
Inseob Kim8471cda2019-11-15 09:59:12 +09001457}
1458
Bill Peckham945441c2020-08-31 16:07:58 -07001459func (c *Module) ExcludeFromVendorSnapshot() bool {
1460 return Bool(c.Properties.Exclude_from_vendor_snapshot)
1461}
1462
Jose Galmesf7294582020-11-13 12:07:36 -08001463func (c *Module) ExcludeFromRecoverySnapshot() bool {
1464 return Bool(c.Properties.Exclude_from_recovery_snapshot)
1465}
1466
Jiyong Parkf1194352019-02-25 11:05:47 +09001467func isBionic(name string) bool {
1468 switch name {
Jooyung Hanbff73352022-12-13 18:29:44 +09001469 case "libc", "libm", "libdl", "libdl_android", "linker":
Jiyong Parkf1194352019-02-25 11:05:47 +09001470 return true
1471 }
1472 return false
1473}
1474
Martin Stjernholm279de572019-09-10 23:18:20 +01001475func InstallToBootstrap(name string, config android.Config) bool {
Jingwen Chen29743c82023-01-25 17:49:46 +00001476 // NOTE: also update //build/bazel/rules/apex/cc.bzl#_installed_to_bootstrap
1477 // if this list is updated.
Colin Cross4c4c1be2022-02-10 11:41:18 -08001478 if name == "libclang_rt.hwasan" {
Jooyung Han8ce8db92020-05-15 19:05:05 +09001479 return true
Peter Collingbourne3478bb22019-04-24 14:41:12 -07001480 }
1481 return isBionic(name)
1482}
1483
Sasha Smundak2a4549e2018-11-05 16:49:08 -08001484func (c *Module) XrefCcFiles() android.Paths {
1485 return c.kytheFiles
1486}
1487
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001488func (c *Module) isCfiAssemblySupportEnabled() bool {
1489 return c.sanitize != nil &&
1490 Bool(c.sanitize.Properties.Sanitize.Config.Cfi_assembly_support)
1491}
1492
Inseob Kim800d1142021-06-14 12:03:51 +09001493func (c *Module) InstallInRoot() bool {
1494 return c.installer != nil && c.installer.installInRoot()
1495}
1496
Colin Crossca860ac2016-01-04 14:34:37 -08001497type baseModuleContext struct {
Colin Cross0ea8ba82019-06-06 14:33:29 -07001498 android.BaseModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001499 moduleContextImpl
1500}
1501
Colin Cross37047f12016-12-13 17:06:13 -08001502type depsContext struct {
1503 android.BottomUpMutatorContext
1504 moduleContextImpl
1505}
1506
Colin Crossca860ac2016-01-04 14:34:37 -08001507type moduleContext struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001508 android.ModuleContext
Colin Crossca860ac2016-01-04 14:34:37 -08001509 moduleContextImpl
1510}
1511
1512type moduleContextImpl struct {
1513 mod *Module
1514 ctx BaseModuleContext
1515}
1516
Colin Crossb98c8b02016-07-29 13:44:28 -07001517func (ctx *moduleContextImpl) toolchain() config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08001518 return ctx.mod.toolchain(ctx.ctx)
1519}
1520
1521func (ctx *moduleContextImpl) static() bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001522 return ctx.mod.static()
Colin Crossca860ac2016-01-04 14:34:37 -08001523}
1524
1525func (ctx *moduleContextImpl) staticBinary() bool {
Jiyong Park379de2f2018-12-19 02:47:14 +09001526 return ctx.mod.staticBinary()
Colin Crossca860ac2016-01-04 14:34:37 -08001527}
1528
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001529func (ctx *moduleContextImpl) testBinary() bool {
1530 return ctx.mod.testBinary()
1531}
1532
Yi Kong56fc1b62022-09-06 16:24:00 +08001533func (ctx *moduleContextImpl) testLibrary() bool {
1534 return ctx.mod.testLibrary()
1535}
1536
Jiyong Park1d1119f2019-07-29 21:27:18 +09001537func (ctx *moduleContextImpl) header() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001538 return ctx.mod.Header()
Jiyong Park1d1119f2019-07-29 21:27:18 +09001539}
1540
Inseob Kim7f283f42020-06-01 21:53:49 +09001541func (ctx *moduleContextImpl) binary() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001542 return ctx.mod.Binary()
Inseob Kim7f283f42020-06-01 21:53:49 +09001543}
1544
Inseob Kim1042d292020-06-01 23:23:05 +09001545func (ctx *moduleContextImpl) object() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001546 return ctx.mod.Object()
Inseob Kim1042d292020-06-01 23:23:05 +09001547}
1548
Jooyung Hanccce2f22020-03-07 03:45:53 +09001549func (ctx *moduleContextImpl) canUseSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001550 return ctx.mod.canUseSdk()
Jooyung Hanccce2f22020-03-07 03:45:53 +09001551}
1552
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001553func (ctx *moduleContextImpl) useSdk() bool {
Colin Crossc511bc52020-04-07 16:50:32 +00001554 return ctx.mod.UseSdk()
Colin Crossca860ac2016-01-04 14:34:37 -08001555}
1556
1557func (ctx *moduleContextImpl) sdkVersion() string {
Dan Willemsena96ff642016-06-07 12:34:45 -07001558 if ctx.ctx.Device() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001559 if ctx.useVndk() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001560 vndkVer := ctx.mod.VndkVersion()
Jooyung Han03302ee2020-04-08 09:22:26 +09001561 if inList(vndkVer, ctx.ctx.Config().PlatformVersionActiveCodenames()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001562 return "current"
Justin Yun732aa6a2018-03-23 17:43:47 +09001563 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001564 return vndkVer
Dan Willemsend2ede872016-11-18 14:54:24 -08001565 }
Justin Yun732aa6a2018-03-23 17:43:47 +09001566 return String(ctx.mod.Properties.Sdk_version)
Dan Willemsena96ff642016-06-07 12:34:45 -07001567 }
1568 return ""
Colin Crossca860ac2016-01-04 14:34:37 -08001569}
1570
Jiyong Parkb35a8192020-08-10 15:59:36 +09001571func (ctx *moduleContextImpl) minSdkVersion() string {
1572 ver := ctx.mod.MinSdkVersion()
1573 if ver == "apex_inherit" && !ctx.isForPlatform() {
1574 ver = ctx.apexSdkVersion().String()
1575 }
1576 if ver == "apex_inherit" || ver == "" {
1577 ver = ctx.sdkVersion()
1578 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001579 // For crt objects, the meaning of min_sdk_version is very different from other types of
1580 // module. For them, min_sdk_version defines the oldest version that the build system will
1581 // create versioned variants for. For example, if min_sdk_version is 16, then sdk variant of
1582 // the crt object has local variants of 16, 17, ..., up to the latest version. sdk_version
1583 // and min_sdk_version properties of the variants are set to the corresponding version
Jiyong Park5df7bd32021-08-25 16:18:46 +09001584 // numbers. However, the non-sdk variant (for apex or platform) of the crt object is left
1585 // untouched. min_sdk_version: 16 doesn't actually mean that the non-sdk variant has to
1586 // support such an old version. The version is set to the later version in case when the
1587 // non-sdk variant is for the platform, or the min_sdk_version of the containing APEX if
1588 // it's for an APEX.
1589 if ctx.mod.isCrt() && !ctx.isSdkVariant() {
1590 if ctx.isForPlatform() {
1591 ver = strconv.Itoa(android.FutureApiLevelInt)
1592 } else { // for apex
1593 ver = ctx.apexSdkVersion().String()
1594 if ver == "" { // in case when min_sdk_version was not set by the APEX
1595 ver = ctx.sdkVersion()
1596 }
1597 }
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09001598 }
1599
Jiyong Parkb35a8192020-08-10 15:59:36 +09001600 // Also make sure that minSdkVersion is not greater than sdkVersion, if they are both numbers
1601 sdkVersionInt, err := strconv.Atoi(ctx.sdkVersion())
1602 minSdkVersionInt, err2 := strconv.Atoi(ver)
1603 if err == nil && err2 == nil {
1604 if sdkVersionInt < minSdkVersionInt {
1605 return strconv.Itoa(sdkVersionInt)
1606 }
1607 }
1608 return ver
1609}
1610
1611func (ctx *moduleContextImpl) isSdkVariant() bool {
1612 return ctx.mod.IsSdkVariant()
1613}
1614
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001615func (ctx *moduleContextImpl) useVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001616 return ctx.mod.UseVndk()
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07001617}
Justin Yun8effde42017-06-23 19:24:43 +09001618
Colin Cross95f1ca02020-10-29 20:47:22 -07001619func (ctx *moduleContextImpl) isNdk(config android.Config) bool {
1620 return ctx.mod.IsNdk(config)
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001621}
1622
Colin Cross127bb8b2020-12-16 16:46:01 -08001623func (ctx *moduleContextImpl) IsLlndk() bool {
1624 return ctx.mod.IsLlndk()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001625}
1626
Colin Cross127bb8b2020-12-16 16:46:01 -08001627func (ctx *moduleContextImpl) IsLlndkPublic() bool {
1628 return ctx.mod.IsLlndkPublic()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001629}
1630
Colin Cross127bb8b2020-12-16 16:46:01 -08001631func (ctx *moduleContextImpl) isImplementationForLLNDKPublic() bool {
1632 return ctx.mod.isImplementationForLLNDKPublic()
1633}
1634
1635func (ctx *moduleContextImpl) IsVndkPrivate() bool {
1636 return ctx.mod.IsVndkPrivate()
Logan Chienf6dbd9c2019-01-16 20:19:51 +08001637}
1638
Logan Chienf3511742017-10-31 18:04:35 +08001639func (ctx *moduleContextImpl) isVndk() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001640 return ctx.mod.IsVndk()
Logan Chienf3511742017-10-31 18:04:35 +08001641}
1642
Yi Kong4ef54592022-02-14 20:00:10 +08001643func (ctx *moduleContextImpl) isAfdoCompile() bool {
1644 return ctx.mod.isAfdoCompile()
1645}
1646
Yi Kong7e53c572018-02-14 18:16:12 +08001647func (ctx *moduleContextImpl) isPgoCompile() bool {
1648 return ctx.mod.isPgoCompile()
1649}
1650
Yi Kongc702ebd2022-08-19 16:02:45 +08001651func (ctx *moduleContextImpl) isCfi() bool {
1652 return ctx.mod.isCfi()
1653}
1654
Pirama Arumuga Nainar1acd4472018-12-10 15:12:40 -08001655func (ctx *moduleContextImpl) isNDKStubLibrary() bool {
1656 return ctx.mod.isNDKStubLibrary()
1657}
1658
Justin Yun8effde42017-06-23 19:24:43 +09001659func (ctx *moduleContextImpl) isVndkSp() bool {
Ivan Lozanod7586b62021-04-01 09:49:36 -04001660 return ctx.mod.IsVndkSp()
Logan Chienf3511742017-10-31 18:04:35 +08001661}
1662
Ivan Lozanof9e21722020-12-02 09:00:51 -05001663func (ctx *moduleContextImpl) IsVndkExt() bool {
1664 return ctx.mod.IsVndkExt()
Justin Yun8effde42017-06-23 19:24:43 +09001665}
1666
Colin Cross5271fea2021-04-27 13:06:04 -07001667func (ctx *moduleContextImpl) IsVendorPublicLibrary() bool {
1668 return ctx.mod.IsVendorPublicLibrary()
1669}
1670
Vic Yangefd249e2018-11-12 20:19:56 -08001671func (ctx *moduleContextImpl) mustUseVendorVariant() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07001672 return ctx.mod.MustUseVendorVariant()
Vic Yangefd249e2018-11-12 20:19:56 -08001673}
1674
Dan Willemsen8146b2f2016-03-30 21:00:30 -07001675func (ctx *moduleContextImpl) selectedStl() string {
1676 if stl := ctx.mod.stl; stl != nil {
1677 return stl.Properties.SelectedStl
1678 }
1679 return ""
1680}
1681
Ivan Lozanobd721262018-11-27 14:33:03 -08001682func (ctx *moduleContextImpl) useClangLld(actx ModuleContext) bool {
1683 return ctx.mod.linker.useClangLld(actx)
1684}
1685
Colin Crossce75d2c2016-10-06 16:12:58 -07001686func (ctx *moduleContextImpl) baseModuleName() string {
1687 return ctx.mod.ModuleBase.BaseModuleName()
1688}
1689
Logan Chienf3511742017-10-31 18:04:35 +08001690func (ctx *moduleContextImpl) getVndkExtendsModuleName() string {
1691 return ctx.mod.getVndkExtendsModuleName()
1692}
1693
Logan Chiene274fc92019-12-03 11:18:32 -08001694func (ctx *moduleContextImpl) isForPlatform() bool {
Colin Cross56a83212020-09-15 18:30:11 -07001695 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform()
Logan Chiene274fc92019-12-03 11:18:32 -08001696}
1697
Colin Crosse07f2312020-08-13 11:24:56 -07001698func (ctx *moduleContextImpl) apexVariationName() string {
Colin Cross56a83212020-09-15 18:30:11 -07001699 return ctx.ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).ApexVariationName
Jiyong Park25fc6a92018-11-18 18:02:45 +09001700}
1701
Dan Albertc8060532020-07-22 22:32:17 -07001702func (ctx *moduleContextImpl) apexSdkVersion() android.ApiLevel {
Jooyung Han75568392020-03-20 04:29:24 +09001703 return ctx.mod.apexSdkVersion
Jooyung Hanccce2f22020-03-07 03:45:53 +09001704}
1705
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001706func (ctx *moduleContextImpl) bootstrap() bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09001707 return ctx.mod.Bootstrap()
Jiyong Parka4b9dd02019-01-16 22:53:13 +09001708}
1709
Pirama Arumuga Nainar65c95ff2019-03-25 10:21:31 -07001710func (ctx *moduleContextImpl) nativeCoverage() bool {
1711 return ctx.mod.nativeCoverage()
1712}
1713
Colin Cross56a83212020-09-15 18:30:11 -07001714func (ctx *moduleContextImpl) directlyInAnyApex() bool {
1715 return ctx.mod.DirectlyInAnyApex()
1716}
1717
Colin Cross95b07f22020-12-16 11:06:50 -08001718func (ctx *moduleContextImpl) isPreventInstall() bool {
1719 return ctx.mod.Properties.PreventInstall
1720}
1721
Chih-Hung Hsieh7540a782022-01-08 19:56:09 -08001722func (ctx *moduleContextImpl) getSharedFlags() *SharedFlags {
1723 shared := &ctx.mod.sharedFlags
1724 if shared.flagsMap == nil {
1725 shared.numSharedFlags = 0
1726 shared.flagsMap = make(map[string]string)
1727 }
1728 return shared
1729}
1730
Cindy Zhou5d5cfc12021-01-09 08:25:22 -08001731func (ctx *moduleContextImpl) isCfiAssemblySupportEnabled() bool {
1732 return ctx.mod.isCfiAssemblySupportEnabled()
1733}
1734
Colin Cross635c3b02016-05-18 15:37:25 -07001735func newBaseModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001736 return &Module{
1737 hod: hod,
1738 multilib: multilib,
1739 }
1740}
1741
Colin Cross635c3b02016-05-18 15:37:25 -07001742func newModule(hod android.HostOrDeviceSupported, multilib android.Multilib) *Module {
Colin Crossca860ac2016-01-04 14:34:37 -08001743 module := newBaseModule(hod, multilib)
Dan Willemsena03cf6d2016-09-26 15:45:04 -07001744 module.features = []feature{
1745 &tidyFeature{},
1746 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07001747 module.stl = &stl{}
Colin Cross16b23492016-01-06 14:41:07 -08001748 module.sanitize = &sanitize{}
Dan Willemsen581341d2017-02-09 16:16:31 -08001749 module.coverage = &coverage{}
Cory Barkera1da26f2022-06-07 20:12:06 +00001750 module.fuzzer = &fuzzer{}
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08001751 module.sabi = &sabi{}
Justin Yun8effde42017-06-23 19:24:43 +09001752 module.vndkdep = &vndkdep{}
Stephen Craneba090d12017-05-09 15:44:35 -07001753 module.lto = &lto{}
Yi Kongeb8efc92021-12-09 18:06:29 +08001754 module.afdo = &afdo{}
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07001755 module.pgo = &pgo{}
Colin Crossca860ac2016-01-04 14:34:37 -08001756 return module
1757}
1758
Colin Crossce75d2c2016-10-06 16:12:58 -07001759func (c *Module) Prebuilt() *android.Prebuilt {
1760 if p, ok := c.linker.(prebuiltLinkerInterface); ok {
1761 return p.prebuilt()
1762 }
1763 return nil
1764}
1765
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001766func (c *Module) IsPrebuilt() bool {
1767 return c.Prebuilt() != nil
1768}
1769
Colin Crossce75d2c2016-10-06 16:12:58 -07001770func (c *Module) Name() string {
1771 name := c.ModuleBase.Name()
Dan Willemsen01a90592017-04-07 15:21:13 -07001772 if p, ok := c.linker.(interface {
1773 Name(string) string
1774 }); ok {
Colin Crossce75d2c2016-10-06 16:12:58 -07001775 name = p.Name(name)
1776 }
1777 return name
1778}
1779
Alex Light3d673592019-01-18 14:37:31 -08001780func (c *Module) Symlinks() []string {
1781 if p, ok := c.installer.(interface {
1782 symlinkList() []string
1783 }); ok {
1784 return p.symlinkList()
1785 }
1786 return nil
1787}
1788
Roland Levillainf89cd092019-07-29 16:22:59 +01001789func (c *Module) IsTestPerSrcAllTestsVariation() bool {
1790 test, ok := c.linker.(testPerSrc)
1791 return ok && test.isAllTestsVariation()
1792}
1793
Chris Parsons216e10a2020-07-09 17:12:52 -04001794func (c *Module) DataPaths() []android.DataPath {
Liz Kammer1c14a212020-05-12 15:26:55 -07001795 if p, ok := c.installer.(interface {
Chris Parsons216e10a2020-07-09 17:12:52 -04001796 dataPaths() []android.DataPath
Liz Kammer1c14a212020-05-12 15:26:55 -07001797 }); ok {
1798 return p.dataPaths()
1799 }
1800 return nil
1801}
1802
Ivan Lozanof1868af2022-04-12 13:08:36 -04001803func getNameSuffixWithVndkVersion(ctx android.ModuleContext, c LinkableInterface) string {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001804 // Returns the name suffix for product and vendor variants. If the VNDK version is not
1805 // "current", it will append the VNDK version to the name suffix.
1806 var vndkVersion string
1807 var nameSuffix string
Ivan Lozanof9e21722020-12-02 09:00:51 -05001808 if c.InProduct() {
Justin Yund00f5ca2021-02-03 19:43:02 +09001809 if c.ProductSpecific() {
1810 // If the module is product specific with 'product_specific: true',
1811 // do not add a name suffix because it is a base module.
1812 return ""
1813 }
Justin Yun5f7f7e82019-11-18 19:52:14 +09001814 vndkVersion = ctx.DeviceConfig().ProductVndkVersion()
Matthew Maurer52af5b02021-05-27 10:01:36 -07001815 nameSuffix = ProductSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001816 } else {
1817 vndkVersion = ctx.DeviceConfig().VndkVersion()
Ivan Lozanoe6d30982021-02-05 10:57:43 -05001818 nameSuffix = VendorSuffix
Justin Yun5f7f7e82019-11-18 19:52:14 +09001819 }
1820 if vndkVersion == "current" {
1821 vndkVersion = ctx.DeviceConfig().PlatformVndkVersion()
1822 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001823 if c.VndkVersion() != vndkVersion && c.VndkVersion() != "" {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001824 // add version suffix only if the module is using different vndk version than the
1825 // version in product or vendor partition.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001826 nameSuffix += "." + c.VndkVersion()
Justin Yun5f7f7e82019-11-18 19:52:14 +09001827 }
1828 return nameSuffix
1829}
1830
Ivan Lozanof1868af2022-04-12 13:08:36 -04001831func GetSubnameProperty(actx android.ModuleContext, c LinkableInterface) string {
1832 var subName = ""
Inseob Kim64c43952019-08-26 16:52:35 +09001833
1834 if c.Target().NativeBridge == android.NativeBridgeEnabled {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001835 subName += NativeBridgeSuffix
Inseob Kim64c43952019-08-26 16:52:35 +09001836 }
1837
Colin Cross127bb8b2020-12-16 16:46:01 -08001838 llndk := c.IsLlndk()
Colin Cross627280f2021-04-26 16:53:58 -07001839 if llndk || (c.UseVndk() && c.HasNonSystemVariants()) {
Justin Yun5f7f7e82019-11-18 19:52:14 +09001840 // .vendor.{version} suffix is added for vendor variant or .product.{version} suffix is
1841 // added for product variant only when we have vendor and product variants with core
1842 // variant. The suffix is not added for vendor-only or product-only module.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001843 subName += getNameSuffixWithVndkVersion(actx, c)
Colin Cross5271fea2021-04-27 13:06:04 -07001844 } else if c.IsVendorPublicLibrary() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001845 subName += vendorPublicLibrarySuffix
1846 } else if c.IsVndkPrebuiltLibrary() {
Inseob Kim64c43952019-08-26 16:52:35 +09001847 // .vendor suffix is added for backward compatibility with VNDK snapshot whose names with
1848 // such suffixes are already hard-coded in prebuilts/vndk/.../Android.bp.
Ivan Lozanof1868af2022-04-12 13:08:36 -04001849 subName += VendorSuffix
Yifan Hong1b3348d2020-01-21 15:53:22 -08001850 } else if c.InRamdisk() && !c.OnlyInRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001851 subName += RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001852 } else if c.InVendorRamdisk() && !c.OnlyInVendorRamdisk() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001853 subName += VendorRamdiskSuffix
Ivan Lozano52767be2019-10-18 14:49:46 -07001854 } else if c.InRecovery() && !c.OnlyInRecovery() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001855 subName += RecoverySuffix
1856 } else if c.IsSdkVariant() && (c.SdkAndPlatformVariantVisibleToMake() || c.SplitPerApiLevel()) {
1857 subName += sdkSuffix
Dan Albert92fe7402020-07-15 13:33:30 -07001858 if c.SplitPerApiLevel() {
Ivan Lozanof1868af2022-04-12 13:08:36 -04001859 subName += "." + c.SdkVersion()
Dan Albert92fe7402020-07-15 13:33:30 -07001860 }
Inseob Kim64c43952019-08-26 16:52:35 +09001861 }
Ivan Lozanof1868af2022-04-12 13:08:36 -04001862
1863 return subName
Chris Parsons8d6e4332021-02-22 16:13:50 -05001864}
1865
Chris Parsonsf874e462022-05-10 13:50:12 -04001866var _ android.MixedBuildBuildable = (*Module)(nil)
1867
1868func (c *Module) getBazelModuleLabel(ctx android.BaseModuleContext) string {
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001869 var bazelModuleLabel string
Liz Kammer35ca77e2021-12-22 15:31:40 -05001870 if c.typ() == fullLibrary && c.static() {
Chris Parsons77acf2e2021-12-03 17:27:16 -05001871 // cc_library is a special case in bp2build; two targets are generated -- one for each
1872 // of the shared and static variants. The shared variant keeps the module name, but the
1873 // static variant uses a different suffixed name.
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001874 bazelModuleLabel = bazelLabelForStaticModule(ctx, c)
1875 } else {
1876 bazelModuleLabel = c.GetBazelLabel(ctx, c)
Chris Parsonsf874e462022-05-10 13:50:12 -04001877 }
Trevor Radcliffe5d6fa4d2022-05-17 21:59:36 +00001878 labelNoPrebuilt := bazelModuleLabel
1879 if c.IsPrebuilt() {
1880 labelNoPrebuilt = android.RemoveOptionalPrebuiltPrefixFromBazelLabel(bazelModuleLabel)
1881 }
1882 return labelNoPrebuilt
Chris Parsonsf874e462022-05-10 13:50:12 -04001883}
1884
1885func (c *Module) QueueBazelCall(ctx android.BaseModuleContext) {
1886 c.bazelHandler.QueueBazelCall(ctx, c.getBazelModuleLabel(ctx))
1887}
1888
Jingwen Chen3952a902022-12-12 12:20:58 +00001889var (
1890 mixedBuildSupportedCcTest = []string{
1891 "adbd_test",
Liz Kammer9c667412023-01-24 10:47:18 -05001892 "adb_crypto_test",
1893 "adb_pairing_auth_test",
1894 "adb_pairing_connection_test",
1895 "adb_tls_connection_test",
Jingwen Chen3952a902022-12-12 12:20:58 +00001896 }
1897)
1898
1899// IsMixedBuildSupported returns true if the module should be analyzed by Bazel
1900// in any of the --bazel-mode(s). This filters at the module level and takes
1901// precedence over the allowlists in allowlists/allowlists.go.
Chris Parsonsf874e462022-05-10 13:50:12 -04001902func (c *Module) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
Sam Delmerico4e115cc2023-01-19 15:36:52 -05001903 _, isForTesting := ctx.Config().BazelContext.(android.MockBazelContext)
1904 if c.testBinary() && !android.InList(c.Name(), mixedBuildSupportedCcTest) && !isForTesting {
Jingwen Chen3952a902022-12-12 12:20:58 +00001905 // Per-module rollout of mixed-builds for cc_test modules.
1906 return false
1907 }
1908
Trevor Radcliffedb7e0262022-10-28 16:48:18 +00001909 // TODO(b/261058727): Remove this (enable mixed builds for modules with UBSan)
Yu Liue4312402023-01-18 09:15:31 -08001910 // Currently we can only support ubsan when minimum runtime is used.
1911 return c.bazelHandler != nil && (!isUbsanEnabled(c) || c.MinimalRuntimeNeeded())
1912}
1913
1914func isUbsanEnabled(c *Module) bool {
1915 if c.sanitize == nil {
1916 return false
1917 }
1918 sanitizeProps := &c.sanitize.Properties.SanitizeMutated
1919 return Bool(sanitizeProps.Integer_overflow) || len(sanitizeProps.Misc_undefined) > 0
1920}
1921
1922func GetApexConfigKey(ctx android.BaseModuleContext) *android.ApexConfigKey {
1923 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1924 if !apexInfo.IsForPlatform() {
Yu Liubfb23622023-02-22 10:42:15 -08001925 if !ctx.Config().BazelContext.IsModuleDclaAllowed(ctx.Module().Name()) {
1926 return nil
1927 }
Yu Liue4312402023-01-18 09:15:31 -08001928 apexKey := android.ApexConfigKey{
1929 WithinApex: true,
1930 ApexSdkVersion: findApexSdkVersion(ctx, apexInfo).String(),
1931 }
1932 return &apexKey
1933 }
1934
1935 return nil
Chris Parsonsf874e462022-05-10 13:50:12 -04001936}
1937
1938func (c *Module) ProcessBazelQueryResponse(ctx android.ModuleContext) {
1939 bazelModuleLabel := c.getBazelModuleLabel(ctx)
Chris Parsonsf874e462022-05-10 13:50:12 -04001940 c.bazelHandler.ProcessBazelQueryResponse(ctx, bazelModuleLabel)
1941
1942 c.Properties.SubName = GetSubnameProperty(ctx, c)
1943 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1944 if !apexInfo.IsForPlatform() {
1945 c.hideApexVariantFromMake = true
Chris Parsons77acf2e2021-12-03 17:27:16 -05001946 }
Liz Kammer35ca77e2021-12-22 15:31:40 -05001947
Chris Parsonsf874e462022-05-10 13:50:12 -04001948 c.makeLinkType = GetMakeLinkType(ctx, c)
1949
1950 mctx := &moduleContext{
1951 ModuleContext: ctx,
1952 moduleContextImpl: moduleContextImpl{
1953 mod: c,
1954 },
Chris Parsons8d6e4332021-02-22 16:13:50 -05001955 }
Chris Parsonsf874e462022-05-10 13:50:12 -04001956 mctx.ctx = mctx
1957
Jingwen Chen3952a902022-12-12 12:20:58 +00001958 // TODO(b/244432500): Get the tradefed config from the bazel target instead
1959 // of generating it with Soong.
Chris Parsonsf874e462022-05-10 13:50:12 -04001960 c.maybeInstall(mctx, apexInfo)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001961}
1962
1963func (c *Module) GenerateAndroidBuildActions(actx android.ModuleContext) {
Chris Parsons8d6e4332021-02-22 16:13:50 -05001964 // Handle the case of a test module split by `test_per_src` mutator.
1965 //
1966 // The `test_per_src` mutator adds an extra variation named "", depending on all the other
1967 // `test_per_src` variations of the test module. Set `outputFile` to an empty path for this
1968 // module and return early, as this module does not produce an output file per se.
1969 if c.IsTestPerSrcAllTestsVariation() {
1970 c.outputFile = android.OptionalPath{}
1971 return
1972 }
1973
Ivan Lozanof1868af2022-04-12 13:08:36 -04001974 c.Properties.SubName = GetSubnameProperty(actx, c)
Chris Parsons8d6e4332021-02-22 16:13:50 -05001975 apexInfo := actx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1976 if !apexInfo.IsForPlatform() {
1977 c.hideApexVariantFromMake = true
1978 }
1979
Chris Parsonseefc9e62021-04-02 17:36:47 -04001980 c.makeLinkType = GetMakeLinkType(actx, c)
1981
Colin Crossca860ac2016-01-04 14:34:37 -08001982 ctx := &moduleContext{
Colin Cross635c3b02016-05-18 15:37:25 -07001983 ModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08001984 moduleContextImpl: moduleContextImpl{
1985 mod: c,
1986 },
1987 }
1988 ctx.ctx = ctx
1989
Colin Crossf18e1102017-11-16 14:33:08 -08001990 deps := c.depsToPaths(ctx)
1991 if ctx.Failed() {
1992 return
1993 }
1994
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001995 if c.Properties.Clang != nil && *c.Properties.Clang == false {
1996 ctx.PropertyErrorf("clang", "false (GCC) is no longer supported")
Alixb5f6d9e2022-04-20 23:00:58 +00001997 } else if c.Properties.Clang != nil && !ctx.DeviceConfig().BuildBrokenClangProperty() {
1998 ctx.PropertyErrorf("clang", "property is deprecated, see Changes.md file")
Dan Willemsen8536d6b2018-10-07 20:54:34 -07001999 }
2000
Colin Crossca860ac2016-01-04 14:34:37 -08002001 flags := Flags{
2002 Toolchain: c.toolchain(ctx),
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002003 EmitXrefs: ctx.Config().EmitXrefRules(),
Colin Crossca860ac2016-01-04 14:34:37 -08002004 }
Colin Crossca860ac2016-01-04 14:34:37 -08002005 if c.compiler != nil {
Colin Crossf18e1102017-11-16 14:33:08 -08002006 flags = c.compiler.compilerFlags(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002007 }
2008 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002009 flags = c.linker.linkerFlags(ctx, flags)
Colin Crossca860ac2016-01-04 14:34:37 -08002010 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002011 if c.stl != nil {
2012 flags = c.stl.flags(ctx, flags)
2013 }
Colin Cross16b23492016-01-06 14:41:07 -08002014 if c.sanitize != nil {
2015 flags = c.sanitize.flags(ctx, flags)
2016 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002017 if c.coverage != nil {
Pirama Arumuga Nainar82fe59b2019-07-02 14:55:35 -07002018 flags, deps = c.coverage.flags(ctx, flags, deps)
Dan Willemsen581341d2017-02-09 16:16:31 -08002019 }
Cory Barkera1da26f2022-06-07 20:12:06 +00002020 if c.fuzzer != nil {
2021 flags = c.fuzzer.flags(ctx, flags)
2022 }
Stephen Craneba090d12017-05-09 15:44:35 -07002023 if c.lto != nil {
2024 flags = c.lto.flags(ctx, flags)
2025 }
Yi Kongeb8efc92021-12-09 18:06:29 +08002026 if c.afdo != nil {
2027 flags = c.afdo.flags(ctx, flags)
2028 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002029 if c.pgo != nil {
2030 flags = c.pgo.flags(ctx, flags)
2031 }
Colin Crossca860ac2016-01-04 14:34:37 -08002032 for _, feature := range c.features {
2033 flags = feature.flags(ctx, flags)
2034 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002035 if ctx.Failed() {
2036 return
2037 }
2038
Colin Cross4af21ed2019-11-04 09:37:55 -08002039 flags.Local.CFlags, _ = filterList(flags.Local.CFlags, config.IllegalFlags)
2040 flags.Local.CppFlags, _ = filterList(flags.Local.CppFlags, config.IllegalFlags)
2041 flags.Local.ConlyFlags, _ = filterList(flags.Local.ConlyFlags, config.IllegalFlags)
Colin Cross3f40fa42015-01-30 17:27:36 -08002042
Colin Cross4af21ed2019-11-04 09:37:55 -08002043 flags.Local.CommonFlags = append(flags.Local.CommonFlags, deps.Flags...)
Inseob Kim69378442019-06-03 19:10:47 +09002044
2045 for _, dir := range deps.IncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002046 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002047 }
2048 for _, dir := range deps.SystemIncludeDirs {
Colin Cross4af21ed2019-11-04 09:37:55 -08002049 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-isystem "+dir.String())
Inseob Kim69378442019-06-03 19:10:47 +09002050 }
2051
Colin Cross3e5e7782022-06-17 22:17:05 +00002052 flags.Local.LdFlags = append(flags.Local.LdFlags, deps.LdFlags...)
2053
Fabien Sanglardd61f1f42017-01-10 16:21:22 -08002054 c.flags = flags
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -07002055 // We need access to all the flags seen by a source file.
2056 if c.sabi != nil {
2057 flags = c.sabi.flags(ctx, flags)
2058 }
Dan Willemsen98ab3112019-08-27 21:20:40 -07002059
Colin Cross4af21ed2019-11-04 09:37:55 -08002060 flags.AssemblerWithCpp = inList("-xassembler-with-cpp", flags.Local.AsFlags)
Dan Willemsen98ab3112019-08-27 21:20:40 -07002061
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002062 var objs Objects
Colin Crossca860ac2016-01-04 14:34:37 -08002063 if c.compiler != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002064 objs = c.compiler.compile(ctx, flags, deps)
Colin Crossca860ac2016-01-04 14:34:37 -08002065 if ctx.Failed() {
2066 return
2067 }
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002068 c.kytheFiles = objs.kytheFiles
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002069 c.objFiles = objs.objFiles
2070 c.tidyFiles = objs.tidyFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08002071 }
2072
Colin Crossca860ac2016-01-04 14:34:37 -08002073 if c.linker != nil {
Dan Willemsen5cb580f2016-09-26 17:33:01 -07002074 outputFile := c.linker.link(ctx, flags, deps, objs)
Colin Crossca860ac2016-01-04 14:34:37 -08002075 if ctx.Failed() {
2076 return
2077 }
Colin Cross635c3b02016-05-18 15:37:25 -07002078 c.outputFile = android.OptionalPathForPath(outputFile)
Jiyong Parkb0788572018-12-20 22:10:17 +09002079
Chris Parsons94a0bba2021-06-04 15:03:47 -04002080 c.maybeUnhideFromMake()
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002081
Jose Galmes6f843bc2020-12-11 13:36:29 -08002082 // glob exported headers for snapshot, if BOARD_VNDK_VERSION is current or
2083 // RECOVERY_SNAPSHOT_VERSION is current.
2084 if i, ok := c.linker.(snapshotLibraryInterface); ok {
Ivan Lozanod7586b62021-04-01 09:49:36 -04002085 if ShouldCollectHeadersForSnapshot(ctx, c, apexInfo) {
Inseob Kimeda2e9c2020-03-03 22:06:32 +09002086 i.collectHeadersForSnapshot(ctx)
2087 }
2088 }
Colin Crossce75d2c2016-10-06 16:12:58 -07002089 }
Colin Cross5049f022015-03-18 13:28:46 -07002090
Chris Parsons94a0bba2021-06-04 15:03:47 -04002091 c.maybeInstall(ctx, apexInfo)
2092}
2093
2094func (c *Module) maybeUnhideFromMake() {
2095 // If a lib is directly included in any of the APEXes or is not available to the
2096 // platform (which is often the case when the stub is provided as a prebuilt),
2097 // unhide the stubs variant having the latest version gets visible to make. In
2098 // addition, the non-stubs variant is renamed to <libname>.bootstrap. This is to
2099 // force anything in the make world to link against the stubs library. (unless it
2100 // is explicitly referenced via .bootstrap suffix or the module is marked with
2101 // 'bootstrap: true').
2102 if c.HasStubsVariants() && c.NotInPlatform() && !c.InRamdisk() &&
2103 !c.InRecovery() && !c.UseVndk() && !c.static() && !c.isCoverageVariant() &&
2104 c.IsStubs() && !c.InVendorRamdisk() {
2105 c.Properties.HideFromMake = false // unhide
2106 // Note: this is still non-installable
2107 }
2108}
2109
Jingwen Chen3952a902022-12-12 12:20:58 +00002110// maybeInstall is called at the end of both GenerateAndroidBuildActions and
2111// ProcessBazelQueryResponse to run the install hooks for installable modules,
2112// like binaries and tests.
Chris Parsons94a0bba2021-06-04 15:03:47 -04002113func (c *Module) maybeInstall(ctx ModuleContext, apexInfo android.ApexInfo) {
Colin Cross1bc94122021-10-28 13:25:54 -07002114 if !proptools.BoolDefault(c.Installable(), true) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002115 // If the module has been specifically configure to not be installed then
2116 // hide from make as otherwise it will break when running inside make
2117 // as the output path to install will not be specified. Not all uninstallable
2118 // modules can be hidden from make as some are needed for resolving make side
2119 // dependencies.
2120 c.HideFromMake()
Ivan Lozanod7586b62021-04-01 09:49:36 -04002121 } else if !installable(c, apexInfo) {
Colin Crossa9c8c9f2020-12-16 10:20:23 -08002122 c.SkipInstall()
2123 }
2124
2125 // Still call c.installer.install though, the installs will be stored as PackageSpecs
2126 // to allow using the outputs in a genrule.
2127 if c.installer != nil && c.outputFile.Valid() {
Colin Crossce75d2c2016-10-06 16:12:58 -07002128 c.installer.install(ctx, c.outputFile.Path())
2129 if ctx.Failed() {
2130 return
Colin Crossca860ac2016-01-04 14:34:37 -08002131 }
Dan Albertc403f7c2015-03-18 14:01:18 -07002132 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002133}
2134
Sam Delmerico5fb794a2023-01-27 16:01:37 -05002135func (c *Module) setAndroidMkVariablesFromCquery(info cquery.CcAndroidMkInfo) {
2136 c.Properties.AndroidMkSharedLibs = info.LocalSharedLibs
2137 c.Properties.AndroidMkStaticLibs = info.LocalStaticLibs
2138 c.Properties.AndroidMkWholeStaticLibs = info.LocalWholeStaticLibs
2139}
2140
Colin Cross0ea8ba82019-06-06 14:33:29 -07002141func (c *Module) toolchain(ctx android.BaseModuleContext) config.Toolchain {
Colin Crossca860ac2016-01-04 14:34:37 -08002142 if c.cachedToolchain == nil {
Liz Kammer356f7d42021-01-26 09:18:53 -05002143 c.cachedToolchain = config.FindToolchainWithContext(ctx)
Colin Cross3f40fa42015-01-30 17:27:36 -08002144 }
Colin Crossca860ac2016-01-04 14:34:37 -08002145 return c.cachedToolchain
Colin Cross3f40fa42015-01-30 17:27:36 -08002146}
2147
Colin Crossca860ac2016-01-04 14:34:37 -08002148func (c *Module) begin(ctx BaseModuleContext) {
2149 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002150 c.compiler.compilerInit(ctx)
Colin Cross21b9a242015-03-24 14:15:58 -07002151 }
Colin Crossca860ac2016-01-04 14:34:37 -08002152 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002153 c.linker.linkerInit(ctx)
Colin Crossca860ac2016-01-04 14:34:37 -08002154 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002155 if c.stl != nil {
2156 c.stl.begin(ctx)
2157 }
Colin Cross16b23492016-01-06 14:41:07 -08002158 if c.sanitize != nil {
2159 c.sanitize.begin(ctx)
2160 }
Dan Willemsen581341d2017-02-09 16:16:31 -08002161 if c.coverage != nil {
2162 c.coverage.begin(ctx)
2163 }
Stephen Craneba090d12017-05-09 15:44:35 -07002164 if c.lto != nil {
2165 c.lto.begin(ctx)
2166 }
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07002167 if c.pgo != nil {
2168 c.pgo.begin(ctx)
2169 }
Dan Albert92fe7402020-07-15 13:33:30 -07002170 if ctx.useSdk() && c.IsSdkVariant() {
Dan Albert1a246272020-07-06 14:49:35 -07002171 version, err := nativeApiLevelFromUser(ctx, ctx.sdkVersion())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002172 if err != nil {
2173 ctx.PropertyErrorf("sdk_version", err.Error())
Dan Albert1a246272020-07-06 14:49:35 -07002174 c.Properties.Sdk_version = nil
2175 } else {
2176 c.Properties.Sdk_version = StringPtr(version.String())
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002177 }
Dan Albert7fa7b2e2016-08-05 16:37:52 -07002178 }
Colin Crossca860ac2016-01-04 14:34:37 -08002179}
2180
Colin Cross37047f12016-12-13 17:06:13 -08002181func (c *Module) deps(ctx DepsContext) Deps {
Colin Crossc99deeb2016-04-11 15:06:20 -07002182 deps := Deps{}
2183
2184 if c.compiler != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002185 deps = c.compiler.compilerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002186 }
2187 if c.linker != nil {
Colin Cross42742b82016-08-01 13:20:05 -07002188 deps = c.linker.linkerDeps(ctx, deps)
Colin Crossc99deeb2016-04-11 15:06:20 -07002189 }
Colin Crossa8e07cc2016-04-04 15:07:06 -07002190 if c.stl != nil {
2191 deps = c.stl.deps(ctx, deps)
2192 }
Pirama Arumuga Nainar0b882f02018-04-23 22:44:39 +00002193 if c.coverage != nil {
2194 deps = c.coverage.deps(ctx, deps)
2195 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002196
Colin Crossb6715442017-10-24 11:13:31 -07002197 deps.WholeStaticLibs = android.LastUniqueStrings(deps.WholeStaticLibs)
2198 deps.StaticLibs = android.LastUniqueStrings(deps.StaticLibs)
2199 deps.LateStaticLibs = android.LastUniqueStrings(deps.LateStaticLibs)
2200 deps.SharedLibs = android.LastUniqueStrings(deps.SharedLibs)
2201 deps.LateSharedLibs = android.LastUniqueStrings(deps.LateSharedLibs)
2202 deps.HeaderLibs = android.LastUniqueStrings(deps.HeaderLibs)
Logan Chien43d34c32017-12-20 01:17:32 +08002203 deps.RuntimeLibs = android.LastUniqueStrings(deps.RuntimeLibs)
Colin Crossc99deeb2016-04-11 15:06:20 -07002204
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002205 for _, lib := range deps.ReexportSharedLibHeaders {
2206 if !inList(lib, deps.SharedLibs) {
2207 ctx.PropertyErrorf("export_shared_lib_headers", "Shared library not in shared_libs: '%s'", lib)
2208 }
2209 }
2210
2211 for _, lib := range deps.ReexportStaticLibHeaders {
Steven Morelandba407c82021-04-01 22:17:50 +00002212 if !inList(lib, deps.StaticLibs) && !inList(lib, deps.WholeStaticLibs) {
2213 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 -07002214 }
2215 }
2216
Colin Cross5950f382016-12-13 12:50:57 -08002217 for _, lib := range deps.ReexportHeaderLibHeaders {
2218 if !inList(lib, deps.HeaderLibs) {
2219 ctx.PropertyErrorf("export_header_lib_headers", "Header library not in header_libs: '%s'", lib)
2220 }
2221 }
2222
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002223 for _, gen := range deps.ReexportGeneratedHeaders {
2224 if !inList(gen, deps.GeneratedHeaders) {
2225 ctx.PropertyErrorf("export_generated_headers", "Generated header module not in generated_headers: '%s'", gen)
2226 }
2227 }
2228
Colin Crossc99deeb2016-04-11 15:06:20 -07002229 return deps
2230}
2231
Dan Albert7e9d2952016-08-04 13:02:36 -07002232func (c *Module) beginMutator(actx android.BottomUpMutatorContext) {
Colin Crossca860ac2016-01-04 14:34:37 -08002233 ctx := &baseModuleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07002234 BaseModuleContext: actx,
Colin Crossca860ac2016-01-04 14:34:37 -08002235 moduleContextImpl: moduleContextImpl{
2236 mod: c,
2237 },
2238 }
2239 ctx.ctx = ctx
2240
Vinh Tran44cb78c2023-03-09 22:07:19 -05002241 if !actx.Host() || !ctx.static() || ctx.staticBinary() {
2242 c.afdo.addDep(ctx, actx)
2243 }
2244
Colin Crossca860ac2016-01-04 14:34:37 -08002245 c.begin(ctx)
Dan Albert7e9d2952016-08-04 13:02:36 -07002246}
2247
Jiyong Park7ed9de32018-10-15 22:25:07 +09002248// Split name#version into name and version
Jiyong Park73c54ee2019-10-22 20:31:18 +09002249func StubsLibNameAndVersion(name string) (string, string) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002250 if sharp := strings.LastIndex(name, "#"); sharp != -1 && sharp != len(name)-1 {
2251 version := name[sharp+1:]
2252 libname := name[:sharp]
2253 return libname, version
2254 }
2255 return name, ""
2256}
2257
Dan Albert92fe7402020-07-15 13:33:30 -07002258func GetCrtVariations(ctx android.BottomUpMutatorContext,
2259 m LinkableInterface) []blueprint.Variation {
2260 if ctx.Os() != android.Android {
2261 return nil
2262 }
2263 if m.UseSdk() {
Jiyong Parkfdaa5f72021-03-19 22:18:04 +09002264 // Choose the CRT that best satisfies the min_sdk_version requirement of this module
2265 minSdkVersion := m.MinSdkVersion()
2266 if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
2267 minSdkVersion = m.SdkVersion()
2268 }
Jooyung Han94a76ee2021-06-08 09:49:48 +09002269 apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
2270 if err != nil {
2271 ctx.PropertyErrorf("min_sdk_version", err.Error())
2272 }
Colin Cross363ec762023-01-13 13:45:14 -08002273
2274 // Raise the minSdkVersion to the minimum supported for the architecture.
Colin Crossbb137a32023-01-26 09:54:42 -08002275 minApiForArch := MinApiForArch(ctx, m.Target().Arch.ArchType)
Colin Cross363ec762023-01-13 13:45:14 -08002276 if apiLevel.LessThan(minApiForArch) {
2277 apiLevel = minApiForArch
2278 }
2279
Dan Albert92fe7402020-07-15 13:33:30 -07002280 return []blueprint.Variation{
2281 {Mutator: "sdk", Variation: "sdk"},
Jooyung Han94a76ee2021-06-08 09:49:48 +09002282 {Mutator: "version", Variation: apiLevel.String()},
Dan Albert92fe7402020-07-15 13:33:30 -07002283 }
2284 }
2285 return []blueprint.Variation{
2286 {Mutator: "sdk", Variation: ""},
2287 }
2288}
2289
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002290func AddSharedLibDependenciesWithVersions(ctx android.BottomUpMutatorContext, mod LinkableInterface,
2291 variations []blueprint.Variation, depTag blueprint.DependencyTag, name, version string, far bool) {
Colin Crosse7257d22020-09-24 09:56:18 -07002292
2293 variations = append([]blueprint.Variation(nil), variations...)
2294
Liz Kammer23942242022-04-08 15:41:00 -04002295 if version != "" && canBeOrLinkAgainstVersionVariants(mod) {
Colin Crosse7257d22020-09-24 09:56:18 -07002296 // Version is explicitly specified. i.e. libFoo#30
2297 variations = append(variations, blueprint.Variation{Mutator: "version", Variation: version})
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002298 if tag, ok := depTag.(libraryDependencyTag); ok {
2299 tag.explicitlyVersioned = true
2300 } else {
2301 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
2302 }
Colin Crosse7257d22020-09-24 09:56:18 -07002303 }
Colin Crosse7257d22020-09-24 09:56:18 -07002304
Colin Cross0de8a1e2020-09-18 14:15:30 -07002305 if far {
2306 ctx.AddFarVariationDependencies(variations, depTag, name)
2307 } else {
2308 ctx.AddVariationDependencies(variations, depTag, name)
Colin Crosse7257d22020-09-24 09:56:18 -07002309 }
2310}
2311
Kiyoung Kim487689e2022-07-26 09:48:22 +09002312func GetApiImports(c LinkableInterface, actx android.BottomUpMutatorContext) multitree.ApiImportInfo {
2313 apiImportInfo := multitree.ApiImportInfo{}
2314
2315 if c.Device() {
2316 var apiImportModule []blueprint.Module
2317 if actx.OtherModuleExists("api_imports") {
2318 apiImportModule = actx.AddDependency(c, nil, "api_imports")
2319 if len(apiImportModule) > 0 && apiImportModule[0] != nil {
2320 apiInfo := actx.OtherModuleProvider(apiImportModule[0], multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2321 apiImportInfo = apiInfo
2322 actx.SetProvider(multitree.ApiImportsProvider, apiInfo)
2323 }
2324 }
2325 }
2326
2327 return apiImportInfo
2328}
2329
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002330func GetSnapshot(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext) SnapshotInfo {
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002331 // Only device modules with BOARD_VNDK_VERSION uses snapshot. Others use the zero value of
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002332 // SnapshotInfo, which provides no mappings.
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002333 if *snapshotInfo == nil && c.Device() {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002334 // Only retrieve the snapshot on demand in order to avoid circular dependencies
2335 // between the modules in the snapshot and the snapshot itself.
2336 var snapshotModule []blueprint.Module
2337 if c.InVendor() && c.VndkVersion() == actx.DeviceConfig().VndkVersion() {
2338 snapshotModule = actx.AddVariationDependencies(nil, nil, "vendor_snapshot")
2339 } else if recoverySnapshotVersion := actx.DeviceConfig().RecoverySnapshotVersion(); recoverySnapshotVersion != "current" && recoverySnapshotVersion != "" && c.InRecovery() {
2340 snapshotModule = actx.AddVariationDependencies(nil, nil, "recovery_snapshot")
2341 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002342 if len(snapshotModule) > 0 && snapshotModule[0] != nil {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002343 snapshot := actx.OtherModuleProvider(snapshotModule[0], SnapshotInfoProvider).(SnapshotInfo)
2344 *snapshotInfo = &snapshot
2345 // republish the snapshot for use in later mutators on this module
2346 actx.SetProvider(SnapshotInfoProvider, snapshot)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002347 }
2348 }
Yi-Yo Chiangec14a4d2021-07-02 21:26:00 +08002349 if *snapshotInfo == nil {
2350 *snapshotInfo = &SnapshotInfo{}
2351 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002352 return **snapshotInfo
2353}
2354
Kiyoung Kim487689e2022-07-26 09:48:22 +09002355func GetReplaceModuleName(lib string, replaceMap map[string]string) string {
2356 if snapshot, ok := replaceMap[lib]; ok {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002357 return snapshot
2358 }
2359
2360 return lib
2361}
2362
2363// RewriteLibs takes a list of names of shared libraries and scans it for three types
2364// of names:
2365//
2366// 1. Name of an NDK library that refers to a prebuilt module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002367//
2368// For each of these, it adds the name of the prebuilt module (which will be in
2369// prebuilts/ndk) to the list of nonvariant libs.
2370//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002371// 2. Name of an NDK library that refers to an ndk_library module.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002372//
2373// For each of these, it adds the name of the ndk_library module to the list of
2374// variant libs.
2375//
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002376// 3. Anything else (so anything that isn't an NDK library).
Kiyoung Kim487689e2022-07-26 09:48:22 +09002377//
2378// It adds these to the nonvariantLibs list.
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002379//
2380// The caller can then know to add the variantLibs dependencies differently from the
2381// nonvariantLibs
2382func RewriteLibs(c LinkableInterface, snapshotInfo **SnapshotInfo, actx android.BottomUpMutatorContext, config android.Config, list []string) (nonvariantLibs []string, variantLibs []string) {
2383 variantLibs = []string{}
2384
2385 nonvariantLibs = []string{}
2386 for _, entry := range list {
2387 // strip #version suffix out
2388 name, _ := StubsLibNameAndVersion(entry)
2389 if c.InRecovery() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002390 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002391 } else if c.UseSdk() && inList(name, *getNDKKnownLibs(config)) {
2392 variantLibs = append(variantLibs, name+ndkLibrarySuffix)
2393 } else if c.UseVndk() {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002394 nonvariantLibs = append(nonvariantLibs, GetReplaceModuleName(entry, GetSnapshot(c, snapshotInfo, actx).SharedLibs))
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002395 } else {
2396 // put name#version back
2397 nonvariantLibs = append(nonvariantLibs, entry)
2398 }
2399 }
2400 return nonvariantLibs, variantLibs
2401}
2402
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002403func rewriteLibsForApiImports(c LinkableInterface, libs []string, replaceList map[string]string, config android.Config) ([]string, []string) {
2404 nonVariantLibs := []string{}
2405 variantLibs := []string{}
2406
2407 for _, lib := range libs {
2408 replaceLibName := GetReplaceModuleName(lib, replaceList)
2409 if replaceLibName == lib {
2410 // Do not handle any libs which are not in API imports
2411 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2412 } else if c.UseSdk() && inList(replaceLibName, *getNDKKnownLibs(config)) {
2413 variantLibs = append(variantLibs, replaceLibName)
2414 } else {
2415 nonVariantLibs = append(nonVariantLibs, replaceLibName)
2416 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002417 }
2418
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002419 return nonVariantLibs, variantLibs
Kiyoung Kim487689e2022-07-26 09:48:22 +09002420}
2421
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002422func (c *Module) shouldUseApiSurface() bool {
2423 if c.Os() == android.Android && c.Target().NativeBridge != android.NativeBridgeEnabled {
2424 if GetImageVariantType(c) == vendorImageVariant || GetImageVariantType(c) == productImageVariant {
2425 // LLNDK Variant
2426 return true
2427 }
2428
2429 if c.Properties.IsSdkVariant {
2430 // NDK Variant
2431 return true
2432 }
2433
2434 if c.isImportedApiLibrary() {
2435 // API Library should depend on API headers
2436 return true
2437 }
2438 }
2439
2440 return false
2441}
2442
Colin Cross1e676be2016-10-12 14:38:15 -07002443func (c *Module) DepsMutator(actx android.BottomUpMutatorContext) {
Inseob Kimeec88e12020-01-22 11:11:29 +09002444 if !c.Enabled() {
2445 return
2446 }
2447
Colin Cross37047f12016-12-13 17:06:13 -08002448 ctx := &depsContext{
2449 BottomUpMutatorContext: actx,
Dan Albert7e9d2952016-08-04 13:02:36 -07002450 moduleContextImpl: moduleContextImpl{
2451 mod: c,
2452 },
2453 }
2454 ctx.ctx = ctx
Colin Crossca860ac2016-01-04 14:34:37 -08002455
Colin Crossc99deeb2016-04-11 15:06:20 -07002456 deps := c.deps(ctx)
Kiyoung Kim487689e2022-07-26 09:48:22 +09002457 apiImportInfo := GetApiImports(c, actx)
Kiyoung Kim11d91082022-10-19 19:20:57 +09002458
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002459 apiNdkLibs := []string{}
2460 apiLateNdkLibs := []string{}
2461
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002462 if c.shouldUseApiSurface() {
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002463 deps.SharedLibs, apiNdkLibs = rewriteLibsForApiImports(c, deps.SharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2464 deps.LateSharedLibs, apiLateNdkLibs = rewriteLibsForApiImports(c, deps.LateSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2465 deps.SystemSharedLibs, _ = rewriteLibsForApiImports(c, deps.SystemSharedLibs, apiImportInfo.SharedLibs, ctx.Config())
2466 deps.ReexportHeaderLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportHeaderLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
2467 deps.ReexportSharedLibHeaders, _ = rewriteLibsForApiImports(c, deps.ReexportSharedLibHeaders, apiImportInfo.SharedLibs, ctx.Config())
Kiyoung Kim11d91082022-10-19 19:20:57 +09002468 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002469
Yo Chiang219968c2020-09-22 18:45:04 +08002470 c.Properties.AndroidMkSystemSharedLibs = deps.SystemSharedLibs
2471
Colin Crosse0edaf92021-01-11 17:31:17 -08002472 var snapshotInfo *SnapshotInfo
Colin Crosse0edaf92021-01-11 17:31:17 -08002473
Dan Albert914449f2016-06-17 16:45:24 -07002474 variantNdkLibs := []string{}
2475 variantLateNdkLibs := []string{}
Dan Willemsenb916b802017-03-19 13:44:32 -07002476 if ctx.Os() == android.Android {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002477 deps.SharedLibs, variantNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.SharedLibs)
2478 deps.LateSharedLibs, variantLateNdkLibs = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.LateSharedLibs)
2479 deps.ReexportSharedLibHeaders, _ = RewriteLibs(c, &snapshotInfo, actx, ctx.Config(), deps.ReexportSharedLibHeaders)
Colin Crosse0edaf92021-01-11 17:31:17 -08002480
2481 for idx, lib := range deps.RuntimeLibs {
Kiyoung Kim487689e2022-07-26 09:48:22 +09002482 deps.RuntimeLibs[idx] = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).SharedLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002483 }
Dan Willemsen72d39932016-07-08 23:23:48 -07002484 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002485
Colin Cross32ec36c2016-12-15 07:39:51 -08002486 for _, lib := range deps.HeaderLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002487 depTag := libraryDependencyTag{Kind: headerLibraryDependency}
Colin Cross32ec36c2016-12-15 07:39:51 -08002488 if inList(lib, deps.ReexportHeaderLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002489 depTag.reexportFlags = true
Colin Cross32ec36c2016-12-15 07:39:51 -08002490 }
Inseob Kimeec88e12020-01-22 11:11:29 +09002491
Kiyoung Kim51279d32022-08-24 14:10:46 +09002492 // Check header lib replacement from API surface first, and then check again with VSDK
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002493 if c.shouldUseApiSurface() {
Kiyoung Kim11d91082022-10-19 19:20:57 +09002494 lib = GetReplaceModuleName(lib, apiImportInfo.HeaderLibs)
2495 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09002496 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).HeaderLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002497
Spandan Das73bcafc2022-08-18 23:26:00 +00002498 if c.isNDKStubLibrary() {
2499 // ndk_headers do not have any variations
2500 actx.AddFarVariationDependencies([]blueprint.Variation{}, depTag, lib)
Kiyoung Kim51279d32022-08-24 14:10:46 +09002501 } else if c.IsStubs() && !c.isImportedApiLibrary() {
Colin Cross7228ecd2019-11-18 16:00:16 -08002502 actx.AddFarVariationDependencies(append(ctx.Target().Variations(), c.ImageVariation()),
Colin Cross0f7d2ef2019-10-16 11:03:10 -07002503 depTag, lib)
Jiyong Park7e636d02019-01-28 16:16:54 +09002504 } else {
2505 actx.AddVariationDependencies(nil, depTag, lib)
2506 }
2507 }
2508
Dan Albertf1d14c72020-07-30 14:32:55 -07002509 if c.isNDKStubLibrary() {
2510 // NDK stubs depend on their implementation because the ABI dumps are
2511 // generated from the implementation library.
Kiyoung Kim487689e2022-07-26 09:48:22 +09002512
Spandan Das8b08aea2023-03-14 19:29:34 +00002513 actx.AddFarVariationDependencies(append(ctx.Target().Variations(),
2514 c.ImageVariation(),
2515 blueprint.Variation{Mutator: "link", Variation: "shared"},
2516 ), stubImplementation, c.BaseModuleName())
Dan Albertf1d14c72020-07-30 14:32:55 -07002517 }
2518
Jiyong Park5d1598f2019-02-25 22:14:17 +09002519 for _, lib := range deps.WholeStaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002520 depTag := libraryDependencyTag{Kind: staticLibraryDependency, wholeStatic: true, reexportFlags: true}
Inseob Kimeec88e12020-01-22 11:11:29 +09002521
Kiyoung Kim487689e2022-07-26 09:48:22 +09002522 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002523
Jiyong Park5d1598f2019-02-25 22:14:17 +09002524 actx.AddVariationDependencies([]blueprint.Variation{
2525 {Mutator: "link", Variation: "static"},
2526 }, depTag, lib)
2527 }
2528
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002529 for _, lib := range deps.StaticLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002530 depTag := libraryDependencyTag{Kind: staticLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002531 if inList(lib, deps.ReexportStaticLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002532 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002533 }
Jiyong Parke3867542020-12-03 17:28:25 +09002534 if inList(lib, deps.ExcludeLibsForApex) {
2535 depTag.excludeInApex = true
2536 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002537
Kiyoung Kim487689e2022-07-26 09:48:22 +09002538 lib = GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs)
Inseob Kimeec88e12020-01-22 11:11:29 +09002539
Dan Willemsen59339a22018-07-22 21:18:45 -07002540 actx.AddVariationDependencies([]blueprint.Variation{
2541 {Mutator: "link", Variation: "static"},
2542 }, depTag, lib)
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002543 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002544
Jooyung Han75568392020-03-20 04:29:24 +09002545 // staticUnwinderDep is treated as staticDep for Q apexes
2546 // so that native libraries/binaries are linked with static unwinder
2547 // because Q libc doesn't have unwinder APIs
2548 if deps.StaticUnwinderIfLegacy {
Colin Cross6e511a92020-07-27 21:26:48 -07002549 depTag := libraryDependencyTag{Kind: staticLibraryDependency, staticUnwinder: true}
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002550 actx.AddVariationDependencies([]blueprint.Variation{
2551 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002552 }, depTag, GetReplaceModuleName(staticUnwinder(actx), GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Peter Collingbournedc4f9862020-02-12 17:13:25 -08002553 }
2554
Jiyong Park7ed9de32018-10-15 22:25:07 +09002555 // shared lib names without the #version suffix
2556 var sharedLibNames []string
2557
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002558 for _, lib := range deps.SharedLibs {
Colin Cross6e511a92020-07-27 21:26:48 -07002559 depTag := libraryDependencyTag{Kind: sharedLibraryDependency}
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002560 if inList(lib, deps.ReexportSharedLibHeaders) {
Colin Cross6e511a92020-07-27 21:26:48 -07002561 depTag.reexportFlags = true
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002562 }
Jiyong Parke3867542020-12-03 17:28:25 +09002563 if inList(lib, deps.ExcludeLibsForApex) {
2564 depTag.excludeInApex = true
2565 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002566
Jiyong Park73c54ee2019-10-22 20:31:18 +09002567 name, version := StubsLibNameAndVersion(lib)
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002568 if apiLibraryName, ok := apiImportInfo.SharedLibs[name]; ok && !ctx.OtherModuleExists(name) {
2569 name = apiLibraryName
2570 }
Inseob Kimc0907f12019-02-08 21:00:45 +09002571 sharedLibNames = append(sharedLibNames, name)
2572
Colin Crosse7257d22020-09-24 09:56:18 -07002573 variations := []blueprint.Variation{
2574 {Mutator: "link", Variation: "shared"},
2575 }
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002576
2577 if _, ok := apiImportInfo.ApexSharedLibs[name]; !ok || ctx.OtherModuleExists(name) {
2578 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, name, version, false)
2579 }
2580
2581 if apiLibraryName, ok := apiImportInfo.ApexSharedLibs[name]; ok {
2582 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, apiLibraryName, version, false)
2583 }
Dan Willemsen490a8dc2016-06-06 18:22:19 -07002584 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002585
Colin Crossfe9acfe2021-06-14 16:13:03 -07002586 for _, lib := range deps.LateStaticLibs {
2587 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency}
2588 actx.AddVariationDependencies([]blueprint.Variation{
2589 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002590 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Crossfe9acfe2021-06-14 16:13:03 -07002591 }
2592
Colin Cross3e5e7782022-06-17 22:17:05 +00002593 for _, lib := range deps.UnexportedStaticLibs {
2594 depTag := libraryDependencyTag{Kind: staticLibraryDependency, Order: lateLibraryDependency, unexportedSymbols: true}
2595 actx.AddVariationDependencies([]blueprint.Variation{
2596 {Mutator: "link", Variation: "static"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002597 }, depTag, GetReplaceModuleName(lib, GetSnapshot(c, &snapshotInfo, actx).StaticLibs))
Colin Cross3e5e7782022-06-17 22:17:05 +00002598 }
2599
Jiyong Park7ed9de32018-10-15 22:25:07 +09002600 for _, lib := range deps.LateSharedLibs {
Jiyong Park25fc6a92018-11-18 18:02:45 +09002601 if inList(lib, sharedLibNames) {
Jiyong Park7ed9de32018-10-15 22:25:07 +09002602 // This is to handle the case that some of the late shared libs (libc, libdl, libm, ...)
2603 // are added also to SharedLibs with version (e.g., libc#10). If not skipped, we will be
2604 // linking against both the stubs lib and the non-stubs lib at the same time.
2605 continue
2606 }
Colin Cross6e511a92020-07-27 21:26:48 -07002607 depTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency}
Colin Crosse7257d22020-09-24 09:56:18 -07002608 variations := []blueprint.Variation{
2609 {Mutator: "link", Variation: "shared"},
2610 }
Ivan Lozanod67a6b02021-05-20 13:01:32 -04002611 AddSharedLibDependenciesWithVersions(ctx, c, variations, depTag, lib, "", false)
Jiyong Park7ed9de32018-10-15 22:25:07 +09002612 }
Colin Crossc99deeb2016-04-11 15:06:20 -07002613
Dan Willemsen59339a22018-07-22 21:18:45 -07002614 actx.AddVariationDependencies([]blueprint.Variation{
2615 {Mutator: "link", Variation: "shared"},
Chris Parsons79d66a52020-06-05 17:26:16 -04002616 }, dataLibDepTag, deps.DataLibs...)
2617
Colin Crossc8caa062021-09-24 16:50:14 -07002618 actx.AddVariationDependencies(nil, dataBinDepTag, deps.DataBins...)
2619
Chris Parsons79d66a52020-06-05 17:26:16 -04002620 actx.AddVariationDependencies([]blueprint.Variation{
2621 {Mutator: "link", Variation: "shared"},
Dan Willemsen59339a22018-07-22 21:18:45 -07002622 }, runtimeDepTag, deps.RuntimeLibs...)
Logan Chien43d34c32017-12-20 01:17:32 +08002623
Colin Cross68861832016-07-08 10:41:41 -07002624 actx.AddDependency(c, genSourceDepTag, deps.GeneratedSources...)
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002625
2626 for _, gen := range deps.GeneratedHeaders {
2627 depTag := genHeaderDepTag
2628 if inList(gen, deps.ReexportGeneratedHeaders) {
2629 depTag = genHeaderExportDepTag
2630 }
2631 actx.AddDependency(c, depTag, gen)
2632 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07002633
Dan Albert92fe7402020-07-15 13:33:30 -07002634 crtVariations := GetCrtVariations(ctx, c)
Colin Crossbbc941b2020-09-30 12:27:01 -07002635 actx.AddVariationDependencies(crtVariations, objDepTag, deps.ObjFiles...)
Colin Crossc465efd2021-06-11 18:00:04 -07002636 for _, crt := range deps.CrtBegin {
Dan Albert92fe7402020-07-15 13:33:30 -07002637 actx.AddVariationDependencies(crtVariations, CrtBeginDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002638 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Crossca860ac2016-01-04 14:34:37 -08002639 }
Colin Crossc465efd2021-06-11 18:00:04 -07002640 for _, crt := range deps.CrtEnd {
Dan Albert92fe7402020-07-15 13:33:30 -07002641 actx.AddVariationDependencies(crtVariations, CrtEndDepTag,
Kiyoung Kim487689e2022-07-26 09:48:22 +09002642 GetReplaceModuleName(crt, GetSnapshot(c, &snapshotInfo, actx).Objects))
Colin Cross21b9a242015-03-24 14:15:58 -07002643 }
Dan Willemsena0790e32018-10-12 00:24:23 -07002644 if deps.DynamicLinker != "" {
2645 actx.AddDependency(c, dynamicLinkerDepTag, deps.DynamicLinker)
Dan Willemsenc77a0b32017-09-18 23:19:12 -07002646 }
Dan Albert914449f2016-06-17 16:45:24 -07002647
2648 version := ctx.sdkVersion()
Colin Cross6e511a92020-07-27 21:26:48 -07002649
2650 ndkStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002651 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002652 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002653 {Mutator: "link", Variation: "shared"},
2654 }, ndkStubDepTag, variantNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002655 actx.AddVariationDependencies([]blueprint.Variation{
2656 {Mutator: "version", Variation: version},
2657 {Mutator: "link", Variation: "shared"},
2658 }, ndkStubDepTag, apiNdkLibs...)
Colin Cross6e511a92020-07-27 21:26:48 -07002659
2660 ndkLateStubDepTag := libraryDependencyTag{Kind: sharedLibraryDependency, Order: lateLibraryDependency, ndk: true, makeSuffix: "." + version}
Dan Albert914449f2016-06-17 16:45:24 -07002661 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross5ec407b2020-09-30 11:41:33 -07002662 {Mutator: "version", Variation: version},
Dan Willemsen59339a22018-07-22 21:18:45 -07002663 {Mutator: "link", Variation: "shared"},
2664 }, ndkLateStubDepTag, variantLateNdkLibs...)
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002665 actx.AddVariationDependencies([]blueprint.Variation{
2666 {Mutator: "version", Variation: version},
2667 {Mutator: "link", Variation: "shared"},
2668 }, ndkLateStubDepTag, apiLateNdkLibs...)
Logan Chienf3511742017-10-31 18:04:35 +08002669
2670 if vndkdep := c.vndkdep; vndkdep != nil {
2671 if vndkdep.isVndkExt() {
Logan Chienf3511742017-10-31 18:04:35 +08002672 actx.AddVariationDependencies([]blueprint.Variation{
Colin Cross7228ecd2019-11-18 16:00:16 -08002673 c.ImageVariation(),
Dan Willemsen59339a22018-07-22 21:18:45 -07002674 {Mutator: "link", Variation: "shared"},
Kiyoung Kim487689e2022-07-26 09:48:22 +09002675 }, vndkExtDepTag, GetReplaceModuleName(vndkdep.getVndkExtendsModuleName(), GetSnapshot(c, &snapshotInfo, actx).SharedLibs))
Logan Chienf3511742017-10-31 18:04:35 +08002676 }
2677 }
Kiyoung Kimee58c932022-10-25 22:59:41 +09002678
2679 updateImportedLibraryDependency(ctx)
Colin Cross6362e272015-10-29 15:25:03 -07002680}
Colin Cross21b9a242015-03-24 14:15:58 -07002681
Colin Crosse40b4ea2018-10-02 22:25:58 -07002682func BeginMutator(ctx android.BottomUpMutatorContext) {
Dan Albert7e9d2952016-08-04 13:02:36 -07002683 if c, ok := ctx.Module().(*Module); ok && c.Enabled() {
2684 c.beginMutator(ctx)
2685 }
2686}
2687
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002688// Whether a module can link to another module, taking into
2689// account NDK linking.
Jooyung Han479ca172020-10-19 18:51:07 +09002690func checkLinkType(ctx android.BaseModuleContext, from LinkableInterface, to LinkableInterface,
Colin Cross6e511a92020-07-27 21:26:48 -07002691 tag blueprint.DependencyTag) {
2692
2693 switch t := tag.(type) {
2694 case dependencyTag:
2695 if t != vndkExtDepTag {
2696 return
2697 }
2698 case libraryDependencyTag:
2699 default:
2700 return
2701 }
2702
Ivan Lozanof9e21722020-12-02 09:00:51 -05002703 if from.Target().Os != android.Android {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002704 // Host code is not restricted
2705 return
2706 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002707
2708 // VNDK is cc.Module supported only for now.
2709 if ccFrom, ok := from.(*Module); ok && from.UseVndk() {
Justin Yun63e9ec72020-10-29 16:49:43 +09002710 // Though allowed dependency is limited by the image mutator,
2711 // each vendor and product module needs to check link-type
2712 // for VNDK.
Ivan Lozano52767be2019-10-18 14:49:46 -07002713 if ccTo, ok := to.(*Module); ok {
2714 if ccFrom.vndkdep != nil {
2715 ccFrom.vndkdep.vndkCheckLinkType(ctx, ccTo, tag)
2716 }
Ivan Lozanoc08897c2021-04-02 12:41:32 -04002717 } else if _, ok := to.(LinkableInterface); !ok {
Ivan Lozano52767be2019-10-18 14:49:46 -07002718 ctx.ModuleErrorf("Attempting to link VNDK cc.Module with unsupported module type")
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002719 }
2720 return
2721 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002722 // TODO(b/244244438) : Remove this once all variants are implemented
2723 if ccFrom, ok := from.(*Module); ok && ccFrom.isImportedApiLibrary() {
2724 return
2725 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002726 if from.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002727 // Platform code can link to anything
2728 return
2729 }
Yifan Hong1b3348d2020-01-21 15:53:22 -08002730 if from.InRamdisk() {
2731 // Ramdisk code is not NDK
2732 return
2733 }
Yifan Hong60e0cfb2020-10-21 15:17:56 -07002734 if from.InVendorRamdisk() {
2735 // Vendor ramdisk code is not NDK
2736 return
2737 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002738 if from.InRecovery() {
Jiyong Parkf9332f12018-02-01 00:54:12 +09002739 // Recovery code is not NDK
2740 return
2741 }
Colin Cross31076b32020-10-23 17:22:06 -07002742 if c, ok := to.(*Module); ok {
Colin Cross31076b32020-10-23 17:22:06 -07002743 if c.NdkPrebuiltStl() {
2744 // These are allowed, but they don't set sdk_version
2745 return
2746 }
2747 if c.StubDecorator() {
2748 // These aren't real libraries, but are the stub shared libraries that are included in
2749 // the NDK.
2750 return
2751 }
Kiyoung Kimd5d1ab12022-11-28 16:47:10 +09002752 if c.isImportedApiLibrary() {
2753 // Imported library from the API surface is a stub library built against interface definition.
2754 return
2755 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002756 }
Logan Chien834b9a62019-01-14 15:39:03 +08002757
Ivan Lozano52767be2019-10-18 14:49:46 -07002758 if strings.HasPrefix(ctx.ModuleName(), "libclang_rt.") && to.Module().Name() == "libc++" {
Logan Chien834b9a62019-01-14 15:39:03 +08002759 // Bug: http://b/121358700 - Allow libclang_rt.* shared libraries (with sdk_version)
2760 // to link to libc++ (non-NDK and without sdk_version).
2761 return
2762 }
2763
Ivan Lozano52767be2019-10-18 14:49:46 -07002764 if to.SdkVersion() == "" {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002765 // NDK code linking to platform code is never okay.
2766 ctx.ModuleErrorf("depends on non-NDK-built library %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002767 ctx.OtherModuleName(to.Module()))
Dan Willemsen155d17c2019-02-06 18:30:02 -08002768 return
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002769 }
2770
2771 // At this point we know we have two NDK libraries, but we need to
2772 // check that we're not linking against anything built against a higher
2773 // API level, as it is only valid to link against older or equivalent
2774 // APIs.
2775
Inseob Kim01a28722018-04-11 09:48:45 +09002776 // Current can link against anything.
Ivan Lozano52767be2019-10-18 14:49:46 -07002777 if from.SdkVersion() != "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002778 // Otherwise we need to check.
Ivan Lozano52767be2019-10-18 14:49:46 -07002779 if to.SdkVersion() == "current" {
Inseob Kim01a28722018-04-11 09:48:45 +09002780 // Current can't be linked against by anything else.
2781 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002782 ctx.OtherModuleName(to.Module()), "current")
Inseob Kim01a28722018-04-11 09:48:45 +09002783 } else {
Ivan Lozano52767be2019-10-18 14:49:46 -07002784 fromApi, err := strconv.Atoi(from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002785 if err != nil {
2786 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002787 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002788 from.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002789 }
Ivan Lozano52767be2019-10-18 14:49:46 -07002790 toApi, err := strconv.Atoi(to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002791 if err != nil {
2792 ctx.PropertyErrorf("sdk_version",
Inseob Kim34b22832018-04-11 10:13:16 +09002793 "Invalid sdk_version value (must be int or current): %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002794 to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002795 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002796
Inseob Kim01a28722018-04-11 09:48:45 +09002797 if toApi > fromApi {
2798 ctx.ModuleErrorf("links %q built against newer API version %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002799 ctx.OtherModuleName(to.Module()), to.SdkVersion())
Inseob Kim01a28722018-04-11 09:48:45 +09002800 }
2801 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002802 }
Dan Albert202fe492017-12-15 13:56:59 -08002803
2804 // Also check that the two STL choices are compatible.
Ivan Lozano52767be2019-10-18 14:49:46 -07002805 fromStl := from.SelectedStl()
2806 toStl := to.SelectedStl()
Dan Albert202fe492017-12-15 13:56:59 -08002807 if fromStl == "" || toStl == "" {
2808 // Libraries that don't use the STL are unrestricted.
Inseob Kimda2171a2018-04-11 15:41:38 +09002809 } else if fromStl == "ndk_system" || toStl == "ndk_system" {
Dan Albert202fe492017-12-15 13:56:59 -08002810 // We can be permissive with the system "STL" since it is only the C++
2811 // ABI layer, but in the future we should make sure that everyone is
2812 // using either libc++ or nothing.
Colin Crossb60190a2018-09-04 16:28:17 -07002813 } else if getNdkStlFamily(from) != getNdkStlFamily(to) {
Dan Albert202fe492017-12-15 13:56:59 -08002814 ctx.ModuleErrorf("uses %q and depends on %q which uses incompatible %q",
Ivan Lozano52767be2019-10-18 14:49:46 -07002815 from.SelectedStl(), ctx.OtherModuleName(to.Module()),
2816 to.SelectedStl())
Dan Albert202fe492017-12-15 13:56:59 -08002817 }
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002818}
2819
Jooyung Han479ca172020-10-19 18:51:07 +09002820func checkLinkTypeMutator(ctx android.BottomUpMutatorContext) {
2821 if c, ok := ctx.Module().(*Module); ok {
2822 ctx.VisitDirectDeps(func(dep android.Module) {
2823 depTag := ctx.OtherModuleDependencyTag(dep)
2824 ccDep, ok := dep.(LinkableInterface)
2825 if ok {
2826 checkLinkType(ctx, c, ccDep, depTag)
2827 }
2828 })
2829 }
2830}
2831
Jiyong Park5fb8c102018-04-09 12:03:06 +09002832// Tests whether the dependent library is okay to be double loaded inside a single process.
Jooyung Hana70f0672019-01-18 15:20:43 +09002833// If a library has a vendor variant and is a (transitive) dependency of an LLNDK library,
2834// it is subject to be double loaded. Such lib should be explicitly marked as double_loadable: true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002835// or as vndk-sp (vndk: { enabled: true, support_system_process: true}).
Jooyung Hana70f0672019-01-18 15:20:43 +09002836func checkDoubleLoadableLibraries(ctx android.TopDownMutatorContext) {
2837 check := func(child, parent android.Module) bool {
2838 to, ok := child.(*Module)
2839 if !ok {
Jooyung Han479ca172020-10-19 18:51:07 +09002840 return false
Jooyung Hana70f0672019-01-18 15:20:43 +09002841 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002842
Jooyung Hana70f0672019-01-18 15:20:43 +09002843 if lib, ok := to.linker.(*libraryDecorator); !ok || !lib.shared() {
2844 return false
Jiyong Park5fb8c102018-04-09 12:03:06 +09002845 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002846
Jiyong Park0474e1f2021-01-14 14:26:06 +09002847 // These dependencies are not excercised at runtime. Tracking these will give us
2848 // false negative, so skip.
Jiyong Park1ad8e162020-12-01 23:40:09 +09002849 depTag := ctx.OtherModuleDependencyTag(child)
2850 if IsHeaderDepTag(depTag) {
2851 return false
2852 }
Jiyong Park0474e1f2021-01-14 14:26:06 +09002853 if depTag == staticVariantTag {
2854 return false
2855 }
2856 if depTag == stubImplDepTag {
2857 return false
2858 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09002859
Justin Yun63e9ec72020-10-29 16:49:43 +09002860 // Even if target lib has no vendor variant, keep checking dependency
2861 // graph in case it depends on vendor_available or product_available
2862 // but not double_loadable transtively.
2863 if !to.HasNonSystemVariants() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002864 return true
Jiyong Park5fb8c102018-04-09 12:03:06 +09002865 }
Jooyung Hana70f0672019-01-18 15:20:43 +09002866
Jiyong Park0474e1f2021-01-14 14:26:06 +09002867 // The happy path. Keep tracking dependencies until we hit a non double-loadable
2868 // one.
2869 if Bool(to.VendorProperties.Double_loadable) {
2870 return true
2871 }
2872
Ivan Lozanod7586b62021-04-01 09:49:36 -04002873 if to.IsVndkSp() || to.IsLlndk() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002874 return false
2875 }
2876
Jooyung Hana70f0672019-01-18 15:20:43 +09002877 ctx.ModuleErrorf("links a library %q which is not LL-NDK, "+
2878 "VNDK-SP, or explicitly marked as 'double_loadable:true'. "+
Jiyong Park0474e1f2021-01-14 14:26:06 +09002879 "Dependency list: %s", ctx.OtherModuleName(to), ctx.GetPathString(false))
Jooyung Hana70f0672019-01-18 15:20:43 +09002880 return false
2881 }
2882 if module, ok := ctx.Module().(*Module); ok {
2883 if lib, ok := module.linker.(*libraryDecorator); ok && lib.shared() {
Jiyong Park0474e1f2021-01-14 14:26:06 +09002884 if lib.hasLLNDKStubs() {
Jooyung Hana70f0672019-01-18 15:20:43 +09002885 ctx.WalkDeps(check)
2886 }
Jiyong Park5fb8c102018-04-09 12:03:06 +09002887 }
2888 }
2889}
2890
Yu Liue4312402023-01-18 09:15:31 -08002891func findApexSdkVersion(ctx android.BaseModuleContext, apexInfo android.ApexInfo) android.ApiLevel {
2892 // For the dependency from platform to apex, use the latest stubs
2893 apexSdkVersion := android.FutureApiLevel
2894 if !apexInfo.IsForPlatform() {
2895 apexSdkVersion = apexInfo.MinSdkVersion
2896 }
2897
2898 if android.InList("hwaddress", ctx.Config().SanitizeDevice()) {
2899 // In hwasan build, we override apexSdkVersion to the FutureApiLevel(10000)
2900 // so that even Q(29/Android10) apexes could use the dynamic unwinder by linking the newer stubs(e.g libc(R+)).
2901 // (b/144430859)
2902 apexSdkVersion = android.FutureApiLevel
2903 }
2904
2905 return apexSdkVersion
2906}
2907
Colin Crossc99deeb2016-04-11 15:06:20 -07002908// Convert dependencies to paths. Returns a PathDeps containing paths
Colin Cross635c3b02016-05-18 15:37:25 -07002909func (c *Module) depsToPaths(ctx android.ModuleContext) PathDeps {
Colin Crossca860ac2016-01-04 14:34:37 -08002910 var depPaths PathDeps
Colin Crossca860ac2016-01-04 14:34:37 -08002911
Colin Cross0de8a1e2020-09-18 14:15:30 -07002912 var directStaticDeps []StaticLibraryInfo
2913 var directSharedDeps []SharedLibraryInfo
Jeff Gaston294356f2017-09-27 17:05:30 -07002914
Colin Cross0de8a1e2020-09-18 14:15:30 -07002915 reexportExporter := func(exporter FlagExporterInfo) {
2916 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, exporter.IncludeDirs...)
2917 depPaths.ReexportedSystemDirs = append(depPaths.ReexportedSystemDirs, exporter.SystemIncludeDirs...)
2918 depPaths.ReexportedFlags = append(depPaths.ReexportedFlags, exporter.Flags...)
2919 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, exporter.Deps...)
2920 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders, exporter.GeneratedHeaders...)
Inseob Kim69378442019-06-03 19:10:47 +09002921 }
2922
Colin Cross56a83212020-09-15 18:30:11 -07002923 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
Yu Liue4312402023-01-18 09:15:31 -08002924 c.apexSdkVersion = findApexSdkVersion(ctx, apexInfo)
Jooyung Hande34d232020-07-23 13:04:15 +09002925
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002926 skipModuleList := map[string]bool{}
2927
2928 var apiImportInfo multitree.ApiImportInfo
2929 hasApiImportInfo := false
2930
2931 ctx.VisitDirectDeps(func(dep android.Module) {
2932 if dep.Name() == "api_imports" {
2933 apiImportInfo = ctx.OtherModuleProvider(dep, multitree.ApiImportsProvider).(multitree.ApiImportInfo)
2934 hasApiImportInfo = true
2935 }
2936 })
2937
2938 if hasApiImportInfo {
2939 targetStubModuleList := map[string]string{}
2940 targetOrigModuleList := map[string]string{}
2941
2942 // Search for dependency which both original module and API imported library with APEX stub exists
2943 ctx.VisitDirectDeps(func(dep android.Module) {
2944 depName := ctx.OtherModuleName(dep)
2945 if apiLibrary, ok := apiImportInfo.ApexSharedLibs[depName]; ok {
2946 targetStubModuleList[apiLibrary] = depName
2947 }
2948 })
2949 ctx.VisitDirectDeps(func(dep android.Module) {
2950 depName := ctx.OtherModuleName(dep)
2951 if origLibrary, ok := targetStubModuleList[depName]; ok {
2952 targetOrigModuleList[origLibrary] = depName
2953 }
2954 })
2955
2956 // Decide which library should be used between original and API imported library
2957 ctx.VisitDirectDeps(func(dep android.Module) {
2958 depName := ctx.OtherModuleName(dep)
2959 if apiLibrary, ok := targetOrigModuleList[depName]; ok {
Spandan Das604f3762023-03-16 22:51:40 +00002960 if ShouldUseStubForApex(ctx, dep) {
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002961 skipModuleList[depName] = true
2962 } else {
2963 skipModuleList[apiLibrary] = true
2964 }
2965 }
2966 })
2967 }
2968
Colin Crossd11fcda2017-10-23 17:59:01 -07002969 ctx.VisitDirectDeps(func(dep android.Module) {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002970 depName := ctx.OtherModuleName(dep)
2971 depTag := ctx.OtherModuleDependencyTag(dep)
Dan Albert9e10cd42016-08-03 14:12:14 -07002972
Kiyoung Kim76b06f32023-02-06 22:08:13 +09002973 if _, ok := skipModuleList[depName]; ok {
2974 // skip this module because original module or API imported module matching with this should be used instead.
2975 return
2976 }
2977
Dan Willemsen47450072021-10-19 20:24:49 -07002978 if depTag == android.DarwinUniversalVariantTag {
2979 depPaths.DarwinSecondArchOutput = dep.(*Module).OutputFile()
2980 return
2981 }
2982
Ivan Lozano52767be2019-10-18 14:49:46 -07002983 ccDep, ok := dep.(LinkableInterface)
2984 if !ok {
2985
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002986 // handling for a few module types that aren't cc Module but that are also supported
2987 switch depTag {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002988 case genSourceDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002989 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Dan Willemsenb40aab62016-04-20 14:21:14 -07002990 depPaths.GeneratedSources = append(depPaths.GeneratedSources,
2991 genRule.GeneratedSourceFiles()...)
2992 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002993 ctx.ModuleErrorf("module %q is not a gensrcs or genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07002994 }
Colin Crosse90bfd12017-04-26 16:59:26 -07002995 // Support exported headers from a generated_sources dependency
2996 fallthrough
Dan Willemsenb3454ab2016-09-28 17:34:58 -07002997 case genHeaderDepTag, genHeaderExportDepTag:
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07002998 if genRule, ok := dep.(genrule.SourceFileGenerator); ok {
Inseob Kimd110f872019-12-06 13:15:38 +09002999 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps,
Dan Willemsen9da9d492018-02-21 18:28:18 -08003000 genRule.GeneratedDeps()...)
Jiyong Park74955042019-10-22 20:19:51 +09003001 dirs := genRule.GeneratedHeaderDirs()
Inseob Kim69378442019-06-03 19:10:47 +09003002 depPaths.IncludeDirs = append(depPaths.IncludeDirs, dirs...)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003003 if depTag == genHeaderExportDepTag {
Inseob Kim69378442019-06-03 19:10:47 +09003004 depPaths.ReexportedDirs = append(depPaths.ReexportedDirs, dirs...)
Inseob Kimd110f872019-12-06 13:15:38 +09003005 depPaths.ReexportedGeneratedHeaders = append(depPaths.ReexportedGeneratedHeaders,
3006 genRule.GeneratedSourceFiles()...)
Inseob Kim69378442019-06-03 19:10:47 +09003007 depPaths.ReexportedDeps = append(depPaths.ReexportedDeps, genRule.GeneratedDeps()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003008 // 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 +09003009 c.sabi.Properties.ReexportedIncludes = append(c.sabi.Properties.ReexportedIncludes, dirs.Strings()...)
Jayant Chowdhary715cac32017-04-20 06:53:59 -07003010
Dan Willemsenb3454ab2016-09-28 17:34:58 -07003011 }
Dan Willemsenb40aab62016-04-20 14:21:14 -07003012 } else {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003013 ctx.ModuleErrorf("module %q is not a genrule", depName)
Dan Willemsenb40aab62016-04-20 14:21:14 -07003014 }
Colin Crosscef792e2021-06-11 18:01:26 -07003015 case CrtBeginDepTag:
3016 depPaths.CrtBegin = append(depPaths.CrtBegin, android.OutputFileForModule(ctx, dep, ""))
3017 case CrtEndDepTag:
3018 depPaths.CrtEnd = append(depPaths.CrtEnd, android.OutputFileForModule(ctx, dep, ""))
Colin Crossca860ac2016-01-04 14:34:37 -08003019 }
Colin Crossc99deeb2016-04-11 15:06:20 -07003020 return
3021 }
3022
Colin Crossfe17f6f2019-03-28 19:30:56 -07003023 if depTag == android.ProtoPluginDepTag {
3024 return
3025 }
3026
Colin Crossd11fcda2017-10-23 17:59:01 -07003027 if dep.Target().Os != ctx.Os() {
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003028 ctx.ModuleErrorf("OS mismatch between %q and %q", ctx.ModuleName(), depName)
3029 return
3030 }
Colin Crossd11fcda2017-10-23 17:59:01 -07003031 if dep.Target().Arch.ArchType != ctx.Arch().ArchType {
Jooyung Han61b66e92020-03-21 14:21:46 +00003032 ctx.ModuleErrorf("Arch mismatch between %q(%v) and %q(%v)",
3033 ctx.ModuleName(), ctx.Arch().ArchType, depName, dep.Target().Arch.ArchType)
Colin Crossa1ad8d12016-06-01 17:09:44 -07003034 return
3035 }
3036
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -07003037 if depTag == reuseObjTag {
Colin Crossa717db72020-10-23 14:53:06 -07003038 // Skip reused objects for stub libraries, they use their own stub object file instead.
3039 // The reuseObjTag dependency still exists because the LinkageMutator runs before the
3040 // version mutator, so the stubs variant is created from the shared variant that
3041 // already has the reuseObjTag dependency on the static variant.
Colin Cross31076b32020-10-23 17:22:06 -07003042 if !c.library.buildStubs() {
Colin Crossa717db72020-10-23 14:53:06 -07003043 staticAnalogue := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3044 objs := staticAnalogue.ReuseObjects
3045 depPaths.Objs = depPaths.Objs.Append(objs)
3046 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3047 reexportExporter(depExporterInfo)
3048 }
Colin Cross0de8a1e2020-09-18 14:15:30 -07003049 return
Jiyong Parke4bb9862019-02-01 00:31:10 +09003050 }
3051
Colin Cross6e511a92020-07-27 21:26:48 -07003052 linkFile := ccDep.OutputFile()
3053
3054 if libDepTag, ok := depTag.(libraryDependencyTag); ok {
3055 // Only use static unwinder for legacy (min_sdk_version = 29) apexes (b/144430859)
Dan Albertc8060532020-07-22 22:32:17 -07003056 if libDepTag.staticUnwinder && c.apexSdkVersion.GreaterThan(android.SdkVersion_Android10) {
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003057 return
3058 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08003059
Jiyong Parke3867542020-12-03 17:28:25 +09003060 if !apexInfo.IsForPlatform() && libDepTag.excludeInApex {
3061 return
3062 }
3063
Colin Cross0de8a1e2020-09-18 14:15:30 -07003064 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
Colin Crossc99deeb2016-04-11 15:06:20 -07003065
Colin Cross6e511a92020-07-27 21:26:48 -07003066 var ptr *android.Paths
3067 var depPtr *android.Paths
Colin Crossc99deeb2016-04-11 15:06:20 -07003068
Colin Cross6e511a92020-07-27 21:26:48 -07003069 depFile := android.OptionalPath{}
Colin Cross26c34ed2016-09-30 17:10:16 -07003070
Colin Cross6e511a92020-07-27 21:26:48 -07003071 switch {
3072 case libDepTag.header():
Colin Cross649d8172020-12-10 12:30:21 -08003073 if !ctx.OtherModuleHasProvider(dep, HeaderLibraryInfoProvider) {
3074 if !ctx.Config().AllowMissingDependencies() {
3075 ctx.ModuleErrorf("module %q is not a header library", depName)
3076 } else {
3077 ctx.AddMissingDependencies([]string{depName})
3078 }
3079 return
3080 }
Colin Cross6e511a92020-07-27 21:26:48 -07003081 case libDepTag.shared():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003082 if !ctx.OtherModuleHasProvider(dep, SharedLibraryInfoProvider) {
3083 if !ctx.Config().AllowMissingDependencies() {
3084 ctx.ModuleErrorf("module %q is not a shared library", depName)
3085 } else {
3086 ctx.AddMissingDependencies([]string{depName})
3087 }
3088 return
3089 }
Jiyong Parke3867542020-12-03 17:28:25 +09003090
Jiyong Park7d55b612021-06-11 17:22:09 +09003091 sharedLibraryInfo, returnedDepExporterInfo := ChooseStubOrImpl(ctx, dep)
3092 depExporterInfo = returnedDepExporterInfo
Colin Cross0de8a1e2020-09-18 14:15:30 -07003093
Jiyong Park1ad8e162020-12-01 23:40:09 +09003094 // Stubs lib doesn't link to the shared lib dependencies. Don't set
3095 // linkFile, depFile, and ptr.
3096 if c.IsStubs() {
3097 break
3098 }
3099
Colin Cross0de8a1e2020-09-18 14:15:30 -07003100 linkFile = android.OptionalPathForPath(sharedLibraryInfo.SharedLibrary)
3101 depFile = sharedLibraryInfo.TableOfContents
3102
Colin Cross6e511a92020-07-27 21:26:48 -07003103 ptr = &depPaths.SharedLibs
3104 switch libDepTag.Order {
3105 case earlyLibraryDependency:
3106 ptr = &depPaths.EarlySharedLibs
3107 depPtr = &depPaths.EarlySharedLibsDeps
3108 case normalLibraryDependency:
3109 ptr = &depPaths.SharedLibs
3110 depPtr = &depPaths.SharedLibsDeps
Colin Cross0de8a1e2020-09-18 14:15:30 -07003111 directSharedDeps = append(directSharedDeps, sharedLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003112 case lateLibraryDependency:
3113 ptr = &depPaths.LateSharedLibs
3114 depPtr = &depPaths.LateSharedLibsDeps
3115 default:
3116 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Colin Crossc99deeb2016-04-11 15:06:20 -07003117 }
Colin Cross6e511a92020-07-27 21:26:48 -07003118 case libDepTag.static():
Colin Cross0de8a1e2020-09-18 14:15:30 -07003119 if !ctx.OtherModuleHasProvider(dep, StaticLibraryInfoProvider) {
3120 if !ctx.Config().AllowMissingDependencies() {
3121 ctx.ModuleErrorf("module %q is not a static library", depName)
3122 } else {
3123 ctx.AddMissingDependencies([]string{depName})
3124 }
3125 return
3126 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003127
3128 // Stubs lib doesn't link to the static lib dependencies. Don't set
3129 // linkFile, depFile, and ptr.
3130 if c.IsStubs() {
3131 break
3132 }
3133
Colin Cross0de8a1e2020-09-18 14:15:30 -07003134 staticLibraryInfo := ctx.OtherModuleProvider(dep, StaticLibraryInfoProvider).(StaticLibraryInfo)
3135 linkFile = android.OptionalPathForPath(staticLibraryInfo.StaticLibrary)
Colin Cross6e511a92020-07-27 21:26:48 -07003136 if libDepTag.wholeStatic {
3137 ptr = &depPaths.WholeStaticLibs
Colin Cross0de8a1e2020-09-18 14:15:30 -07003138 if len(staticLibraryInfo.Objects.objFiles) > 0 {
3139 depPaths.WholeStaticLibObjs = depPaths.WholeStaticLibObjs.Append(staticLibraryInfo.Objects)
Inseob Kimeec88e12020-01-22 11:11:29 +09003140 } else {
Colin Cross0de8a1e2020-09-18 14:15:30 -07003141 // This case normally catches prebuilt static
3142 // libraries, but it can also occur when
3143 // AllowMissingDependencies is on and the
3144 // dependencies has no sources of its own
3145 // but has a whole_static_libs dependency
3146 // on a missing library. We want to depend
3147 // on the .a file so that there is something
3148 // in the dependency tree that contains the
3149 // error rule for the missing transitive
3150 // dependency.
3151 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003152 }
Colin Crossa2bcf2c2022-02-11 13:11:55 -08003153 depPaths.WholeStaticLibsFromPrebuilts = append(depPaths.WholeStaticLibsFromPrebuilts,
3154 staticLibraryInfo.WholeStaticLibsFromPrebuilts...)
Colin Cross6e511a92020-07-27 21:26:48 -07003155 } else {
3156 switch libDepTag.Order {
3157 case earlyLibraryDependency:
3158 panic(fmt.Errorf("early static libs not suppported"))
3159 case normalLibraryDependency:
3160 // static dependencies will be handled separately so they can be ordered
3161 // using transitive dependencies.
3162 ptr = nil
Colin Cross0de8a1e2020-09-18 14:15:30 -07003163 directStaticDeps = append(directStaticDeps, staticLibraryInfo)
Colin Cross6e511a92020-07-27 21:26:48 -07003164 case lateLibraryDependency:
3165 ptr = &depPaths.LateStaticLibs
3166 default:
3167 panic(fmt.Errorf("unexpected library dependency order %d", libDepTag.Order))
Inseob Kimeec88e12020-01-22 11:11:29 +09003168 }
3169 }
Colin Cross3e5e7782022-06-17 22:17:05 +00003170 if libDepTag.unexportedSymbols {
3171 depPaths.LdFlags = append(depPaths.LdFlags,
3172 "-Wl,--exclude-libs="+staticLibraryInfo.StaticLibrary.Base())
3173 }
Inseob Kimeec88e12020-01-22 11:11:29 +09003174 }
3175
Colin Cross6e511a92020-07-27 21:26:48 -07003176 if libDepTag.static() && !libDepTag.wholeStatic {
3177 if !ccDep.CcLibraryInterface() || !ccDep.Static() {
3178 ctx.ModuleErrorf("module %q not a static library", depName)
3179 return
3180 }
Logan Chien43d34c32017-12-20 01:17:32 +08003181
Colin Cross6e511a92020-07-27 21:26:48 -07003182 // When combining coverage files for shared libraries and executables, coverage files
3183 // in static libraries act as if they were whole static libraries. The same goes for
3184 // source based Abi dump files.
3185 if c, ok := ccDep.(*Module); ok {
3186 staticLib := c.linker.(libraryInterface)
3187 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
3188 staticLib.objs().coverageFiles...)
3189 depPaths.StaticLibObjs.sAbiDumpFiles = append(depPaths.StaticLibObjs.sAbiDumpFiles,
3190 staticLib.objs().sAbiDumpFiles...)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003191 } else {
Colin Cross6e511a92020-07-27 21:26:48 -07003192 // Handle non-CC modules here
3193 depPaths.StaticLibObjs.coverageFiles = append(depPaths.StaticLibObjs.coverageFiles,
Colin Cross0de8a1e2020-09-18 14:15:30 -07003194 ccDep.CoverageFiles()...)
Jiyong Parkde866cb2018-12-07 23:08:36 +09003195 }
3196 }
3197
Colin Cross6e511a92020-07-27 21:26:48 -07003198 if ptr != nil {
3199 if !linkFile.Valid() {
3200 if !ctx.Config().AllowMissingDependencies() {
3201 ctx.ModuleErrorf("module %q missing output file", depName)
3202 } else {
3203 ctx.AddMissingDependencies([]string{depName})
3204 }
3205 return
3206 }
3207 *ptr = append(*ptr, linkFile.Path())
3208 }
3209
3210 if depPtr != nil {
3211 dep := depFile
3212 if !dep.Valid() {
3213 dep = linkFile
3214 }
3215 *depPtr = append(*depPtr, dep.Path())
3216 }
3217
Colin Cross0de8a1e2020-09-18 14:15:30 -07003218 depPaths.IncludeDirs = append(depPaths.IncludeDirs, depExporterInfo.IncludeDirs...)
3219 depPaths.SystemIncludeDirs = append(depPaths.SystemIncludeDirs, depExporterInfo.SystemIncludeDirs...)
3220 depPaths.GeneratedDeps = append(depPaths.GeneratedDeps, depExporterInfo.Deps...)
3221 depPaths.Flags = append(depPaths.Flags, depExporterInfo.Flags...)
3222
3223 if libDepTag.reexportFlags {
3224 reexportExporter(depExporterInfo)
3225 // Add these re-exported flags to help header-abi-dumper to infer the abi exported by a library.
3226 // Re-exported shared library headers must be included as well since they can help us with type information
3227 // about template instantiations (instantiated from their headers).
3228 // -isystem headers are not included since for bionic libraries, abi-filtering is taken care of by version
3229 // scripts.
3230 c.sabi.Properties.ReexportedIncludes = append(
3231 c.sabi.Properties.ReexportedIncludes, depExporterInfo.IncludeDirs.Strings()...)
3232 }
3233
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003234 makeLibName := MakeLibName(ctx, c, ccDep, depName) + libDepTag.makeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003235 switch {
3236 case libDepTag.header():
Colin Cross370173e2020-07-29 12:48:33 -07003237 c.Properties.AndroidMkHeaderLibs = append(
3238 c.Properties.AndroidMkHeaderLibs, makeLibName)
Colin Cross6e511a92020-07-27 21:26:48 -07003239 case libDepTag.shared():
Colin Cross31076b32020-10-23 17:22:06 -07003240 if lib := moduleLibraryInterface(dep); lib != nil {
3241 if lib.buildStubs() && dep.(android.ApexModule).InAnyApex() {
Colin Cross6e511a92020-07-27 21:26:48 -07003242 // Add the dependency to the APEX(es) providing the library so that
3243 // m <module> can trigger building the APEXes as well.
Colin Cross56a83212020-09-15 18:30:11 -07003244 depApexInfo := ctx.OtherModuleProvider(dep, android.ApexInfoProvider).(android.ApexInfo)
Jiyong Parkab50b072021-05-12 17:13:56 +09003245 for _, an := range depApexInfo.InApexVariants {
Colin Cross6e511a92020-07-27 21:26:48 -07003246 c.Properties.ApexesProvidingSharedLibs = append(
3247 c.Properties.ApexesProvidingSharedLibs, an)
3248 }
3249 }
3250 }
3251
3252 // Note: the order of libs in this list is not important because
3253 // they merely serve as Make dependencies and do not affect this lib itself.
Colin Cross370173e2020-07-29 12:48:33 -07003254 c.Properties.AndroidMkSharedLibs = append(
3255 c.Properties.AndroidMkSharedLibs, makeLibName)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003256 // Record BaseLibName for snapshots.
3257 c.Properties.SnapshotSharedLibs = append(c.Properties.SnapshotSharedLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003258 case libDepTag.static():
3259 if libDepTag.wholeStatic {
3260 c.Properties.AndroidMkWholeStaticLibs = append(
3261 c.Properties.AndroidMkWholeStaticLibs, makeLibName)
3262 } else {
3263 c.Properties.AndroidMkStaticLibs = append(
3264 c.Properties.AndroidMkStaticLibs, makeLibName)
3265 }
Justin Yun5e035862021-06-29 20:50:37 +09003266 // Record BaseLibName for snapshots.
3267 c.Properties.SnapshotStaticLibs = append(c.Properties.SnapshotStaticLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003268 }
Jiyong Park1ad8e162020-12-01 23:40:09 +09003269 } else if !c.IsStubs() {
3270 // Stubs lib doesn't link to the runtime lib, object, crt, etc. dependencies.
3271
Colin Cross6e511a92020-07-27 21:26:48 -07003272 switch depTag {
3273 case runtimeDepTag:
3274 c.Properties.AndroidMkRuntimeLibs = append(
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003275 c.Properties.AndroidMkRuntimeLibs, MakeLibName(ctx, c, ccDep, depName)+libDepTag.makeSuffix)
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003276 // Record BaseLibName for snapshots.
3277 c.Properties.SnapshotRuntimeLibs = append(c.Properties.SnapshotRuntimeLibs, BaseLibName(depName))
Colin Cross6e511a92020-07-27 21:26:48 -07003278 case objDepTag:
3279 depPaths.Objs.objFiles = append(depPaths.Objs.objFiles, linkFile.Path())
3280 case CrtBeginDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003281 depPaths.CrtBegin = append(depPaths.CrtBegin, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003282 case CrtEndDepTag:
Colin Crossc465efd2021-06-11 18:00:04 -07003283 depPaths.CrtEnd = append(depPaths.CrtEnd, linkFile.Path())
Colin Cross6e511a92020-07-27 21:26:48 -07003284 case dynamicLinkerDepTag:
3285 depPaths.DynamicLinker = linkFile
3286 }
Jiyong Park27b188b2017-07-18 13:23:39 +09003287 }
Colin Crossca860ac2016-01-04 14:34:37 -08003288 })
3289
Jeff Gaston294356f2017-09-27 17:05:30 -07003290 // use the ordered dependencies as this module's dependencies
Colin Cross0de8a1e2020-09-18 14:15:30 -07003291 orderedStaticPaths, transitiveStaticLibs := orderStaticModuleDeps(directStaticDeps, directSharedDeps)
3292 depPaths.TranstiveStaticLibrariesForOrdering = transitiveStaticLibs
3293 depPaths.StaticLibs = append(depPaths.StaticLibs, orderedStaticPaths...)
Jeff Gaston294356f2017-09-27 17:05:30 -07003294
Colin Crossdd84e052017-05-17 13:44:16 -07003295 // Dedup exported flags from dependencies
Colin Crossb6715442017-10-24 11:13:31 -07003296 depPaths.Flags = android.FirstUniqueStrings(depPaths.Flags)
Jiyong Park74955042019-10-22 20:19:51 +09003297 depPaths.IncludeDirs = android.FirstUniquePaths(depPaths.IncludeDirs)
3298 depPaths.SystemIncludeDirs = android.FirstUniquePaths(depPaths.SystemIncludeDirs)
Inseob Kimd110f872019-12-06 13:15:38 +09003299 depPaths.GeneratedDeps = android.FirstUniquePaths(depPaths.GeneratedDeps)
Jiyong Park74955042019-10-22 20:19:51 +09003300 depPaths.ReexportedDirs = android.FirstUniquePaths(depPaths.ReexportedDirs)
3301 depPaths.ReexportedSystemDirs = android.FirstUniquePaths(depPaths.ReexportedSystemDirs)
Colin Crossb6715442017-10-24 11:13:31 -07003302 depPaths.ReexportedFlags = android.FirstUniqueStrings(depPaths.ReexportedFlags)
Inseob Kim69378442019-06-03 19:10:47 +09003303 depPaths.ReexportedDeps = android.FirstUniquePaths(depPaths.ReexportedDeps)
Inseob Kimd110f872019-12-06 13:15:38 +09003304 depPaths.ReexportedGeneratedHeaders = android.FirstUniquePaths(depPaths.ReexportedGeneratedHeaders)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003305
3306 if c.sabi != nil {
Inseob Kim69378442019-06-03 19:10:47 +09003307 c.sabi.Properties.ReexportedIncludes = android.FirstUniqueStrings(c.sabi.Properties.ReexportedIncludes)
Dan Willemsenfe92c962017-08-29 12:28:37 -07003308 }
Colin Crossdd84e052017-05-17 13:44:16 -07003309
Colin Crossca860ac2016-01-04 14:34:37 -08003310 return depPaths
3311}
3312
Spandan Das604f3762023-03-16 22:51:40 +00003313func ShouldUseStubForApex(ctx android.ModuleContext, dep android.Module) bool {
Jiyong Park7d55b612021-06-11 17:22:09 +09003314 depName := ctx.OtherModuleName(dep)
Jiyong Park7d55b612021-06-11 17:22:09 +09003315 thisModule, ok := ctx.Module().(android.ApexModule)
3316 if !ok {
3317 panic(fmt.Errorf("Not an APEX module: %q", ctx.ModuleName()))
3318 }
3319
3320 useVndk := false
3321 bootstrap := false
3322 if linkable, ok := ctx.Module().(LinkableInterface); !ok {
3323 panic(fmt.Errorf("Not a Linkable module: %q", ctx.ModuleName()))
3324 } else {
3325 useVndk = linkable.UseVndk()
3326 bootstrap = linkable.Bootstrap()
3327 }
3328
Kiyoung Kim76b06f32023-02-06 22:08:13 +09003329 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
3330
3331 useStubs := false
3332
3333 if lib := moduleLibraryInterface(dep); lib.buildStubs() && useVndk { // LLNDK
3334 if !apexInfo.IsForPlatform() {
3335 // For platform libraries, use current version of LLNDK
3336 // If this is for use_vendor apex we will apply the same rules
3337 // of apex sdk enforcement below to choose right version.
3338 useStubs = true
3339 }
3340 } else if apexInfo.IsForPlatform() || apexInfo.UsePlatformApis {
3341 // If not building for APEX or the containing APEX allows the use of
3342 // platform APIs, use stubs only when it is from an APEX (and not from
3343 // platform) However, for host, ramdisk, vendor_ramdisk, recovery or
3344 // bootstrap modules, always link to non-stub variant
3345 isNotInPlatform := dep.(android.ApexModule).NotInPlatform()
3346
3347 isApexImportedApiLibrary := false
3348
3349 if cc, ok := dep.(*Module); ok {
3350 if apiLibrary, ok := cc.linker.(*apiLibraryDecorator); ok {
3351 if apiLibrary.hasApexStubs() {
3352 isApexImportedApiLibrary = true
3353 }
3354 }
3355 }
3356
3357 useStubs = (isNotInPlatform || isApexImportedApiLibrary) && !bootstrap
3358
3359 if useStubs {
3360 // Another exception: if this module is a test for an APEX, then
3361 // it is linked with the non-stub variant of a module in the APEX
3362 // as if this is part of the APEX.
3363 testFor := ctx.Provider(android.ApexTestForInfoProvider).(android.ApexTestForInfo)
3364 for _, apexContents := range testFor.ApexContents {
3365 if apexContents.DirectlyInApex(depName) {
3366 useStubs = false
3367 break
3368 }
3369 }
3370 }
3371 if useStubs {
3372 // Yet another exception: If this module and the dependency are
3373 // available to the same APEXes then skip stubs between their
3374 // platform variants. This complements the test_for case above,
3375 // which avoids the stubs on a direct APEX library dependency, by
3376 // avoiding stubs for indirect test dependencies as well.
3377 //
3378 // TODO(b/183882457): This doesn't work if the two libraries have
3379 // only partially overlapping apex_available. For that test_for
3380 // modules would need to be split into APEX variants and resolved
3381 // separately for each APEX they have access to.
3382 if !isApexImportedApiLibrary && android.AvailableToSameApexes(thisModule, dep.(android.ApexModule)) {
3383 useStubs = false
3384 }
3385 }
3386 } else {
3387 // If building for APEX, use stubs when the parent is in any APEX that
3388 // the child is not in.
3389 useStubs = !android.DirectlyInAllApexes(apexInfo, depName)
3390 }
3391
3392 return useStubs
3393}
3394
3395// ChooseStubOrImpl determines whether a given dependency should be redirected to the stub variant
3396// of the dependency or not, and returns the SharedLibraryInfo and FlagExporterInfo for the right
3397// dependency. The stub variant is selected when the dependency crosses a boundary where each side
3398// has different level of updatability. For example, if a library foo in an APEX depends on a
3399// library bar which provides stable interface and exists in the platform, foo uses the stub variant
3400// of bar. If bar doesn't provide a stable interface (i.e. buildStubs() == false) or is in the
3401// same APEX as foo, the non-stub variant of bar is used.
3402func ChooseStubOrImpl(ctx android.ModuleContext, dep android.Module) (SharedLibraryInfo, FlagExporterInfo) {
3403 depTag := ctx.OtherModuleDependencyTag(dep)
3404 libDepTag, ok := depTag.(libraryDependencyTag)
3405 if !ok || !libDepTag.shared() {
3406 panic(fmt.Errorf("Unexpected dependency tag: %T", depTag))
3407 }
3408
Jiyong Park7d55b612021-06-11 17:22:09 +09003409 sharedLibraryInfo := ctx.OtherModuleProvider(dep, SharedLibraryInfoProvider).(SharedLibraryInfo)
3410 depExporterInfo := ctx.OtherModuleProvider(dep, FlagExporterInfoProvider).(FlagExporterInfo)
3411 sharedLibraryStubsInfo := ctx.OtherModuleProvider(dep, SharedLibraryStubsProvider).(SharedLibraryStubsInfo)
Jiyong Park7d55b612021-06-11 17:22:09 +09003412
3413 if !libDepTag.explicitlyVersioned && len(sharedLibraryStubsInfo.SharedStubLibraries) > 0 {
Jiyong Park7d55b612021-06-11 17:22:09 +09003414 // when to use (unspecified) stubs, use the latest one.
Spandan Das604f3762023-03-16 22:51:40 +00003415 if ShouldUseStubForApex(ctx, dep) {
Jiyong Park7d55b612021-06-11 17:22:09 +09003416 stubs := sharedLibraryStubsInfo.SharedStubLibraries
3417 toUse := stubs[len(stubs)-1]
3418 sharedLibraryInfo = toUse.SharedLibraryInfo
3419 depExporterInfo = toUse.FlagExporterInfo
3420 }
3421 }
3422 return sharedLibraryInfo, depExporterInfo
3423}
3424
Colin Cross0de8a1e2020-09-18 14:15:30 -07003425// orderStaticModuleDeps rearranges the order of the static library dependencies of the module
3426// to match the topological order of the dependency tree, including any static analogues of
3427// direct shared libraries. It returns the ordered static dependencies, and an android.DepSet
3428// of the transitive dependencies.
3429func orderStaticModuleDeps(staticDeps []StaticLibraryInfo, sharedDeps []SharedLibraryInfo) (ordered android.Paths, transitive *android.DepSet) {
3430 transitiveStaticLibsBuilder := android.NewDepSetBuilder(android.TOPOLOGICAL)
3431 var staticPaths android.Paths
3432 for _, staticDep := range staticDeps {
3433 staticPaths = append(staticPaths, staticDep.StaticLibrary)
3434 transitiveStaticLibsBuilder.Transitive(staticDep.TransitiveStaticLibrariesForOrdering)
3435 }
3436 for _, sharedDep := range sharedDeps {
Liz Kammeref6dfea2021-06-08 15:37:09 -04003437 if sharedDep.TransitiveStaticLibrariesForOrdering != nil {
3438 transitiveStaticLibsBuilder.Transitive(sharedDep.TransitiveStaticLibrariesForOrdering)
Colin Cross0de8a1e2020-09-18 14:15:30 -07003439 }
3440 }
3441 transitiveStaticLibs := transitiveStaticLibsBuilder.Build()
3442
3443 orderedTransitiveStaticLibs := transitiveStaticLibs.ToList()
3444
3445 // reorder the dependencies based on transitive dependencies
3446 staticPaths = android.FirstUniquePaths(staticPaths)
3447 _, orderedStaticPaths := android.FilterPathList(orderedTransitiveStaticLibs, staticPaths)
3448
3449 if len(orderedStaticPaths) != len(staticPaths) {
3450 missing, _ := android.FilterPathList(staticPaths, orderedStaticPaths)
3451 panic(fmt.Errorf("expected %d ordered static paths , got %d, missing %q %q %q", len(staticPaths), len(orderedStaticPaths), missing, orderedStaticPaths, staticPaths))
3452 }
3453
3454 return orderedStaticPaths, transitiveStaticLibs
3455}
3456
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003457// BaseLibName trims known prefixes and suffixes
3458func BaseLibName(depName string) string {
Colin Cross6e511a92020-07-27 21:26:48 -07003459 libName := strings.TrimSuffix(depName, llndkLibrarySuffix)
3460 libName = strings.TrimSuffix(libName, vendorPublicLibrarySuffix)
Paul Duffind23c7262020-12-11 18:13:08 +00003461 libName = android.RemoveOptionalPrebuiltPrefix(libName)
Colin Cross6e511a92020-07-27 21:26:48 -07003462 return libName
3463}
3464
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003465func MakeLibName(ctx android.ModuleContext, c LinkableInterface, ccDep LinkableInterface, depName string) string {
Ivan Lozanod67a6b02021-05-20 13:01:32 -04003466 libName := BaseLibName(depName)
Colin Cross127bb8b2020-12-16 16:46:01 -08003467 ccDepModule, _ := ccDep.(*Module)
3468 isLLndk := ccDepModule != nil && ccDepModule.IsLlndk()
Justin Yuncbca3732021-02-03 19:24:13 +09003469 nonSystemVariantsExist := ccDep.HasNonSystemVariants() || isLLndk
Colin Cross6e511a92020-07-27 21:26:48 -07003470
Justin Yuncbca3732021-02-03 19:24:13 +09003471 if ccDepModule != nil {
Colin Cross6e511a92020-07-27 21:26:48 -07003472 // Use base module name for snapshots when exporting to Makefile.
Ivan Lozanod1dec542021-05-26 15:33:11 -04003473 if snapshotPrebuilt, ok := ccDepModule.linker.(SnapshotInterface); ok {
Justin Yuncbca3732021-02-03 19:24:13 +09003474 baseName := ccDepModule.BaseModuleName()
Colin Cross6e511a92020-07-27 21:26:48 -07003475
Ivan Lozanod1dec542021-05-26 15:33:11 -04003476 return baseName + snapshotPrebuilt.SnapshotAndroidMkSuffix()
Colin Cross6e511a92020-07-27 21:26:48 -07003477 }
3478 }
3479
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003480 if ctx.DeviceConfig().VndkUseCoreVariant() && ccDep.IsVndk() && !ccDep.MustUseVendorVariant() &&
3481 !c.InRamdisk() && !c.InVendorRamdisk() && !c.InRecovery() {
Colin Cross6e511a92020-07-27 21:26:48 -07003482 // The vendor module is a no-vendor-variant VNDK library. Depend on the
3483 // core module instead.
3484 return libName
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003485 } else if ccDep.UseVndk() && nonSystemVariantsExist {
Justin Yuncbca3732021-02-03 19:24:13 +09003486 // The vendor and product modules in Make will have been renamed to not conflict with the
3487 // core module, so update the dependency name here accordingly.
Ivan Lozanoc08897c2021-04-02 12:41:32 -04003488 return libName + ccDep.SubName()
Colin Cross6e511a92020-07-27 21:26:48 -07003489 } else if ccDep.InRamdisk() && !ccDep.OnlyInRamdisk() {
Matthew Maurerc6868382021-07-13 14:12:37 -07003490 return libName + RamdiskSuffix
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003491 } else if ccDep.InVendorRamdisk() && !ccDep.OnlyInVendorRamdisk() {
Ivan Lozanoe6d30982021-02-05 10:57:43 -05003492 return libName + VendorRamdiskSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003493 } else if ccDep.InRecovery() && !ccDep.OnlyInRecovery() {
Matthew Maurer460ee942021-02-11 12:31:46 -08003494 return libName + RecoverySuffix
Ivan Lozanof9e21722020-12-02 09:00:51 -05003495 } else if ccDep.Target().NativeBridge == android.NativeBridgeEnabled {
Matthew Maurera61e31f2021-05-27 11:09:11 -07003496 return libName + NativeBridgeSuffix
Colin Cross6e511a92020-07-27 21:26:48 -07003497 } else {
3498 return libName
3499 }
3500}
3501
Colin Crossca860ac2016-01-04 14:34:37 -08003502func (c *Module) InstallInData() bool {
3503 if c.installer == nil {
3504 return false
3505 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003506 return c.installer.inData()
3507}
3508
3509func (c *Module) InstallInSanitizerDir() bool {
3510 if c.installer == nil {
3511 return false
3512 }
3513 if c.sanitize != nil && c.sanitize.inSanitizerDir() {
Colin Cross94610402016-08-29 13:41:32 -07003514 return true
3515 }
Vishwath Mohan1dd88392017-03-29 22:00:18 -07003516 return c.installer.inSanitizerDir()
Colin Crossca860ac2016-01-04 14:34:37 -08003517}
3518
Yifan Hong1b3348d2020-01-21 15:53:22 -08003519func (c *Module) InstallInRamdisk() bool {
3520 return c.InRamdisk()
3521}
3522
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003523func (c *Module) InstallInVendorRamdisk() bool {
3524 return c.InVendorRamdisk()
3525}
3526
Jiyong Parkf9332f12018-02-01 00:54:12 +09003527func (c *Module) InstallInRecovery() bool {
Ivan Lozano52767be2019-10-18 14:49:46 -07003528 return c.InRecovery()
Jiyong Parkf9332f12018-02-01 00:54:12 +09003529}
3530
Jingwen Chen8ac7d7d2023-03-20 11:05:16 +00003531func (c *Module) MakeUninstallable() {
3532 if c.installer == nil {
3533 c.ModuleBase.MakeUninstallable()
3534 return
3535 }
3536 c.installer.makeUninstallable(c)
3537}
3538
Dan Willemsen4aa75ca2016-09-28 16:18:03 -07003539func (c *Module) HostToolPath() android.OptionalPath {
3540 if c.installer == nil {
3541 return android.OptionalPath{}
3542 }
3543 return c.installer.hostToolPath()
3544}
3545
Nan Zhangd4e641b2017-07-12 12:55:28 -07003546func (c *Module) IntermPathForModuleOut() android.OptionalPath {
3547 return c.outputFile
3548}
3549
Colin Cross41955e82019-05-29 14:40:35 -07003550func (c *Module) OutputFiles(tag string) (android.Paths, error) {
3551 switch tag {
3552 case "":
3553 if c.outputFile.Valid() {
3554 return android.Paths{c.outputFile.Path()}, nil
3555 }
3556 return android.Paths{}, nil
Colin Cross31d89b42022-10-04 16:35:39 -07003557 case "unstripped":
3558 if c.linker != nil {
3559 return android.PathsIfNonNil(c.linker.unstrippedOutputFilePath()), nil
3560 }
3561 return nil, nil
Colin Cross41955e82019-05-29 14:40:35 -07003562 default:
3563 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003564 }
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07003565}
3566
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00003567func (c *Module) static() bool {
3568 if static, ok := c.linker.(interface {
3569 static() bool
3570 }); ok {
3571 return static.static()
3572 }
3573 return false
3574}
3575
Jiyong Park379de2f2018-12-19 02:47:14 +09003576func (c *Module) staticBinary() bool {
3577 if static, ok := c.linker.(interface {
3578 staticBinary() bool
3579 }); ok {
3580 return static.staticBinary()
3581 }
3582 return false
3583}
3584
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07003585func (c *Module) testBinary() bool {
3586 if test, ok := c.linker.(interface {
3587 testBinary() bool
3588 }); ok {
3589 return test.testBinary()
3590 }
3591 return false
3592}
3593
Jingwen Chen537242c2022-08-24 11:53:27 +00003594func (c *Module) testLibrary() bool {
3595 if test, ok := c.linker.(interface {
3596 testLibrary() bool
3597 }); ok {
3598 return test.testLibrary()
3599 }
3600 return false
3601}
3602
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003603func (c *Module) benchmarkBinary() bool {
3604 if b, ok := c.linker.(interface {
3605 benchmarkBinary() bool
3606 }); ok {
3607 return b.benchmarkBinary()
3608 }
3609 return false
3610}
3611
3612func (c *Module) fuzzBinary() bool {
3613 if f, ok := c.linker.(interface {
3614 fuzzBinary() bool
3615 }); ok {
3616 return f.fuzzBinary()
3617 }
3618 return false
3619}
3620
Ivan Lozano3968d8f2020-12-14 11:27:52 -05003621// Header returns true if the module is a header-only variant. (See cc/library.go header()).
3622func (c *Module) Header() bool {
Jiyong Park1d1119f2019-07-29 21:27:18 +09003623 if h, ok := c.linker.(interface {
3624 header() bool
3625 }); ok {
3626 return h.header()
3627 }
3628 return false
3629}
3630
Ivan Lozanod7586b62021-04-01 09:49:36 -04003631func (c *Module) Binary() bool {
Inseob Kim7f283f42020-06-01 21:53:49 +09003632 if b, ok := c.linker.(interface {
3633 binary() bool
3634 }); ok {
3635 return b.binary()
3636 }
3637 return false
3638}
3639
Justin Yun5e035862021-06-29 20:50:37 +09003640func (c *Module) StaticExecutable() bool {
3641 if b, ok := c.linker.(*binaryDecorator); ok {
3642 return b.static()
3643 }
3644 return false
3645}
3646
Ivan Lozanod7586b62021-04-01 09:49:36 -04003647func (c *Module) Object() bool {
Inseob Kim1042d292020-06-01 23:23:05 +09003648 if o, ok := c.linker.(interface {
3649 object() bool
3650 }); ok {
3651 return o.object()
3652 }
3653 return false
3654}
3655
Ivan Lozanof9e21722020-12-02 09:00:51 -05003656func GetMakeLinkType(actx android.ModuleContext, c LinkableInterface) string {
Ivan Lozano52767be2019-10-18 14:49:46 -07003657 if c.UseVndk() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003658 if c.IsLlndk() {
3659 if !c.IsLlndkPublic() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003660 return "native:vndk_private"
Colin Crossb60190a2018-09-04 16:28:17 -07003661 }
Colin Cross127bb8b2020-12-16 16:46:01 -08003662 return "native:vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003663 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003664 if c.IsVndk() && !c.IsVndkExt() {
Colin Cross127bb8b2020-12-16 16:46:01 -08003665 if c.IsVndkPrivate() {
Ivan Lozanof9e21722020-12-02 09:00:51 -05003666 return "native:vndk_private"
Jooyung Han38002912019-05-16 04:01:54 +09003667 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003668 return "native:vndk"
Jooyung Han38002912019-05-16 04:01:54 +09003669 }
Ivan Lozanof9e21722020-12-02 09:00:51 -05003670 if c.InProduct() {
Justin Yun5f7f7e82019-11-18 19:52:14 +09003671 return "native:product"
3672 }
Jooyung Han38002912019-05-16 04:01:54 +09003673 return "native:vendor"
Yifan Hong1b3348d2020-01-21 15:53:22 -08003674 } else if c.InRamdisk() {
3675 return "native:ramdisk"
Yifan Hong60e0cfb2020-10-21 15:17:56 -07003676 } else if c.InVendorRamdisk() {
3677 return "native:vendor_ramdisk"
Ivan Lozano52767be2019-10-18 14:49:46 -07003678 } else if c.InRecovery() {
Colin Crossb60190a2018-09-04 16:28:17 -07003679 return "native:recovery"
Ivan Lozanof9e21722020-12-02 09:00:51 -05003680 } else if c.Target().Os == android.Android && c.SdkVersion() != "" {
Colin Crossb60190a2018-09-04 16:28:17 -07003681 return "native:ndk:none:none"
3682 // TODO(b/114741097): use the correct ndk stl once build errors have been fixed
3683 //family, link := getNdkStlFamilyAndLinkType(c)
3684 //return fmt.Sprintf("native:ndk:%s:%s", family, link)
Ivan Lozano52767be2019-10-18 14:49:46 -07003685 } else if actx.DeviceConfig().VndkUseCoreVariant() && !c.MustUseVendorVariant() {
Vic Yangefd249e2018-11-12 20:19:56 -08003686 return "native:platform_vndk"
Colin Crossb60190a2018-09-04 16:28:17 -07003687 } else {
3688 return "native:platform"
3689 }
3690}
3691
Jiyong Park9d452992018-10-03 00:38:19 +09003692// Overrides ApexModule.IsInstallabeToApex()
Roland Levillainf89cd092019-07-29 16:22:59 +01003693// Only shared/runtime libraries and "test_per_src" tests are installable to APEX.
Jiyong Park9d452992018-10-03 00:38:19 +09003694func (c *Module) IsInstallableToApex() bool {
Colin Cross31076b32020-10-23 17:22:06 -07003695 if lib := c.library; lib != nil {
Jiyong Park73c54ee2019-10-22 20:31:18 +09003696 // Stub libs and prebuilt libs in a versioned SDK are not
3697 // installable to APEX even though they are shared libs.
Paul Duffin458a15b2022-11-25 12:18:24 +00003698 return lib.shared() && !lib.buildStubs()
Roland Levillainf89cd092019-07-29 16:22:59 +01003699 } else if _, ok := c.linker.(testPerSrc); ok {
3700 return true
Jiyong Park9d452992018-10-03 00:38:19 +09003701 }
3702 return false
3703}
3704
Jiyong Parka90ca002019-10-07 15:47:24 +09003705func (c *Module) AvailableFor(what string) bool {
3706 if linker, ok := c.linker.(interface {
3707 availableFor(string) bool
3708 }); ok {
3709 return c.ApexModuleBase.AvailableFor(what) || linker.availableFor(what)
3710 } else {
3711 return c.ApexModuleBase.AvailableFor(what)
3712 }
3713}
3714
Jiyong Park62304bb2020-04-13 16:19:48 +09003715func (c *Module) TestFor() []string {
Jiyong Park46a512f2020-12-04 18:02:13 +09003716 return c.Properties.Test_for
Jiyong Park62304bb2020-04-13 16:19:48 +09003717}
3718
Paul Duffin0cb37b92020-03-04 14:52:46 +00003719func (c *Module) EverInstallable() bool {
3720 return c.installer != nil &&
3721 // Check to see whether the module is actually ever installable.
3722 c.installer.everInstallable()
3723}
3724
Ivan Lozanod7586b62021-04-01 09:49:36 -04003725func (c *Module) PreventInstall() bool {
3726 return c.Properties.PreventInstall
3727}
3728
3729func (c *Module) Installable() *bool {
Colin Cross1bc94122021-10-28 13:25:54 -07003730 if c.library != nil {
3731 if i := c.library.installable(); i != nil {
3732 return i
3733 }
3734 }
Ivan Lozanod7586b62021-04-01 09:49:36 -04003735 return c.Properties.Installable
3736}
3737
3738func installable(c LinkableInterface, apexInfo android.ApexInfo) bool {
Paul Duffin0cb37b92020-03-04 14:52:46 +00003739 ret := c.EverInstallable() &&
3740 // Check to see whether the module has been configured to not be installed.
Ivan Lozanod7586b62021-04-01 09:49:36 -04003741 proptools.BoolDefault(c.Installable(), true) &&
3742 !c.PreventInstall() && c.OutputFile().Valid()
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003743
3744 // The platform variant doesn't need further condition. Apex variants however might not
3745 // be installable because it will likely to be included in the APEX and won't appear
3746 // in the system partition.
Colin Cross56a83212020-09-15 18:30:11 -07003747 if apexInfo.IsForPlatform() {
Jiyong Parkfe9a4302020-01-07 16:59:44 +09003748 return ret
3749 }
3750
3751 // Special case for modules that are configured to be installed to /data, which includes
3752 // test modules. For these modules, both APEX and non-APEX variants are considered as
3753 // installable. This is because even the APEX variants won't be included in the APEX, but
3754 // will anyway be installed to /data/*.
3755 // See b/146995717
3756 if c.InstallInData() {
3757 return ret
3758 }
3759
3760 return false
Inseob Kim1f086e22019-05-09 13:29:15 +09003761}
3762
Logan Chien41eabe62019-04-10 13:33:58 +08003763func (c *Module) AndroidMkWriteAdditionalDependenciesForSourceAbiDiff(w io.Writer) {
3764 if c.linker != nil {
3765 if library, ok := c.linker.(*libraryDecorator); ok {
3766 library.androidMkWriteAdditionalDependenciesForSourceAbiDiff(w)
3767 }
3768 }
3769}
3770
Jiyong Park45bf82e2020-12-15 22:29:02 +09003771var _ android.ApexModule = (*Module)(nil)
3772
3773// Implements android.ApexModule
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003774func (c *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07003775 depTag := ctx.OtherModuleDependencyTag(dep)
3776 libDepTag, isLibDepTag := depTag.(libraryDependencyTag)
3777
3778 if cc, ok := dep.(*Module); ok {
3779 if cc.HasStubsVariants() {
3780 if isLibDepTag && libDepTag.shared() {
3781 // dynamic dep to a stubs lib crosses APEX boundary
3782 return false
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003783 }
Colin Cross6e511a92020-07-27 21:26:48 -07003784 if IsRuntimeDepTag(depTag) {
3785 // runtime dep to a stubs lib also crosses APEX boundary
Jiyong Parkd7536ba2020-01-16 17:14:23 +09003786 return false
3787 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003788 }
Zhijun Heec285872021-04-24 10:47:08 -07003789 if cc.IsLlndk() {
3790 return false
3791 }
Colin Crossaac32222020-07-29 12:51:56 -07003792 if isLibDepTag && c.static() && libDepTag.shared() {
Colin Cross6e511a92020-07-27 21:26:48 -07003793 // shared_lib dependency from a static lib is considered as crossing
3794 // the APEX boundary because the dependency doesn't actually is
3795 // linked; the dependency is used only during the compilation phase.
3796 return false
3797 }
Jiyong Parke3867542020-12-03 17:28:25 +09003798
3799 if isLibDepTag && libDepTag.excludeInApex {
3800 return false
3801 }
Colin Cross6e511a92020-07-27 21:26:48 -07003802 }
Colin Crossc1b36442021-05-06 13:42:48 -07003803 if depTag == stubImplDepTag {
3804 // We don't track from an implementation library to its stubs.
Jiyong Park7d95a512020-05-10 15:16:24 +09003805 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003806 }
Jiyong Park12177fc2021-01-05 14:37:15 +09003807 if depTag == staticVariantTag {
3808 // This dependency is for optimization (reuse *.o from the static lib). It doesn't
3809 // actually mean that the static lib (and its dependencies) are copied into the
3810 // APEX.
3811 return false
3812 }
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09003813 return true
3814}
3815
Jiyong Park45bf82e2020-12-15 22:29:02 +09003816// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07003817func (c *Module) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
3818 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09003819 // We ignore libclang_rt.* prebuilt libs since they declare sdk_version: 14(b/121358700)
3820 if strings.HasPrefix(ctx.OtherModuleName(c), "libclang_rt") {
3821 return nil
3822 }
Jooyung Han749dc692020-04-15 11:03:39 +09003823 // We don't check for prebuilt modules
3824 if _, ok := c.linker.(prebuiltLinkerInterface); ok {
3825 return nil
3826 }
Kiyoung Kim487689e2022-07-26 09:48:22 +09003827
Jooyung Han749dc692020-04-15 11:03:39 +09003828 minSdkVersion := c.MinSdkVersion()
3829 if minSdkVersion == "apex_inherit" {
3830 return nil
3831 }
3832 if minSdkVersion == "" {
3833 // JNI libs within APK-in-APEX fall into here
3834 // Those are okay to set sdk_version instead
3835 // We don't have to check if this is a SDK variant because
3836 // non-SDK variant resets sdk_version, which works too.
3837 minSdkVersion = c.SdkVersion()
3838 }
Dan Albertc8060532020-07-22 22:32:17 -07003839 if minSdkVersion == "" {
3840 return fmt.Errorf("neither min_sdk_version nor sdk_version specificed")
3841 }
3842 // Not using nativeApiLevelFromUser because the context here is not
3843 // necessarily a native context.
3844 ver, err := android.ApiLevelFromUser(ctx, minSdkVersion)
Jooyung Han749dc692020-04-15 11:03:39 +09003845 if err != nil {
3846 return err
3847 }
Dan Albertc8060532020-07-22 22:32:17 -07003848
Colin Cross8ca61c12022-10-06 21:00:14 -07003849 // A dependency only needs to support a min_sdk_version at least
3850 // as high as the api level that the architecture was introduced in.
3851 // This allows introducing new architectures in the platform that
3852 // need to be included in apexes that normally require an older
3853 // min_sdk_version.
Colin Crossbb137a32023-01-26 09:54:42 -08003854 minApiForArch := MinApiForArch(ctx, c.Target().Arch.ArchType)
Colin Cross8ca61c12022-10-06 21:00:14 -07003855 if sdkVersion.LessThan(minApiForArch) {
3856 sdkVersion = minApiForArch
3857 }
3858
Dan Albertc8060532020-07-22 22:32:17 -07003859 if ver.GreaterThan(sdkVersion) {
Jooyung Han749dc692020-04-15 11:03:39 +09003860 return fmt.Errorf("newer SDK(%v)", ver)
3861 }
3862 return nil
3863}
3864
Paul Duffinb5769c12021-05-12 16:16:51 +01003865// Implements android.ApexModule
3866func (c *Module) AlwaysRequiresPlatformApexVariant() bool {
3867 // stub libraries and native bridge libraries are always available to platform
3868 return c.IsStubs() || c.Target().NativeBridge == android.NativeBridgeEnabled
3869}
3870
Jooyung Han91f92032022-02-04 12:36:33 +09003871// Overrides android.ApexModuleBase.UniqueApexVariations
3872func (c *Module) UniqueApexVariations() bool {
3873 // When a vendor APEX needs a VNDK lib in it (use_vndk_as_stable: false), it should be a unique
3874 // APEX variation. Otherwise, another vendor APEX with use_vndk_as_stable:true may use a wrong
3875 // variation of the VNDK lib because APEX variations are merged/grouped.
Jooyung Handfc864c2023-03-20 18:19:07 +09003876 // TODO(b/274401041) Find a way to merge APEX variations for vendor apexes.
Jooyung Han91f92032022-02-04 12:36:33 +09003877 return c.UseVndk() && c.IsVndk()
3878}
3879
Inseob Kima1888ce2022-10-04 14:42:02 +09003880func (c *Module) overriddenModules() []string {
3881 if o, ok := c.linker.(overridable); ok {
3882 return o.overriddenModules()
3883 }
3884 return nil
3885}
3886
Rob Seymour925aa092021-08-10 20:42:03 +00003887var _ snapshot.RelativeInstallPath = (*Module)(nil)
3888
Liz Kammer35ca77e2021-12-22 15:31:40 -05003889type moduleType int
3890
3891const (
3892 unknownType moduleType = iota
3893 binary
3894 object
3895 fullLibrary
3896 staticLibrary
3897 sharedLibrary
3898 headerLibrary
Jingwen Chen537242c2022-08-24 11:53:27 +00003899 testBin // testBinary already declared
Spandan Das1278c2c2022-08-19 18:17:28 +00003900 ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003901)
3902
3903func (c *Module) typ() moduleType {
Jingwen Chen537242c2022-08-24 11:53:27 +00003904 if c.testBinary() {
3905 // testBinary is also a binary, so this comes before the c.Binary()
3906 // conditional. A testBinary has additional implicit dependencies and
3907 // other test-only semantics.
3908 return testBin
3909 } else if c.Binary() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003910 return binary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003911 } else if c.Object() {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003912 return object
Jingwen Chen537242c2022-08-24 11:53:27 +00003913 } else if c.testLibrary() {
3914 // TODO(b/244431896) properly convert cc_test_library to its own macro. This
3915 // will let them add implicit compile deps on gtest, for example.
3916 //
Liz Kammerefc51d92023-04-21 15:11:25 -04003917 // For now, treat them as regular libraries.
3918 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003919 } else if c.CcLibrary() {
Chris Parsons58852a02021-12-09 18:10:18 -05003920 static := false
3921 shared := false
3922 if library, ok := c.linker.(*libraryDecorator); ok {
3923 static = library.MutatedProperties.BuildStatic
3924 shared = library.MutatedProperties.BuildShared
3925 } else if library, ok := c.linker.(*prebuiltLibraryLinker); ok {
3926 static = library.MutatedProperties.BuildStatic
3927 shared = library.MutatedProperties.BuildShared
3928 }
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003929 if static && shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003930 return fullLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003931 } else if !static && !shared {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003932 return headerLibrary
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003933 } else if static {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003934 return staticLibrary
3935 }
3936 return sharedLibrary
Spandan Das1278c2c2022-08-19 18:17:28 +00003937 } else if c.isNDKStubLibrary() {
3938 return ndkLibrary
Liz Kammer35ca77e2021-12-22 15:31:40 -05003939 }
3940 return unknownType
3941}
3942
3943// ConvertWithBp2build converts Module to Bazel for bp2build.
3944func (c *Module) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
3945 prebuilt := c.IsPrebuilt()
3946 switch c.typ() {
3947 case binary:
Alex Márquez Pérez Muñíz Díaz Púras Thaureauxb12ff592022-09-01 15:04:04 +00003948 if prebuilt {
3949 prebuiltBinaryBp2Build(ctx, c)
3950 } else {
Jingwen Chen537242c2022-08-24 11:53:27 +00003951 binaryBp2build(ctx, c)
3952 }
3953 case testBin:
3954 if !prebuilt {
3955 testBinaryBp2build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003956 }
3957 case object:
Colin Crossc5075e92022-12-05 16:46:39 -08003958 if prebuilt {
3959 prebuiltObjectBp2Build(ctx, c)
3960 } else {
Liz Kammer35ca77e2021-12-22 15:31:40 -05003961 objectBp2Build(ctx, c)
3962 }
3963 case fullLibrary:
3964 if !prebuilt {
3965 libraryBp2Build(ctx, c)
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003966 } else {
3967 prebuiltLibraryBp2Build(ctx, c)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003968 }
3969 case headerLibrary:
3970 libraryHeadersBp2Build(ctx, c)
3971 case staticLibrary:
Liz Kammer35ca77e2021-12-22 15:31:40 -05003972 if prebuilt {
Trevor Radcliffe58ea4512022-04-07 20:36:39 +00003973 prebuiltLibraryStaticBp2Build(ctx, c, false)
Liz Kammer35ca77e2021-12-22 15:31:40 -05003974 } else {
3975 sharedOrStaticLibraryBp2Build(ctx, c, true)
3976 }
3977 case sharedLibrary:
3978 if prebuilt {
3979 prebuiltLibrarySharedBp2Build(ctx, c)
3980 } else {
3981 sharedOrStaticLibraryBp2Build(ctx, c, false)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04003982 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00003983 }
3984}
3985
3986var _ android.ApiProvider = (*Module)(nil)
3987
3988func (c *Module) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) {
Spandan Das4238c652022-09-09 01:38:47 +00003989 if c.IsPrebuilt() {
3990 return
3991 }
Spandan Das8b4a5f32022-09-29 00:28:24 +00003992 switch c.typ() {
Spandan Das4238c652022-09-09 01:38:47 +00003993 case fullLibrary:
3994 apiContributionBp2Build(ctx, c)
3995 case sharedLibrary:
3996 apiContributionBp2Build(ctx, c)
3997 case headerLibrary:
3998 // Aggressively generate api targets for all header modules
3999 // This is necessary since the header module does not know if it is a dep of API surface stub library
4000 apiLibraryHeadersBp2Build(ctx, c)
Spandan Das1278c2c2022-08-19 18:17:28 +00004001 case ndkLibrary:
4002 ndkLibraryBp2build(ctx, c)
Liz Kammerbe46fcc2021-11-01 15:32:43 -04004003 }
4004}
4005
Colin Crosscfad1192015-11-02 16:43:11 -08004006// Defaults
Colin Crossca860ac2016-01-04 14:34:37 -08004007type Defaults struct {
Colin Cross635c3b02016-05-18 15:37:25 -07004008 android.ModuleBase
Colin Cross1f44a3a2017-07-07 14:33:33 -07004009 android.DefaultsModuleBase
Jiyong Park9d452992018-10-03 00:38:19 +09004010 android.ApexModuleBase
Colin Crosscfad1192015-11-02 16:43:11 -08004011}
4012
Patrice Arrudac249c712019-03-19 17:00:29 -07004013// cc_defaults provides a set of properties that can be inherited by other cc
4014// modules. A module can use the properties from a cc_defaults using
4015// `defaults: ["<:default_module_name>"]`. Properties of both modules are
4016// merged (when possible) by prepending the default module's values to the
4017// depending module's values.
Colin Cross36242852017-06-23 15:06:31 -07004018func defaultsFactory() android.Module {
Colin Crosse1d764e2016-08-18 14:18:32 -07004019 return DefaultsFactory()
4020}
4021
Colin Cross36242852017-06-23 15:06:31 -07004022func DefaultsFactory(props ...interface{}) android.Module {
Colin Crossca860ac2016-01-04 14:34:37 -08004023 module := &Defaults{}
Colin Crosscfad1192015-11-02 16:43:11 -08004024
Colin Cross36242852017-06-23 15:06:31 -07004025 module.AddProperties(props...)
4026 module.AddProperties(
Colin Crossca860ac2016-01-04 14:34:37 -08004027 &BaseProperties{},
Dan Willemsen3e5bdf22017-09-13 18:37:08 -07004028 &VendorProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004029 &BaseCompilerProperties{},
4030 &BaseLinkerProperties{},
Paul Duffina37832a2019-07-18 12:31:26 +01004031 &ObjectLinkerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004032 &LibraryProperties{},
Colin Crosse1bb5d02019-09-24 14:55:04 -07004033 &StaticProperties{},
4034 &SharedProperties{},
Colin Cross919281a2016-04-05 16:42:05 -07004035 &FlagExporterProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004036 &BinaryLinkerProperties{},
Trevor Radcliffef389cb42022-03-24 21:06:14 +00004037 &TestLinkerProperties{},
4038 &TestInstallerProperties{},
Colin Crossb916a382016-07-29 17:28:03 -07004039 &TestBinaryProperties{},
Colin Cross43287652020-06-30 10:15:07 -07004040 &BenchmarkProperties{},
hamzehc0a671f2021-07-22 12:05:08 -07004041 &fuzz.FuzzProperties{},
Colin Crossca860ac2016-01-04 14:34:37 -08004042 &StlProperties{},
Colin Cross16b23492016-01-06 14:41:07 -08004043 &SanitizeProperties{},
Colin Cross665dce92016-04-28 14:50:03 -07004044 &StripProperties{},
Dan Willemsen7424d612016-09-01 13:45:39 -07004045 &InstallerProperties{},
Dan Willemsena03cf6d2016-09-26 15:45:04 -07004046 &TidyProperties{},
Dan Willemsen581341d2017-02-09 16:16:31 -08004047 &CoverageProperties{},
Jayant Chowdhary3e231fd2017-02-08 13:45:53 -08004048 &SAbiProperties{},
Justin Yun4b2382f2017-07-26 14:22:10 +09004049 &VndkProperties{},
Stephen Craneba090d12017-05-09 15:44:35 -07004050 &LTOProperties{},
Yi Kongeb8efc92021-12-09 18:06:29 +08004051 &AfdoProperties{},
Pirama Arumuga Nainarada83ec2017-08-31 23:38:27 -07004052 &PgoProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08004053 &android.ProtoProperties{},
Ivan Lozanobc9e4212020-09-25 16:08:34 -04004054 // RustBindgenProperties is included here so that cc_defaults can be used for rust_bindgen modules.
4055 &RustBindgenClangProperties{},
Yu-Chi Cheng24b2b0f2021-06-23 15:56:39 -07004056 &prebuiltLinkerProperties{},
Colin Crosse1d764e2016-08-18 14:18:32 -07004057 )
Colin Crosscfad1192015-11-02 16:43:11 -08004058
Jooyung Hancc372c52019-09-25 15:18:44 +09004059 android.InitDefaultsModule(module)
Colin Cross36242852017-06-23 15:06:31 -07004060
4061 return module
Colin Crosscfad1192015-11-02 16:43:11 -08004062}
4063
Jiyong Park2286afd2020-06-16 21:58:53 +09004064func (c *Module) IsSdkVariant() bool {
Lukacs T. Berki2063a0d2021-06-17 09:32:36 +02004065 return c.Properties.IsSdkVariant
Jiyong Park2286afd2020-06-16 21:58:53 +09004066}
4067
Kiyoung Kim51279d32022-08-24 14:10:46 +09004068func (c *Module) isImportedApiLibrary() bool {
4069 _, ok := c.linker.(*apiLibraryDecorator)
4070 return ok
4071}
4072
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004073func kytheExtractAllFactory() android.Singleton {
4074 return &kytheExtractAllSingleton{}
4075}
4076
4077type kytheExtractAllSingleton struct {
4078}
4079
4080func (ks *kytheExtractAllSingleton) GenerateBuildActions(ctx android.SingletonContext) {
4081 var xrefTargets android.Paths
4082 ctx.VisitAllModules(func(module android.Module) {
4083 if ccModule, ok := module.(xref); ok {
4084 xrefTargets = append(xrefTargets, ccModule.XrefCcFiles()...)
4085 }
4086 })
4087 // TODO(asmundak): Perhaps emit a rule to output a warning if there were no xrefTargets
4088 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07004089 ctx.Phony("xref_cxx", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08004090 }
4091}
4092
Jihoon Kangf78a8902022-09-01 22:47:07 +00004093func (c *Module) Partition() string {
4094 if p, ok := c.installer.(interface {
4095 getPartition() string
4096 }); ok {
4097 return p.getPartition()
4098 }
4099 return ""
4100}
4101
Colin Cross06a931b2015-10-28 17:23:31 -07004102var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07004103var BoolDefault = proptools.BoolDefault
Nan Zhang0007d812017-11-07 10:57:05 -08004104var BoolPtr = proptools.BoolPtr
4105var String = proptools.String
4106var StringPtr = proptools.StringPtr